text stringlengths 54 60.6k |
|---|
<commit_before>#pragma once
#include <map>
#include <unordered_map>
#include <chrono>
#include <cmath>
#include <glm/vec3.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "helper.hxx"
namespace wonder_rabbit_project
{
namespace wonderland
{
namespace renderer
{
namespace model
{
struct animation_state_t
{
using fseconds = std::chrono::duration<float>;
std::string name;
fseconds time;
float weight;
explicit animation_state_t()
: weight( 1.0f )
{ }
animation_state_t
( const std::string& n
, const float t = 0.0f
, const float w = 1.0f
)
: name( n )
, time( t )
, weight( w )
{ }
animation_state_t
( const std::string& n
, const fseconds& t = fseconds( 0 )
, const float w = 1.0f
)
: name( n )
, time( t )
, weight( w )
{ }
inline auto operator+=( const float delta_time_in_seconds )
-> void
{ time += fseconds( delta_time_in_seconds ); }
template < class T_duration = fseconds >
inline auto operator+=( const T_duration& delta_time )
-> void
{ time += delta_time; }
template < class T_duration = fseconds >
inline auto operator=( const T_duration& t )
-> void
{ time = t; }
};
using animation_states_t = std::list< animation_state_t >;
struct animation_t
{
struct channel_t
{
std::map< float, glm::vec3 > scalings;
std::map< float, glm::quat > rotations;
std::map< float, glm::vec3 > translations;
};
float duration;
float ticks_per_second;
// bone_name, channel
std::unordered_map< std::string, channel_t > channels;
auto transformation( const std::string& bone_name, const animation_state_t::fseconds time ) const
-> glm::mat4
{
if ( channels.find( bone_name ) == channels.end() )
return glm::mat4( 1.0f );
const auto time_in_ticks = time.count() * ticks_per_second;
const auto animation_time = std::fmod( time_in_ticks, duration );
//const auto animation_time = 2560 - 8 * 3;
const auto& channel = channels.at( bone_name );
const auto scaling_matrix = scaling ( channel, animation_time );
const auto rotation_matrix = rotation ( channel, animation_time );
const auto translation_matrix = translation( channel, animation_time );
return translation_matrix * rotation_matrix * scaling_matrix;
}
private:
inline auto scaling( const channel_t& channel, const float animation_time ) const
-> glm::mat4
{
const auto blended_scaling = blending_value( channel.scalings, animation_time );
return glm::scale( glm::mat4( 1.0f ), blended_scaling );
}
inline auto rotation( const channel_t& channel, const float animation_time ) const
-> glm::mat4
{
const auto blended_rotation = blending_value( channel.rotations, animation_time );
return glm::mat4_cast( blended_rotation );
}
inline auto translation( const channel_t& channel, const float animation_time ) const
-> glm::mat4
{
const auto blended_translation = blending_value( channel.translations, animation_time );
return glm::translate( glm::mat4( 1.0f ), blended_translation );
}
template < class T >
inline auto blending_value( const T& map, const float animation_time ) const
-> typename T::mapped_type
{
auto upper_bound = map.upper_bound( animation_time );
float upper_time, lower_time;
typename T::mapped_type upper_value, lower_value;
if ( upper_bound not_eq map.end() )
{
upper_value = upper_bound -> second;
upper_time = upper_bound -> first;
}
else
{
upper_value = map.begin() -> second;
upper_time = duration;
}
lower_value = ( --upper_bound ) -> second;
lower_time = upper_bound -> first;
if ( upper_value == lower_value )
return upper_value;
const auto blending_factor = ( animation_time - lower_time ) / ( upper_time - lower_time );
return blending_value_blend( lower_value, upper_value, blending_factor );
}
template < class T >
inline auto blending_value_blend( const T& lower_value, const T& upper_value, const float blending_factor ) const
-> T
{
const auto reverse_blending_factor = 1.0f - blending_factor;
const auto blending_lower_value = lower_value * reverse_blending_factor;
const auto blending_upper_value = upper_value * blending_factor;
return blending_lower_value + blending_upper_value;
}
};
template <>
inline auto animation_t::blending_value_blend< glm::quat >( const glm::quat& lower_value, const glm::quat& upper_value, const float blending_factor ) const
-> glm::quat
{
const auto reverse_blending_factor = 1.0f - blending_factor;
const auto blending_lower_value = glm::mat4_cast( lower_value ) * reverse_blending_factor;
const auto blending_upper_value = glm::mat4_cast( upper_value ) * blending_factor;
return glm::quat_cast( blending_lower_value + blending_upper_value );
}
}
}
}
}<commit_msg>remove commented debugging code.<commit_after>#pragma once
#include <map>
#include <unordered_map>
#include <chrono>
#include <cmath>
#include <glm/vec3.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "helper.hxx"
namespace wonder_rabbit_project
{
namespace wonderland
{
namespace renderer
{
namespace model
{
struct animation_state_t
{
using fseconds = std::chrono::duration<float>;
std::string name;
fseconds time;
float weight;
explicit animation_state_t()
: weight( 1.0f )
{ }
animation_state_t
( const std::string& n
, const float t = 0.0f
, const float w = 1.0f
)
: name( n )
, time( t )
, weight( w )
{ }
animation_state_t
( const std::string& n
, const fseconds& t = fseconds( 0 )
, const float w = 1.0f
)
: name( n )
, time( t )
, weight( w )
{ }
inline auto operator+=( const float delta_time_in_seconds )
-> void
{ time += fseconds( delta_time_in_seconds ); }
template < class T_duration = fseconds >
inline auto operator+=( const T_duration& delta_time )
-> void
{ time += delta_time; }
template < class T_duration = fseconds >
inline auto operator=( const T_duration& t )
-> void
{ time = t; }
};
using animation_states_t = std::list< animation_state_t >;
struct animation_t
{
struct channel_t
{
std::map< float, glm::vec3 > scalings;
std::map< float, glm::quat > rotations;
std::map< float, glm::vec3 > translations;
};
float duration;
float ticks_per_second;
// bone_name, channel
std::unordered_map< std::string, channel_t > channels;
auto transformation( const std::string& bone_name, const animation_state_t::fseconds time ) const
-> glm::mat4
{
if ( channels.find( bone_name ) == channels.end() )
return glm::mat4( 1.0f );
const auto time_in_ticks = time.count() * ticks_per_second;
const auto animation_time = std::fmod( time_in_ticks, duration );
const auto& channel = channels.at( bone_name );
const auto scaling_matrix = scaling ( channel, animation_time );
const auto rotation_matrix = rotation ( channel, animation_time );
const auto translation_matrix = translation( channel, animation_time );
return translation_matrix * rotation_matrix * scaling_matrix;
}
private:
inline auto scaling( const channel_t& channel, const float animation_time ) const
-> glm::mat4
{
const auto blended_scaling = blending_value( channel.scalings, animation_time );
return glm::scale( glm::mat4( 1.0f ), blended_scaling );
}
inline auto rotation( const channel_t& channel, const float animation_time ) const
-> glm::mat4
{
const auto blended_rotation = blending_value( channel.rotations, animation_time );
return glm::mat4_cast( blended_rotation );
}
inline auto translation( const channel_t& channel, const float animation_time ) const
-> glm::mat4
{
const auto blended_translation = blending_value( channel.translations, animation_time );
return glm::translate( glm::mat4( 1.0f ), blended_translation );
}
template < class T >
inline auto blending_value( const T& map, const float animation_time ) const
-> typename T::mapped_type
{
auto upper_bound = map.upper_bound( animation_time );
float upper_time, lower_time;
typename T::mapped_type upper_value, lower_value;
if ( upper_bound not_eq map.end() )
{
upper_value = upper_bound -> second;
upper_time = upper_bound -> first;
}
else
{
upper_value = map.begin() -> second;
upper_time = duration;
}
lower_value = ( --upper_bound ) -> second;
lower_time = upper_bound -> first;
if ( upper_value == lower_value )
return upper_value;
const auto blending_factor = ( animation_time - lower_time ) / ( upper_time - lower_time );
return blending_value_blend( lower_value, upper_value, blending_factor );
}
template < class T >
inline auto blending_value_blend( const T& lower_value, const T& upper_value, const float blending_factor ) const
-> T
{
const auto reverse_blending_factor = 1.0f - blending_factor;
const auto blending_lower_value = lower_value * reverse_blending_factor;
const auto blending_upper_value = upper_value * blending_factor;
return blending_lower_value + blending_upper_value;
}
};
template <>
inline auto animation_t::blending_value_blend< glm::quat >( const glm::quat& lower_value, const glm::quat& upper_value, const float blending_factor ) const
-> glm::quat
{
const auto reverse_blending_factor = 1.0f - blending_factor;
const auto blending_lower_value = glm::mat4_cast( lower_value ) * reverse_blending_factor;
const auto blending_upper_value = glm::mat4_cast( upper_value ) * blending_factor;
return glm::quat_cast( blending_lower_value + blending_upper_value );
}
}
}
}
}<|endoftext|> |
<commit_before>#include "nkit/dynamic.h"
#include "nkit/logger_brief.h"
int main(void)
{
using namespace nkit;
Dynamic i0(0);
Dynamic i2(2);
Dynamic i6(-6);
CINFO(i2); // prints: 2
CINFO(i6); // prints: -6
CINFO(i6 / i2); // prints: -3
CINFO(i6 * i2); // prints: -12
Dynamic i3 = i6 / i2;
CINFO(i3); // prints: -3
i6 /= i2;
CINFO(i6); // prints: -3
i6 *= i2;
CINFO(i6); // prints: -6
if (i0)
CINFO("This is never prints");
if (i6)
CINFO("This will be printed");
if (i6 > i2)
CINFO("This is never prints");
if (i6 != i2)
CINFO("This will be printed");
if (i6 == i2)
CINFO("This is never prints");
CINFO("as int64_t: " << static_cast<int64_t>(i2)); // prints: 2
// prints: max(uint64_t) - (6 - 1)
CINFO("as uint64_t: " << static_cast<uint64_t>(i6)
<< ", max(uint64_t): " << std::numeric_limits<uint64_t>::max());
CINFO("as double: " << static_cast<double>(i6)); // prints: -6
CINFO("as std::string: " << static_cast<std::string>(i6)); // prints: -6
if (i2.IsSignedInteger())
CINFO("This will be printed");
}
<commit_msg>Sphinx docs (under construction)<commit_after>#include "nkit/dynamic.h"
#include "nkit/logger_brief.h"
int main(void)
{
using namespace nkit;
Dynamic i0(0);
Dynamic i2(2);
Dynamic i6(-6);
CINFO(i2); // prints: 2
CINFO(i6); // prints: -6
CINFO(i6 / i2); // prints: -3
CINFO(i6 * i2); // prints: -12
Dynamic i3 = i6 / i2;
CINFO(i3); // prints: -3
i6 /= i2;
CINFO(i6); // prints: -3
i6 *= i2;
CINFO(i6); // prints: -6
if (i0)
CINFO("This is never prints");
if (i6)
CINFO("This will be printed");
if (i6 > i2)
CINFO("This is never prints");
if (i6 != i2)
CINFO("This will be printed");
if (i6 == i2)
CINFO("This is never prints");
CINFO("as int64_t: " << static_cast<int64_t>(i2)); // prints: 2
// prints: max(uint64_t) - (6 - 1)
CINFO("as uint64_t: " << static_cast<uint64_t>(i6)
<< ", max(uint64_t): " << std::numeric_limits<uint64_t>::max());
CINFO("as double: " << static_cast<double>(i6)); // prints: -6
//std::string w(static_cast<std::string>(i6));
//CINFO("as std::string: " << static_cast<std::string>(i6)); // prints: -6
if (i2.IsSignedInteger())
CINFO("This will be printed");
}
<|endoftext|> |
<commit_before>// Copyright © 2014 German Neuroinformatics Node (G-Node)
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted under the terms of the BSD License. See
// LICENSE file in the root of the Project.
//
// Author: Jan Grewe <jan.grewe@g-node.org>
#include "TestTag.hpp"
#include <nix/Exception.hpp>
#include <nix/valid/validate.hpp>
#include <sstream>
#include <ctime>
using namespace nix;
using namespace valid;
using namespace std;
void TestTag::setUp() {
startup_time = time(NULL);
file = File::open("test_multiTag.h5", FileMode::Overwrite);
block = file.createBlock("block", "dataset");
vector<string> array_names = { "data_array_a", "data_array_b", "data_array_c",
"data_array_d", "data_array_e" };
refs.clear();
for (const auto & name : array_names) {
refs.push_back(block.createDataArray(name, "reference",
DataType::Double, nix::NDSize({ 0 })));
}
tag = block.createTag("tag_one", "test_tag", {0.0, 2.0, 3.4});
tag_other = block.createTag("tag_two", "test_tag", {0.0, 2.0, 3.4});
tag_null = nullptr;
section = file.createSection("foo_section", "metadata");
}
void TestTag::tearDown() {
file.deleteBlock(block.id());
file.deleteSection(section.id());
file.close();
}
void TestTag::testValidate() {
valid::Result result = validate(tag);
CPPUNIT_ASSERT(result.getErrors().size() == 0);
CPPUNIT_ASSERT(result.getWarnings().size() == 0);
}
void TestTag::testId() {
CPPUNIT_ASSERT(tag.id().size() == 36);
}
void TestTag::testName() {
CPPUNIT_ASSERT(tag.name() == "tag_one");
}
void TestTag::testType() {
CPPUNIT_ASSERT(tag.type() == "test_tag");
std::string type = util::createId();
tag.type(type);
CPPUNIT_ASSERT(tag.type() == type);
}
void TestTag::testDefinition() {
std::string def = util::createId();
tag.definition(def);
CPPUNIT_ASSERT(*tag.definition() == def);
tag.definition(nix::none);
CPPUNIT_ASSERT(tag.definition() == nix::none);
}
void TestTag::testCreateRemove() {
std::vector<std::string> ids;
size_t count = static_cast<size_t>(block.tagCount());
const char *names[5] = { "tag_a", "tag_b", "tag_c", "tag_d", "tag_e" };
for (int i = 0; i < 5; i++) {
std::string type = "Event";
Tag st1 = block.createTag(names[i], type, {0.0, 2.0, 3.4});
st1.references(refs);
Tag st2 = block.getTag(st1.id());
ids.push_back(st1.id());
std::stringstream errmsg;
errmsg << "Error while accessing tag: st1.id() = " << st1.id()
<< " / st2.id() = " << st2.id();
CPPUNIT_ASSERT_MESSAGE(errmsg.str(), st1.id().compare(st2.id()) == 0);
}
std::stringstream errmsg2;
errmsg2 << "Error creating Tags. Counts do not match!";
CPPUNIT_ASSERT_MESSAGE(errmsg2.str(), block.tagCount() == (count+5));
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
for (size_t i = 0; i < ids.size(); i++) {
block.deleteTag(ids[i]);
}
std::stringstream errmsg1;
errmsg1 << "Error while removing tags!";
CPPUNIT_ASSERT_MESSAGE(errmsg1.str(), block.tagCount() == count);
}
void TestTag::testExtent() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<double> extent = {1.0, 2.0, 3.0};
st.extent(extent);
std::vector<double> retrieved = st.extent();
CPPUNIT_ASSERT(retrieved.size() == extent.size());
for(size_t i = 0; i < retrieved.size(); i++){
CPPUNIT_ASSERT(retrieved[i] == extent[i]);
}
st.extent(none);
CPPUNIT_ASSERT(st.extent().size() == 0);
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
block.deleteTag(st.id());
}
void TestTag::testPosition() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<double> position = {1.0, 2.0, 3.0};
std::vector<double> new_position = {2.0};
st.position(position);
std::vector<double> retrieved = st.position();
CPPUNIT_ASSERT(retrieved.size() == position.size());
for(size_t i = 0; i < retrieved.size(); i++){
CPPUNIT_ASSERT(retrieved[i] == position[i]);
}
st.position(new_position);
retrieved = st.position();
CPPUNIT_ASSERT(retrieved.size() == new_position.size());
for(size_t i = 0; i < retrieved.size(); i++){
CPPUNIT_ASSERT(retrieved[i] == new_position[i]);
}
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
block.deleteTag(st.id());
}
void TestTag::testMetadataAccess() {
CPPUNIT_ASSERT(!tag.metadata());
tag.metadata(section);
CPPUNIT_ASSERT(tag.metadata());
// TODO This test fails due to operator== of Section
CPPUNIT_ASSERT(tag.metadata().id() == section.id());
// test none-unsetter
tag.metadata(none);
CPPUNIT_ASSERT(!tag.metadata());
// test deleter removing link too
tag.metadata(section);
file.deleteSection(section.id());
CPPUNIT_ASSERT(!tag.metadata());
// re-create section
section = file.createSection("foo_section", "metadata");
}
void TestTag::testSourceAccess() {
std::vector<std::string> names = { "source_a", "source_b", "source_c", "source_d", "source_e" };
CPPUNIT_ASSERT(tag.sourceCount() == 0);
CPPUNIT_ASSERT(tag.sources().size() == 0);
std::vector<std::string> ids;
for (auto it = names.begin(); it != names.end(); it++) {
Source child_source = block.createSource(*it,"channel");
tag.addSource(child_source);
CPPUNIT_ASSERT(child_source.name() == *it);
ids.push_back(child_source.id());
}
CPPUNIT_ASSERT(tag.sourceCount() == names.size());
CPPUNIT_ASSERT(tag.sources().size() == names.size());
std::string name = names[0];
Source source = tag.getSource(name);
CPPUNIT_ASSERT(source.name() == name);
for (auto it = ids.begin(); it != ids.end(); it++) {
Source child_source = tag.getSource(*it);
CPPUNIT_ASSERT(tag.hasSource(*it) == true);
CPPUNIT_ASSERT(child_source.id() == *it);
tag.removeSource(*it);
block.deleteSource(*it);
}
CPPUNIT_ASSERT(tag.sourceCount() == 0);
}
void TestTag::testUnits() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<std::string> valid_units = {"mV", "cm", "m^2"};
std::vector<std::string> invalid_units = {"mV", "haha", "qm^2"};
std::vector<std::string> insane_units = {"muV ", " muS"};
CPPUNIT_ASSERT_NO_THROW(st.units(valid_units));
CPPUNIT_ASSERT(st.units().size() == valid_units.size());
std::vector<std::string> retrieved_units = st.units();
for(size_t i = 0; i < retrieved_units.size(); i++){
CPPUNIT_ASSERT(retrieved_units[i] == valid_units[i]);
}
st.units(none);
CPPUNIT_ASSERT(st.units().size() == 0);
CPPUNIT_ASSERT_THROW(st.units(invalid_units), nix::InvalidUnit);
CPPUNIT_ASSERT(st.units().size() == 0);
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
st.units(insane_units);
retrieved_units = st.units();
CPPUNIT_ASSERT(retrieved_units.size() == 2);
CPPUNIT_ASSERT(retrieved_units[0] == "uV");
CPPUNIT_ASSERT(retrieved_units[1] == "uS");
block.deleteTag(st.id());
}
void TestTag::testReferences() {
CPPUNIT_ASSERT(tag.referenceCount() == 0);
for (size_t i = 0; i < refs.size(); ++i) {
CPPUNIT_ASSERT(!tag.hasReference(refs[i]));
CPPUNIT_ASSERT_NO_THROW(tag.addReference(refs[i]));
CPPUNIT_ASSERT(tag.hasReference(refs[i]));
}
CPPUNIT_ASSERT(tag.referenceCount() == refs.size());
for (size_t i = 0; i < refs.size(); ++i) {
CPPUNIT_ASSERT_NO_THROW(tag.removeReference(refs[i]));
}
CPPUNIT_ASSERT(tag.referenceCount() == 0);
}
void TestTag::testDataAccess() {
double samplingInterval = 1.0;
vector<double> ticks {1.2, 2.3, 3.4, 4.5, 6.7};
string unit = "ms";
SampledDimension sampledDim;
RangeDimension rangeDim;
SetDimension setDim;
vector<double> position {0.0, 2.0, 3.4};
vector<double> extent {0.0, 6.0, 2.3};
vector<string> units {"none", "ms", "ms"};
DataArray data_array = block.createDataArray("dimensionTest",
"test",
DataType::Double,
NDSize({0, 0, 0}));
vector<DataArray> reference;
reference.push_back(data_array);
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type data(boost::extents[2][10][5]);
int value;
for(index i = 0; i != 2; ++i) {
value = 0;
for(index j = 0; j != 10; ++j) {
for(index k = 0; k != 5; ++k) {
data[i][j][k] = value++;
}
}
}
data_array.setData(data);
setDim = data_array.appendSetDimension();
std::vector<std::string> labels = {"label_a", "label_b"};
setDim.labels(labels);
sampledDim = data_array.appendSampledDimension(samplingInterval);
sampledDim.unit(unit);
rangeDim = data_array.appendRangeDimension(ticks);
rangeDim.unit(unit);
Tag position_tag = block.createTag("position tag", "event", position);
position_tag.references(reference);
position_tag.units(units);
Tag segment_tag = block.createTag("region tag", "segment", position);
segment_tag.references(reference);
segment_tag.extent(extent);
segment_tag.units(units);
DataView retrieved_data = position_tag.retrieveData(0);
NDSize data_size = retrieved_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 1 && data_size[2] == 1);
retrieved_data = segment_tag.retrieveData( 0);
data_size = retrieved_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 6 && data_size[2] == 2);
block.deleteTag(position_tag);
block.deleteTag(segment_tag);
}
void TestTag::testOperators() {
CPPUNIT_ASSERT(tag_null == false);
CPPUNIT_ASSERT(tag_null == none);
CPPUNIT_ASSERT(tag != false);
CPPUNIT_ASSERT(tag != none);
CPPUNIT_ASSERT(tag == tag);
CPPUNIT_ASSERT(tag != tag_other);
tag_other = tag;
CPPUNIT_ASSERT(tag == tag_other);
tag_other = none;
CPPUNIT_ASSERT(tag_null == false);
CPPUNIT_ASSERT(tag_null == none);
}
void TestTag::testCreatedAt() {
CPPUNIT_ASSERT(tag.createdAt() >= startup_time);
time_t past_time = time(NULL) - 10000000;
tag.forceCreatedAt(past_time);
CPPUNIT_ASSERT(tag.createdAt() == past_time);
}
void TestTag::testUpdatedAt() {
CPPUNIT_ASSERT(tag.updatedAt() >= startup_time);
}
<commit_msg>[testTag] extent test to check for exceptions<commit_after>// Copyright © 2014 German Neuroinformatics Node (G-Node)
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted under the terms of the BSD License. See
// LICENSE file in the root of the Project.
//
// Author: Jan Grewe <jan.grewe@g-node.org>
#include "TestTag.hpp"
#include <nix/Exception.hpp>
#include <nix/valid/validate.hpp>
#include <sstream>
#include <ctime>
using namespace nix;
using namespace valid;
using namespace std;
void TestTag::setUp() {
startup_time = time(NULL);
file = File::open("test_multiTag.h5", FileMode::Overwrite);
block = file.createBlock("block", "dataset");
vector<string> array_names = { "data_array_a", "data_array_b", "data_array_c",
"data_array_d", "data_array_e" };
refs.clear();
for (const auto & name : array_names) {
refs.push_back(block.createDataArray(name, "reference",
DataType::Double, nix::NDSize({ 0 })));
}
tag = block.createTag("tag_one", "test_tag", {0.0, 2.0, 3.4});
tag_other = block.createTag("tag_two", "test_tag", {0.0, 2.0, 3.4});
tag_null = nullptr;
section = file.createSection("foo_section", "metadata");
}
void TestTag::tearDown() {
file.deleteBlock(block.id());
file.deleteSection(section.id());
file.close();
}
void TestTag::testValidate() {
valid::Result result = validate(tag);
CPPUNIT_ASSERT(result.getErrors().size() == 0);
CPPUNIT_ASSERT(result.getWarnings().size() == 0);
}
void TestTag::testId() {
CPPUNIT_ASSERT(tag.id().size() == 36);
}
void TestTag::testName() {
CPPUNIT_ASSERT(tag.name() == "tag_one");
}
void TestTag::testType() {
CPPUNIT_ASSERT(tag.type() == "test_tag");
std::string type = util::createId();
tag.type(type);
CPPUNIT_ASSERT(tag.type() == type);
}
void TestTag::testDefinition() {
std::string def = util::createId();
tag.definition(def);
CPPUNIT_ASSERT(*tag.definition() == def);
tag.definition(nix::none);
CPPUNIT_ASSERT(tag.definition() == nix::none);
}
void TestTag::testCreateRemove() {
std::vector<std::string> ids;
size_t count = static_cast<size_t>(block.tagCount());
const char *names[5] = { "tag_a", "tag_b", "tag_c", "tag_d", "tag_e" };
for (int i = 0; i < 5; i++) {
std::string type = "Event";
Tag st1 = block.createTag(names[i], type, {0.0, 2.0, 3.4});
st1.references(refs);
Tag st2 = block.getTag(st1.id());
ids.push_back(st1.id());
std::stringstream errmsg;
errmsg << "Error while accessing tag: st1.id() = " << st1.id()
<< " / st2.id() = " << st2.id();
CPPUNIT_ASSERT_MESSAGE(errmsg.str(), st1.id().compare(st2.id()) == 0);
}
std::stringstream errmsg2;
errmsg2 << "Error creating Tags. Counts do not match!";
CPPUNIT_ASSERT_MESSAGE(errmsg2.str(), block.tagCount() == (count+5));
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
for (size_t i = 0; i < ids.size(); i++) {
block.deleteTag(ids[i]);
}
std::stringstream errmsg1;
errmsg1 << "Error while removing tags!";
CPPUNIT_ASSERT_MESSAGE(errmsg1.str(), block.tagCount() == count);
}
void TestTag::testExtent() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<double> extent = {1.0, 2.0, 3.0};
st.extent(extent);
std::vector<double> retrieved = st.extent();
CPPUNIT_ASSERT(retrieved.size() == extent.size());
for(size_t i = 0; i < retrieved.size(); i++){
CPPUNIT_ASSERT(retrieved[i] == extent[i]);
}
st.extent(none);
CPPUNIT_ASSERT(st.extent().size() == 0);
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
block.deleteTag(st.id());
}
void TestTag::testPosition() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<double> position = {1.0, 2.0, 3.0};
std::vector<double> new_position = {2.0};
st.position(position);
std::vector<double> retrieved = st.position();
CPPUNIT_ASSERT(retrieved.size() == position.size());
for(size_t i = 0; i < retrieved.size(); i++){
CPPUNIT_ASSERT(retrieved[i] == position[i]);
}
st.position(new_position);
retrieved = st.position();
CPPUNIT_ASSERT(retrieved.size() == new_position.size());
for(size_t i = 0; i < retrieved.size(); i++){
CPPUNIT_ASSERT(retrieved[i] == new_position[i]);
}
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
block.deleteTag(st.id());
}
void TestTag::testMetadataAccess() {
CPPUNIT_ASSERT(!tag.metadata());
tag.metadata(section);
CPPUNIT_ASSERT(tag.metadata());
// TODO This test fails due to operator== of Section
CPPUNIT_ASSERT(tag.metadata().id() == section.id());
// test none-unsetter
tag.metadata(none);
CPPUNIT_ASSERT(!tag.metadata());
// test deleter removing link too
tag.metadata(section);
file.deleteSection(section.id());
CPPUNIT_ASSERT(!tag.metadata());
// re-create section
section = file.createSection("foo_section", "metadata");
}
void TestTag::testSourceAccess() {
std::vector<std::string> names = { "source_a", "source_b", "source_c", "source_d", "source_e" };
CPPUNIT_ASSERT(tag.sourceCount() == 0);
CPPUNIT_ASSERT(tag.sources().size() == 0);
std::vector<std::string> ids;
for (auto it = names.begin(); it != names.end(); it++) {
Source child_source = block.createSource(*it,"channel");
tag.addSource(child_source);
CPPUNIT_ASSERT(child_source.name() == *it);
ids.push_back(child_source.id());
}
CPPUNIT_ASSERT(tag.sourceCount() == names.size());
CPPUNIT_ASSERT(tag.sources().size() == names.size());
std::string name = names[0];
Source source = tag.getSource(name);
CPPUNIT_ASSERT(source.name() == name);
for (auto it = ids.begin(); it != ids.end(); it++) {
Source child_source = tag.getSource(*it);
CPPUNIT_ASSERT(tag.hasSource(*it) == true);
CPPUNIT_ASSERT(child_source.id() == *it);
tag.removeSource(*it);
block.deleteSource(*it);
}
CPPUNIT_ASSERT(tag.sourceCount() == 0);
}
void TestTag::testUnits() {
Tag st = block.createTag("TestTag1", "Tag", {0.0, 2.0, 3.4});
st.references(refs);
std::vector<std::string> valid_units = {"mV", "cm", "m^2"};
std::vector<std::string> invalid_units = {"mV", "haha", "qm^2"};
std::vector<std::string> insane_units = {"muV ", " muS"};
CPPUNIT_ASSERT_NO_THROW(st.units(valid_units));
CPPUNIT_ASSERT(st.units().size() == valid_units.size());
std::vector<std::string> retrieved_units = st.units();
for(size_t i = 0; i < retrieved_units.size(); i++){
CPPUNIT_ASSERT(retrieved_units[i] == valid_units[i]);
}
st.units(none);
CPPUNIT_ASSERT(st.units().size() == 0);
CPPUNIT_ASSERT_THROW(st.units(invalid_units), nix::InvalidUnit);
CPPUNIT_ASSERT(st.units().size() == 0);
for (auto it = refs.begin(); it != refs.end(); it++) {
block.deleteDataArray((*it).id());
}
st.units(insane_units);
retrieved_units = st.units();
CPPUNIT_ASSERT(retrieved_units.size() == 2);
CPPUNIT_ASSERT(retrieved_units[0] == "uV");
CPPUNIT_ASSERT(retrieved_units[1] == "uS");
block.deleteTag(st.id());
}
void TestTag::testReferences() {
CPPUNIT_ASSERT(tag.referenceCount() == 0);
for (size_t i = 0; i < refs.size(); ++i) {
CPPUNIT_ASSERT(!tag.hasReference(refs[i]));
CPPUNIT_ASSERT_NO_THROW(tag.addReference(refs[i]));
CPPUNIT_ASSERT(tag.hasReference(refs[i]));
}
CPPUNIT_ASSERT(tag.referenceCount() == refs.size());
for (size_t i = 0; i < refs.size(); ++i) {
CPPUNIT_ASSERT_NO_THROW(tag.removeReference(refs[i]));
}
CPPUNIT_ASSERT(tag.referenceCount() == 0);
DataArray a;
CPPUNIT_ASSERT_THROW(tag.hasReference(a), std::runtime_error);
CPPUNIT_ASSERT_THROW(tag.addReference(a), std::runtime_error);
CPPUNIT_ASSERT_THROW(tag.removeReference(a), std::runtime_error);
}
void TestTag::testDataAccess() {
double samplingInterval = 1.0;
vector<double> ticks {1.2, 2.3, 3.4, 4.5, 6.7};
string unit = "ms";
SampledDimension sampledDim;
RangeDimension rangeDim;
SetDimension setDim;
vector<double> position {0.0, 2.0, 3.4};
vector<double> extent {0.0, 6.0, 2.3};
vector<string> units {"none", "ms", "ms"};
DataArray data_array = block.createDataArray("dimensionTest",
"test",
DataType::Double,
NDSize({0, 0, 0}));
vector<DataArray> reference;
reference.push_back(data_array);
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type data(boost::extents[2][10][5]);
int value;
for(index i = 0; i != 2; ++i) {
value = 0;
for(index j = 0; j != 10; ++j) {
for(index k = 0; k != 5; ++k) {
data[i][j][k] = value++;
}
}
}
data_array.setData(data);
setDim = data_array.appendSetDimension();
std::vector<std::string> labels = {"label_a", "label_b"};
setDim.labels(labels);
sampledDim = data_array.appendSampledDimension(samplingInterval);
sampledDim.unit(unit);
rangeDim = data_array.appendRangeDimension(ticks);
rangeDim.unit(unit);
Tag position_tag = block.createTag("position tag", "event", position);
position_tag.references(reference);
position_tag.units(units);
Tag segment_tag = block.createTag("region tag", "segment", position);
segment_tag.references(reference);
segment_tag.extent(extent);
segment_tag.units(units);
DataView retrieved_data = position_tag.retrieveData(0);
NDSize data_size = retrieved_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 1 && data_size[2] == 1);
retrieved_data = segment_tag.retrieveData( 0);
data_size = retrieved_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 6 && data_size[2] == 2);
block.deleteTag(position_tag);
block.deleteTag(segment_tag);
}
void TestTag::testOperators() {
CPPUNIT_ASSERT(tag_null == false);
CPPUNIT_ASSERT(tag_null == none);
CPPUNIT_ASSERT(tag != false);
CPPUNIT_ASSERT(tag != none);
CPPUNIT_ASSERT(tag == tag);
CPPUNIT_ASSERT(tag != tag_other);
tag_other = tag;
CPPUNIT_ASSERT(tag == tag_other);
tag_other = none;
CPPUNIT_ASSERT(tag_null == false);
CPPUNIT_ASSERT(tag_null == none);
}
void TestTag::testCreatedAt() {
CPPUNIT_ASSERT(tag.createdAt() >= startup_time);
time_t past_time = time(NULL) - 10000000;
tag.forceCreatedAt(past_time);
CPPUNIT_ASSERT(tag.createdAt() == past_time);
}
void TestTag::testUpdatedAt() {
CPPUNIT_ASSERT(tag.updatedAt() >= startup_time);
}
<|endoftext|> |
<commit_before>// Copyright Hugh Perkins 2016
// 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 "InstructionDumper.h"
#include "type_dumper.h"
#include "GlobalNames.h"
#include "LocalNames.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
#include <iostream>
#include <memory>
#include "gtest/gtest.h"
using namespace std;
using namespace cocl;
using namespace llvm;
namespace {
class StandaloneBlock{
public:
StandaloneBlock() {
M.reset(new Module("mymodule", context));
F = cast<Function>(M->getOrInsertFunction(
"mykernel",
Type::getVoidTy(context),
NULL
));
F->setCallingConv(CallingConv::C);
F->dump();
block = BasicBlock::Create(context, "entry", F);
block->dump();
}
virtual ~StandaloneBlock() {
}
LLVMContext context;
unique_ptr<Module> M;
Function *F;
BasicBlock *block;
// unique_ptrIRBuilder builder;
};
class InstructionDumperWrapper {
public:
InstructionDumperWrapper() {
typeDumper.reset(new TypeDumper(&globalNames));
instructionDumper.reset(new InstructionDumper(&globalNames, &localNames, typeDumper.get(), &functionNamesMap,
&allocaDeclarations, &variablesToDeclare, &sharedVariablesToDeclare, &shimFunctionsNeeded,
&neededFunctions,
&globalExpressionByValue, &localExpressionByValue));
}
virtual ~InstructionDumperWrapper() {
}
void runRhsGeneration(Instruction *inst) {
instructionDumper->runRhsGeneration(inst, &extraInstructions, dumpedFunctions, returnTypeByFunction);
}
string getExpr(Instruction *inst) {
return instructionDumper->localExpressionByValue->at(inst);
}
GlobalNames globalNames;
LocalNames localNames;
unique_ptr<TypeDumper> typeDumper;
FunctionNamesMap functionNamesMap;
set<Function *> dumpedFunctions;
map<Function *, Type*> returnTypeByFunction;
std::vector<AllocaInfo> allocaDeclarations;
std::set<llvm::Value *> variablesToDeclare;
std::set<llvm::Value *> sharedVariablesToDeclare;
std::set<std::string> shimFunctionsNeeded;
std::set<llvm::Function *> neededFunctions;
std::map<llvm::Value *, std::string> globalExpressionByValue;
std::map<llvm::Value *, std::string> localExpressionByValue;
vector<string> extraInstructions;
unique_ptr<InstructionDumper> instructionDumper;
};
// Lets think about how instructiondumper should behave for various inputs:
//
// we give it an add, for two declared values, it should output eg 'v1 + v2'
TEST(test_instructiondumper, add_two_declared_variables) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
// we should create allocas really, and load those. I guess?
AllocaInst *a = builder.CreateAlloca(IntegerType::get(context, 32));
AllocaInst *b = builder.CreateAlloca(IntegerType::get(context, 32));
LoadInst *aLoad = builder.CreateLoad(a);
LoadInst *bLoad = builder.CreateLoad(b);
InstructionDumperWrapper wrapper;
// since they are declared, we expect to find them in localnames:
wrapper.localNames.getOrCreateName(aLoad, "v_a");
wrapper.localNames.getOrCreateName(bLoad, "v_b");
// Instruction *add = BinaryOperator::Create(Instruction::FAdd, aLoad, bLoad);
Instruction *add = cast<Instruction>(builder.CreateAdd(aLoad, bLoad));
wrapper.runRhsGeneration(add);
string expr = wrapper.getExpr(add);
cout << "expr " << expr << endl;
ASSERT_EQ("v_a + v_b", expr);
// if we check local names, we should NOT find the add, since we havent declared it
ASSERT_FALSE(wrapper.localNames.hasValue(add));
// but we should find an expression for it:
/// oh ... we already tested this :-)
// we should not find a requirement to declare the variable
ASSERT_EQ(0u, wrapper.variablesToDeclare.size());
// ... and no allocas
ASSERT_EQ(0u, wrapper.allocaDeclarations.size());
}
TEST(test_instructiondumper, store) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
// create an alloca,and store into that?
AllocaInst *a = builder.CreateAlloca(IntegerType::get(context, 32));
AllocaInst *b = builder.CreateAlloca(IntegerType::get(context, 32));
LoadInst *aLoad = builder.CreateLoad(a);
InstructionDumperWrapper wrapper;
// since they are declared, we expect to find them in localnames:
wrapper.localNames.getOrCreateName(aLoad, "v_a");
wrapper.localNames.getOrCreateName(b, "v_b");
StoreInst *bStore = builder.CreateStore(aLoad, b);
wrapper.runRhsGeneration(bStore);
ASSERT_EQ(0u, wrapper.instructionDumper->localExpressionByValue->size());
cout << "variablesToDeclare.size() " << wrapper.variablesToDeclare.size() << endl;
cout << "additionalLines.size() " << wrapper.extraInstructions.size() << endl;
cout << "additionalline [" << wrapper.extraInstructions[0] << "]" << endl;
ASSERT_EQ("v_b[0] = v_a", wrapper.extraInstructions[0]);
// if we check local names, we should NOT find the add, since we havent declared it
// ASSERT_FALSE(wrapper.localNames.hasValue(add));
// but we should find an expression for it:
/// oh ... we already tested this :-)
// we should not find a requirement to declare the variable
// ASSERT_EQ(0u, wrapper.variablesToDeclare.size());
// ... and no allocas
// ASSERT_EQ(0u, wrapper.allocaDeclarations.size());
}
TEST(test_instructiondumper, callsomething) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
Module *M = myblock.M.get();
AllocaInst *charArray = builder.CreateAlloca(IntegerType::get(context, 8));
cout << "charArray:" << endl;
charArray->dump();
cout << endl;
Function *childF = cast<Function>(M->getOrInsertFunction(
"mychildfunc",
PointerType::get(IntegerType::get(context, 8), 0),
PointerType::get(IntegerType::get(context, 8), 0),
NULL));
cout << "childF:" << endl;
childF->dump();
cout << endl;
Value *args[] = {charArray};
CallInst *call = builder.CreateCall(childF, ArrayRef<Value *>(args));
cout << "call:" << endl;
call->dump();
cout << endl;
InstructionDumperWrapper wrapper;
InstructionDumper *instructionDumper = wrapper.instructionDumper.get();
wrapper.localNames.getOrCreateName(charArray, "myCharArray");
ASSERT_EQ(0u, instructionDumper->localExpressionByValue->size());
wrapper.runRhsGeneration(call);
ASSERT_TRUE(instructionDumper->needDependencies);
ASSERT_EQ(1u, instructionDumper->neededFunctions->size());
(*instructionDumper->neededFunctions->begin())->dump();
cout << endl;
ASSERT_EQ(childF, (*instructionDumper->neededFunctions->begin()));
ASSERT_EQ(0u, instructionDumper->generatedCl.size());
ASSERT_EQ(0u, instructionDumper->variablesToDeclare->size());
ASSERT_EQ(0u, instructionDumper->globalExpressionByValue->size());
ASSERT_EQ(0u, instructionDumper->localExpressionByValue->size());
wrapper.dumpedFunctions.insert(childF);
wrapper.returnTypeByFunction[childF] = PointerType::get(IntegerType::get(context, 8), 1);
wrapper.runRhsGeneration(call);
ASSERT_FALSE(instructionDumper->needDependencies);
ASSERT_EQ(1u, instructionDumper->neededFunctions->size());
// (*instructionDumper->neededFunctions->begin())->dump();
// cout << endl;
// ASSERT_EQ(childF, (*instructionDumper->neededFunctions->begin()));
ASSERT_EQ(0u, instructionDumper->generatedCl.size());
ASSERT_EQ(0u, instructionDumper->variablesToDeclare->size());
ASSERT_EQ(0u, instructionDumper->globalExpressionByValue->size());
ASSERT_EQ(1u, instructionDumper->localExpressionByValue->size());
auto it = instructionDumper->localExpressionByValue->begin();
cout << "localexpr name=[" << it->second << "]" << endl;
cout << "local expr value=" << endl;
it->first->dump();
cout << endl;
cout << wrapper.getExpr(call) << endl;
ASSERT_EQ("mychildfunc(myCharArray)", it->second);
ASSERT_EQ(call, it->first);
}
TEST(test_instructiondumper, basic) {
LLVMContext context;
unique_ptr<Module>M(new Module("module", context));
Value *a = ConstantInt::getSigned(IntegerType::get(context, 32), 123);
Value *b = ConstantInt::getSigned(IntegerType::get(context, 32), 47);
Instruction *add = BinaryOperator::Create(Instruction::FAdd, a, b);
GlobalNames globalNames;
LocalNames localNames;
TypeDumper typeDumper(&globalNames);
FunctionNamesMap functionNamesMap;
std::vector<AllocaInfo> allocaDeclarations;
std::set<llvm::Value *> variablesToDeclare;
std::set<llvm::Value *> sharedVariablesToDeclare;
std::set<std::string> shimFunctionsNeeded; // for __shfldown_3 etc, that we provide as opencl directly
std::set<llvm::Function *> neededFunctions;
std::map<llvm::Value *, std::string> globalExpressionByValue;
std::map<llvm::Value *, std::string> localExpressionByValue;
InstructionDumper instructionDumper(&globalNames, &localNames, &typeDumper, &functionNamesMap,
&allocaDeclarations, &variablesToDeclare, &sharedVariablesToDeclare, &shimFunctionsNeeded,
&neededFunctions,
&globalExpressionByValue, &localExpressionByValue);
vector<string> extraInstructions;
std::set< llvm::Function *> dumpedFunctions;
map<Function *, Type *>returnTypeByFunction;
instructionDumper.runRhsGeneration(add, &extraInstructions, dumpedFunctions, returnTypeByFunction);
string expr = instructionDumper.localExpressionByValue->operator[](add);
cout << "expr " << expr << endl;
ASSERT_EQ("123 + 47", expr);
instructionDumper.localExpressionByValue->operator[](a) = "v1";
instructionDumper.runRhsGeneration(add, &extraInstructions, dumpedFunctions, returnTypeByFunction);
expr = instructionDumper.localExpressionByValue->operator[](add);
cout << "expr " << expr << endl;
a = new AllocaInst(IntegerType::get(context, 32));
b = new AllocaInst(IntegerType::get(context, 32));
instructionDumper.localExpressionByValue->operator[](a) = "v3";
instructionDumper.localExpressionByValue->operator[](b) = "v4";
add = BinaryOperator::Create(Instruction::Add, a, b);
instructionDumper.runRhsGeneration(add, &extraInstructions, dumpedFunctions, returnTypeByFunction);
expr = instructionDumper.localExpressionByValue->operator[](add);
cout << "expr " << expr << endl;
instructionDumper.localExpressionByValue->operator[](add) = "v5";
// expr = instructionDumper.dumpInstructionRhs(add, &extraInstructions);
instructionDumper.runRhsGeneration(add, &extraInstructions, dumpedFunctions, returnTypeByFunction);
expr = instructionDumper.localExpressionByValue->operator[](add);
cout << "expr " << expr << endl;
}
TEST(test_instructiondumper, globalexpr) {
LLVMContext context;
unique_ptr<Module>M(new Module("module", context));
Value *a = ConstantInt::getSigned(IntegerType::get(context, 32), 123);
Value *b = ConstantInt::getSigned(IntegerType::get(context, 32), 47);
Instruction *add = BinaryOperator::Create(Instruction::FAdd, a, b);
GlobalNames globalNames;
LocalNames localNames;
TypeDumper typeDumper(&globalNames);
FunctionNamesMap functionNamesMap;
std::vector<AllocaInfo> allocaDeclarations;
std::set<llvm::Value *> variablesToDeclare;
std::set<llvm::Value *> sharedVariablesToDeclare;
std::set<std::string> shimFunctionsNeeded; // for __shfldown_3 etc, that we provide as opencl directly
std::set<llvm::Function *> neededFunctions;
std::map<llvm::Value *, std::string> globalExpressionByValue;
std::map<llvm::Value *, std::string> localExpressionByValue;
InstructionDumper instructionDumper(&globalNames, &localNames, &typeDumper, &functionNamesMap,
&allocaDeclarations, &variablesToDeclare, &sharedVariablesToDeclare, &shimFunctionsNeeded,
&neededFunctions,
&globalExpressionByValue, &localExpressionByValue);
vector<string> extraInstructions;
std::set< llvm::Function *> dumpedFunctions;
map<Function *, Type *>returnTypeByFunction;
instructionDumper.runRhsGeneration(add, &extraInstructions, dumpedFunctions, returnTypeByFunction);
string expr = instructionDumper.localExpressionByValue->operator[](add);
cout << "expr " << expr << endl;
}
TEST(test_instructiondumper, alloca) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
InstructionDumperWrapper wrapper;
InstructionDumper *instructionDumper = wrapper.instructionDumper.get();
AllocaInst *aAlloca = builder.CreateAlloca(IntegerType::get(context, 32));
LoadInst *aLoad = builder.CreateLoad(aAlloca);
// we should create allocas really, and load those. I guess?
AllocaInst *bAlloca = builder.CreateAlloca(IntegerType::get(context, 32));
StoreInst *bstore = builder.CreateStore(aLoad, bAlloca);
myblock.block->dump();
wrapper.runRhsGeneration(bAlloca);
string expr = wrapper.getExpr(bAlloca);
// string expr = instructionDumper.localExpressionByValue->operator[](alloca);
cout << "expr " << expr << endl;
ASSERT_EQ("v1", expr);
cout << "allocaDeclarations.size() " << instructionDumper->allocaDeclarations->size() << endl;
AllocaInfo allocaInfo = instructionDumper->allocaDeclarations->operator[](0);
ASSERT_EQ(bAlloca, allocaInfo.alloca);
allocaInfo.refValue->dump();
ASSERT_EQ(aLoad, allocaInfo.refValue);
cout << "allocaInfo->definition [" << allocaInfo.definition << "]" << endl;
ASSERT_EQ("int v1[1]", allocaInfo.definition);
}
}
<commit_msg>purge hardtounderstand test_isntrucitondumper.basic<commit_after>// Copyright Hugh Perkins 2016
// 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 "InstructionDumper.h"
#include "type_dumper.h"
#include "GlobalNames.h"
#include "LocalNames.h"
#include "llvm/IRReader/IRReader.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
#include <iostream>
#include <memory>
#include "gtest/gtest.h"
using namespace std;
using namespace cocl;
using namespace llvm;
namespace {
class StandaloneBlock{
public:
StandaloneBlock() {
M.reset(new Module("mymodule", context));
F = cast<Function>(M->getOrInsertFunction(
"mykernel",
Type::getVoidTy(context),
NULL
));
F->setCallingConv(CallingConv::C);
F->dump();
block = BasicBlock::Create(context, "entry", F);
block->dump();
}
virtual ~StandaloneBlock() {
}
LLVMContext context;
unique_ptr<Module> M;
Function *F;
BasicBlock *block;
// unique_ptrIRBuilder builder;
};
class InstructionDumperWrapper {
public:
InstructionDumperWrapper() {
typeDumper.reset(new TypeDumper(&globalNames));
instructionDumper.reset(new InstructionDumper(&globalNames, &localNames, typeDumper.get(), &functionNamesMap,
&allocaDeclarations, &variablesToDeclare, &sharedVariablesToDeclare, &shimFunctionsNeeded,
&neededFunctions,
&globalExpressionByValue, &localExpressionByValue));
}
virtual ~InstructionDumperWrapper() {
}
void runRhsGeneration(Instruction *inst) {
instructionDumper->runRhsGeneration(inst, &extraInstructions, dumpedFunctions, returnTypeByFunction);
}
string getExpr(Instruction *inst) {
return instructionDumper->localExpressionByValue->at(inst);
}
GlobalNames globalNames;
LocalNames localNames;
unique_ptr<TypeDumper> typeDumper;
FunctionNamesMap functionNamesMap;
set<Function *> dumpedFunctions;
map<Function *, Type*> returnTypeByFunction;
std::vector<AllocaInfo> allocaDeclarations;
std::set<llvm::Value *> variablesToDeclare;
std::set<llvm::Value *> sharedVariablesToDeclare;
std::set<std::string> shimFunctionsNeeded;
std::set<llvm::Function *> neededFunctions;
std::map<llvm::Value *, std::string> globalExpressionByValue;
std::map<llvm::Value *, std::string> localExpressionByValue;
vector<string> extraInstructions;
unique_ptr<InstructionDumper> instructionDumper;
};
// Lets think about how instructiondumper should behave for various inputs:
//
// we give it an add, for two declared values, it should output eg 'v1 + v2'
TEST(test_instructiondumper, add_two_declared_variables) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
// we should create allocas really, and load those. I guess?
AllocaInst *a = builder.CreateAlloca(IntegerType::get(context, 32));
AllocaInst *b = builder.CreateAlloca(IntegerType::get(context, 32));
LoadInst *aLoad = builder.CreateLoad(a);
LoadInst *bLoad = builder.CreateLoad(b);
InstructionDumperWrapper wrapper;
// since they are declared, we expect to find them in localnames:
wrapper.localNames.getOrCreateName(aLoad, "v_a");
wrapper.localNames.getOrCreateName(bLoad, "v_b");
// Instruction *add = BinaryOperator::Create(Instruction::FAdd, aLoad, bLoad);
Instruction *add = cast<Instruction>(builder.CreateAdd(aLoad, bLoad));
wrapper.runRhsGeneration(add);
string expr = wrapper.getExpr(add);
cout << "expr " << expr << endl;
ASSERT_EQ("v_a + v_b", expr);
// if we check local names, we should NOT find the add, since we havent declared it
ASSERT_FALSE(wrapper.localNames.hasValue(add));
// but we should find an expression for it:
/// oh ... we already tested this :-)
// we should not find a requirement to declare the variable
ASSERT_EQ(0u, wrapper.variablesToDeclare.size());
// ... and no allocas
ASSERT_EQ(0u, wrapper.allocaDeclarations.size());
}
TEST(test_instructiondumper, store) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
// create an alloca,and store into that?
AllocaInst *a = builder.CreateAlloca(IntegerType::get(context, 32));
AllocaInst *b = builder.CreateAlloca(IntegerType::get(context, 32));
LoadInst *aLoad = builder.CreateLoad(a);
InstructionDumperWrapper wrapper;
// since they are declared, we expect to find them in localnames:
wrapper.localNames.getOrCreateName(aLoad, "v_a");
wrapper.localNames.getOrCreateName(b, "v_b");
StoreInst *bStore = builder.CreateStore(aLoad, b);
wrapper.runRhsGeneration(bStore);
ASSERT_EQ(0u, wrapper.instructionDumper->localExpressionByValue->size());
cout << "variablesToDeclare.size() " << wrapper.variablesToDeclare.size() << endl;
cout << "additionalLines.size() " << wrapper.extraInstructions.size() << endl;
cout << "additionalline [" << wrapper.extraInstructions[0] << "]" << endl;
ASSERT_EQ("v_b[0] = v_a", wrapper.extraInstructions[0]);
// if we check local names, we should NOT find the add, since we havent declared it
// ASSERT_FALSE(wrapper.localNames.hasValue(add));
// but we should find an expression for it:
/// oh ... we already tested this :-)
// we should not find a requirement to declare the variable
// ASSERT_EQ(0u, wrapper.variablesToDeclare.size());
// ... and no allocas
// ASSERT_EQ(0u, wrapper.allocaDeclarations.size());
}
TEST(test_instructiondumper, callsomething) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
Module *M = myblock.M.get();
AllocaInst *charArray = builder.CreateAlloca(IntegerType::get(context, 8));
cout << "charArray:" << endl;
charArray->dump();
cout << endl;
Function *childF = cast<Function>(M->getOrInsertFunction(
"mychildfunc",
PointerType::get(IntegerType::get(context, 8), 0),
PointerType::get(IntegerType::get(context, 8), 0),
NULL));
cout << "childF:" << endl;
childF->dump();
cout << endl;
Value *args[] = {charArray};
CallInst *call = builder.CreateCall(childF, ArrayRef<Value *>(args));
cout << "call:" << endl;
call->dump();
cout << endl;
InstructionDumperWrapper wrapper;
InstructionDumper *instructionDumper = wrapper.instructionDumper.get();
wrapper.localNames.getOrCreateName(charArray, "myCharArray");
ASSERT_EQ(0u, instructionDumper->localExpressionByValue->size());
wrapper.runRhsGeneration(call);
ASSERT_TRUE(instructionDumper->needDependencies);
ASSERT_EQ(1u, instructionDumper->neededFunctions->size());
(*instructionDumper->neededFunctions->begin())->dump();
cout << endl;
ASSERT_EQ(childF, (*instructionDumper->neededFunctions->begin()));
ASSERT_EQ(0u, instructionDumper->generatedCl.size());
ASSERT_EQ(0u, instructionDumper->variablesToDeclare->size());
ASSERT_EQ(0u, instructionDumper->globalExpressionByValue->size());
ASSERT_EQ(0u, instructionDumper->localExpressionByValue->size());
wrapper.dumpedFunctions.insert(childF);
wrapper.returnTypeByFunction[childF] = PointerType::get(IntegerType::get(context, 8), 1);
wrapper.runRhsGeneration(call);
ASSERT_FALSE(instructionDumper->needDependencies);
ASSERT_EQ(1u, instructionDumper->neededFunctions->size());
// (*instructionDumper->neededFunctions->begin())->dump();
// cout << endl;
// ASSERT_EQ(childF, (*instructionDumper->neededFunctions->begin()));
ASSERT_EQ(0u, instructionDumper->generatedCl.size());
ASSERT_EQ(0u, instructionDumper->variablesToDeclare->size());
ASSERT_EQ(0u, instructionDumper->globalExpressionByValue->size());
ASSERT_EQ(1u, instructionDumper->localExpressionByValue->size());
auto it = instructionDumper->localExpressionByValue->begin();
cout << "localexpr name=[" << it->second << "]" << endl;
cout << "local expr value=" << endl;
it->first->dump();
cout << endl;
cout << wrapper.getExpr(call) << endl;
ASSERT_EQ("mychildfunc(myCharArray)", it->second);
ASSERT_EQ(call, it->first);
}
TEST(test_instructiondumper, globalexpr) {
LLVMContext context;
unique_ptr<Module>M(new Module("module", context));
Value *a = ConstantInt::getSigned(IntegerType::get(context, 32), 123);
Value *b = ConstantInt::getSigned(IntegerType::get(context, 32), 47);
Instruction *add = BinaryOperator::Create(Instruction::FAdd, a, b);
GlobalNames globalNames;
LocalNames localNames;
TypeDumper typeDumper(&globalNames);
FunctionNamesMap functionNamesMap;
std::vector<AllocaInfo> allocaDeclarations;
std::set<llvm::Value *> variablesToDeclare;
std::set<llvm::Value *> sharedVariablesToDeclare;
std::set<std::string> shimFunctionsNeeded; // for __shfldown_3 etc, that we provide as opencl directly
std::set<llvm::Function *> neededFunctions;
std::map<llvm::Value *, std::string> globalExpressionByValue;
std::map<llvm::Value *, std::string> localExpressionByValue;
InstructionDumper instructionDumper(&globalNames, &localNames, &typeDumper, &functionNamesMap,
&allocaDeclarations, &variablesToDeclare, &sharedVariablesToDeclare, &shimFunctionsNeeded,
&neededFunctions,
&globalExpressionByValue, &localExpressionByValue);
vector<string> extraInstructions;
std::set< llvm::Function *> dumpedFunctions;
map<Function *, Type *>returnTypeByFunction;
instructionDumper.runRhsGeneration(add, &extraInstructions, dumpedFunctions, returnTypeByFunction);
string expr = instructionDumper.localExpressionByValue->operator[](add);
cout << "expr " << expr << endl;
}
TEST(test_instructiondumper, alloca) {
StandaloneBlock myblock;
IRBuilder<> builder(myblock.block);
LLVMContext &context = myblock.context;
InstructionDumperWrapper wrapper;
InstructionDumper *instructionDumper = wrapper.instructionDumper.get();
AllocaInst *aAlloca = builder.CreateAlloca(IntegerType::get(context, 32));
LoadInst *aLoad = builder.CreateLoad(aAlloca);
// we should create allocas really, and load those. I guess?
AllocaInst *bAlloca = builder.CreateAlloca(IntegerType::get(context, 32));
StoreInst *bstore = builder.CreateStore(aLoad, bAlloca);
myblock.block->dump();
wrapper.runRhsGeneration(bAlloca);
string expr = wrapper.getExpr(bAlloca);
// string expr = instructionDumper.localExpressionByValue->operator[](alloca);
cout << "expr " << expr << endl;
ASSERT_EQ("v1", expr);
cout << "allocaDeclarations.size() " << instructionDumper->allocaDeclarations->size() << endl;
AllocaInfo allocaInfo = instructionDumper->allocaDeclarations->operator[](0);
ASSERT_EQ(bAlloca, allocaInfo.alloca);
allocaInfo.refValue->dump();
ASSERT_EQ(aLoad, allocaInfo.refValue);
cout << "allocaInfo->definition [" << allocaInfo.definition << "]" << endl;
ASSERT_EQ("int v1[1]", allocaInfo.definition);
}
}
<|endoftext|> |
<commit_before>//===--------------------------------------------------------------------------------*- C++ -*-===//
// _ _
// | | | |
// __ _| |_ ___| | __ _ _ __ __ _
// / _` | __/ __| |/ _` | '_ \ / _` |
// | (_| | || (__| | (_| | | | | (_| |
// \__, |\__\___|_|\__,_|_| |_|\__, | - GridTools Clang DSL
// __/ | __/ |
// |___/ |___/
//
//
// This file is distributed under the MIT License (MIT).
// See LICENSE.txt for details.
//
//===------------------------------------------------------------------------------------------===//
#include "gridtools/clang_dsl.hpp"
using namespace gridtools::clang;
stencil lap {
storage in, out;
var tmp;
Do {
vertical_region(k_start, k_end) {
tmp = in[j - 2] + in[j + 2] + in[i - 2] + in[i + 2];
out = tmp[i + 1] + tmp[j + 1] + tmp[i - 1] + tmp[i - 1];
}
}
};
<commit_msg>Fix lap stencil (#166)<commit_after>//===--------------------------------------------------------------------------------*- C++ -*-===//
// _ _
// | | | |
// __ _| |_ ___| | __ _ _ __ __ _
// / _` | __/ __| |/ _` | '_ \ / _` |
// | (_| | || (__| | (_| | | | | (_| |
// \__, |\__\___|_|\__,_|_| |_|\__, | - GridTools Clang DSL
// __/ | __/ |
// |___/ |___/
//
//
// This file is distributed under the MIT License (MIT).
// See LICENSE.txt for details.
//
//===------------------------------------------------------------------------------------------===//
#include "gridtools/clang_dsl.hpp"
using namespace gridtools::clang;
stencil lap {
storage in, out;
var tmp;
Do {
vertical_region(k_start, k_end) {
tmp = in[j - 2] + in[j + 2] + in[i - 2] + in[i + 2];
out = tmp[j - 1] + tmp[j + 1] + tmp[i - 1] + tmp[i + 1];
}
}
};
<|endoftext|> |
<commit_before>/******************************************************************************
* Copyright (c) 2014, Howard Butler (howard@hobu.co)
*
* 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 Hobu, Inc. or Flaxen Geo Consulting 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 <boost/test/unit_test.hpp>
#include <boost/cstdint.hpp>
#include <pdal/drivers/faux/Reader.hpp>
#include <pdal/filters/Reprojection.hpp>
#include <pdal/filters/Ferry.hpp>
#include <pdal/drivers/las/Reader.hpp>
#include <pdal/FileUtils.hpp>
#include <pdal/PointBuffer.hpp>
#include "Support.hpp"
#include "../StageTester.hpp"
using namespace pdal;
BOOST_AUTO_TEST_SUITE(FerryFilterTest)
BOOST_AUTO_TEST_CASE(test_ferry_polygon)
{
using namespace pdal;
Options ops1;
ops1.add("filename", Support::datapath("las/1.2-with-color.las"));
drivers::las::Reader reader(ops1);
Options options;
Option x("dimension", "X", "");
Option toX("to","X", "");
Options xO;
xO.add(toX);
x.setOptions(xO);
options.add(x);
Option y("dimension", "Y", "");
Option toY("to","Y", "");
Options yO;
yO.add(toY);
y.setOptions(yO);
options.add(y);
filters::Ferry ferry(options);
ferry.setInput(&reader);
PointContext ctx;
ferry.prepare(ctx);
PointBufferSet pbSet = ferry.execute(ctx);
BOOST_CHECK_EQUAL(pbSet.size(), 1);
PointBufferPtr buffer = *pbSet.begin();
BOOST_CHECK_EQUAL(buffer->size(), 47u);
}
BOOST_AUTO_TEST_SUITE_END()
<commit_msg>make tests pass<commit_after>/******************************************************************************
* Copyright (c) 2014, Howard Butler (howard@hobu.co)
*
* 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 Hobu, Inc. or Flaxen Geo Consulting 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 <boost/test/unit_test.hpp>
#include <boost/cstdint.hpp>
#include <pdal/drivers/faux/Reader.hpp>
#include <pdal/filters/Reprojection.hpp>
#include <pdal/filters/Ferry.hpp>
#include <pdal/drivers/las/Reader.hpp>
#include <pdal/FileUtils.hpp>
#include <pdal/PointBuffer.hpp>
#include "Support.hpp"
#include "../StageTester.hpp"
using namespace pdal;
BOOST_AUTO_TEST_SUITE(FerryFilterTest)
BOOST_AUTO_TEST_CASE(test_ferry_polygon)
{
using namespace pdal;
Options ops1;
ops1.add("filename", Support::datapath("las/1.2-with-color.las"));
drivers::las::Reader reader(ops1);
Options options;
Option x("dimension", "X", "");
Option toX("to","X", "");
Options xO;
xO.add(toX);
x.setOptions(xO);
options.add(x);
Option y("dimension", "Y", "");
Option toY("to","Y", "");
Options yO;
yO.add(toY);
y.setOptions(yO);
options.add(y);
filters::Ferry ferry(options);
ferry.setInput(&reader);
PointContext ctx;
ferry.prepare(ctx);
PointBufferSet pbSet = ferry.execute(ctx);
BOOST_CHECK_EQUAL(pbSet.size(), 1);
PointBufferPtr buffer = *pbSet.begin();
BOOST_CHECK_EQUAL(buffer->size(), 1065u);
}
BOOST_AUTO_TEST_SUITE_END()
<|endoftext|> |
<commit_before>// symbiosis: A hacky and lightweight compiler framework
//
#include "symbiosis.hpp"
#include <sys/stat.h>
#include <iostream>
#include <vector>
#include "cpu_defines.hpp"
using namespace std;
namespace symbiosis {
void dump(uchar* start, size_t s) {
for (size_t i = 0; i < s; i++) {
printf("%02x ", start[i]);
}
}
bool intel = false;
bool arm = false;
bool pic_mode = false;
bool figure_out_cpu_architecture() {
uchar *start = (uchar *)figure_out_cpu_architecture;
uchar *p = start;
bool found = false;
int i = 0;
uchar c0,c1,c2;
do {
c0 = *p; c1 = *(p+1); c2 = *(p+2);
if ((c0 >= I_REX_W_48 && c0 <= I_REX_WRXB_4f) &&
(c1 == I_LEA_8d || c1 == I_MOV_r64_r64_8b) &&
((c2 & I_MOD_RM_BITS_07) == I_BP_MODRM_RIP_DISP32_05)) {
intel = true; pic_mode = true; return true;
}
if (c0 == I_MOV_r8_rm8_8a &&
(c1 & I_MOD_RM_BITS_07) == I_BP_MODRM_RIP_DISP32_05) {
intel = true; pic_mode = false; return true;
}
p++;
} while (!found && ++i < 20);
//if (p[0] == I_REX_B_41 || (p[0] == I_PUSH_BP_55 &&
// p[1] == I_REX_W_48)) { cout << "Intel" << endl;
// intel = true; return true; }
//if (p[3] == A_PUSH_e9 || p[3] == A_LDR_e5) { cout << "ARM" << endl;
// arm = true; return true; }
cout << "Unknown CPU id: "; dump(start, 20);
return false;
}
//bool __am_i_pic() {
// uchar *p = (uchar *)__am_i_pic;
// printf("am i pic?\n");
// int i = 0;
// uchar c = 0;
// do {
// c = p[i++];
// } while (i < 10 && c != I_REX_W_48 && c != I_LEA_bf);
// return c == I_REX_W_48;
//}
class exception : public std::exception {
const char *what_;
public:
exception(const char *w) : what_(w) { }
virtual ~exception() throw() { }
virtual const char* what() const throw() { return what_; }
};
char *command_file = 0;;
#define M10(v, b) #v #b
#define M3(a,b) M10(a+1000, v),M10(a+2000, v), M10(a+3000, v),M10(a+4000, v)
#define M2(a,b) M3(a+100, v) , M3(a+200, v) , M3(a+300, v) , M3(a+400, v)
#define M1(a,b) M2(a+10, v) , M2(a+20, v) , M2(a+30, v) , M2(a+40, v)
#define M(v) M1(1, v), M1(2, v), M1(3, v), M1(4, v), M1(5, v)
uchar *virtual_code_start = 0;
uchar *virtual_code_end = 0;
uchar *out_code_start = 0;
uchar *out_code_end = 0;
uchar *out_c = 0;
uchar *out_c0 = 0;
uchar *virtual_strings_start = 0;
uchar *virtual_strings_end = 0;
uchar *out_strings_start = 0;
uchar *out_strings_end = 0;
uchar *out_s = 0;
#define STRINGS_START "STRINGS_START"
#define STRINGS_END "STRINGS_END"
unsigned int _i32 = 0;
const char* id::i32() {
if (virtual_adr) { _i32 = (size_t)virtual_adr;
//printf("virtual_adr: %x\n", _i32);
return (const char*)&_i32; }
if (type == T_UINT) return (const char*)&d.ui;
return (const char*)&d.i;
}
const char* id::i64() {
if (type == T_ULONG) return (const char*)&d.ul;
return (const char*)&d.l;
}
vector<const char*> type_str = { "0:???", "int", "uint", "long", "ulong",
"charp", "float", "double"};
void id::describe() {
if (type > type_str.size() - 1) {
cout << "<id:" << type << ">";
} else {
cout << type_str[type];
}
cout << endl;
}
id id::operator()(id i) { add_parameter(i); return i; }
id_new::id_new(const char *p) : id(p) {
virtual_adr = virtual_strings_start + (out_s - out_strings_start);
virtual_size = strlen(p);
if (out_s + virtual_size + 1 > out_strings_end)
throw exception("Strings: Out of memory");
memcpy(out_s, p, virtual_size + 1);
out_s += virtual_size + 1;
};
const char *reserved_strings[] = { STRINGS_START,
M(ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc)
STRINGS_END };
#define FIND(v) { \
pos = 0; \
bool found = false; \
for (size_t i = 0; !found && i < (input_size - v##_s); i++) { \
for (int j = 0; j < v##_s; j++) { \
if (buf[i + j] != v[j]) break; \
if (j == v##_s - 1) { \
pos = i; \
found = true; \
} \
} \
} }
uchar buf[200 * 1024];
FILE* input = 0;
size_t input_size = 0;
void find_space(uchar* start, size_t start_s,
uchar* end, size_t end_s, uchar **out_start, uchar **out_end) {
if (!input) {
input = fopen(command_file, "r");
if (!input) { fprintf(stderr, "Failed\n"); }
input_size = fread(buf, 1, sizeof(buf), input);
}
size_t pos = 0, s = 0, e = 0;
FIND(start); s = pos;
FIND(end); e = pos;
*out_start = &buf[s];
*out_end = &buf[e];
//printf("s: %zd, e:%zd, l:%zd\n", s, e, e - s);
}
void write() {
FILE *out = fopen("a.out", "w");
fwrite(buf, 1, input_size, out);
fclose(out);
printf("Writing a.out\n");
chmod("a.out", 0777);
}
int __offset = 0;
const char* call_offset(uchar *out_current_code_pos, void *__virt_f) {
auto virt_f = (uchar*)__virt_f;
ssize_t out_start_distance = out_current_code_pos - out_code_start;
ssize_t virt_dist_from_code_start = virt_f - virtual_code_start;
__offset = virt_dist_from_code_start - out_start_distance - 5;
cout << "__virt_f: " << __virt_f << endl;
//cout << "call_offset: " << __offset << " virt: " << virt_dist_from_code_start << " out: " << out_start_distance << endl;
return (const char*)&__offset;
}
const char* rip_relative_offset(uchar *out_current_code_pos,
uchar *virt_adr) {
ssize_t distance = out_current_code_pos - out_code_start;
ssize_t virt_dist_from_code_start = (size_t)virt_adr -
(size_t)virtual_code_start - distance;
__offset = virt_dist_from_code_start - 7;
printf("virt_dist_from_code_start: %zx %x, string ofs: %zd\n",
(size_t)virt_adr, __offset,
(size_t)(out_s - out_strings_start));
return (const char*)&__offset;
}
int parameter_count = 0;
const char *register_parameters_intel_32[] = {
"\xbf", /*edi*/ "\xbe", /*esi*/ "\xba" /*edx*/ };
const char *register_rip_relative_parameters_intel_64[] = {
"\x48\x8d\x3d", /* rdi */ "\x48\x8d\x35", /* rsi */
"\x48\x8d\x15" /* rdx */ };
const char *register_parameters_arm_32[] = {
"\xe5\x9f\x00", /*r0*/ "\xe5\x9f\x10", /*r1*/ "\xe5\x9f\x20" /*r2*/ };
const char *register_parameters_intel_64[] = {
"\x48\xbf" /*rdi*/, "\x48\xbe" ,/*rsi*/ "\x48\xba" /*rdx*/ };
constexpr int parameters_max = 3;
void emit(const char* _s, size_t _l = 0) {
size_t l = _l > 0 ? _l : strlen(_s);
uchar *s = (uchar *)_s; uchar *e = s + l;
if (out_c + l > out_code_end) throw exception("Code: Out of memory");
for (uchar * b = s; b < e; b++, out_c++) {
*out_c = *b;
}
dump(s, l);
}
void emit(uchar uc) { emit((const char *)&uc, sizeof(uc)); }
id add_parameter(id p) {
if (parameter_count >= parameters_max) {
fprintf(stderr, "Too many parameters!\n");
return p;
}
//cout << "parameter_count: " << parameter_count << " "; p.describe();
if (p.is_charp()) {
if (!pic_mode) {
emit(register_parameters_intel_32[parameter_count]);
emit(p.i32(), 4);
} else {
uchar *out_current_code_pos = out_c;
emit(register_rip_relative_parameters_intel_64[parameter_count]);
emit(rip_relative_offset(out_current_code_pos, p.virtual_adr), 4);
}
} else if (p.is_integer()) {
//cout << "is_integer" << endl;
if (intel) {
//cout << "intel" << endl;
if (p.is_32()) {
//cout << "is_32" << endl;
emit(register_parameters_intel_32[parameter_count]);
emit(p.i32(), 4);
} else if (p.is_64()) {
//cout << "is_64" << endl;
emit(register_parameters_intel_64[parameter_count]);
emit(p.i64(), 8);
}
} else if (arm) {
emit(register_parameters_intel_32[parameter_count]);
}
}
++parameter_count;
return p;
}
void jmp(void *f) {
uchar *out_current_code_pos = out_c;
emit(I_JMP_e9);
emit(call_offset(out_current_code_pos, f), 4);
}
void __call(void *f) {
uchar *out_current_code_pos = out_c;
emit(I_CALL_e8);
emit(call_offset(out_current_code_pos, f), 4);
parameter_count = 0;
}
void __vararg_call(void *f) {
emit(I_XOR_30); emit(0xc0); // xor al,al
call(f);
}
size_t __p = 0;
void f(const char *s, int i) {
__p += (size_t)s + i;
}
void init(char *c, uchar *start, size_t ss, uchar *end, size_t es) {
if (!figure_out_cpu_architecture()) exit(1);
cout << "intel: " << intel << ", arm: " << arm <<
", pic_mode: " << pic_mode << endl;
///am_i_pic = __am_i_pic();
//printf("am_i_pic: %d\n", am_i_pic);
command_file = c;
virtual_code_start = start;
virtual_code_end = end;
find_space(start, ss, end, es, &out_code_start,
&out_code_end);
//printf("code: %zu\n", out_code_end - out_code_start);
virtual_strings_start = (uchar *)STRINGS_START;
virtual_strings_end = (uchar *)STRINGS_END;
out_c = out_code_start;
find_space(virtual_strings_start, strlen(STRINGS_START),
virtual_strings_end, strlen(STRINGS_END),
&out_strings_start, &out_strings_end);
//printf("strings: %zu\n", out_strings_end - out_strings_start);
out_s = out_strings_start;
}
void finish() {
jmp(virtual_code_end);
write();
}
}
<commit_msg>Can detect intel + pic on OS X.<commit_after>// symbiosis: A hacky and lightweight compiler framework
//
#include "symbiosis.hpp"
#include <sys/stat.h>
#include <iostream>
#include <vector>
#include "cpu_defines.hpp"
using namespace std;
namespace symbiosis {
void dump(uchar* start, size_t s) {
for (size_t i = 0; i < s; i++) {
printf("%02x ", start[i]);
}
}
bool intel = false;
bool arm = false;
bool pic_mode = false;
bool figure_out_cpu_architecture() {
uchar *start = (uchar *)figure_out_cpu_architecture;
uchar *p = start;
uchar c0,c1,c2;
int i = 0; p = start;
do {
c0 = *p; c1 = *(p+1); c2 = *(p+2);
if ((c0 >= I_REX_W_48 && c0 <= I_REX_WRXB_4f) &&
(c1 == I_LEA_8d || c1 == I_MOV_r64_r64_8b) &&
((c2 & I_MOD_RM_BITS_07) == I_BP_MODRM_RIP_DISP32_05)) {
intel = true; pic_mode = true; return true;
}
p++;
} while (++i < 20);
i = 0; p = start;
do {
if (c0 == I_MOV_r8_rm8_8a &&
(c1 & I_MOD_RM_BITS_07) == I_BP_MODRM_RIP_DISP32_05) {
intel = true; pic_mode = false; return true;
}
p++;
} while (++i < 20);
//if (p[0] == I_REX_B_41 || (p[0] == I_PUSH_BP_55 &&
// p[1] == I_REX_W_48)) { cout << "Intel" << endl;
// intel = true; return true; }
//if (p[3] == A_PUSH_e9 || p[3] == A_LDR_e5) { cout << "ARM" << endl;
// arm = true; return true; }
cout << "Unknown CPU id: "; dump(start, 20);
return false;
}
//bool __am_i_pic() {
// uchar *p = (uchar *)__am_i_pic;
// printf("am i pic?\n");
// int i = 0;
// uchar c = 0;
// do {
// c = p[i++];
// } while (i < 10 && c != I_REX_W_48 && c != I_LEA_bf);
// return c == I_REX_W_48;
//}
class exception : public std::exception {
const char *what_;
public:
exception(const char *w) : what_(w) { }
virtual ~exception() throw() { }
virtual const char* what() const throw() { return what_; }
};
char *command_file = 0;;
#define M10(v, b) #v #b
#define M3(a,b) M10(a+1000, v),M10(a+2000, v), M10(a+3000, v),M10(a+4000, v)
#define M2(a,b) M3(a+100, v) , M3(a+200, v) , M3(a+300, v) , M3(a+400, v)
#define M1(a,b) M2(a+10, v) , M2(a+20, v) , M2(a+30, v) , M2(a+40, v)
#define M(v) M1(1, v), M1(2, v), M1(3, v), M1(4, v), M1(5, v)
uchar *virtual_code_start = 0;
uchar *virtual_code_end = 0;
uchar *out_code_start = 0;
uchar *out_code_end = 0;
uchar *out_c = 0;
uchar *out_c0 = 0;
uchar *virtual_strings_start = 0;
uchar *virtual_strings_end = 0;
uchar *out_strings_start = 0;
uchar *out_strings_end = 0;
uchar *out_s = 0;
#define STRINGS_START "STRINGS_START"
#define STRINGS_END "STRINGS_END"
unsigned int _i32 = 0;
const char* id::i32() {
if (virtual_adr) { _i32 = (size_t)virtual_adr;
//printf("virtual_adr: %x\n", _i32);
return (const char*)&_i32; }
if (type == T_UINT) return (const char*)&d.ui;
return (const char*)&d.i;
}
const char* id::i64() {
if (type == T_ULONG) return (const char*)&d.ul;
return (const char*)&d.l;
}
vector<const char*> type_str = { "0:???", "int", "uint", "long", "ulong",
"charp", "float", "double"};
void id::describe() {
if (type > type_str.size() - 1) {
cout << "<id:" << type << ">";
} else {
cout << type_str[type];
}
cout << endl;
}
id id::operator()(id i) { add_parameter(i); return i; }
id_new::id_new(const char *p) : id(p) {
virtual_adr = virtual_strings_start + (out_s - out_strings_start);
virtual_size = strlen(p);
if (out_s + virtual_size + 1 > out_strings_end)
throw exception("Strings: Out of memory");
memcpy(out_s, p, virtual_size + 1);
out_s += virtual_size + 1;
};
const char *reserved_strings[] = { STRINGS_START,
M(ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc)
STRINGS_END };
#define FIND(v) { \
pos = 0; \
bool found = false; \
for (size_t i = 0; !found && i < (input_size - v##_s); i++) { \
for (int j = 0; j < v##_s; j++) { \
if (buf[i + j] != v[j]) break; \
if (j == v##_s - 1) { \
pos = i; \
found = true; \
} \
} \
} }
uchar buf[200 * 1024];
FILE* input = 0;
size_t input_size = 0;
void find_space(uchar* start, size_t start_s,
uchar* end, size_t end_s, uchar **out_start, uchar **out_end) {
if (!input) {
input = fopen(command_file, "r");
if (!input) { fprintf(stderr, "Failed\n"); }
input_size = fread(buf, 1, sizeof(buf), input);
}
size_t pos = 0, s = 0, e = 0;
FIND(start); s = pos;
FIND(end); e = pos;
*out_start = &buf[s];
*out_end = &buf[e];
//printf("s: %zd, e:%zd, l:%zd\n", s, e, e - s);
}
void write() {
FILE *out = fopen("a.out", "w");
fwrite(buf, 1, input_size, out);
fclose(out);
printf("Writing a.out\n");
chmod("a.out", 0777);
}
int __offset = 0;
const char* call_offset(uchar *out_current_code_pos, void *__virt_f) {
auto virt_f = (uchar*)__virt_f;
ssize_t out_start_distance = out_current_code_pos - out_code_start;
ssize_t virt_dist_from_code_start = virt_f - virtual_code_start;
__offset = virt_dist_from_code_start - out_start_distance - 5;
cout << "__virt_f: " << __virt_f << endl;
//cout << "call_offset: " << __offset << " virt: " << virt_dist_from_code_start << " out: " << out_start_distance << endl;
return (const char*)&__offset;
}
const char* rip_relative_offset(uchar *out_current_code_pos,
uchar *virt_adr) {
ssize_t distance = out_current_code_pos - out_code_start;
ssize_t virt_dist_from_code_start = (size_t)virt_adr -
(size_t)virtual_code_start - distance;
__offset = virt_dist_from_code_start - 7;
printf("virt_dist_from_code_start: %zx %x, string ofs: %zd\n",
(size_t)virt_adr, __offset,
(size_t)(out_s - out_strings_start));
return (const char*)&__offset;
}
int parameter_count = 0;
const char *register_parameters_intel_32[] = {
"\xbf", /*edi*/ "\xbe", /*esi*/ "\xba" /*edx*/ };
const char *register_rip_relative_parameters_intel_64[] = {
"\x48\x8d\x3d", /* rdi */ "\x48\x8d\x35", /* rsi */
"\x48\x8d\x15" /* rdx */ };
const char *register_parameters_arm_32[] = {
"\xe5\x9f\x00", /*r0*/ "\xe5\x9f\x10", /*r1*/ "\xe5\x9f\x20" /*r2*/ };
const char *register_parameters_intel_64[] = {
"\x48\xbf" /*rdi*/, "\x48\xbe" ,/*rsi*/ "\x48\xba" /*rdx*/ };
constexpr int parameters_max = 3;
void emit(const char* _s, size_t _l = 0) {
size_t l = _l > 0 ? _l : strlen(_s);
uchar *s = (uchar *)_s; uchar *e = s + l;
if (out_c + l > out_code_end) throw exception("Code: Out of memory");
for (uchar * b = s; b < e; b++, out_c++) {
*out_c = *b;
}
dump(s, l);
}
void emit(uchar uc) { emit((const char *)&uc, sizeof(uc)); }
id add_parameter(id p) {
if (parameter_count >= parameters_max) {
fprintf(stderr, "Too many parameters!\n");
return p;
}
//cout << "parameter_count: " << parameter_count << " "; p.describe();
if (p.is_charp()) {
if (!pic_mode) {
emit(register_parameters_intel_32[parameter_count]);
emit(p.i32(), 4);
} else {
uchar *out_current_code_pos = out_c;
emit(register_rip_relative_parameters_intel_64[parameter_count]);
emit(rip_relative_offset(out_current_code_pos, p.virtual_adr), 4);
}
} else if (p.is_integer()) {
//cout << "is_integer" << endl;
if (intel) {
//cout << "intel" << endl;
if (p.is_32()) {
//cout << "is_32" << endl;
emit(register_parameters_intel_32[parameter_count]);
emit(p.i32(), 4);
} else if (p.is_64()) {
//cout << "is_64" << endl;
emit(register_parameters_intel_64[parameter_count]);
emit(p.i64(), 8);
}
} else if (arm) {
emit(register_parameters_intel_32[parameter_count]);
}
}
++parameter_count;
return p;
}
void jmp(void *f) {
uchar *out_current_code_pos = out_c;
emit(I_JMP_e9);
emit(call_offset(out_current_code_pos, f), 4);
}
void __call(void *f) {
uchar *out_current_code_pos = out_c;
emit(I_CALL_e8);
emit(call_offset(out_current_code_pos, f), 4);
parameter_count = 0;
}
void __vararg_call(void *f) {
emit(I_XOR_30); emit(0xc0); // xor al,al
call(f);
}
size_t __p = 0;
void f(const char *s, int i) {
__p += (size_t)s + i;
}
void init(char *c, uchar *start, size_t ss, uchar *end, size_t es) {
if (!figure_out_cpu_architecture()) exit(1);
cout << "intel: " << intel << ", arm: " << arm <<
", pic_mode: " << pic_mode << endl;
///am_i_pic = __am_i_pic();
//printf("am_i_pic: %d\n", am_i_pic);
command_file = c;
virtual_code_start = start;
virtual_code_end = end;
find_space(start, ss, end, es, &out_code_start,
&out_code_end);
//printf("code: %zu\n", out_code_end - out_code_start);
virtual_strings_start = (uchar *)STRINGS_START;
virtual_strings_end = (uchar *)STRINGS_END;
out_c = out_code_start;
find_space(virtual_strings_start, strlen(STRINGS_START),
virtual_strings_end, strlen(STRINGS_END),
&out_strings_start, &out_strings_end);
//printf("strings: %zu\n", out_strings_end - out_strings_start);
out_s = out_strings_start;
}
void finish() {
jmp(virtual_code_end);
write();
}
}
<|endoftext|> |
<commit_before>/*****************************************************************************\
* ANALYSIS PERFORMANCE TOOLS *
* libparaver-api *
* API Library for libparaver-kernel *
*****************************************************************************
* ___ This library is free software; you can redistribute it and/or *
* / __ modify it under the terms of the GNU LGPL as published *
* / / _____ by the Free Software Foundation; either version 2.1 *
* / / / \ of the License, or (at your option) any later version. *
* ( ( ( B S C ) *
* \ \ \_____/ This library is distributed in 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 LGPL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
* The GNU LEsser General Public License is contained in the file COPYING. *
* --------- *
* Barcelona Supercomputing Center - Centro Nacional de Supercomputacion *
\*****************************************************************************/
/* -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- *\
| @file: $HeadURL$
| @last_commit: $Date$
| @version: $Revision$
\* -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- */
#include "eventlabels.h"
#include "pcfparser/ParaverEventType.h"
#include "pcfparser/ParaverEventValue.h"
const string EventLabels::unknownLabel = "Unknown";
EventLabels::EventLabels()
{}
EventLabels::EventLabels( const set<TEventType>& eventsLoaded )
{
/* for ( set<TEventType>::const_iterator it = eventsLoaded.begin();
it != eventsLoaded.end(); ++it )
eventTypeLabel[ *it ] = unknownLabel + " type ";*/
}
EventLabels::EventLabels( const libparaver::ParaverTraceConfig& config,
const set<TEventType>& eventsLoaded )
{
/* for ( set<TEventType>::const_iterator it = eventsLoaded.begin();
it != eventsLoaded.end(); ++it )
eventTypeLabel[ *it ] = unknownLabel + " type ";*/
const vector<ParaverEventType *>& types = config.get_eventTypes();
for ( vector<ParaverEventType *>::const_iterator it = types.begin();
it != types.end(); ++it )
{
eventTypeLabel[ ( *it )->get_key() ] = ( *it )->get_description();
eventValueLabel[ ( *it )->get_key() ] = map<TEventValue, string>();
const vector<ParaverEventValue *>& values = ( *it )->get_eventValues();
for ( vector<ParaverEventValue *>::const_iterator itVal = values.begin();
itVal != values.end(); ++itVal )
{
( eventValueLabel[ ( *it )->get_key() ] )[ ( *itVal )->get_key() ] =
( *itVal )->get_value();
}
}
}
EventLabels::~EventLabels()
{}
void EventLabels::getTypes( vector<TEventType>& onVector ) const
{
for ( map<TEventType, string>::const_iterator it = eventTypeLabel.begin();
it != eventTypeLabel.end(); ++it )
onVector.push_back( ( *it ).first );
}
bool EventLabels::getEventTypeLabel( TEventType type, string& onStr ) const
{
map<TEventType, string>::const_iterator it = eventTypeLabel.find( type );
if ( it == eventTypeLabel.end() )
{
onStr = unknownLabel;
return false;
}
onStr = ( *it ).second;
return true;
}
bool EventLabels::getEventValueLabel( TEventType type, TEventValue value, string& onStr ) const
{
map<TEventType, map<TEventValue, string> >::const_iterator it = eventValueLabel.find( type );
if ( it == eventValueLabel.end() )
{
onStr = unknownLabel;
return false;
}
map<TEventValue, string>::const_iterator itVal = ( *it ).second.find( value );
if ( itVal == ( *it ).second.end() )
{
onStr = unknownLabel;
return false;
}
onStr = ( *itVal ).second;
return true;
}
bool EventLabels::getEventValueLabel( TEventValue value, string& onStr ) const
{
bool found = false;
map<TEventType, map<TEventValue, string> >::const_iterator it = eventValueLabel.begin();
while ( !found && it != eventValueLabel.end() )
{
map<TEventValue, string>::const_iterator itVal = ( *it ).second.find( value );
if ( itVal != ( *it ).second.end() )
{
onStr = ( *itVal ).second;
found = true;
}
++it;
}
if ( found )
return true;
onStr = unknownLabel;
return false;
}
<commit_msg>*** empty log message ***<commit_after>/*****************************************************************************\
* ANALYSIS PERFORMANCE TOOLS *
* libparaver-api *
* API Library for libparaver-kernel *
*****************************************************************************
* ___ This library is free software; you can redistribute it and/or *
* / __ modify it under the terms of the GNU LGPL as published *
* / / _____ by the Free Software Foundation; either version 2.1 *
* / / / \ of the License, or (at your option) any later version. *
* ( ( ( B S C ) *
* \ \ \_____/ This library is distributed in 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 LGPL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
* The GNU LEsser General Public License is contained in the file COPYING. *
* --------- *
* Barcelona Supercomputing Center - Centro Nacional de Supercomputacion *
\*****************************************************************************/
/* -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- *\
| @file: $HeadURL$
| @last_commit: $Date$
| @version: $Revision$
\* -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- */
#include "eventlabels.h"
#include "pcfparser/ParaverEventType.h"
#include "pcfparser/ParaverEventValue.h"
const string EventLabels::unknownLabel = "Unknown";
EventLabels::EventLabels()
{}
EventLabels::EventLabels( const set<TEventType>& eventsLoaded )
{
/* for ( set<TEventType>::const_iterator it = eventsLoaded.begin();
it != eventsLoaded.end(); ++it )
eventTypeLabel[ *it ] = unknownLabel + " type ";*/
}
EventLabels::EventLabels( const libparaver::ParaverTraceConfig& config,
const set<TEventType>& eventsLoaded )
{
/* for ( set<TEventType>::const_iterator it = eventsLoaded.begin();
it != eventsLoaded.end(); ++it )
eventTypeLabel[ *it ] = unknownLabel + " type ";*/
const vector<ParaverEventType *>& types = config.get_eventTypes();
for ( vector<ParaverEventType *>::const_iterator it = types.begin();
it != types.end(); ++it )
{
eventTypeLabel[ ( *it )->get_key() ] = ( *it )->get_description();
eventValueLabel[ ( *it )->get_key() ] = map<TEventValue, string>();
const vector<ParaverEventValue *>& values = ( *it )->get_eventValues();
for ( vector<ParaverEventValue *>::const_iterator itVal = values.begin();
itVal != values.end(); ++itVal )
{
( eventValueLabel[ ( *it )->get_key() ] )[ ( *itVal )->get_key() ] =
( *itVal )->get_value();
}
}
}
EventLabels::~EventLabels()
{}
void EventLabels::getTypes( vector<TEventType>& onVector ) const
{
for ( map<TEventType, string>::const_iterator it = eventTypeLabel.begin();
it != eventTypeLabel.end(); ++it )
onVector.push_back( ( *it ).first );
}
bool EventLabels::getEventTypeLabel( TEventType type, string& onStr ) const
{
map<TEventType, string>::const_iterator it = eventTypeLabel.find( type );
if ( it == eventTypeLabel.end() )
{
onStr = unknownLabel;
return false;
}
onStr = ( *it ).second;
return true;
}
bool EventLabels::getEventValueLabel( TEventType type, TEventValue value, string& onStr ) const
{
map<TEventType, map<TEventValue, string> >::const_iterator it = eventValueLabel.find( type );
if ( it == eventValueLabel.end() )
{
//onStr = unknownLabel;
return false;
}
map<TEventValue, string>::const_iterator itVal = ( *it ).second.find( value );
if ( itVal == ( *it ).second.end() )
{
//onStr = unknownLabel;
return false;
}
onStr = ( *itVal ).second;
return true;
}
bool EventLabels::getEventValueLabel( TEventValue value, string& onStr ) const
{
bool found = false;
map<TEventType, map<TEventValue, string> >::const_iterator it = eventValueLabel.begin();
while ( !found && it != eventValueLabel.end() )
{
map<TEventValue, string>::const_iterator itVal = ( *it ).second.find( value );
if ( itVal != ( *it ).second.end() )
{
onStr = ( *itVal ).second;
found = true;
}
++it;
}
if ( found )
return true;
//onStr = unknownLabel;
return false;
}
<|endoftext|> |
<commit_before>///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2014 Tavendo GmbH
//
// 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 <autobahn/autobahn.hpp>
#include <boost/asio.hpp>
#include <boost/version.hpp>
#include <iostream>
#include <string>
#include <tuple>
using namespace std;
using namespace boost;
using namespace autobahn;
using boost::asio::ip::tcp;
int main () {
cerr << "Running on " << BOOST_VERSION << endl;
try {
// ASIO service object
//
asio::io_service io;
// the TCP socket we connect
//
tcp::socket socket(io);
// connect to this server/port
//
tcp::resolver resolver(io);
auto endpoint_iterator = resolver.resolve({"127.0.0.1", "8090"});
// create a WAMP session that talks over TCP
//
bool debug = false;
autobahn::wamp_session<tcp::socket,
tcp::socket> session(io, socket, socket, debug);
// make sure the future returned from the session joining a realm (see below)
// does not run out of scope (being destructed prematurely ..)
//
future<void> session_future;
// now do an asynchronous connect ..
//
boost::asio::async_connect(socket, endpoint_iterator,
// we either connected or an error happened during connect ..
//
[&](boost::system::error_code ec, tcp::resolver::iterator) {
if (!ec) {
cerr << "Connected to server" << endl;
// start the WAMP session on the transport that has been connected
//
session.start();
// join a realm with the WAMP session
//
session_future = session.join("realm1").then([&](future<uint64_t> s) {
cerr << "Session joined to realm with session ID " << s.get() << endl;
// call a remote procedure with positional arguments
//
std::tuple<uint64_t, uint64_t> c1_args(23, 777);
auto c1 = session.call("com.mathservice.add2", c1_args)
.then([&](future<wamp_call_result> result) {
std::tuple<uint64_t> result_arguments;
result.get().arguments().convert(result_arguments);
cerr << "Call 1 result: " << std::get<0>(result_arguments) << endl;
}
);
// call a remote procedure with keyword arguments
//
std::tuple<> c2_args;
std::unordered_map<std::string, uint64_t> c2_kw_args = {{"stars", 10}};
auto c2 = session.call("com.arguments.stars", c1_args, c2_kw_args)
.then([&](future<wamp_call_result> result) {
std::tuple<std::string> result_arguments;
result.get().arguments().convert(result_arguments);
cerr << "Call 2 result: " << std::get<0>(result_arguments) << endl;
}
);
// call a remote procedure with positional and keyword arguments
//
std::tuple<uint64_t, uint64_t> c3_args(1, 7);
std::unordered_map<std::string, std::string> c3_kw_args = {{"prefix", string("Hello number: ")}};
auto c3 = session.call("com.arguments.numbers", c3_args, c3_kw_args)
.then([](boost::future<wamp_call_result> result) {
std::tuple<std::vector<std::string>> result_arguments;
result.get().arguments().convert(result_arguments);
auto& v = std::get<0>(result_arguments);
for (size_t i = 0; i < v.size(); ++i) {
cerr << v[i] << endl;
}
});
// do something when all remote procedure calls have finished
//
auto finish = boost::when_all(std::move(c1), std::move(c2), std::move(c3));
finish.then([&](decltype(finish)) {
cerr << "All calls finished" << endl;
// leave the session and stop I/O loop
//
session.leave().then([&](future<string> reason) {
cerr << "Session left (" << reason.get() << ")" << endl;
io.stop();
}).wait();
});
});
} else {
cerr << "Could not connect to server: " << ec.message() << endl;
}
}
);
cerr << "Starting ASIO I/O loop .." << endl;
io.run();
cerr << "ASIO I/O loop ended" << endl;
}
catch (std::exception& e) {
cerr << e.what() << endl;
return 1;
}
return 0;
}
<commit_msg>[examples] Fix unused variable build error<commit_after>///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2014 Tavendo GmbH
//
// 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 <autobahn/autobahn.hpp>
#include <boost/asio.hpp>
#include <boost/version.hpp>
#include <iostream>
#include <string>
#include <tuple>
using namespace std;
using namespace boost;
using namespace autobahn;
using boost::asio::ip::tcp;
int main () {
cerr << "Running on " << BOOST_VERSION << endl;
try {
// ASIO service object
//
asio::io_service io;
// the TCP socket we connect
//
tcp::socket socket(io);
// connect to this server/port
//
tcp::resolver resolver(io);
auto endpoint_iterator = resolver.resolve({"127.0.0.1", "8090"});
// create a WAMP session that talks over TCP
//
bool debug = false;
autobahn::wamp_session<tcp::socket,
tcp::socket> session(io, socket, socket, debug);
// make sure the future returned from the session joining a realm (see below)
// does not run out of scope (being destructed prematurely ..)
//
future<void> session_future;
// now do an asynchronous connect ..
//
boost::asio::async_connect(socket, endpoint_iterator,
// we either connected or an error happened during connect ..
//
[&](boost::system::error_code ec, tcp::resolver::iterator) {
if (!ec) {
cerr << "Connected to server" << endl;
// start the WAMP session on the transport that has been connected
//
session.start();
// join a realm with the WAMP session
//
session_future = session.join("realm1").then([&](future<uint64_t> s) {
cerr << "Session joined to realm with session ID " << s.get() << endl;
// call a remote procedure with positional arguments
//
std::tuple<uint64_t, uint64_t> c1_args(23, 777);
auto c1 = session.call("com.mathservice.add2", c1_args)
.then([&](future<wamp_call_result> result) {
std::tuple<uint64_t> result_arguments;
result.get().arguments().convert(result_arguments);
cerr << "Call 1 result: " << std::get<0>(result_arguments) << endl;
}
);
// call a remote procedure with keyword arguments
//
std::tuple<> c2_args;
std::unordered_map<std::string, uint64_t> c2_kw_args = {{"stars", 10}};
auto c2 = session.call("com.arguments.stars", c2_args, c2_kw_args)
.then([&](future<wamp_call_result> result) {
std::tuple<std::string> result_arguments;
result.get().arguments().convert(result_arguments);
cerr << "Call 2 result: " << std::get<0>(result_arguments) << endl;
}
);
// call a remote procedure with positional and keyword arguments
//
std::tuple<uint64_t, uint64_t> c3_args(1, 7);
std::unordered_map<std::string, std::string> c3_kw_args = {{"prefix", string("Hello number: ")}};
auto c3 = session.call("com.arguments.numbers", c3_args, c3_kw_args)
.then([](boost::future<wamp_call_result> result) {
std::tuple<std::vector<std::string>> result_arguments;
result.get().arguments().convert(result_arguments);
auto& v = std::get<0>(result_arguments);
for (size_t i = 0; i < v.size(); ++i) {
cerr << v[i] << endl;
}
});
// do something when all remote procedure calls have finished
//
auto finish = boost::when_all(std::move(c1), std::move(c2), std::move(c3));
finish.then([&](decltype(finish)) {
cerr << "All calls finished" << endl;
// leave the session and stop I/O loop
//
session.leave().then([&](future<string> reason) {
cerr << "Session left (" << reason.get() << ")" << endl;
io.stop();
}).wait();
});
});
} else {
cerr << "Could not connect to server: " << ec.message() << endl;
}
}
);
cerr << "Starting ASIO I/O loop .." << endl;
io.run();
cerr << "ASIO I/O loop ended" << endl;
}
catch (std::exception& e) {
cerr << e.what() << endl;
return 1;
}
return 0;
}
<|endoftext|> |
<commit_before>// Copyright 2017 The SwiftShader 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 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 "OpenGL/compiler/InitializeGlobals.h"
#include "OpenGL/compiler/InitializeParseContext.h"
#include "OpenGL/compiler/TranslatorASM.h"
// TODO: Debug macros of the GLSL compiler clash with core SwiftShader's.
// They should not be exposed through the interface headers above.
#undef ASSERT
#undef UNIMPLEMENTED
#include "Renderer/VertexProcessor.hpp"
#include "Shader/VertexProgram.hpp"
#include <cstdint>
#include <memory>
namespace {
// TODO(cwallez@google.com): Like in ANGLE, disable most of the pool allocator for fuzzing
// This is a helper class to make sure all the resources used by the compiler are initialized
class ScopedPoolAllocatorAndTLS {
public:
ScopedPoolAllocatorAndTLS() {
InitializeParseContextIndex();
InitializePoolIndex();
SetGlobalPoolAllocator(&allocator);
}
~ScopedPoolAllocatorAndTLS() {
SetGlobalPoolAllocator(nullptr);
FreePoolIndex();
FreeParseContextIndex();
}
private:
TPoolAllocator allocator;
};
// Trivial implementation of the glsl::Shader interface that fakes being an API-level
// shader object.
class FakeVS : public glsl::Shader {
public:
FakeVS(sw::VertexShader* bytecode) : bytecode(bytecode) {
}
sw::Shader *getShader() const override {
return bytecode;
}
sw::VertexShader *getVertexShader() const override {
return bytecode;
}
private:
sw::VertexShader* bytecode;
};
} // anonymous namespace
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
std::unique_ptr<ScopedPoolAllocatorAndTLS> allocatorAndTLS(new ScopedPoolAllocatorAndTLS);
std::unique_ptr<sw::VertexShader> shader(new sw::VertexShader);
std::unique_ptr<FakeVS> fakeVS(new FakeVS(shader.get()));
std::unique_ptr<TranslatorASM> glslCompiler(new TranslatorASM(fakeVS.get(), GL_VERTEX_SHADER));
// TODO(cwallez@google.com): have a function to init to default values somewhere
ShBuiltInResources resources;
resources.MaxVertexAttribs = sw::MAX_VERTEX_INPUTS;
resources.MaxVertexUniformVectors = sw::VERTEX_UNIFORM_VECTORS - 3;
resources.MaxVaryingVectors = MIN(sw::MAX_VERTEX_OUTPUTS, sw::MAX_VERTEX_INPUTS);
resources.MaxVertexTextureImageUnits = sw::VERTEX_TEXTURE_IMAGE_UNITS;
resources.MaxCombinedTextureImageUnits = sw::TEXTURE_IMAGE_UNITS + sw::VERTEX_TEXTURE_IMAGE_UNITS;
resources.MaxTextureImageUnits = sw::TEXTURE_IMAGE_UNITS;
resources.MaxFragmentUniformVectors = sw::FRAGMENT_UNIFORM_VECTORS - 3;
resources.MaxDrawBuffers = sw::RENDERTARGETS;
resources.MaxVertexOutputVectors = 16; // ???
resources.MaxFragmentInputVectors = 15; // ???
resources.MinProgramTexelOffset = sw::MIN_PROGRAM_TEXEL_OFFSET;
resources.MaxProgramTexelOffset = sw::MAX_PROGRAM_TEXEL_OFFSET;
resources.OES_standard_derivatives = 1;
resources.OES_fragment_precision_high = 1;
resources.OES_EGL_image_external = 1;
resources.EXT_draw_buffers = 1;
resources.MaxCallStackDepth = 16;
glslCompiler->Init(resources);
const char* glslSource = "void main() {gl_Position = vec4(1.0);}";
if (!glslCompiler->compile(&glslSource, 1, SH_OBJECT_CODE))
{
return 0;
}
std::unique_ptr<sw::VertexShader> bytecodeShader(new sw::VertexShader(fakeVS->getVertexShader()));
sw::VertexProcessor::State state;
// Data layout:
//
// byte: boolean states
// {
// byte: stream type
// byte: stream count and normalized
// } [MAX_VERTEX_INPUTS]
// {
// byte[32]: reserved sampler state
// } [VERTEX_TEXTURE_IMAGE_UNITS]
const int state_size = 1 + 2 * sw::MAX_VERTEX_INPUTS + 32 * sw::VERTEX_TEXTURE_IMAGE_UNITS;
if(size < state_size)
{
return 0;
}
state.textureSampling = bytecodeShader->containsTextureSampling();
state.positionRegister = bytecodeShader->getPositionRegister();
state.pointSizeRegister = bytecodeShader->getPointSizeRegister();
state.preTransformed = (data[0] & 0x01) != 0;
state.superSampling = (data[0] & 0x02) != 0;
state.multiSampling = (data[0] & 0x04) != 0;
state.transformFeedbackQueryEnabled = (data[0] & 0x08) != 0;
state.transformFeedbackEnabled = (data[0] & 0x10) != 0;
state.verticesPerPrimitive = 1 + ((data[0] & 0x20) != 0) + ((data[0] & 0x40) != 0);
if((data[0] & 0x80) != 0) // Unused/reserved.
{
return 0;
}
struct Stream
{
uint8_t count : BITS(sw::STREAMTYPE_LAST);
bool normalized;
uint8_t reserved : 8 - BITS(sw::STREAMTYPE_LAST) - 1;
};
for(int i = 0; i < sw::MAX_VERTEX_INPUTS; i++)
{
sw::StreamType type = (sw::StreamType)data[1 + 2 * i + 0];
Stream stream = (Stream&)data[1 + 2 * i + 1];
if(type > sw::STREAMTYPE_LAST) return 0;
if(stream.count > 4) return 0;
if(stream.reserved != 0) return 0;
state.input[i].type = type;
state.input[i].count = stream.count;
state.input[i].normalized = stream.normalized;
state.input[i].attribType = bytecodeShader->getAttribType(i);
}
for(unsigned int i = 0; i < sw::VERTEX_TEXTURE_IMAGE_UNITS; i++)
{
// TODO
// if(bytecodeShader->usesSampler(i))
// {
// state.samplerState[i] = context->sampler[sw::TEXTURE_IMAGE_UNITS + i].samplerState();
// }
for(int j = 0; j < 32; j++)
{
if(data[1 + 2 * sw::MAX_VERTEX_INPUTS + 32 * i + j] != 0)
{
return 0;
}
}
}
for(int i = 0; i < sw::MAX_VERTEX_OUTPUTS; i++)
{
state.output[i].xWrite = bytecodeShader->getOutput(i, 0).active();
state.output[i].yWrite = bytecodeShader->getOutput(i, 1).active();
state.output[i].zWrite = bytecodeShader->getOutput(i, 2).active();
state.output[i].wWrite = bytecodeShader->getOutput(i, 3).active();
}
sw::VertexProgram program(state, bytecodeShader.get());
program.generate();
return 0;
}
<commit_msg>vertex_routine_fuzzer: Get source from `data`<commit_after>// Copyright 2017 The SwiftShader 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 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 "OpenGL/compiler/InitializeGlobals.h"
#include "OpenGL/compiler/InitializeParseContext.h"
#include "OpenGL/compiler/TranslatorASM.h"
// TODO: Debug macros of the GLSL compiler clash with core SwiftShader's.
// They should not be exposed through the interface headers above.
#undef ASSERT
#undef UNIMPLEMENTED
#include "Renderer/VertexProcessor.hpp"
#include "Shader/VertexProgram.hpp"
#include <cstdint>
#include <memory>
namespace {
// TODO(cwallez@google.com): Like in ANGLE, disable most of the pool allocator for fuzzing
// This is a helper class to make sure all the resources used by the compiler are initialized
class ScopedPoolAllocatorAndTLS {
public:
ScopedPoolAllocatorAndTLS() {
InitializeParseContextIndex();
InitializePoolIndex();
SetGlobalPoolAllocator(&allocator);
}
~ScopedPoolAllocatorAndTLS() {
SetGlobalPoolAllocator(nullptr);
FreePoolIndex();
FreeParseContextIndex();
}
private:
TPoolAllocator allocator;
};
// Trivial implementation of the glsl::Shader interface that fakes being an API-level
// shader object.
class FakeVS : public glsl::Shader {
public:
FakeVS(sw::VertexShader* bytecode) : bytecode(bytecode) {
}
sw::Shader *getShader() const override {
return bytecode;
}
sw::VertexShader *getVertexShader() const override {
return bytecode;
}
private:
sw::VertexShader* bytecode;
};
} // anonymous namespace
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
{
// Data layout:
//
// byte: boolean states
// {
// byte: stream type
// byte: stream count and normalized
// } [MAX_VERTEX_INPUTS]
// {
// byte[32]: reserved sampler state
// } [VERTEX_TEXTURE_IMAGE_UNITS]
//
// char source[] // null terminated
const size_t kHeaderSize = 1 + 2 * sw::MAX_VERTEX_INPUTS + 32 * sw::VERTEX_TEXTURE_IMAGE_UNITS;
if(size <= kHeaderSize)
{
return 0;
}
if (data[size -1] != 0)
{
return 0;
}
std::unique_ptr<ScopedPoolAllocatorAndTLS> allocatorAndTLS(new ScopedPoolAllocatorAndTLS);
std::unique_ptr<sw::VertexShader> shader(new sw::VertexShader);
std::unique_ptr<FakeVS> fakeVS(new FakeVS(shader.get()));
std::unique_ptr<TranslatorASM> glslCompiler(new TranslatorASM(fakeVS.get(), GL_VERTEX_SHADER));
// TODO(cwallez@google.com): have a function to init to default values somewhere
ShBuiltInResources resources;
resources.MaxVertexAttribs = sw::MAX_VERTEX_INPUTS;
resources.MaxVertexUniformVectors = sw::VERTEX_UNIFORM_VECTORS - 3;
resources.MaxVaryingVectors = MIN(sw::MAX_VERTEX_OUTPUTS, sw::MAX_VERTEX_INPUTS);
resources.MaxVertexTextureImageUnits = sw::VERTEX_TEXTURE_IMAGE_UNITS;
resources.MaxCombinedTextureImageUnits = sw::TEXTURE_IMAGE_UNITS + sw::VERTEX_TEXTURE_IMAGE_UNITS;
resources.MaxTextureImageUnits = sw::TEXTURE_IMAGE_UNITS;
resources.MaxFragmentUniformVectors = sw::FRAGMENT_UNIFORM_VECTORS - 3;
resources.MaxDrawBuffers = sw::RENDERTARGETS;
resources.MaxVertexOutputVectors = 16; // ???
resources.MaxFragmentInputVectors = 15; // ???
resources.MinProgramTexelOffset = sw::MIN_PROGRAM_TEXEL_OFFSET;
resources.MaxProgramTexelOffset = sw::MAX_PROGRAM_TEXEL_OFFSET;
resources.OES_standard_derivatives = 1;
resources.OES_fragment_precision_high = 1;
resources.OES_EGL_image_external = 1;
resources.EXT_draw_buffers = 1;
resources.MaxCallStackDepth = 16;
glslCompiler->Init(resources);
const char* glslSource = reinterpret_cast<const char*>(data + kHeaderSize);
if (!glslCompiler->compile(&glslSource, 1, SH_OBJECT_CODE))
{
return 0;
}
std::unique_ptr<sw::VertexShader> bytecodeShader(new sw::VertexShader(fakeVS->getVertexShader()));
sw::VertexProcessor::State state;
state.textureSampling = bytecodeShader->containsTextureSampling();
state.positionRegister = bytecodeShader->getPositionRegister();
state.pointSizeRegister = bytecodeShader->getPointSizeRegister();
state.preTransformed = (data[0] & 0x01) != 0;
state.superSampling = (data[0] & 0x02) != 0;
state.multiSampling = (data[0] & 0x04) != 0;
state.transformFeedbackQueryEnabled = (data[0] & 0x08) != 0;
state.transformFeedbackEnabled = (data[0] & 0x10) != 0;
state.verticesPerPrimitive = 1 + ((data[0] & 0x20) != 0) + ((data[0] & 0x40) != 0);
if((data[0] & 0x80) != 0) // Unused/reserved.
{
return 0;
}
struct Stream
{
uint8_t count : BITS(sw::STREAMTYPE_LAST);
bool normalized;
uint8_t reserved : 8 - BITS(sw::STREAMTYPE_LAST) - 1;
};
for(int i = 0; i < sw::MAX_VERTEX_INPUTS; i++)
{
sw::StreamType type = (sw::StreamType)data[1 + 2 * i + 0];
Stream stream = (Stream&)data[1 + 2 * i + 1];
if(type > sw::STREAMTYPE_LAST) return 0;
if(stream.count > 4) return 0;
if(stream.reserved != 0) return 0;
state.input[i].type = type;
state.input[i].count = stream.count;
state.input[i].normalized = stream.normalized;
state.input[i].attribType = bytecodeShader->getAttribType(i);
}
for(unsigned int i = 0; i < sw::VERTEX_TEXTURE_IMAGE_UNITS; i++)
{
// TODO
// if(bytecodeShader->usesSampler(i))
// {
// state.samplerState[i] = context->sampler[sw::TEXTURE_IMAGE_UNITS + i].samplerState();
// }
for(int j = 0; j < 32; j++)
{
if(data[1 + 2 * sw::MAX_VERTEX_INPUTS + 32 * i + j] != 0)
{
return 0;
}
}
}
for(int i = 0; i < sw::MAX_VERTEX_OUTPUTS; i++)
{
state.output[i].xWrite = bytecodeShader->getOutput(i, 0).active();
state.output[i].yWrite = bytecodeShader->getOutput(i, 1).active();
state.output[i].zWrite = bytecodeShader->getOutput(i, 2).active();
state.output[i].wWrite = bytecodeShader->getOutput(i, 3).active();
}
sw::VertexProgram program(state, bytecodeShader.get());
program.generate();
return 0;
}
<|endoftext|> |
<commit_before>/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* 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 <miopen/miopen.h>
#include <miopen/manage_ptr.hpp>
#include <miopen/fusion_plan.hpp>
#include <miopen/env.hpp>
#include "get_handle.hpp"
#include "test.hpp"
MIOPEN_DECLARE_ENV_VAR(MIOPEN_DEBUG_AMD_FUSED_WINOGRAD)
MIOPEN_DECLARE_ENV_VAR(MIOPEN_DEBUG_GCN_ASM_KERNELS)
void BNAlgTest(std::vector<int> inputs,
miopenBatchNormMode_t bnmode,
std::string& pgm,
std::string& krn,
std::string& alg)
{
MIOPEN_LOG_I("*********************************************************");
auto&& handle = get_handle();
miopen::TensorDescriptor inputTensor;
miopen::TensorDescriptor scaleTensor;
miopenFusionOpDescriptor_t bNormOp = nullptr;
// input descriptor
STATUS(miopenSet4dTensorDescriptor(
&inputTensor, miopenFloat, inputs[0], inputs[1], inputs[2], inputs[3]));
miopen::FusionPlanDescriptor fp(miopenVerticalFusion, inputTensor);
miopenCreateOpBatchNormInference(&fp, &bNormOp, bnmode, &scaleTensor);
pgm = fp.GetProgramName(handle);
krn = fp.GetKernelName(handle);
alg = fp.GetAlgorithmName(handle);
}
void ConvAlgTest(std::vector<int> inputs,
std::vector<int> conv_filter,
std::vector<int> conv_desc,
std::string& pgm,
std::string& krn,
std::string& alg)
{
MIOPEN_LOG_I("*********************************************************");
auto&& handle = get_handle();
miopen::TensorDescriptor inputTensor;
miopen::TensorDescriptor convFilter;
miopenConvolutionDescriptor_t convDesc{};
miopenFusionOpDescriptor_t convoOp;
// input descriptor
STATUS(miopenSet4dTensorDescriptor(
&inputTensor, miopenFloat, inputs[0], inputs[1], inputs[2], inputs[3]));
// convolution descriptor
STATUS(miopenSet4dTensorDescriptor(&convFilter,
miopenFloat,
conv_filter[0], // outputs k
conv_filter[1], // inputs c
conv_filter[2], // kernel size
conv_filter[3]));
STATUS(miopenCreateConvolutionDescriptor(&convDesc));
STATUS(miopenInitConvolutionDescriptor(convDesc,
miopenConvolution,
conv_desc[0],
conv_desc[1],
conv_desc[2],
conv_desc[3],
conv_desc[4],
conv_desc[5]));
miopen::FusionPlanDescriptor fp(miopenVerticalFusion, inputTensor);
STATUS(miopenCreateOpConvForward(&fp, &convoOp, convDesc, &convFilter));
pgm = fp.GetProgramName(handle);
krn = fp.GetKernelName(handle);
alg = fp.GetAlgorithmName(handle);
// Cleanup
miopenDestroyConvolutionDescriptor(convDesc);
}
int main()
{
std::string pgm_name;
std::string krn_name;
std::string alg_name;
if(!miopen::IsDisabled(MIOPEN_DEBUG_AMD_FUSED_WINOGRAD{}))
{
// Winograd because c, x and y satisfy criteria
ConvAlgTest(
{100, 32, 8, 8}, {64, 32, 3, 3}, {1, 1, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(krn_name == "miopenSp3AsmConvRxSU_CBA");
EXPECT(alg_name == "miopenConvolutionWinogradBiasActiv");
// c is odd so winograd not supported and padding is zero
ConvAlgTest(
{100, 31, 8, 8}, {64, 31, 3, 3}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(krn_name != "miopenSp3AsmConvRxSU_CBA");
EXPECT(alg_name != "miopenConvolutionWinogradBiasActiv");
// c is less than 18 so winograd not supported and padding is zero
ConvAlgTest(
{100, 15, 8, 8}, {64, 15, 3, 3}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(krn_name != "miopenSp3AsmConvRxSU_CBA");
EXPECT(alg_name != "miopenConvolutionWinogradBiasActiv");
}
// the asm kernel is the fastest for 1x1 and padding
if(!miopen::IsDisabled(MIOPEN_DEBUG_GCN_ASM_KERNELS{}))
{
ConvAlgTest(
{100, 32, 8, 8}, {64, 32, 1, 1}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "conv1x1u_bias_activ.s");
EXPECT(krn_name == "miopenGcnAsmConv1x1U");
EXPECT(alg_name == "miopenConvolutionDirectBiasActivAsm");
}
// only the opencl kernels supports other odd sizes with padding zero
for(auto idx : {5, 7, 9, 11})
{
ConvAlgTest(
{100, 32, 8, 8}, {64, 32, idx, idx}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "MIOpenConvDirBatchNormActiv.cl");
EXPECT(krn_name == "MIOpenConvUniBatchNormActiv");
EXPECT(alg_name == "miopenConvolutionDirectBiasActiv");
}
BNAlgTest({100, 32, 8, 8}, miopenBNSpatial, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "MIOpenBatchNormActivInfer.cl");
EXPECT(krn_name == "MIOpenBatchNormActivInferSpatialEst");
EXPECT(alg_name == "MIOpenBatchNormActivInferSpatialEst");
BNAlgTest({100, 32, 8, 8}, miopenBNPerActivation, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "MIOpenBatchNormActivInfer.cl");
EXPECT(krn_name == "MIOpenBatchNormActivInferPerActEst");
EXPECT(alg_name == "MIOpenBatchNormActivInferPerActEst");
}
<commit_msg>[WORKAROUND][tests] Skip unsupported algo for navi21 (#764)<commit_after>/*******************************************************************************
*
* MIT License
*
* Copyright (c) 2017 Advanced Micro Devices, Inc.
*
* 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 <miopen/miopen.h>
#include <miopen/manage_ptr.hpp>
#include <miopen/fusion_plan.hpp>
#include <miopen/env.hpp>
#include "get_handle.hpp"
#include "test.hpp"
#define WORKAROUND_ISSUE_763 1
MIOPEN_DECLARE_ENV_VAR(MIOPEN_DEBUG_AMD_FUSED_WINOGRAD)
MIOPEN_DECLARE_ENV_VAR(MIOPEN_DEBUG_GCN_ASM_KERNELS)
void BNAlgTest(std::vector<int> inputs,
miopenBatchNormMode_t bnmode,
std::string& pgm,
std::string& krn,
std::string& alg)
{
MIOPEN_LOG_I("*********************************************************");
auto&& handle = get_handle();
miopen::TensorDescriptor inputTensor;
miopen::TensorDescriptor scaleTensor;
miopenFusionOpDescriptor_t bNormOp = nullptr;
// input descriptor
STATUS(miopenSet4dTensorDescriptor(
&inputTensor, miopenFloat, inputs[0], inputs[1], inputs[2], inputs[3]));
miopen::FusionPlanDescriptor fp(miopenVerticalFusion, inputTensor);
miopenCreateOpBatchNormInference(&fp, &bNormOp, bnmode, &scaleTensor);
pgm = fp.GetProgramName(handle);
krn = fp.GetKernelName(handle);
alg = fp.GetAlgorithmName(handle);
}
void ConvAlgTest(std::vector<int> inputs,
std::vector<int> conv_filter,
std::vector<int> conv_desc,
std::string& pgm,
std::string& krn,
std::string& alg)
{
MIOPEN_LOG_I("*********************************************************");
auto&& handle = get_handle();
miopen::TensorDescriptor inputTensor;
miopen::TensorDescriptor convFilter;
miopenConvolutionDescriptor_t convDesc{};
miopenFusionOpDescriptor_t convoOp;
// input descriptor
STATUS(miopenSet4dTensorDescriptor(
&inputTensor, miopenFloat, inputs[0], inputs[1], inputs[2], inputs[3]));
// convolution descriptor
STATUS(miopenSet4dTensorDescriptor(&convFilter,
miopenFloat,
conv_filter[0], // outputs k
conv_filter[1], // inputs c
conv_filter[2], // kernel size
conv_filter[3]));
STATUS(miopenCreateConvolutionDescriptor(&convDesc));
STATUS(miopenInitConvolutionDescriptor(convDesc,
miopenConvolution,
conv_desc[0],
conv_desc[1],
conv_desc[2],
conv_desc[3],
conv_desc[4],
conv_desc[5]));
miopen::FusionPlanDescriptor fp(miopenVerticalFusion, inputTensor);
STATUS(miopenCreateOpConvForward(&fp, &convoOp, convDesc, &convFilter));
pgm = fp.GetProgramName(handle);
krn = fp.GetKernelName(handle);
alg = fp.GetAlgorithmName(handle);
// Cleanup
miopenDestroyConvolutionDescriptor(convDesc);
}
int main()
{
std::string pgm_name;
std::string krn_name;
std::string alg_name;
bool skip_unsupported_alg = false;
#if WORKAROUND_ISSUE_763
auto&& h = get_handle();
auto this_arch = h.GetDeviceName();
if(this_arch.find("gfx10") != std::string::npos)
skip_unsupported_alg = true;
#endif
if(!miopen::IsDisabled(MIOPEN_DEBUG_AMD_FUSED_WINOGRAD{}) && !skip_unsupported_alg)
{
// Winograd because c, x and y satisfy criteria
ConvAlgTest(
{100, 32, 8, 8}, {64, 32, 3, 3}, {1, 1, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(krn_name == "miopenSp3AsmConvRxSU_CBA");
EXPECT(alg_name == "miopenConvolutionWinogradBiasActiv");
// c is odd so winograd not supported and padding is zero
ConvAlgTest(
{100, 31, 8, 8}, {64, 31, 3, 3}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(krn_name != "miopenSp3AsmConvRxSU_CBA");
EXPECT(alg_name != "miopenConvolutionWinogradBiasActiv");
// c is less than 18 so winograd not supported and padding is zero
ConvAlgTest(
{100, 15, 8, 8}, {64, 15, 3, 3}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(krn_name != "miopenSp3AsmConvRxSU_CBA");
EXPECT(alg_name != "miopenConvolutionWinogradBiasActiv");
}
// the asm kernel is the fastest for 1x1 and padding
if(!miopen::IsDisabled(MIOPEN_DEBUG_GCN_ASM_KERNELS{}) && !skip_unsupported_alg)
{
ConvAlgTest(
{100, 32, 8, 8}, {64, 32, 1, 1}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "conv1x1u_bias_activ.s");
EXPECT(krn_name == "miopenGcnAsmConv1x1U");
EXPECT(alg_name == "miopenConvolutionDirectBiasActivAsm");
}
// only the opencl kernels supports other odd sizes with padding zero
for(auto idx : {5, 7, 9, 11})
{
ConvAlgTest(
{100, 32, 8, 8}, {64, 32, idx, idx}, {0, 0, 1, 1, 1, 1}, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "MIOpenConvDirBatchNormActiv.cl");
EXPECT(krn_name == "MIOpenConvUniBatchNormActiv");
EXPECT(alg_name == "miopenConvolutionDirectBiasActiv");
}
BNAlgTest({100, 32, 8, 8}, miopenBNSpatial, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "MIOpenBatchNormActivInfer.cl");
EXPECT(krn_name == "MIOpenBatchNormActivInferSpatialEst");
EXPECT(alg_name == "MIOpenBatchNormActivInferSpatialEst");
BNAlgTest({100, 32, 8, 8}, miopenBNPerActivation, pgm_name, krn_name, alg_name);
EXPECT(pgm_name == "MIOpenBatchNormActivInfer.cl");
EXPECT(krn_name == "MIOpenBatchNormActivInferPerActEst");
EXPECT(alg_name == "MIOpenBatchNormActivInferPerActEst");
}
<|endoftext|> |
<commit_before>#include <catch2/catch.hpp>
#include <test_utils.hpp>
#include <libslic3r/SLA/EigenMesh3D.hpp>
#include <libslic3r/SLA/Hollowing.hpp>
#include "sla_test_utils.hpp"
using namespace Slic3r;
// Create a simple scene with a 20mm cube and a big hole in the front wall
// with 5mm radius. Then shoot rays from interesting positions and see where
// they land.
TEST_CASE("Raycaster with loaded drillholes", "[sla_raycast]")
{
// Load the cube and make it hollow.
TriangleMesh cube = load_model("20mm_cube.obj");
sla::HollowingConfig hcfg;
std::unique_ptr<TriangleMesh> cube_inside = sla::generate_interior(cube, hcfg);
REQUIRE(cube_inside);
// Helper bb
auto boxbb = cube.bounding_box();
// Create the big 10mm long drainhole in the front wall.
Vec3f center = boxbb.center().cast<float>();
Vec3f p = {center.x(), 0., center.z()};
Vec3f normal = {0.f, 1.f, 0.f};
float radius = 5.f;
float hole_length = 10.;
sla::DrainHoles holes = { sla::DrainHole{p, normal, radius, hole_length} };
cube.merge(*cube_inside);
cube.require_shared_vertices();
sla::EigenMesh3D emesh{cube};
emesh.load_holes(holes);
Vec3d s = center.cast<double>();
SECTION("Fire from center, should hit the interior wall") {
auto hit = emesh.query_ray_hit(s, {0, 1., 0.});
REQUIRE(hit.distance() == Approx(boxbb.size().x() / 2 - hcfg.min_thickness));
}
SECTION("Fire upward from hole center, hit distance equals the radius") {
s.y() = hcfg.min_thickness / 2;
auto hit = emesh.query_ray_hit(s, {0, 0., 1.});
REQUIRE(hit.distance() == Approx(radius));
}
SECTION("Fire from outside, hit the back side of the hole cylinder.") {
s.y() = -1.;
auto hit = emesh.query_ray_hit(s, {0, 1., 0.});
REQUIRE(hit.distance() == Approx(boxbb.size().y() - hcfg.min_thickness + 1.));
}
SECTION("Check for support tree correctness") {
test_support_model_collision("20mm_cube.obj", {}, hcfg, holes);
}
}
<commit_msg>more raycaster tests, without repeating the hollowing every time<commit_after>#include <catch2/catch.hpp>
#include <test_utils.hpp>
#include <libslic3r/SLA/EigenMesh3D.hpp>
#include <libslic3r/SLA/Hollowing.hpp>
#include "sla_test_utils.hpp"
using namespace Slic3r;
// Create a simple scene with a 20mm cube and a big hole in the front wall
// with 5mm radius. Then shoot rays from interesting positions and see where
// they land.
TEST_CASE("Raycaster with loaded drillholes", "[sla_raycast]")
{
// Load the cube and make it hollow.
TriangleMesh cube = load_model("20mm_cube.obj");
sla::HollowingConfig hcfg;
std::unique_ptr<TriangleMesh> cube_inside = sla::generate_interior(cube, hcfg);
REQUIRE(cube_inside);
// Helper bb
auto boxbb = cube.bounding_box();
// Create the big 10mm long drainhole in the front wall.
Vec3f center = boxbb.center().cast<float>();
Vec3f p = {center.x(), 0., center.z()};
Vec3f normal = {0.f, 1.f, 0.f};
float radius = 5.f;
float hole_length = 10.;
sla::DrainHoles holes = { sla::DrainHole{p, normal, radius, hole_length} };
cube.merge(*cube_inside);
cube.require_shared_vertices();
sla::EigenMesh3D emesh{cube};
emesh.load_holes(holes);
Vec3d s = center.cast<double>();
// Fire from center, should hit the interior wall
auto hit = emesh.query_ray_hit(s, {0, 1., 0.});
REQUIRE(hit.distance() == Approx(boxbb.size().x() / 2 - hcfg.min_thickness));
// Fire upward from hole center, hit distance equals the radius (hits the
// side of the hole cut.
s.y() = hcfg.min_thickness / 2;
hit = emesh.query_ray_hit(s, {0, 0., 1.});
REQUIRE(hit.distance() == Approx(radius));
// Fire from outside, hit the back side of the cube interior
s.y() = -1.;
hit = emesh.query_ray_hit(s, {0, 1., 0.});
REQUIRE(hit.distance() == Approx(boxbb.max.y() - hcfg.min_thickness - s.y()));
// Fire downwards from above the hole cylinder. Has to go through the cyl.
// as it was not there.
s = center.cast<double>();
s.z() = boxbb.max.z() - hcfg.min_thickness - 1.;
hit = emesh.query_ray_hit(s, {0, 0., -1.});
REQUIRE(hit.distance() == Approx(s.z() - boxbb.min.z() - hcfg.min_thickness));
// Check for support tree correctness
test_support_model_collision("20mm_cube.obj", {}, hcfg, holes);
}
<|endoftext|> |
<commit_before>#include <mart-netlib/port_layer.hpp>
#include <catch2/catch.hpp>
namespace pl = mart::nw::socks::port_layer;
namespace socks = mart::nw::socks;
// call ech function at least once to ensure the implementation is there
TEST_CASE( "net_port-layer_check_function_implementation_exists" )
{
[[maybe_unused]] auto nh = pl::to_native( pl::handle_t::Invalid );
[[maybe_unused]] int d = pl::to_native( socks::Domain::Inet );
[[maybe_unused]] int t = pl::to_native( socks::TransportType::Datagram );
[[maybe_unused]] int p = pl::to_native( socks::Protocol::Tcp );
socks::ReturnValue<pl::handle_t> ts
= pl::socket( socks::Domain::Inet, socks::TransportType::Datagram, socks::Protocol::Default );
CHECK( ts.success() );
CHECK( ts.value_or( pl::handle_t::Invalid ) != pl::handle_t::Invalid );
pl::close_socket( ts.value_or( pl::handle_t::Invalid ) );
pl::handle_t s2 = pl::socket( socks::Domain::Inet, socks::TransportType::Datagram )
.value_or( pl::handle_t::Invalid );
CHECK( s2 != pl::handle_t::Invalid );
pl::SockaddrIn addr {};
CHECK( set_blocking( s2, false ) );
CHECK( !accept( s2 ) );
CHECK( !accept( s2,addr ) );
// CHECK( connect( s2,addr ) ); // TODO: connect to empty works on some platforms but not on all
CHECK( !bind( s2, addr ) );
CHECK( !listen( s2, 10 ) );
}
<commit_msg>[Netlib] Deactivate non-portable checks for now<commit_after>#include <mart-netlib/port_layer.hpp>
#include <catch2/catch.hpp>
namespace pl = mart::nw::socks::port_layer;
namespace socks = mart::nw::socks;
// call ech function at least once to ensure the implementation is there
TEST_CASE( "net_port-layer_check_function_implementation_exists" )
{
[[maybe_unused]] auto nh = pl::to_native( pl::handle_t::Invalid );
[[maybe_unused]] int d = pl::to_native( socks::Domain::Inet );
[[maybe_unused]] int t = pl::to_native( socks::TransportType::Datagram );
[[maybe_unused]] int p = pl::to_native( socks::Protocol::Tcp );
socks::ReturnValue<pl::handle_t> ts
= pl::socket( socks::Domain::Inet, socks::TransportType::Datagram, socks::Protocol::Default );
CHECK( ts.success() );
CHECK( ts.value_or( pl::handle_t::Invalid ) != pl::handle_t::Invalid );
pl::close_socket( ts.value_or( pl::handle_t::Invalid ) );
pl::handle_t s2
= pl::socket( socks::Domain::Inet, socks::TransportType::Datagram ).value_or( pl::handle_t::Invalid );
CHECK( s2 != pl::handle_t::Invalid );
pl::SockaddrIn addr {};
CHECK( set_blocking( s2, false ) );
CHECK( !accept( s2 ) );
CHECK( !accept( s2, addr ) );
// CHECK( connect( s2,addr ) ); // TODO: connect to empty works on some platforms but not on all
connect( s2, addr );
// CHECK( !bind( s2, addr ) );
bind( s2, addr );
// CHECK( !listen( s2, 10 ) );
listen( s2, 10 );
}
<|endoftext|> |
<commit_before>#include <cstdint>
#include <algorithm>
#include "Schema.hpp"
void newOrder (int32_t w_id, int32_t d_id, int32_t c_id, int32_t items, int32_t supware[15], int32_t itemid[15], int32_t qty[15], Timestamp datetime) {
// select w_tax from warehouse w where w.w_id=w_id;
auto warehouse_iter = std::find_if(warehouse.begin(), warehouse.end(), [=](auto& row){return row.w_id == w_id;});
if(warehouse_iter == warehouse.end()) {
throw "warehouse entry not found";
}
auto w_tax = (*warehouse_iter).w_tax();
// select c_discount from customer c where c_w_id=w_id and c_d_id=d_id and c.c_id=c_id;
auto customer_iter = std::find_if(customer.begin(), customer.end(), [=](auto& row){return row.c_w_id()==w_id && row.c_d_id()==d_id && row.c_c_id()=c_id;});
if(customer_iter == customer.end()) {
throw "customer entry not found";
}
auto c_discount = (*customer_iter).c_discount();
// select d_next_o_id as o_id,d_tax from district d where d_w_id=w_id and d.d_id=d_id;
auto district_iter = std::find_if(district.begin(), district.end(), [=](auto& row){return row.d_w_id()==w_id && row.d_id()==d_id;});
if(district_iter == district.end()) {
throw "district entry not found";
}
auto o_id = (*district_iter).d_next_o_id();
auto d_tax = (*district_iter).d_tax();
// update district set d_next_o_id=o_id+1 where d_w_id=w_id and district.d_id=d_id;
(*district_iter).d_next_o_id() = o_id+1;
auto all_local = true;
for (int32_t i = 0; i < items; i++) {
if(w_id != supware[i]) all_local = false;
}
// insert into "order" values (o_id,d_id,w_id,c_id,datetime,0,items,all_local);
order.o_id() .push_back(o_id);
order.o_d_id() .push_back(d_id);
order.o_w_id() .push_back(w_id);
order.o_c_id() .push_back(c_id);
order.o_entry_d() .push_back(datetime);
order.o_carrier_id().push_back(0);
order.o_ol_cnt() .push_back(items);
order.o_all_local() .push_back(all_local);
// insert into neworder values (o_id,d_id,w_id);
neworder.no_o_id().push_back(o_id);
neworder.no_d_id().push_back(d_id);
neworder.no_w_id().push_back(w_id);
for (int32_t index = 0; index < items; index++) {
// select i_price from item where i_id=itemid[index];
auto item_iter = std::find_if(item.begin(), item.end(), [=](auto& row){return row.i_id() == itemid[index];});
if(item_iter == item.end()) {
throw "item entry not found";
}
auto i_price = (*item_iter).i_price();
// select s_quantity,s_remote_cnt,s_order_cnt,case d_id when 1 then s_dist_01 when 2 then s_dist_02 ... end as s_dist from stock where s_w_id=supware[index] and s_i_id=itemid[index];
auto stock_iter = std::find_if(stock.begin(), stock.end(), [=](auto& row){return row.s_w_id() == supware[index] && row.s_i_id() == itemid[index];});
if(stock_iter == stock.end()) {
throw "stock entry not found";
}
auto s_quantity = (*stock_iter).s_quantity();
auto s_remote_cnt = (*stock_iter).s_remote_cnt();
auto s_order_cnt = (*stock_iter).s_order_cnt();
Char<24> s_dist;
switch (d_id) {
case 1: s_dist = (*stock_iter).s_dist_01(); break;
case 2: s_dist = (*stock_iter).s_dist_02(); break;
case 3: s_dist = (*stock_iter).s_dist_03(); break;
case 4: s_dist = (*stock_iter).s_dist_04(); break;
case 5: s_dist = (*stock_iter).s_dist_05(); break;
case 6: s_dist = (*stock_iter).s_dist_06(); break;
case 7: s_dist = (*stock_iter).s_dist_07(); break;
case 8: s_dist = (*stock_iter).s_dist_08(); break;
case 9: s_dist = (*stock_iter).s_dist_09(); break;
case 10: s_dist = (*stock_iter).s_dist_10(); break;
default: throw "invalid d_id";;
}
if (s_quantity > qty[index]) {
// update stock set s_quantity=s_quantity-qty[index] where s_w_id=supware[index] and s_i_id=itemid[index];
(*stock_iter).s_quantity() = s_quantity-qty[index];
} else {
// update stock set s_quantity=s_quantity+91-qty[index] where s_w_id=supware[index] and s_i_id=itemid[index];
(*stock_iter).s_quantity() = s_quantity+91-qty[index];
}
auto stock_iter2 = std::find_if(stock.begin(), stock.end(), [=](auto& row){return row.s_w_id() == w_id && row.s_i_id() == itemid[index];});
if(stock_iter2 == stock.end()) {
throw "stock entry not found";
}
if (supware[index]!=w_id) {
// update stock set s_remote_cnt=s_remote_cnt+1 where s_w_id=w_id and s_i_id=itemid[index];
(*stock_iter2).s_remote_cnt() = (*stock_iter2).s_remote_cnt() + 1;
} else {
// update stock set s_order_cnt=s_order_cnt+1 where s_w_id=w_id and s_i_id=itemid[index];
(*stock_iter2).s_order_cnt() = (*stock_iter2).s_order_cnt() + 1;
}
// var numeric(6,2) ol_amount=qty[index]*i_price*(1.0+w_tax+d_tax)*(1.0-c_discount);
Numeric<6,2> ol_amount = Numeric<5,4>{i_price}*Numeric<5,4>{qty[index]}*Numeric<4,4>{i_price}*(Numeric<4,4>(10000)-c_discount) * (Numeric<4,4>(10000)+w_tax+d_tax);
// insert into orderline values (o_id,d_id,w_id,index+1,itemid[index],supware[index],0,qty[index],ol_amount,s_dist);
orderline.ol_o_id() .push_back(o_id);
orderline.ol_d_id() .push_back(d_id);
orderline.ol_w_id() .push_back(w_id);
orderline.ol_number() .push_back(index+1);
orderline.ol_i_id() .push_back(itemid[index]);
orderline.ol_supply_w_id().push_back(supware[index]);
orderline.ol_delivery_d() .push_back(0);
orderline.ol_quantity() .push_back(qty[index]);
orderline.ol_amount() .push_back(ol_amount);
orderline.ol_dist_info() .push_back(s_dist);
}
}
<commit_msg> newOrder: correct fixed-point arithemtics<commit_after>#include <cstdint>
#include <algorithm>
#include "Schema.hpp"
void newOrder (int32_t w_id, int32_t d_id, int32_t c_id, int32_t items, int32_t supware[15], int32_t itemid[15], int32_t qty[15], Timestamp datetime) {
// select w_tax from warehouse w where w.w_id=w_id;
auto warehouse_iter = std::find_if(warehouse.begin(), warehouse.end(), [=](auto& row){return row.w_id == w_id;});
if(warehouse_iter == warehouse.end()) {
throw "warehouse entry not found";
}
auto w_tax = (*warehouse_iter).w_tax();
// select c_discount from customer c where c_w_id=w_id and c_d_id=d_id and c.c_id=c_id;
auto customer_iter = std::find_if(customer.begin(), customer.end(), [=](auto& row){return row.c_w_id()==w_id && row.c_d_id()==d_id && row.c_c_id()=c_id;});
if(customer_iter == customer.end()) {
throw "customer entry not found";
}
auto c_discount = (*customer_iter).c_discount();
// select d_next_o_id as o_id,d_tax from district d where d_w_id=w_id and d.d_id=d_id;
auto district_iter = std::find_if(district.begin(), district.end(), [=](auto& row){return row.d_w_id()==w_id && row.d_id()==d_id;});
if(district_iter == district.end()) {
throw "district entry not found";
}
auto o_id = (*district_iter).d_next_o_id();
auto d_tax = (*district_iter).d_tax();
// update district set d_next_o_id=o_id+1 where d_w_id=w_id and district.d_id=d_id;
(*district_iter).d_next_o_id() = o_id+1;
auto all_local = true;
for (int32_t i = 0; i < items; i++) {
if(w_id != supware[i]) all_local = false;
}
// insert into "order" values (o_id,d_id,w_id,c_id,datetime,0,items,all_local);
order.o_id() .push_back(o_id);
order.o_d_id() .push_back(d_id);
order.o_w_id() .push_back(w_id);
order.o_c_id() .push_back(c_id);
order.o_entry_d() .push_back(datetime);
order.o_carrier_id().push_back(0);
order.o_ol_cnt() .push_back(items);
order.o_all_local() .push_back(all_local);
// insert into neworder values (o_id,d_id,w_id);
neworder.no_o_id().push_back(o_id);
neworder.no_d_id().push_back(d_id);
neworder.no_w_id().push_back(w_id);
for (int32_t index = 0; index < items; index++) {
// select i_price from item where i_id=itemid[index];
auto item_iter = std::find_if(item.begin(), item.end(), [=](auto& row){return row.i_id() == itemid[index];});
if(item_iter == item.end()) {
throw "item entry not found";
}
auto i_price = (*item_iter).i_price();
// select s_quantity,s_remote_cnt,s_order_cnt,case d_id when 1 then s_dist_01 when 2 then s_dist_02 ... end as s_dist from stock where s_w_id=supware[index] and s_i_id=itemid[index];
auto stock_iter = std::find_if(stock.begin(), stock.end(), [=](auto& row){return row.s_w_id() == supware[index] && row.s_i_id() == itemid[index];});
if(stock_iter == stock.end()) {
throw "stock entry not found";
}
auto s_quantity = (*stock_iter).s_quantity();
auto s_remote_cnt = (*stock_iter).s_remote_cnt();
auto s_order_cnt = (*stock_iter).s_order_cnt();
Char<24> s_dist;
switch (d_id) {
case 1: s_dist = (*stock_iter).s_dist_01(); break;
case 2: s_dist = (*stock_iter).s_dist_02(); break;
case 3: s_dist = (*stock_iter).s_dist_03(); break;
case 4: s_dist = (*stock_iter).s_dist_04(); break;
case 5: s_dist = (*stock_iter).s_dist_05(); break;
case 6: s_dist = (*stock_iter).s_dist_06(); break;
case 7: s_dist = (*stock_iter).s_dist_07(); break;
case 8: s_dist = (*stock_iter).s_dist_08(); break;
case 9: s_dist = (*stock_iter).s_dist_09(); break;
case 10: s_dist = (*stock_iter).s_dist_10(); break;
default: throw "invalid d_id";;
}
if (s_quantity > qty[index]) {
// update stock set s_quantity=s_quantity-qty[index] where s_w_id=supware[index] and s_i_id=itemid[index];
(*stock_iter).s_quantity() = s_quantity-qty[index];
} else {
// update stock set s_quantity=s_quantity+91-qty[index] where s_w_id=supware[index] and s_i_id=itemid[index];
(*stock_iter).s_quantity() = s_quantity+91-qty[index];
}
auto stock_iter2 = std::find_if(stock.begin(), stock.end(), [=](auto& row){return row.s_w_id() == w_id && row.s_i_id() == itemid[index];});
if(stock_iter2 == stock.end()) {
throw "stock entry not found";
}
if (supware[index]!=w_id) {
// update stock set s_remote_cnt=s_remote_cnt+1 where s_w_id=w_id and s_i_id=itemid[index];
(*stock_iter2).s_remote_cnt() = (*stock_iter2).s_remote_cnt() + 1;
} else {
// update stock set s_order_cnt=s_order_cnt+1 where s_w_id=w_id and s_i_id=itemid[index];
(*stock_iter2).s_order_cnt() = (*stock_iter2).s_order_cnt() + 1;
}
// var numeric(6,2) ol_amount=qty[index]*i_price*(1.0+w_tax+d_tax)*(1.0-c_discount);
auto ol_amount = Numeric<6,2>{Numeric<6,2>{qty[index]}*Numeric<6,2>{i_price}*Numeric<6,4>{(Numeric<4,4>(10000)-c_discount) * (Numeric<4,4>(10000)+w_tax+d_tax)}};
// insert into orderline values (o_id,d_id,w_id,index+1,itemid[index],supware[index],0,qty[index],ol_amount,s_dist);
orderline.ol_o_id() .push_back(o_id);
orderline.ol_d_id() .push_back(d_id);
orderline.ol_w_id() .push_back(w_id);
orderline.ol_number() .push_back(index+1);
orderline.ol_i_id() .push_back(itemid[index]);
orderline.ol_supply_w_id().push_back(supware[index]);
orderline.ol_delivery_d() .push_back(0);
orderline.ol_quantity() .push_back(qty[index]);
orderline.ol_amount() .push_back(ol_amount);
orderline.ol_dist_info() .push_back(s_dist);
}
}
<|endoftext|> |
<commit_before>// Copyright 2019 The TCMalloc Authors
//
// 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
//
// https://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 "tcmalloc/common.h"
#include <algorithm>
#include "tcmalloc/experiment.h"
#include "tcmalloc/internal/environment.h"
#include "tcmalloc/internal/optimization.h"
#include "tcmalloc/pages.h"
#include "tcmalloc/runtime_size_classes.h"
#include "tcmalloc/sampler.h"
GOOGLE_MALLOC_SECTION_BEGIN
namespace tcmalloc {
namespace tcmalloc_internal {
ABSL_CONST_INIT std::atomic<bool> hot_cold_pageheap_active{true};
absl::string_view MemoryTagToLabel(MemoryTag tag) {
switch (tag) {
case MemoryTag::kNormal:
return "NORMAL";
case MemoryTag::kNormalP1:
return "NORMAL_P1";
case MemoryTag::kSampled:
return "SAMPLED";
case MemoryTag::kCold:
return "COLD";
default:
ASSUME(false);
}
}
// Load sizes classes from environment variable if present
// and valid, then returns True. If not found or valid, returns
// False.
bool SizeMap::MaybeRunTimeSizeClasses() {
SizeClassInfo parsed[kNumClasses];
int num_classes = MaybeSizeClassesFromEnv(kMaxSize, kNumClasses, parsed);
if (!ValidSizeClasses(num_classes, parsed)) {
return false;
}
if (num_classes != kSizeClassesCount) {
// TODO(b/122839049) - Add tests for num_classes < kSizeClassesCount before
// allowing that case.
Log(kLog, __FILE__, __LINE__, "Can't change the number of size classes",
num_classes, kSizeClassesCount);
return false;
}
SetSizeClasses(num_classes, parsed);
Log(kLog, __FILE__, __LINE__, "Loaded valid Runtime Size classes");
return true;
}
void SizeMap::SetSizeClasses(int num_classes, const SizeClassInfo* parsed) {
CHECK_CONDITION(ValidSizeClasses(num_classes, parsed));
class_to_size_[0] = 0;
class_to_pages_[0] = 0;
num_objects_to_move_[0] = 0;
for (int c = 1; c < num_classes; c++) {
class_to_size_[c] = parsed[c].size;
class_to_pages_[c] = parsed[c].pages;
num_objects_to_move_[c] = parsed[c].num_to_move;
}
// Fill any unspecified size classes with 0.
for (int x = num_classes; x < kNumBaseClasses; x++) {
class_to_size_[x] = 0;
class_to_pages_[x] = 0;
num_objects_to_move_[x] = 0;
}
// Copy selected size classes into the upper registers.
for (int i = 1; i < (kNumClasses / kNumBaseClasses); i++) {
std::copy(&class_to_size_[0], &class_to_size_[kNumBaseClasses],
&class_to_size_[kNumBaseClasses * i]);
std::copy(&class_to_pages_[0], &class_to_pages_[kNumBaseClasses],
&class_to_pages_[kNumBaseClasses * i]);
std::copy(&num_objects_to_move_[0], &num_objects_to_move_[kNumBaseClasses],
&num_objects_to_move_[kNumBaseClasses * i]);
}
}
// Return true if all size classes meet the requirements for alignment
// ordering and min and max values.
bool SizeMap::ValidSizeClasses(int num_classes, const SizeClassInfo* parsed) {
if (num_classes <= 0) {
return false;
}
if (kHasExpandedClasses && num_classes > kNumBaseClasses) {
num_classes = kNumBaseClasses;
}
for (int c = 1; c < num_classes; c++) {
size_t class_size = parsed[c].size;
size_t pages = parsed[c].pages;
size_t num_objects_to_move = parsed[c].num_to_move;
// Each size class must be larger than the previous size class.
if (class_size <= parsed[c - 1].size) {
Log(kLog, __FILE__, __LINE__, "Non-increasing size class", c,
parsed[c - 1].size, class_size);
return false;
}
if (class_size > kMaxSize) {
Log(kLog, __FILE__, __LINE__, "size class too big", c, class_size,
kMaxSize);
return false;
}
// Check required alignment
size_t alignment = 128;
if (class_size <= kMultiPageSize) {
alignment = kAlignment;
} else if (class_size <= SizeMap::kMaxSmallSize) {
alignment = kMultiPageAlignment;
}
if ((class_size & (alignment - 1)) != 0) {
Log(kLog, __FILE__, __LINE__, "Not aligned properly", c, class_size,
alignment);
return false;
}
if (class_size <= kMultiPageSize && pages != 1) {
Log(kLog, __FILE__, __LINE__, "Multiple pages not allowed", class_size,
pages, kMultiPageSize);
return false;
}
if (pages >= 256) {
Log(kLog, __FILE__, __LINE__, "pages limited to 255", pages);
return false;
}
if (num_objects_to_move > kMaxObjectsToMove) {
Log(kLog, __FILE__, __LINE__, "num objects to move too large",
num_objects_to_move, kMaxObjectsToMove);
return false;
}
}
// Last size class must be kMaxSize. This is not strictly
// class_to_size_[kNumBaseClasses - 1] because several size class
// configurations populate fewer distinct size classes and fill the tail of
// the array with zeroes.
if (parsed[num_classes - 1].size != kMaxSize) {
Log(kLog, __FILE__, __LINE__, "last class doesn't cover kMaxSize",
num_classes - 1, parsed[num_classes - 1].size, kMaxSize);
return false;
}
return true;
}
// Initialize the mapping arrays
void SizeMap::Init() {
// Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
if (ClassIndex(0) != 0) {
Crash(kCrash, __FILE__, __LINE__, "Invalid class index for size 0",
ClassIndex(0));
}
if (ClassIndex(kMaxSize) >= sizeof(class_array_)) {
Crash(kCrash, __FILE__, __LINE__, "Invalid class index for kMaxSize",
ClassIndex(kMaxSize));
}
static_assert(kAlignment <= 16, "kAlignment is too large");
if (IsExperimentActive(Experiment::TEST_ONLY_TCMALLOC_POW2_SIZECLASS)) {
SetSizeClasses(kExperimentalPow2SizeClassesCount,
kExperimentalPow2SizeClasses);
} else if (IsExperimentActive(Experiment::TCMALLOC_POW2_BELOW_64) ||
IsExperimentActive(
Experiment::TEST_ONLY_TCMALLOC_POW2_BELOW64_SIZECLASS)) {
SetSizeClasses(kExperimentalPow2Below64SizeClassesCount,
kExperimentalPow2Below64SizeClasses);
} else if (IsExperimentActive(
Experiment::TEST_ONLY_TCMALLOC_CFL_AWARE_SIZECLASS)) {
SetSizeClasses(kExperimentalCFLAwareSizeClassesCount,
kExperimentalCFLAwareSizeClasses);
} else {
SetSizeClasses(kSizeClassesCount, kSizeClasses);
}
MaybeRunTimeSizeClasses();
int next_size = 0;
for (int c = 1; c < kNumClasses; c++) {
const int max_size_in_class = class_to_size_[c];
for (int s = next_size; s <= max_size_in_class; s += kAlignment) {
class_array_[ClassIndex(s)] = c;
}
next_size = max_size_in_class + kAlignment;
if (next_size > kMaxSize) {
break;
}
}
if (!kHasExpandedClasses) {
return;
}
memset(cold_sizes_, 0, sizeof(cold_sizes_));
cold_sizes_count_ = 0;
// Initialize hot_cold_pageheap_active.
const char* e = thread_safe_getenv("TCMALLOC_HOTCOLD_CONTROL");
if (e) {
switch (e[0]) {
case '0':
hot_cold_pageheap_active.store(false, std::memory_order_relaxed);
break;
case '1':
// Do nothing.
ASSERT(hot_cold_pageheap_active.load(std::memory_order_relaxed));
break;
default:
Crash(kCrash, __FILE__, __LINE__, "bad env var", e);
break;
}
}
if (!ColdExperimentActive()) {
std::copy(&class_array_[0], &class_array_[kClassArraySize],
&class_array_[kClassArraySize]);
return;
}
// TODO(b/124707070): Systematically identify candidates for cold allocation
// and include them explicitly in size_classes.cc.
ABSL_CONST_INIT static constexpr size_t kColdCandidates[] = {
2048, 4096, 6144, 7168, 8192, 16384,
20480, 32768, 40960, 65536, 131072, 262144,
};
static_assert(ABSL_ARRAYSIZE(kColdCandidates) <= ABSL_ARRAYSIZE(cold_sizes_),
"kColdCandidates is too large.");
// Point all lookups in the upper register of class_array_ (allocations
// seeking cold memory) to the lower size classes. This gives us an easy
// fallback for sizes that are too small for moving to cold memory (due to
// intrusive span metadata).
std::copy(&class_array_[0], &class_array_[kClassArraySize],
&class_array_[kClassArraySize]);
for (size_t max_size_in_class : kColdCandidates) {
ASSERT(max_size_in_class != 0);
// Find the size class. Some of our kColdCandidates may not map to actual
// size classes in our current configuration.
bool found = false;
int c;
for (c = kExpandedClassesStart; c < kNumClasses; c++) {
if (class_to_size_[c] == max_size_in_class) {
found = true;
break;
}
}
if (!found) {
continue;
}
// Verify the candidate can fit into a single span's kCacheSize, otherwise,
// we use an intrusive freelist which triggers memory accesses.
if (Length(class_to_pages_[c]).in_bytes() / max_size_in_class >
Span::kCacheSize) {
continue;
}
cold_sizes_[cold_sizes_count_] = c;
cold_sizes_count_++;
for (int s = next_size; s <= max_size_in_class; s += kAlignment) {
class_array_[ClassIndex(s) + kClassArraySize] = c;
}
next_size = max_size_in_class + kAlignment;
if (next_size > kMaxSize) {
break;
}
}
}
extern "C" bool TCMalloc_Internal_ColdExperimentActive() {
return ColdExperimentActive();
}
// This only provides correct answer for TCMalloc-allocated memory,
// and may give a false positive for non-allocated block.
extern "C" bool TCMalloc_Internal_PossiblyCold(const void* ptr) {
return IsColdMemory(ptr);
}
} // namespace tcmalloc_internal
} // namespace tcmalloc
GOOGLE_MALLOC_SECTION_END
<commit_msg>Fix two C++20 compatibility issues.<commit_after>// Copyright 2019 The TCMalloc Authors
//
// 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
//
// https://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 "tcmalloc/common.h"
#include <algorithm>
#include "tcmalloc/experiment.h"
#include "tcmalloc/internal/environment.h"
#include "tcmalloc/internal/optimization.h"
#include "tcmalloc/pages.h"
#include "tcmalloc/runtime_size_classes.h"
#include "tcmalloc/sampler.h"
GOOGLE_MALLOC_SECTION_BEGIN
namespace tcmalloc {
namespace tcmalloc_internal {
ABSL_CONST_INIT std::atomic<bool> hot_cold_pageheap_active{true};
absl::string_view MemoryTagToLabel(MemoryTag tag) {
switch (tag) {
case MemoryTag::kNormal:
return "NORMAL";
case MemoryTag::kNormalP1:
return "NORMAL_P1";
case MemoryTag::kSampled:
return "SAMPLED";
case MemoryTag::kCold:
return "COLD";
default:
ASSUME(false);
}
}
// Load sizes classes from environment variable if present
// and valid, then returns True. If not found or valid, returns
// False.
bool SizeMap::MaybeRunTimeSizeClasses() {
SizeClassInfo parsed[kNumClasses];
int num_classes = MaybeSizeClassesFromEnv(kMaxSize, kNumClasses, parsed);
if (!ValidSizeClasses(num_classes, parsed)) {
return false;
}
if (num_classes != kSizeClassesCount) {
// TODO(b/122839049) - Add tests for num_classes < kSizeClassesCount before
// allowing that case.
Log(kLog, __FILE__, __LINE__, "Can't change the number of size classes",
num_classes, kSizeClassesCount);
return false;
}
SetSizeClasses(num_classes, parsed);
Log(kLog, __FILE__, __LINE__, "Loaded valid Runtime Size classes");
return true;
}
void SizeMap::SetSizeClasses(int num_classes, const SizeClassInfo* parsed) {
CHECK_CONDITION(ValidSizeClasses(num_classes, parsed));
class_to_size_[0] = 0;
class_to_pages_[0] = 0;
num_objects_to_move_[0] = 0;
for (int c = 1; c < num_classes; c++) {
class_to_size_[c] = parsed[c].size;
class_to_pages_[c] = parsed[c].pages;
num_objects_to_move_[c] = parsed[c].num_to_move;
}
// Fill any unspecified size classes with 0.
for (int x = num_classes; x < kNumBaseClasses; x++) {
class_to_size_[x] = 0;
class_to_pages_[x] = 0;
num_objects_to_move_[x] = 0;
}
// Copy selected size classes into the upper registers.
for (int i = 1; i < (kNumClasses / kNumBaseClasses); i++) {
std::copy(&class_to_size_[0], &class_to_size_[kNumBaseClasses],
&class_to_size_[kNumBaseClasses * i]);
std::copy(&class_to_pages_[0], &class_to_pages_[kNumBaseClasses],
&class_to_pages_[kNumBaseClasses * i]);
std::copy(&num_objects_to_move_[0], &num_objects_to_move_[kNumBaseClasses],
&num_objects_to_move_[kNumBaseClasses * i]);
}
}
// Return true if all size classes meet the requirements for alignment
// ordering and min and max values.
bool SizeMap::ValidSizeClasses(int num_classes, const SizeClassInfo* parsed) {
if (num_classes <= 0) {
return false;
}
if (kHasExpandedClasses && num_classes > kNumBaseClasses) {
num_classes = kNumBaseClasses;
}
for (int c = 1; c < num_classes; c++) {
size_t class_size = parsed[c].size;
size_t pages = parsed[c].pages;
size_t num_objects_to_move = parsed[c].num_to_move;
// Each size class must be larger than the previous size class.
if (class_size <= parsed[c - 1].size) {
Log(kLog, __FILE__, __LINE__, "Non-increasing size class", c,
parsed[c - 1].size, class_size);
return false;
}
if (class_size > kMaxSize) {
Log(kLog, __FILE__, __LINE__, "size class too big", c, class_size,
kMaxSize);
return false;
}
// Check required alignment
size_t alignment = 128;
if (class_size <= kMultiPageSize) {
alignment = kAlignment;
} else if (class_size <= SizeMap::kMaxSmallSize) {
alignment = kMultiPageAlignment;
}
if ((class_size & (alignment - 1)) != 0) {
Log(kLog, __FILE__, __LINE__, "Not aligned properly", c, class_size,
alignment);
return false;
}
if (class_size <= kMultiPageSize && pages != 1) {
Log(kLog, __FILE__, __LINE__, "Multiple pages not allowed", class_size,
pages, kMultiPageSize);
return false;
}
if (pages >= 256) {
Log(kLog, __FILE__, __LINE__, "pages limited to 255", pages);
return false;
}
if (num_objects_to_move > kMaxObjectsToMove) {
Log(kLog, __FILE__, __LINE__, "num objects to move too large",
num_objects_to_move, kMaxObjectsToMove);
return false;
}
}
// Last size class must be kMaxSize. This is not strictly
// class_to_size_[kNumBaseClasses - 1] because several size class
// configurations populate fewer distinct size classes and fill the tail of
// the array with zeroes.
if (parsed[num_classes - 1].size != kMaxSize) {
Log(kLog, __FILE__, __LINE__, "last class doesn't cover kMaxSize",
num_classes - 1, parsed[num_classes - 1].size, kMaxSize);
return false;
}
return true;
}
// Initialize the mapping arrays
void SizeMap::Init() {
// Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
if (ClassIndex(0) != 0) {
Crash(kCrash, __FILE__, __LINE__, "Invalid class index for size 0",
ClassIndex(0));
}
if (ClassIndex(kMaxSize) >= sizeof(class_array_)) {
Crash(kCrash, __FILE__, __LINE__, "Invalid class index for kMaxSize",
ClassIndex(kMaxSize));
}
static_assert(kAlignment <= 16, "kAlignment is too large");
if (IsExperimentActive(Experiment::TEST_ONLY_TCMALLOC_POW2_SIZECLASS)) {
SetSizeClasses(kExperimentalPow2SizeClassesCount,
kExperimentalPow2SizeClasses);
} else if (IsExperimentActive(Experiment::TCMALLOC_POW2_BELOW_64) ||
IsExperimentActive(
Experiment::TEST_ONLY_TCMALLOC_POW2_BELOW64_SIZECLASS)) {
SetSizeClasses(kExperimentalPow2Below64SizeClassesCount,
kExperimentalPow2Below64SizeClasses);
} else if (IsExperimentActive(
Experiment::TEST_ONLY_TCMALLOC_CFL_AWARE_SIZECLASS)) {
SetSizeClasses(kExperimentalCFLAwareSizeClassesCount,
kExperimentalCFLAwareSizeClasses);
} else {
SetSizeClasses(kSizeClassesCount, kSizeClasses);
}
MaybeRunTimeSizeClasses();
int next_size = 0;
for (int c = 1; c < kNumClasses; c++) {
const int max_size_in_class = class_to_size_[c];
for (int s = next_size; s <= max_size_in_class; s += kAlignment) {
class_array_[ClassIndex(s)] = c;
}
next_size = max_size_in_class + kAlignment;
if (next_size > kMaxSize) {
break;
}
}
if (!kHasExpandedClasses) {
return;
}
memset(cold_sizes_, 0, sizeof(cold_sizes_));
cold_sizes_count_ = 0;
// Initialize hot_cold_pageheap_active.
const char* e = thread_safe_getenv("TCMALLOC_HOTCOLD_CONTROL");
if (e) {
switch (e[0]) {
case '0':
hot_cold_pageheap_active.store(false, std::memory_order_relaxed);
break;
case '1':
// Do nothing.
ASSERT(hot_cold_pageheap_active.load(std::memory_order_relaxed));
break;
default:
Crash(kCrash, __FILE__, __LINE__, "bad env var", e);
break;
}
}
if (!ColdExperimentActive()) {
std::copy(&class_array_[0], &class_array_[kClassArraySize],
&class_array_[kClassArraySize]);
return;
}
// TODO(b/124707070): Systematically identify candidates for cold allocation
// and include them explicitly in size_classes.cc.
static constexpr size_t kColdCandidates[] = {
2048, 4096, 6144, 7168, 8192, 16384,
20480, 32768, 40960, 65536, 131072, 262144,
};
static_assert(ABSL_ARRAYSIZE(kColdCandidates) <= ABSL_ARRAYSIZE(cold_sizes_),
"kColdCandidates is too large.");
// Point all lookups in the upper register of class_array_ (allocations
// seeking cold memory) to the lower size classes. This gives us an easy
// fallback for sizes that are too small for moving to cold memory (due to
// intrusive span metadata).
std::copy(&class_array_[0], &class_array_[kClassArraySize],
&class_array_[kClassArraySize]);
for (size_t max_size_in_class : kColdCandidates) {
ASSERT(max_size_in_class != 0);
// Find the size class. Some of our kColdCandidates may not map to actual
// size classes in our current configuration.
bool found = false;
int c;
for (c = kExpandedClassesStart; c < kNumClasses; c++) {
if (class_to_size_[c] == max_size_in_class) {
found = true;
break;
}
}
if (!found) {
continue;
}
// Verify the candidate can fit into a single span's kCacheSize, otherwise,
// we use an intrusive freelist which triggers memory accesses.
if (Length(class_to_pages_[c]).in_bytes() / max_size_in_class >
Span::kCacheSize) {
continue;
}
cold_sizes_[cold_sizes_count_] = c;
cold_sizes_count_++;
for (int s = next_size; s <= max_size_in_class; s += kAlignment) {
class_array_[ClassIndex(s) + kClassArraySize] = c;
}
next_size = max_size_in_class + kAlignment;
if (next_size > kMaxSize) {
break;
}
}
}
extern "C" bool TCMalloc_Internal_ColdExperimentActive() {
return ColdExperimentActive();
}
// This only provides correct answer for TCMalloc-allocated memory,
// and may give a false positive for non-allocated block.
extern "C" bool TCMalloc_Internal_PossiblyCold(const void* ptr) {
return IsColdMemory(ptr);
}
} // namespace tcmalloc_internal
} // namespace tcmalloc
GOOGLE_MALLOC_SECTION_END
<|endoftext|> |
<commit_before>/**
* @file
* @author Alexander Sherikov
* @brief Simulate control loop, which is shorter than preview window iteration.
*/
#include <cstring> //strcmp
#include "tests_common.h"
///@addtogroup gTEST
///@{
int main(int argc, char **argv)
{
//-----------------------------------------------------------
// the numbers must correspond to the numbers in init_04()
int control_sampling_time_ms = 10;
int preview_sampling_time_ms = 100;
int next_preview_len_ms = 0;
// initialize
WMG wmg;
init_04 (&wmg);
std::string fs_out_filename("test_07_fs.m");
wmg.FS2file(fs_out_filename); // output results for later use in Matlab/Octave
//-----------------------------------------------------------
test_start(argv[0]);
//-----------------------------------------------------------
smpc::solver solver(
wmg.N, // size of the preview window
300.0, // Alpha
800.0, // Beta
1.0, // Gamma
0.01, // regularization
1e-7); // tolerance
//-----------------------------------------------------------
//-----------------------------------------------------------
wmg.initABMatrices ((double) control_sampling_time_ms / 1000);
wmg.init_state.set (0.019978839010709938, -6.490507362468014e-05);
// state_tilde = state_orig, when velocity = acceleration = 0
wmg.X_tilde.set (0.019978839010709938, -6.490507362468014e-05);
//-----------------------------------------------------------
FILE *file_op = fopen(fs_out_filename.c_str(), "a");
fprintf(file_op,"hold on\n");
vector<double> ZMP_ref_x;
vector<double> ZMP_ref_y;
vector<double> ZMP_x;
vector<double> ZMP_y;
vector<double> CoM_x;
vector<double> CoM_y;
vector<double> swing_foot_x;
vector<double> swing_foot_y;
vector<double> swing_foot_z;
for(int i=0 ;; i++)
{
if (next_preview_len_ms == 0)
{
WMGret wmg_retval = wmg.FormPreviewWindow();
if (wmg_retval == WMG_HALT)
{
cout << "EXIT (halt = 1)" << endl;
break;
}
ZMP_ref_x.push_back(wmg.zref_x[0]);
ZMP_ref_y.push_back(wmg.zref_y[0]);
next_preview_len_ms = preview_sampling_time_ms;
}
//------------------------------------------------------
wmg.T[0] = (double) next_preview_len_ms / 1000; // get seconds
solver.set_parameters (wmg.T, wmg.h, wmg.h[0], wmg.angle, wmg.zref_x, wmg.zref_y, wmg.lb, wmg.ub);
solver.form_init_fp (wmg.fp_x, wmg.fp_y, wmg.init_state, wmg.X);
solver.solve();
//------------------------------------------------------
// update state
wmg.next_control.get_first_controls (solver);
wmg.calculateNextState(wmg.next_control, wmg.init_state);
//-----------------------------------------------------------
if (next_preview_len_ms == preview_sampling_time_ms)
{
// if the values are saved on each iteration the plot becomes sawlike.
// better solution - more frequent sampling.
ZMP_x.push_back(wmg.X_tilde.x());
ZMP_y.push_back(wmg.X_tilde.y());
wmg.X_tilde.get_next_state (solver);
}
CoM_x.push_back(wmg.init_state.x());
CoM_y.push_back(wmg.init_state.y());
// support foot and swing foot position/orientation
double LegPos[3];
double angle;
/* wrong, but makes nice graph */
wmg.getSwingFootPosition (
WMG_SWING_2D_PARABOLA,
preview_sampling_time_ms / control_sampling_time_ms,
(preview_sampling_time_ms - next_preview_len_ms) / control_sampling_time_ms,
LegPos,
&angle);
/* correct
wmg.getSwingFootPosition (
WMG_SWING_2D_PARABOLA,
1,
1,
LegPos,
&angle);
*/
swing_foot_x.push_back(LegPos[0]);
swing_foot_y.push_back(LegPos[1]);
swing_foot_z.push_back(LegPos[2]);
/*
fprintf(file_op, "plot3([%f %f], [%f %f], [%f %f])\n",
LegPos[0], LegPos[0] + cos(angle)*0.005,
LegPos[1], LegPos[1] + sin(angle)*0.005,
LegPos[2], LegPos[2]);
*/
next_preview_len_ms -= control_sampling_time_ms;
}
/*
fprintf(file_op,"SFP = [\n");
for (unsigned int i=0; i < swing_foot_x.size(); i++)
{
fprintf(file_op, "%f %f %f;\n", swing_foot_x[i], swing_foot_y[i], swing_foot_z[i]);
}
fprintf(file_op, "];\n\n plot3(SFP(:,1), SFP(:,2), SFP(:,3), 'r')\n");
*/
fprintf(file_op,"ZMP = [\n");
for (unsigned int i=0; i < ZMP_x.size(); i++)
{
fprintf(file_op, "%f %f;\n", ZMP_x[i], ZMP_y[i]);
}
fprintf(file_op, "];\n\n plot(ZMP(:,1), ZMP(:,2), 'k')\n");
fprintf(file_op,"ZMPref = [\n");
for (unsigned int i=0; i < ZMP_ref_x.size(); i++)
{
fprintf(file_op, "%f %f;\n", ZMP_ref_x[i], ZMP_ref_y[i]);
}
fprintf(file_op, "];\n\n plot(ZMPref(:,1), ZMPref(:,2), 'ko')\n");
fprintf(file_op,"CoM = [\n");
for (unsigned int i=0; i < CoM_x.size(); i++)
{
fprintf(file_op, "%f %f;\n", CoM_x[i], CoM_y[i]);
}
fprintf(file_op, "];\n\n plot(CoM(:,1), CoM(:,2), 'b')\n");
fprintf(file_op,"hold off\n");
fclose(file_op);
test_end(argv[0]);
return 0;
}
///@}
<commit_msg>Fixed compilation of test_07.<commit_after>/**
* @file
* @author Alexander Sherikov
* @brief Simulate control loop, which is shorter than preview window iteration.
*/
#include <cstring> //strcmp
#include "tests_common.h"
///@addtogroup gTEST
///@{
int main(int argc, char **argv)
{
//-----------------------------------------------------------
// the numbers must correspond to the numbers in init_04()
int control_sampling_time_ms = 10;
int preview_sampling_time_ms = 100;
int next_preview_len_ms = 0;
// initialize
WMG wmg;
init_04 (&wmg);
std::string fs_out_filename("test_07_fs.m");
wmg.FS2file(fs_out_filename); // output results for later use in Matlab/Octave
//-----------------------------------------------------------
test_start(argv[0]);
//-----------------------------------------------------------
smpc::solver solver(
wmg.N, // size of the preview window
300.0, // Alpha
800.0, // Beta
1.0, // Gamma
0.01, // regularization
1e-7); // tolerance
//-----------------------------------------------------------
//-----------------------------------------------------------
wmg.initABMatrices ((double) control_sampling_time_ms / 1000);
wmg.init_state.set (0.019978839010709938, -6.490507362468014e-05);
// state_tilde = state_orig, when velocity = acceleration = 0
wmg.X_tilde.set (0.019978839010709938, -6.490507362468014e-05);
//-----------------------------------------------------------
FILE *file_op = fopen(fs_out_filename.c_str(), "a");
fprintf(file_op,"hold on\n");
vector<double> ZMP_ref_x;
vector<double> ZMP_ref_y;
vector<double> ZMP_x;
vector<double> ZMP_y;
vector<double> CoM_x;
vector<double> CoM_y;
vector<double> swing_foot_x;
vector<double> swing_foot_y;
vector<double> swing_foot_z;
for(int i=0 ;; i++)
{
if (next_preview_len_ms == 0)
{
WMGret wmg_retval = wmg.FormPreviewWindow();
if (wmg_retval == WMG_HALT)
{
cout << "EXIT (halt = 1)" << endl;
break;
}
ZMP_ref_x.push_back(wmg.zref_x[0]);
ZMP_ref_y.push_back(wmg.zref_y[0]);
next_preview_len_ms = preview_sampling_time_ms;
}
//------------------------------------------------------
wmg.T[0] = (double) next_preview_len_ms / 1000; // get seconds
solver.set_parameters (wmg.T, wmg.h, wmg.h[0], wmg.angle, wmg.zref_x, wmg.zref_y, wmg.lb, wmg.ub);
solver.form_init_fp (wmg.fp_x, wmg.fp_y, wmg.init_state, wmg.X);
solver.solve();
//------------------------------------------------------
// update state
wmg.next_control.get_first_controls (solver);
wmg.calculateNextState(wmg.next_control, wmg.init_state);
//-----------------------------------------------------------
if (next_preview_len_ms == preview_sampling_time_ms)
{
// if the values are saved on each iteration the plot becomes sawlike.
// better solution - more frequent sampling.
ZMP_x.push_back(wmg.X_tilde.x());
ZMP_y.push_back(wmg.X_tilde.y());
wmg.X_tilde.get_next_state (solver);
}
CoM_x.push_back(wmg.init_state.x());
CoM_y.push_back(wmg.init_state.y());
// support foot and swing foot position/orientation
double LegPos[3+1];
/* wrong, but makes nice graph */
wmg.getSwingFootPosition (
preview_sampling_time_ms / control_sampling_time_ms,
(preview_sampling_time_ms - next_preview_len_ms) / control_sampling_time_ms,
LegPos);
/* correct
wmg.getSwingFootPosition (
WMG_SWING_2D_PARABOLA,
1,
1,
LegPos,
&angle);
*/
swing_foot_x.push_back(LegPos[0]);
swing_foot_y.push_back(LegPos[1]);
swing_foot_z.push_back(LegPos[2]);
/*
fprintf(file_op, "plot3([%f %f], [%f %f], [%f %f])\n",
LegPos[0], LegPos[0] + cos(angle)*0.005,
LegPos[1], LegPos[1] + sin(angle)*0.005,
LegPos[2], LegPos[2]);
*/
next_preview_len_ms -= control_sampling_time_ms;
}
/*
fprintf(file_op,"SFP = [\n");
for (unsigned int i=0; i < swing_foot_x.size(); i++)
{
fprintf(file_op, "%f %f %f;\n", swing_foot_x[i], swing_foot_y[i], swing_foot_z[i]);
}
fprintf(file_op, "];\n\n plot3(SFP(:,1), SFP(:,2), SFP(:,3), 'r')\n");
*/
fprintf(file_op,"ZMP = [\n");
for (unsigned int i=0; i < ZMP_x.size(); i++)
{
fprintf(file_op, "%f %f;\n", ZMP_x[i], ZMP_y[i]);
}
fprintf(file_op, "];\n\n plot(ZMP(:,1), ZMP(:,2), 'k')\n");
fprintf(file_op,"ZMPref = [\n");
for (unsigned int i=0; i < ZMP_ref_x.size(); i++)
{
fprintf(file_op, "%f %f;\n", ZMP_ref_x[i], ZMP_ref_y[i]);
}
fprintf(file_op, "];\n\n plot(ZMPref(:,1), ZMPref(:,2), 'ko')\n");
fprintf(file_op,"CoM = [\n");
for (unsigned int i=0; i < CoM_x.size(); i++)
{
fprintf(file_op, "%f %f;\n", CoM_x[i], CoM_y[i]);
}
fprintf(file_op, "];\n\n plot(CoM(:,1), CoM(:,2), 'b')\n");
fprintf(file_op,"hold off\n");
fclose(file_op);
test_end(argv[0]);
return 0;
}
///@}
<|endoftext|> |
<commit_before>#include "utest.h"
#include "tensor.h"
#include "io/istream.h"
#include "io/ibstream.h"
#include "io/obstream.h"
#include "math/random.h"
#include "math/epsilon.h"
#include "io/istream_mem.h"
#include "io/istream_std.h"
#include "tensor/numeric.h"
#include <cstdio>
#include <fstream>
using namespace nano;
buffer_t load_buffer(istream_t& stream, const std::size_t buff_size)
{
buffer_t buff, data;
buff.resize(buff_size);
while (stream)
{
stream.read(buff.data(), static_cast<std::streamsize>(buff_size));
data.insert(data.end(), buff.data(), buff.data() + stream.gcount());
}
return data;
}
NANO_BEGIN_MODULE(test_io)
NANO_CASE(istream)
{
const size_t min_size = 3;
const size_t max_size = 679 * 1024;
random_t<char> rng_value;
random_t<std::streamsize> rng_skip(1, 1024);
for (size_t size = min_size; size <= max_size; size *= 2)
{
// generate reference buffer
buffer_t ref_buffer = make_buffer(size);
NANO_CHECK_EQUAL(ref_buffer.size(), size);
for (auto& value : ref_buffer)
{
value = rng_value();
}
// check saving to file
const std::string path = "mstream.test";
NANO_CHECK(save_buffer(path, ref_buffer));
// check loading from file
{
buffer_t buffer;
NANO_CHECK(load_buffer(path, buffer));
NANO_REQUIRE_EQUAL(buffer.size(), ref_buffer.size());
NANO_CHECK(std::equal(buffer.begin(), buffer.end(), ref_buffer.begin()));
}
// check loading from memory stream (by block)
{
mem_istream_t stream(ref_buffer.data(), size);
NANO_CHECK_EQUAL(stream.tellg(), std::streamsize(0));
const buffer_t buffer = load_buffer(stream, size % 43);
NANO_REQUIRE_EQUAL(buffer.size(), ref_buffer.size());
NANO_CHECK(std::equal(buffer.begin(), buffer.end(), ref_buffer.begin()));
NANO_CHECK_EQUAL(stream.tellg(), static_cast<std::streamsize>(size));
}
// check loading from std::istream wrapper (by block)
{
std::ifstream istream(path.c_str(), std::ios::binary | std::ios::in);
NANO_REQUIRE(istream.is_open());
std_istream_t stream(istream);
NANO_CHECK_EQUAL(stream.tellg(), std::streamsize(0));
const buffer_t buffer = load_buffer(stream, size % 17);
NANO_REQUIRE_EQUAL(buffer.size(), ref_buffer.size());
NANO_CHECK(std::equal(buffer.begin(), buffer.end(), ref_buffer.begin()));
NANO_CHECK_EQUAL(stream.tellg(), static_cast<std::streamsize>(size));
}
// check random skip ranges
{
mem_istream_t stream(ref_buffer.data(), size);
NANO_CHECK_EQUAL(stream.tellg(), std::streamsize(0));
auto remaining = static_cast<std::streamsize>(size);
while (stream)
{
NANO_REQUIRE_GREATER(remaining, 0);
const std::streamsize skip_size = std::min(remaining, rng_skip());
NANO_CHECK(stream.skip(skip_size));
remaining -= skip_size;
}
NANO_CHECK_EQUAL(stream.tellg(), static_cast<std::streamsize>(size));
}
// cleanup
std::remove(path.c_str());
}
}
NANO_CASE(bstream)
{
struct pod_t
{
int i;
float f;
double d;
};
const double var_double = -1.45;
const std::string var_string = "string to write";
const float var_float = 45.7f;
const int var_int = 393440;
const std::size_t var_size_t = 323203023;
const auto var_struct = pod_t{ 45, 23.6f, -4.389384934 };
auto var_vector = vector_t(13);
auto var_matrix = matrix_t(17, 5);
auto var_tensor = tensor3d_t(3, 4, 5);
auto rng = make_rng<scalar_t>(-1, +1);
nano::set_random(rng, var_vector, var_matrix, var_tensor);
const std::string path = "bstream.test";
// check writing
{
obstream_t ob(path);
NANO_CHECK(ob.write(var_double));
NANO_CHECK(ob.write(var_string));
NANO_CHECK(ob.write(var_float));
NANO_CHECK(ob.write(var_int));
NANO_CHECK(ob.write(var_size_t));
NANO_CHECK(ob.write(var_struct));
NANO_CHECK(ob.write_vector(var_vector));
NANO_CHECK(ob.write_matrix(var_matrix));
NANO_CHECK(ob.write_tensor(var_tensor));
}
// check reading
{
ibstream_t ib(path);
double var_double_ex;
std::string var_string_ex;
float var_float_ex;
int var_int_ex;
std::size_t var_size_t_ex;
pod_t var_struct_ex;
vector_t var_vector_ex;
matrix_t var_matrix_ex;
tensor3d_t var_tensor_ex;
NANO_CHECK(ib.read(var_double_ex));
NANO_CHECK(ib.read(var_string_ex));
NANO_CHECK(ib.read(var_float_ex));
NANO_CHECK(ib.read(var_int_ex));
NANO_CHECK(ib.read(var_size_t_ex));
NANO_CHECK(ib.read(var_struct_ex));
NANO_CHECK(ib.read_vector(var_vector_ex));
NANO_CHECK(ib.read_matrix(var_matrix_ex));
NANO_CHECK(ib.read_tensor(var_tensor_ex));
NANO_CHECK_EQUAL(var_double, var_double_ex);
NANO_CHECK_EQUAL(var_string, var_string_ex);
NANO_CHECK_EQUAL(var_float, var_float_ex);
NANO_CHECK_EQUAL(var_int, var_int_ex);
NANO_CHECK_EQUAL(var_size_t, var_size_t_ex);
NANO_CHECK_EQUAL(var_struct.d, var_struct_ex.d);
NANO_CHECK_EQUAL(var_struct.f, var_struct_ex.f);
NANO_CHECK_EQUAL(var_struct.i, var_struct_ex.i);
NANO_REQUIRE_EQUAL(var_vector.size(), var_vector_ex.size());
NANO_REQUIRE_EQUAL(var_matrix.rows(), var_matrix_ex.rows());
NANO_REQUIRE_EQUAL(var_matrix.cols(), var_matrix_ex.cols());
NANO_REQUIRE_EQUAL(var_tensor.dims(), var_tensor_ex.dims());
NANO_CHECK_EIGEN_CLOSE(var_vector, var_vector_ex, epsilon0<scalar_t>());
NANO_CHECK_EIGEN_CLOSE(var_matrix, var_matrix_ex, epsilon0<scalar_t>());
NANO_CHECK_EIGEN_CLOSE(var_tensor.vector(), var_tensor_ex.vector(), epsilon0<scalar_t>());
}
// cleanup
std::remove(path.c_str());
}
NANO_END_MODULE()
<commit_msg>extend unit test (io)<commit_after>#include "utest.h"
#include "tensor.h"
#include "io/istream.h"
#include "io/ibstream.h"
#include "io/obstream.h"
#include "math/random.h"
#include "math/epsilon.h"
#include "io/istream_mem.h"
#include "io/istream_std.h"
#include "tensor/numeric.h"
#include <cstdio>
#include <fstream>
using namespace nano;
buffer_t load_buffer(istream_t& stream, const std::size_t buff_size)
{
buffer_t buff, data;
buff.resize(buff_size);
while (stream)
{
stream.read(buff.data(), static_cast<std::streamsize>(buff_size));
data.insert(data.end(), buff.data(), buff.data() + stream.gcount());
}
return data;
}
NANO_BEGIN_MODULE(test_io)
NANO_CASE(string)
{
const std::string path = "string.test";
const std::string ref_str = "secret sauce 42";
NANO_CHECK(save_string(path, ref_str));
std::string str = "testing";
NANO_CHECK(load_string(path, str));
NANO_CHECK_EQUAL(str, ref_str);
NANO_CHECK(load_string(path, str));
NANO_CHECK_EQUAL(str, ref_str);
// cleanup
std::remove(path.c_str());
}
NANO_CASE(istream)
{
const size_t min_size = 3;
const size_t max_size = 679 * 1024;
random_t<char> rng_value;
random_t<std::streamsize> rng_skip(1, 1024);
for (size_t size = min_size; size <= max_size; size *= 2)
{
// generate reference buffer
buffer_t ref_buffer = make_buffer(size);
NANO_CHECK_EQUAL(ref_buffer.size(), size);
for (auto& value : ref_buffer)
{
value = rng_value();
}
// check saving to file
const std::string path = "mstream.test";
NANO_CHECK(save_buffer(path, ref_buffer));
// check loading from file
{
buffer_t buffer;
NANO_CHECK(load_buffer(path, buffer));
NANO_REQUIRE_EQUAL(buffer.size(), ref_buffer.size());
NANO_CHECK(std::equal(buffer.begin(), buffer.end(), ref_buffer.begin()));
}
// check loading from memory stream (by block)
{
mem_istream_t stream(ref_buffer.data(), size);
NANO_CHECK_EQUAL(stream.tellg(), std::streamsize(0));
const buffer_t buffer = load_buffer(stream, size % 43);
NANO_REQUIRE_EQUAL(buffer.size(), ref_buffer.size());
NANO_CHECK(std::equal(buffer.begin(), buffer.end(), ref_buffer.begin()));
NANO_CHECK_EQUAL(stream.tellg(), static_cast<std::streamsize>(size));
}
// check loading from std::istream wrapper (by block)
{
std::ifstream istream(path.c_str(), std::ios::binary | std::ios::in);
NANO_REQUIRE(istream.is_open());
std_istream_t stream(istream);
NANO_CHECK_EQUAL(stream.tellg(), std::streamsize(0));
const buffer_t buffer = load_buffer(stream, size % 17);
NANO_REQUIRE_EQUAL(buffer.size(), ref_buffer.size());
NANO_CHECK(std::equal(buffer.begin(), buffer.end(), ref_buffer.begin()));
NANO_CHECK_EQUAL(stream.tellg(), static_cast<std::streamsize>(size));
}
// check random skip ranges
{
mem_istream_t stream(ref_buffer.data(), size);
NANO_CHECK_EQUAL(stream.tellg(), std::streamsize(0));
auto remaining = static_cast<std::streamsize>(size);
while (stream)
{
NANO_REQUIRE_GREATER(remaining, 0);
const std::streamsize skip_size = std::min(remaining, rng_skip());
NANO_CHECK(stream.skip(skip_size));
remaining -= skip_size;
}
NANO_CHECK_EQUAL(stream.tellg(), static_cast<std::streamsize>(size));
}
// cleanup
std::remove(path.c_str());
}
}
NANO_CASE(bstream)
{
struct pod_t
{
int i;
float f;
double d;
};
const double var_double = -1.45;
const std::string var_string = "string to write";
const float var_float = 45.7f;
const int var_int = 393440;
const std::size_t var_size_t = 323203023;
const auto var_struct = pod_t{ 45, 23.6f, -4.389384934 };
auto var_vector = vector_t(13);
auto var_matrix = matrix_t(17, 5);
auto var_tensor = tensor3d_t(3, 4, 5);
auto rng = make_rng<scalar_t>(-1, +1);
nano::set_random(rng, var_vector, var_matrix, var_tensor);
const std::string path = "bstream.test";
// check writing
{
obstream_t ob(path);
NANO_CHECK(ob.write(var_double));
NANO_CHECK(ob.write(var_string));
NANO_CHECK(ob.write(var_float));
NANO_CHECK(ob.write(var_int));
NANO_CHECK(ob.write(var_size_t));
NANO_CHECK(ob.write(var_struct));
NANO_CHECK(ob.write_vector(var_vector));
NANO_CHECK(ob.write_matrix(var_matrix));
NANO_CHECK(ob.write_tensor(var_tensor));
}
// check reading
{
ibstream_t ib(path);
double var_double_ex;
std::string var_string_ex;
float var_float_ex;
int var_int_ex;
std::size_t var_size_t_ex;
pod_t var_struct_ex;
vector_t var_vector_ex;
matrix_t var_matrix_ex;
tensor3d_t var_tensor_ex;
NANO_CHECK(ib.read(var_double_ex));
NANO_CHECK(ib.read(var_string_ex));
NANO_CHECK(ib.read(var_float_ex));
NANO_CHECK(ib.read(var_int_ex));
NANO_CHECK(ib.read(var_size_t_ex));
NANO_CHECK(ib.read(var_struct_ex));
NANO_CHECK(ib.read_vector(var_vector_ex));
NANO_CHECK(ib.read_matrix(var_matrix_ex));
NANO_CHECK(ib.read_tensor(var_tensor_ex));
NANO_CHECK_EQUAL(var_double, var_double_ex);
NANO_CHECK_EQUAL(var_string, var_string_ex);
NANO_CHECK_EQUAL(var_float, var_float_ex);
NANO_CHECK_EQUAL(var_int, var_int_ex);
NANO_CHECK_EQUAL(var_size_t, var_size_t_ex);
NANO_CHECK_EQUAL(var_struct.d, var_struct_ex.d);
NANO_CHECK_EQUAL(var_struct.f, var_struct_ex.f);
NANO_CHECK_EQUAL(var_struct.i, var_struct_ex.i);
NANO_REQUIRE_EQUAL(var_vector.size(), var_vector_ex.size());
NANO_REQUIRE_EQUAL(var_matrix.rows(), var_matrix_ex.rows());
NANO_REQUIRE_EQUAL(var_matrix.cols(), var_matrix_ex.cols());
NANO_REQUIRE_EQUAL(var_tensor.dims(), var_tensor_ex.dims());
NANO_CHECK_EIGEN_CLOSE(var_vector, var_vector_ex, epsilon0<scalar_t>());
NANO_CHECK_EIGEN_CLOSE(var_matrix, var_matrix_ex, epsilon0<scalar_t>());
NANO_CHECK_EIGEN_CLOSE(var_tensor.vector(), var_tensor_ex.vector(), epsilon0<scalar_t>());
}
// cleanup
std::remove(path.c_str());
}
NANO_END_MODULE()
<|endoftext|> |
<commit_before>/*
* Logger.cpp
*
* Created on: Oct 9, 2012
* Author: Barber
*/
#include "../src/Helper/Logger.hpp"
#include <iostream>
void Log(LogTag tag, const char* title, const char* message)
{
// Doing nothing here on purpose
}
<commit_msg>Implemented a test logger.<commit_after>/*
* Logger.cpp
*
* Created on: Oct 9, 2012
* Author: Barber
*/
#include "../src/Helper/Logger.hpp"
#include <iostream>
void Log(LogTag tag, const char* title, const char* message)
{
const char* tag_str;
switch (tag) {
case LOG_INFO:
tag_str = "LOG_INFO";
break;
case LOG_EVENT:
tag_str = "LOG_EVENT";
break;
case LOG_ERROR:
tag_str = ">>>> LOG_ERROR <<<<";
break;
default:
tag_str = "UNKNOWN_LOG_TAG";
break;
}
std::cout << tag_str << "\t" << title << "\t" << message << "\n";
}<|endoftext|> |
<commit_before>#include "catch.hpp"
#include "Graphics/Engine.h"
#include "Graphics/Sprite.h"
#include "Platform/MemoryMappedFile.h"
#include "Platform/PathUtils.h"
#include "TestFixture.h"
using namespace CR;
using namespace CR::Graphics;
using namespace std;
TEST_CASE_METHOD(TestFixture, "sprites_basic", "") {
auto crsm = Platform::OpenMMapFile(Platform::GetCurrentProcessPath() / "simple.crsm");
SpriteTypeCreateInfo info;
info.Name = "sprite type";
info.ShaderModule = Core::Span<byte>{crsm->data(), crsm->size()};
auto spriteType = CreateSpriteType(info);
SpriteTemplateCreateInfo templateInfo;
templateInfo.Name = "test template";
templateInfo.Type = spriteType;
templateInfo.FrameSize = {64, 64};
auto spriteTemplate = CreateSpriteTemplate(templateInfo);
Graphics::SpriteCreateInfo spriteInfo;
spriteInfo.Name = "test sprite";
spriteInfo.Template = spriteTemplate;
auto sprite = CreateSprite(spriteInfo);
Sprite::Props props;
props.Position = glm::vec2{256.0f, 64.0f};
props.Color = glm::vec4{1.0f, 1.0f, 0.0f, 1.0f};
sprite->SetProps(props);
constexpr bool loop = true;
while(loop && !glfwWindowShouldClose(Window)) {
glfwPollEvents();
Frame();
}
}
<commit_msg>make sprite move around in unit test<commit_after>#include "catch.hpp"
#include "Graphics/Engine.h"
#include "Graphics/Sprite.h"
#include "Platform/MemoryMappedFile.h"
#include "Platform/PathUtils.h"
#include "TestFixture.h"
using namespace CR;
using namespace CR::Graphics;
using namespace std;
TEST_CASE_METHOD(TestFixture, "sprites_basic", "") {
auto crsm = Platform::OpenMMapFile(Platform::GetCurrentProcessPath() / "simple.crsm");
SpriteTypeCreateInfo info;
info.Name = "sprite type";
info.ShaderModule = Core::Span<byte>{crsm->data(), crsm->size()};
auto spriteType = CreateSpriteType(info);
SpriteTemplateCreateInfo templateInfo;
templateInfo.Name = "test template";
templateInfo.Type = spriteType;
templateInfo.FrameSize = {64, 64};
auto spriteTemplate = CreateSpriteTemplate(templateInfo);
Graphics::SpriteCreateInfo spriteInfo;
spriteInfo.Name = "test sprite";
spriteInfo.Template = spriteTemplate;
auto sprite = CreateSprite(spriteInfo);
Sprite::Props props;
props.Position = glm::vec2{256.0f, 64.0f};
props.Color = glm::vec4{1.0f, 1.0f, 0.0f, 1.0f};
sprite->SetProps(props);
glm::vec2 step{1.0f, 2.0f};
constexpr bool loop = true;
while(loop && !glfwWindowShouldClose(Window)) {
glfwPollEvents();
props.Position += step;
if(props.Position.x > 1280.0f) { step.x = -1.0f; }
if(props.Position.x < 0.0f) { step.x = 1.0f; }
if(props.Position.y > 720.0f) { step.y = -2.0f; }
if(props.Position.y < 0.0f) { step.y = 2.0f; }
sprite->SetProps(props);
Frame();
}
}
<|endoftext|> |
<commit_before>#ifndef ERROR_HPP
#define ERROR_HPP
#include <stdexcept>
#include <string>
#include <sstream>
#include <map>
#include "util.hpp"
#define GET_ERR_METADATA __FILE__, __PRETTY_FUNCTION__, __LINE__
#define ERR_METADATA_TYPES(arg1, arg2, arg3) std::string arg1, std::string arg2, int arg3
#define METADATA_PAIRS_FROM(file, func, line) {"file", file}, {"function", func}, {"line", std::to_string(line)}
#define METADATA_PAIRS {"file", __FILE__}, {"function", __PRETTY_FUNCTION__}, {"line", std::to_string(__LINE__)}
class Error: public std::runtime_error {
public:
Error(std::string errType, std::string msg, uint64 line):
runtime_error(errType + ": " + msg + ", at line " + std::to_string(line)) {}
};
typedef std::map<std::string, std::string> ErrorData;
class InternalError: public std::runtime_error {
private:
static std::string buildErrorMessage(std::string msg, ErrorData data) {
std::stringstream ss;
ss << "\n" << "InternalError: " << msg << "\n";
for (auto& extra : data) {
ss << "\t" << extra.first << ": " << extra.second << "\n";
}
return ss.str();
}
public:
InternalError(std::string msg, ErrorData data):
runtime_error(buildErrorMessage(msg, data)) {}
};
#endif
<commit_msg>Made inheritance easier for InternalError<commit_after>#ifndef ERROR_HPP
#define ERROR_HPP
#include <stdexcept>
#include <string>
#include <sstream>
#include <map>
#include "util.hpp"
#define GET_ERR_METADATA __FILE__, __PRETTY_FUNCTION__, __LINE__
#define ERR_METADATA_TYPES(arg1, arg2, arg3) std::string arg1, std::string arg2, int arg3
#define METADATA_PAIRS_FROM(file, func, line) {"file", file}, {"function", func}, {"line", std::to_string(line)}
#define METADATA_PAIRS {"file", __FILE__}, {"function", __PRETTY_FUNCTION__}, {"line", std::to_string(__LINE__)}
class Error: public std::runtime_error {
public:
Error(std::string errType, std::string msg, uint64 line):
runtime_error(errType + ": " + msg + ", at line " + std::to_string(line)) {}
};
typedef std::map<std::string, std::string> ErrorData;
class InternalError: public std::runtime_error {
private:
static std::string buildErrorMessage(std::string errorName, std::string msg, ErrorData data) {
std::stringstream ss;
ss << "\n" << errorName << ": " << msg << "\n";
for (auto& extra : data) {
ss << "\t" << extra.first << ": " << extra.second << "\n";
}
return ss.str();
}
protected:
InternalError(std::string errorName, std::string msg, ErrorData data):
runtime_error(buildErrorMessage(errorName, msg, data)) {}
public:
InternalError(std::string msg, ErrorData data):
runtime_error(buildErrorMessage("InternalError", msg, data)) {}
};
#endif
<|endoftext|> |
<commit_before>/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
#include "config.h"
#include <algorithm>
#include "ep_engine.h"
#include "tapconnmap.hh"
#include "tapconnection.hh"
void TapConnMap::disconnect(const void *cookie, int tapKeepAlive) {
LockHolder lh(notifySync);
std::map<const void*, TapConnection*>::iterator iter(map.find(cookie));
if (iter != map.end()) {
if (iter->second) {
iter->second->expiry_time = ep_current_time();
if (iter->second->doDisconnect) {
iter->second->expiry_time--;
} else {
iter->second->expiry_time += tapKeepAlive;
}
iter->second->connected = false;
iter->second->disconnects++;
} else {
getLogger()->log(EXTENSION_LOG_WARNING, NULL,
"Found half-linked tap connection at: %p\n",
cookie);
}
map.erase(iter);
}
purgeExpiredConnections_UNLOCKED();
}
bool TapConnMap::setEvents(const std::string &name,
std::list<QueuedItem> *q) {
bool shouldNotify(true);
bool found(false);
LockHolder lh(notifySync);
TapConnection *tc = findByName_UNLOCKED(name);
if (tc) {
found = true;
tc->appendQueue(q);
shouldNotify = tc->paused; // notify if paused
}
if (shouldNotify) {
notifySync.notify();
}
return found;
}
ssize_t TapConnMap::queueDepth(const std::string &name) {
ssize_t rv(-1);
LockHolder lh(notifySync);
TapConnection *tc = findByName_UNLOCKED(name);
if (tc) {
rv = tc->getBacklogSize();
}
return rv;
}
TapConnection* TapConnMap::findByName_UNLOCKED(const std::string&name) {
TapConnection *rv(NULL);
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); ++iter) {
TapConnection *tc = *iter;
if (tc->client == name) {
rv = tc;
}
}
return rv;
}
int TapConnMap::purgeExpiredConnections_UNLOCKED() {
rel_time_t now = ep_current_time();
std::list<TapConnection*> deadClients;
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); ++iter) {
TapConnection *tc = *iter;
if (tc->expiry_time <= now && !mapped(tc) && !tc->connected && !tc->suspended) {
deadClients.push_back(tc);
}
}
for (iter = deadClients.begin(); iter != deadClients.end(); ++iter) {
TapConnection *tc = *iter;
purgeSingleExpiredTapConnection(tc);
}
return static_cast<int>(deadClients.size());
}
void TapConnMap::addFlushEvent() {
LockHolder lh(notifySync);
bool shouldNotify(false);
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); iter++) {
TapConnection *tc = *iter;
if (!tc->dumpQueue) {
tc->flush();
shouldNotify = true;
}
}
if (shouldNotify) {
notifySync.notify();
}
}
TapConnection *TapConnMap::newConn(const void* cookie,
const std::string &name,
uint32_t flags,
uint64_t backfillAge,
int tapKeepAlive) {
LockHolder lh(notifySync);
purgeExpiredConnections_UNLOCKED();
TapConnection *tap(NULL);
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); ++iter) {
tap = *iter;
if (tap->client == name) {
tap->expiry_time = (rel_time_t)-1;
++tap->reconnects;
break;
} else {
tap = NULL;
}
}
// Disconnects aren't quite immediate yet, so if we see a
// connection request for a client *and* expiry_time is 0, we
// should kill this guy off.
if (tap != NULL) {
std::map<const void*, TapConnection*>::iterator miter;
for (miter = map.begin(); miter != map.end(); ++miter) {
if (miter->second == tap) {
break;
}
}
if (tapKeepAlive == 0) {
getLogger()->log(EXTENSION_LOG_INFO, NULL,
"The TAP channel (\"%s\") exists, but should be nuked\n",
name.c_str());
tap->client.assign(TapConnection::getAnonTapName());
tap->doDisconnect = true;
tap->paused = true;
tap = NULL;
} else {
getLogger()->log(EXTENSION_LOG_INFO, NULL,
"The TAP channel (\"%s\") exists... grabbing the channel\n",
name.c_str());
if (miter != map.end()) {
TapConnection *n = new TapConnection(engine,
NULL,
TapConnection::getAnonTapName(),
0);
n->doDisconnect = true;
n->paused = true;
all.push_back(n);
map[miter->first] = n;
}
}
}
bool reconnect = false;
if (tap == NULL) {
tap = new TapConnection(engine, cookie, name, flags);
all.push_back(tap);
} else {
tap->setCookie(cookie);
tap->rollback();
tap->connected = true;
tap->evaluateFlags();
reconnect = true;
}
tap->setBackfillAge(backfillAge, reconnect);
if (tap->doRunBackfill && tap->pendingBackfill) {
setValidity(tap->client, cookie);
}
map[cookie] = tap;
return tap;
}
// These two methods are always called with a lock.
void TapConnMap::setValidity(const std::string &name,
const void* token) {
validity[name] = token;
}
void TapConnMap::clearValidity(const std::string &name) {
validity.erase(name);
}
// This is always called without a lock.
bool TapConnMap::checkValidity(const std::string &name,
const void* token) {
LockHolder lh(notifySync);
std::map<const std::string, const void*>::iterator viter =
validity.find(name);
return viter != validity.end() && viter->second == token;
}
void TapConnMap::purgeSingleExpiredTapConnection(TapConnection *tc) {
all.remove(tc);
/* Assert that the connection doesn't live in the map.. */
assert(!mapped(tc));
const void *cookie = tc->cookie;
delete tc;
engine.getServerApi()->cookie->release(cookie);
}
bool TapConnMap::mapped(TapConnection *tc) {
bool rv = false;
std::map<const void*, TapConnection*>::iterator it;
for (it = map.begin(); it != map.end(); ++it) {
if (it->second == tc) {
rv = true;
}
}
return rv;
}
bool TapConnMap::isPaused(TapConnection *tc) {
return tc && tc->paused;
}
bool TapConnMap::shouldDisconnect(TapConnection *tc) {
return tc && tc->doDisconnect;
}
void TapConnMap::notifyIOThreadMain() {
bool addNoop = false;
rel_time_t now = ep_current_time();
if (now > engine.nextTapNoop && engine.tapNoopInterval != (size_t)-1) {
addNoop = true;
engine.nextTapNoop = now + engine.tapNoopInterval;
}
LockHolder lh(notifySync);
// We should pause unless we purged some connections or
// all queues have items.
bool shouldPause = purgeExpiredConnections_UNLOCKED() == 0;
bool noEvents = engine.populateEvents();
if (shouldPause) {
shouldPause = noEvents;
}
// see if I have some channels that I have to signal..
std::map<const void*, TapConnection*>::iterator iter;
for (iter = map.begin(); iter != map.end(); ++iter) {
if (iter->second->ackSupported &&
(iter->second->expiry_time < now) &&
iter->second->windowIsFull())
{
shouldPause = false;
iter->second->doDisconnect = true;
} else if (iter->second->doDisconnect || !iter->second->idle()) {
shouldPause = false;
} else if (addNoop) {
iter->second->setTimeForNoop();
shouldPause = false;
}
}
if (shouldPause) {
double diff = engine.nextTapNoop - now;
if (diff > 0) {
notifySync.wait(diff);
}
if (engine.shutdown) {
return;
}
purgeExpiredConnections_UNLOCKED();
}
// Collect the list of connections that need to be signaled.
std::list<const void *> toNotify;
for (iter = map.begin(); iter != map.end(); ++iter) {
if (iter->second->shouldNotify()) {
iter->second->notifySent.set(true);
toNotify.push_back(iter->first);
}
}
lh.unlock();
engine.notifyIOComplete(toNotify, ENGINE_SUCCESS);
}
void CompleteBackfillTapOperation::perform(TapConnection *tc, void *arg) {
(void)arg;
tc->completeBackfill();
}
void CompleteDiskBackfillTapOperation::perform(TapConnection *tc, void *arg) {
(void)arg;
tc->completeDiskBackfill();
}
void ScheduleDiskBackfillTapOperation::perform(TapConnection *tc, void *arg) {
(void)arg;
tc->scheduleDiskBackfill();
}
void ReceivedItemTapOperation::perform(TapConnection *tc, Item *arg) {
tc->gotBGItem(arg, implicitEnqueue);
}
void CompletedBGFetchTapOperation::perform(TapConnection *tc,
EventuallyPersistentEngine *epe) {
(void)epe;
tc->completedBGFetchJob();
}
void NotifyIOTapOperation::perform(TapConnection *tc,
EventuallyPersistentEngine *epe) {
epe->notifyIOComplete(tc->getCookie(), ENGINE_SUCCESS);
}
<commit_msg>MB-3495 Don't try to release "temporary" tapconnection objects<commit_after>/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
#include "config.h"
#include <algorithm>
#include "ep_engine.h"
#include "tapconnmap.hh"
#include "tapconnection.hh"
void TapConnMap::disconnect(const void *cookie, int tapKeepAlive) {
LockHolder lh(notifySync);
std::map<const void*, TapConnection*>::iterator iter(map.find(cookie));
if (iter != map.end()) {
if (iter->second) {
iter->second->expiry_time = ep_current_time();
if (iter->second->doDisconnect) {
iter->second->expiry_time--;
} else {
iter->second->expiry_time += tapKeepAlive;
}
iter->second->connected = false;
iter->second->disconnects++;
} else {
getLogger()->log(EXTENSION_LOG_WARNING, NULL,
"Found half-linked tap connection at: %p\n",
cookie);
}
map.erase(iter);
}
purgeExpiredConnections_UNLOCKED();
}
bool TapConnMap::setEvents(const std::string &name,
std::list<QueuedItem> *q) {
bool shouldNotify(true);
bool found(false);
LockHolder lh(notifySync);
TapConnection *tc = findByName_UNLOCKED(name);
if (tc) {
found = true;
tc->appendQueue(q);
shouldNotify = tc->paused; // notify if paused
}
if (shouldNotify) {
notifySync.notify();
}
return found;
}
ssize_t TapConnMap::queueDepth(const std::string &name) {
ssize_t rv(-1);
LockHolder lh(notifySync);
TapConnection *tc = findByName_UNLOCKED(name);
if (tc) {
rv = tc->getBacklogSize();
}
return rv;
}
TapConnection* TapConnMap::findByName_UNLOCKED(const std::string&name) {
TapConnection *rv(NULL);
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); ++iter) {
TapConnection *tc = *iter;
if (tc->client == name) {
rv = tc;
}
}
return rv;
}
int TapConnMap::purgeExpiredConnections_UNLOCKED() {
rel_time_t now = ep_current_time();
std::list<TapConnection*> deadClients;
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); ++iter) {
TapConnection *tc = *iter;
if (tc->expiry_time <= now && !mapped(tc) && !tc->connected && !tc->suspended) {
deadClients.push_back(tc);
}
}
for (iter = deadClients.begin(); iter != deadClients.end(); ++iter) {
TapConnection *tc = *iter;
purgeSingleExpiredTapConnection(tc);
}
return static_cast<int>(deadClients.size());
}
void TapConnMap::addFlushEvent() {
LockHolder lh(notifySync);
bool shouldNotify(false);
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); iter++) {
TapConnection *tc = *iter;
if (!tc->dumpQueue) {
tc->flush();
shouldNotify = true;
}
}
if (shouldNotify) {
notifySync.notify();
}
}
TapConnection *TapConnMap::newConn(const void* cookie,
const std::string &name,
uint32_t flags,
uint64_t backfillAge,
int tapKeepAlive) {
LockHolder lh(notifySync);
purgeExpiredConnections_UNLOCKED();
TapConnection *tap(NULL);
std::list<TapConnection*>::iterator iter;
for (iter = all.begin(); iter != all.end(); ++iter) {
tap = *iter;
if (tap->client == name) {
tap->expiry_time = (rel_time_t)-1;
++tap->reconnects;
break;
} else {
tap = NULL;
}
}
// Disconnects aren't quite immediate yet, so if we see a
// connection request for a client *and* expiry_time is 0, we
// should kill this guy off.
if (tap != NULL) {
std::map<const void*, TapConnection*>::iterator miter;
for (miter = map.begin(); miter != map.end(); ++miter) {
if (miter->second == tap) {
break;
}
}
if (tapKeepAlive == 0) {
getLogger()->log(EXTENSION_LOG_INFO, NULL,
"The TAP channel (\"%s\") exists, but should be nuked\n",
name.c_str());
tap->client.assign(TapConnection::getAnonTapName());
tap->doDisconnect = true;
tap->paused = true;
tap = NULL;
} else {
getLogger()->log(EXTENSION_LOG_INFO, NULL,
"The TAP channel (\"%s\") exists... grabbing the channel\n",
name.c_str());
if (miter != map.end()) {
TapConnection *n = new TapConnection(engine,
NULL,
TapConnection::getAnonTapName(),
0);
n->doDisconnect = true;
n->paused = true;
all.push_back(n);
map[miter->first] = n;
}
}
}
bool reconnect = false;
if (tap == NULL) {
tap = new TapConnection(engine, cookie, name, flags);
all.push_back(tap);
} else {
tap->setCookie(cookie);
tap->rollback();
tap->connected = true;
tap->evaluateFlags();
reconnect = true;
}
tap->setBackfillAge(backfillAge, reconnect);
if (tap->doRunBackfill && tap->pendingBackfill) {
setValidity(tap->client, cookie);
}
map[cookie] = tap;
return tap;
}
// These two methods are always called with a lock.
void TapConnMap::setValidity(const std::string &name,
const void* token) {
validity[name] = token;
}
void TapConnMap::clearValidity(const std::string &name) {
validity.erase(name);
}
// This is always called without a lock.
bool TapConnMap::checkValidity(const std::string &name,
const void* token) {
LockHolder lh(notifySync);
std::map<const std::string, const void*>::iterator viter =
validity.find(name);
return viter != validity.end() && viter->second == token;
}
void TapConnMap::purgeSingleExpiredTapConnection(TapConnection *tc) {
all.remove(tc);
/* Assert that the connection doesn't live in the map.. */
assert(!mapped(tc));
const void *cookie = tc->cookie;
delete tc;
if (cookie != NULL) {
engine.getServerApi()->cookie->release(cookie);
}
}
bool TapConnMap::mapped(TapConnection *tc) {
bool rv = false;
std::map<const void*, TapConnection*>::iterator it;
for (it = map.begin(); it != map.end(); ++it) {
if (it->second == tc) {
rv = true;
}
}
return rv;
}
bool TapConnMap::isPaused(TapConnection *tc) {
return tc && tc->paused;
}
bool TapConnMap::shouldDisconnect(TapConnection *tc) {
return tc && tc->doDisconnect;
}
void TapConnMap::notifyIOThreadMain() {
bool addNoop = false;
rel_time_t now = ep_current_time();
if (now > engine.nextTapNoop && engine.tapNoopInterval != (size_t)-1) {
addNoop = true;
engine.nextTapNoop = now + engine.tapNoopInterval;
}
LockHolder lh(notifySync);
// We should pause unless we purged some connections or
// all queues have items.
bool shouldPause = purgeExpiredConnections_UNLOCKED() == 0;
bool noEvents = engine.populateEvents();
if (shouldPause) {
shouldPause = noEvents;
}
// see if I have some channels that I have to signal..
std::map<const void*, TapConnection*>::iterator iter;
for (iter = map.begin(); iter != map.end(); ++iter) {
if (iter->second->ackSupported &&
(iter->second->expiry_time < now) &&
iter->second->windowIsFull())
{
shouldPause = false;
iter->second->doDisconnect = true;
} else if (iter->second->doDisconnect || !iter->second->idle()) {
shouldPause = false;
} else if (addNoop) {
iter->second->setTimeForNoop();
shouldPause = false;
}
}
if (shouldPause) {
double diff = engine.nextTapNoop - now;
if (diff > 0) {
notifySync.wait(diff);
}
if (engine.shutdown) {
return;
}
purgeExpiredConnections_UNLOCKED();
}
// Collect the list of connections that need to be signaled.
std::list<const void *> toNotify;
for (iter = map.begin(); iter != map.end(); ++iter) {
if (iter->second->shouldNotify()) {
iter->second->notifySent.set(true);
toNotify.push_back(iter->first);
}
}
lh.unlock();
engine.notifyIOComplete(toNotify, ENGINE_SUCCESS);
}
void CompleteBackfillTapOperation::perform(TapConnection *tc, void *arg) {
(void)arg;
tc->completeBackfill();
}
void CompleteDiskBackfillTapOperation::perform(TapConnection *tc, void *arg) {
(void)arg;
tc->completeDiskBackfill();
}
void ScheduleDiskBackfillTapOperation::perform(TapConnection *tc, void *arg) {
(void)arg;
tc->scheduleDiskBackfill();
}
void ReceivedItemTapOperation::perform(TapConnection *tc, Item *arg) {
tc->gotBGItem(arg, implicitEnqueue);
}
void CompletedBGFetchTapOperation::perform(TapConnection *tc,
EventuallyPersistentEngine *epe) {
(void)epe;
tc->completedBGFetchJob();
}
void NotifyIOTapOperation::perform(TapConnection *tc,
EventuallyPersistentEngine *epe) {
epe->notifyIOComplete(tc->getCookie(), ENGINE_SUCCESS);
}
<|endoftext|> |
<commit_before><commit_msg>coverity#704604 Explicit null dereferenced<commit_after><|endoftext|> |
<commit_before>/* The MIT License
*
* Copyright (c) 2011 Masaki Saito <rezoolab@gmail.com>
*
* 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.
*/
#pragma once
#include <opencv2/core/core.hpp>
#ifdef _OPENMP
#include <omp.h>
#endif
namespace cvutil {
template<typename SrcType,
typename DstType,
typename UnaryFunction>
void transform_image(const cv::Mat_<SrcType>& src,
cv::Mat_<DstType>& dst,
UnaryFunction f) {
assert(src.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType* src_x = src[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src_x[x]);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename DstType,
typename BinaryFunction>
void transform_image(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
cv::Mat_<DstType>& dst,
BinaryFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x]);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename SrcType3,
typename DstType,
typename TernaryFunction>
void transform_image(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
const cv::Mat_<SrcType3>& src3,
cv::Mat_<DstType>& dst,
TernaryFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
assert(src3.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
const SrcType3* src3_x = src3[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x], src3_x[x]);
}
}
}
template<typename SrcType,
typename DstType,
typename CoordinateFunction>
void transform_image_xy(const cv::Mat_<SrcType>& src,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType* src_x = src[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src_x[x], x, y);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename DstType,
typename CoordinateFunction>
void transform_image_xy(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x], x, y);
}
}
}
template<typename SrcType,
typename DstType,
typename CoordinateFunction>
void transform_image_uv(const cv::Mat_<SrcType>& src,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src.size == dst.size);
const int cx = dst.cols / 2;
const int cy = dst.rows / 2;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType* src_x = src[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src_x[x], x - cx, y - cy);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename DstType,
typename CoordinateFunction>
void transform_image_uv(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
const int cx = dst.cols / 2;
const int cy = dst.rows / 2;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x], x - cx, y - cy);
}
}
}
} // namespace cvutil
<commit_msg>fix transform_image_uv()<commit_after>/* The MIT License
*
* Copyright (c) 2011 Masaki Saito <rezoolab@gmail.com>
*
* 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.
*/
#pragma once
#include <opencv2/core/core.hpp>
#ifdef _OPENMP
#include <omp.h>
#endif
namespace cvutil {
template<typename SrcType,
typename DstType,
typename UnaryFunction>
void transform_image(const cv::Mat_<SrcType>& src,
cv::Mat_<DstType>& dst,
UnaryFunction f) {
assert(src.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType* src_x = src[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src_x[x]);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename DstType,
typename BinaryFunction>
void transform_image(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
cv::Mat_<DstType>& dst,
BinaryFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x]);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename SrcType3,
typename DstType,
typename TernaryFunction>
void transform_image(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
const cv::Mat_<SrcType3>& src3,
cv::Mat_<DstType>& dst,
TernaryFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
assert(src3.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
const SrcType3* src3_x = src3[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x], src3_x[x]);
}
}
}
template<typename SrcType,
typename DstType,
typename CoordinateFunction>
void transform_image_xy(const cv::Mat_<SrcType>& src,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType* src_x = src[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src_x[x], x, y);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename DstType,
typename CoordinateFunction>
void transform_image_xy(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x], x, y);
}
}
}
template<typename SrcType,
typename DstType,
typename CoordinateFunction>
void transform_image_uv(const cv::Mat_<SrcType>& src,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src.size == dst.size);
const int cx = dst.cols / 2;
const int cy = dst.rows / 2;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType* src_x = src[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src_x[x], x - cx, cy - y);
}
}
}
template<typename SrcType1,
typename SrcType2,
typename DstType,
typename CoordinateFunction>
void transform_image_uv(const cv::Mat_<SrcType1>& src1,
const cv::Mat_<SrcType2>& src2,
cv::Mat_<DstType>& dst,
CoordinateFunction f) {
assert(src1.size == dst.size);
assert(src2.size == dst.size);
const int cx = dst.cols / 2;
const int cy = dst.rows / 2;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for(int y=0; y<dst.rows; ++y) {
const SrcType1* src1_x = src1[y];
const SrcType2* src2_x = src2[y];
DstType* dst_x = dst[y];
for(int x=0; x<dst.cols; ++x) {
dst_x[x] = f(src1_x[x], src2_x[x], x - cx, cy - y);
}
}
}
} // namespace cvutil
<|endoftext|> |
<commit_before>//=======================================================================
// Copyright (c) 2014-2015 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
#include <vector>
#include "catch.hpp"
#include "cpp_utils/algorithm.hpp"
TEST_CASE( "foreach/container", "foreach_1" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach(a, [&sum](auto& v){ sum += v; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach/range", "foreach_2" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach(a.begin(), a.end(), [&sum](auto& v){ sum += v; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach/references", "foreach_3" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach(a.begin(), a.end(), [&sum](auto& v){ v += 1; });
REQUIRE(a[0] == 2);
REQUIRE(a[1] == 3);
REQUIRE(a[2] == 4);
REQUIRE(a[3] == 5);
REQUIRE(a[4] == 6);
}
TEST_CASE( "foreach_it/container", "foreach_it_1" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_it(a, [&sum](auto it){ sum += *it; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach_it/range", "foreach_it_2" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_it(a.begin(), a.end(), [&sum](auto it){ sum += *it; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach_it/references", "foreach_it_3" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_it(a.begin(), a.end(), [&sum](auto v){ *v += 1; });
REQUIRE(a[0] == 2);
REQUIRE(a[1] == 3);
REQUIRE(a[2] == 4);
REQUIRE(a[3] == 5);
REQUIRE(a[4] == 6);
}
TEST_CASE( "foreach_i/container", "foreach_i_1" ) {
std::vector<int> a{1,2,3,4,5};
int sum_1 = 0;
int sum_2 = 0;
cpp::foreach_i(a,
[&sum_1,&sum_2,&a](auto& v, std::size_t i){ REQUIRE(a[i] == v); sum_1 += v; sum_2 += a[i];});
REQUIRE(sum_1 == 15);
REQUIRE(sum_2 == 15);
}
TEST_CASE( "foreach_i/range", "foreach_i_2" ) {
std::vector<int> a{1,2,3,4,5};
int sum_1 = 0;
int sum_2 = 0;
cpp::foreach_i(a.begin(), a.end(),
[&sum_1,&sum_2,&a](auto& v, std::size_t i){ REQUIRE(a[i] == v); sum_1 += v; sum_2 += a[i];});
REQUIRE(sum_1 == 15);
REQUIRE(sum_2 == 15);
}
TEST_CASE( "foreach_i/references", "foreach_it_3" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_i(a.begin(), a.end(),
[&sum,&a](auto& v, std::size_t i){ v += 1; a[i] += 1; });
REQUIRE(a[0] == 3);
REQUIRE(a[1] == 4);
REQUIRE(a[2] == 5);
REQUIRE(a[3] == 6);
REQUIRE(a[4] == 7);
}
TEST_CASE( "foreach_pair/container", "foreach_pair_1" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair(a,
[&i](auto& v1, auto& v2){ REQUIRE(v1 != v2); ++i;});
REQUIRE(i == 10);
}
TEST_CASE( "foreach_pair/range", "foreach_pair_2" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair(a.begin(), a.end(),
[&i](auto& v1, auto& v2){ REQUIRE(v1 != v2); ++i;});
REQUIRE(i == 10);
}
TEST_CASE( "foreach_pair_it/container", "foreach_pair_it_1" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair_it(a,
[&i](auto i1, auto i2){ REQUIRE(*i1 != *i2); ++i;});
REQUIRE(i == 10);
}
TEST_CASE( "foreach_pair_it/range", "foreach_pair_it_2" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair_it(a.begin(), a.end(),
[&i](auto i1, auto i2){ REQUIRE(*i1 != *i2); ++i;});
REQUIRE(i == 10);
}
<commit_msg>A test with std::list<commit_after>//=======================================================================
// Copyright (c) 2014-2015 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
#include <vector>
#include <list>
#include "catch.hpp"
#include "cpp_utils/algorithm.hpp"
TEST_CASE( "foreach/container", "foreach_1" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach(a, [&sum](auto& v){ sum += v; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach/range", "foreach_2" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach(a.begin(), a.end(), [&sum](auto& v){ sum += v; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach/references", "foreach_3" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach(a.begin(), a.end(), [&sum](auto& v){ v += 1; });
REQUIRE(a[0] == 2);
REQUIRE(a[1] == 3);
REQUIRE(a[2] == 4);
REQUIRE(a[3] == 5);
REQUIRE(a[4] == 6);
}
TEST_CASE( "foreach_it/container", "foreach_it_1" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_it(a, [&sum](auto it){ sum += *it; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach_it/range", "foreach_it_2" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_it(a.begin(), a.end(), [&sum](auto it){ sum += *it; });
REQUIRE(sum == 15);
}
TEST_CASE( "foreach_it/references", "foreach_it_3" ) {
std::vector<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_it(a.begin(), a.end(), [&sum](auto v){ *v += 1; });
REQUIRE(a[0] == 2);
REQUIRE(a[1] == 3);
REQUIRE(a[2] == 4);
REQUIRE(a[3] == 5);
REQUIRE(a[4] == 6);
}
TEST_CASE( "foreach_i/container", "foreach_i_1" ) {
std::vector<int> a{1,2,3,4,5};
int sum_1 = 0;
int sum_2 = 0;
cpp::foreach_i(a,
[&sum_1,&sum_2,&a](auto& v, std::size_t i){ REQUIRE(a[i] == v); sum_1 += v; sum_2 += a[i];});
REQUIRE(sum_1 == 15);
REQUIRE(sum_2 == 15);
}
TEST_CASE( "foreach_i/range", "foreach_i_2" ) {
std::vector<int> a{1,2,3,4,5};
int sum_1 = 0;
int sum_2 = 0;
cpp::foreach_i(a.begin(), a.end(),
[&sum_1,&sum_2,&a](auto& v, std::size_t i){ REQUIRE(a[i] == v); sum_1 += v; sum_2 += a[i];});
REQUIRE(sum_1 == 15);
REQUIRE(sum_2 == 15);
}
TEST_CASE( "foreach_i/references", "foreach_i_3" ) {
std::vector<int> a{1,2,3,4,5};
cpp::foreach_i(a.begin(), a.end(),
[&a](auto& v, std::size_t i){ v += 1; a[i] += 1; });
REQUIRE(a[0] == 3);
REQUIRE(a[1] == 4);
REQUIRE(a[2] == 5);
REQUIRE(a[3] == 6);
REQUIRE(a[4] == 7);
}
TEST_CASE( "foreach_i/list", "foreach_i_4" ) {
std::list<int> a{1,2,3,4,5};
int sum = 0;
cpp::foreach_i(a.begin(), a.end(),
[&sum](auto& v, std::size_t i){ v += 1; sum += i; });
REQUIRE(sum == 10);
auto it = a.begin();
REQUIRE(*it++ == 2);
REQUIRE(*it++ == 3);
REQUIRE(*it++ == 4);
REQUIRE(*it++ == 5);
REQUIRE(*it++ == 6);
}
TEST_CASE( "foreach_pair/container", "foreach_pair_1" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair(a,
[&i](auto& v1, auto& v2){ REQUIRE(v1 != v2); ++i;});
REQUIRE(i == 10);
}
TEST_CASE( "foreach_pair/range", "foreach_pair_2" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair(a.begin(), a.end(),
[&i](auto& v1, auto& v2){ REQUIRE(v1 != v2); ++i;});
REQUIRE(i == 10);
}
TEST_CASE( "foreach_pair_it/container", "foreach_pair_it_1" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair_it(a,
[&i](auto i1, auto i2){ REQUIRE(*i1 != *i2); ++i;});
REQUIRE(i == 10);
}
TEST_CASE( "foreach_pair_it/range", "foreach_pair_it_2" ) {
std::vector<int> a{1,2,3,4,5};
int i = 0;
cpp::foreach_pair_it(a.begin(), a.end(),
[&i](auto i1, auto i2){ REQUIRE(*i1 != *i2); ++i;});
REQUIRE(i == 10);
}
<|endoftext|> |
<commit_before>
/*
* benchmark.cpp - Contains benchmark code for measuring performance related
* numbers in this project
*
* This module should be compiled with all possible optimization flags, and
* also with libc debugging flag turned off
*/
#include "../src/AtomicStack.h"
#include "../src/LocalWriteEM.h"
#include "../src/GlobalWriteEM.h"
#include "test_suite.h"
using namespace peloton;
using namespace index;
// Number of cores we test EM on (this does not have to match the number
// of cores on the testing machine since we only test correctness but
// not performance)
uint64_t CoreNum;
// Declear stack and its node type here
using StackType = AtomicStack<uint64_t>;
using NodeType = typename StackType::NodeType;
// EM type declaration
using LEM = LocalWriteEM<NodeType>;
using GEM = GlobalWriteEM<NodeType>;
/*
* IntHasherRandBenchmark() - Benchmarks integer number hash function from
* Murmurhash3, which is then used as a random
* number generator
*/
void IntHasherRandBenchmark(uint64_t iter, uint64_t salt_num) {
PrintTestName("IntHasherRandBenchmark");
std::vector<uint64_t> v{};
v.reserve(1);
SimpleInt64Random<0, 10000000> r{};
Timer t{true};
for(uint64_t salt = 0;salt < salt_num;salt++) {
for(uint64_t i = 0;i < iter;i++) {
v[0] = r(i, salt);
}
}
double duration = t.Stop();
dbg_printf("Iteration = %lu, Duration = %f\n",
iter * salt_num,
duration);
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(iter * salt_num) / duration / 1024.0 / 1024.0);
return;
}
/*
* RandomNumberBenchmark() - Benchmark random number genrator inside C++11
*/
void RandomNumberBenchmark(int thread_num, int iter) {
PrintTestName("RandomNumberBenchmark");
auto f = [thread_num, iter](uint64_t id) -> void {
Random<uint64_t, 0, -1> r{};
// Avoid optimization
std::vector<uint64_t> v{};
v.reserve(1);
// Bring it into the cache such that we do not suffer from cache miss
v[0] = 1;
for(int i = 0;i < iter;i++) {
uint64_t num = r();
// This should be a cached write, so super fast
v[0] = num;
}
return;
};
Timer t{true};
StartThreads(thread_num, f);
double duration = t.Stop();
dbg_printf("Thread num = %d, Iteration = %d, Duration = %f\n",
thread_num,
iter,
duration);
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(iter) / duration / 1024.0 / 1024.0);
dbg_printf(" Throughput = %f M op/(sec * thread)\n",
static_cast<double>(iter) / duration / 1024.0 / 1024.0 / thread_num);
return;
}
/*
* GetThreadAffinityBenchmark() - Measures how fast we could call this function
*/
void GetThreadAffinityBenchmark(uint64_t thread_num) {
PrintTestName("GetThreadAffinityBenchmark");
constexpr int iter = 10000000;
auto f = [iter](uint64_t thread_id) {
// We need this to avoid the following loop being optimized out
std::vector<int> v{};
v.reserve(10);
for(int i = 0;i < iter;i++) {
int core_id = GetThreadAffinity();
v[0] = core_id;
}
return;
};
// Start Threads and timer
Timer t{true};
StartThreads(thread_num, f);
double duration = t.Stop();
dbg_printf("Time usage (iter %d, thread %lu) = %f\n",
iter,
thread_num,
duration);
dbg_printf(" Throughput = %f op/second\n",
static_cast<double>(iter) / duration);
dbg_printf(" Throughput = %f op/(second * thread)\n",
static_cast<double>(iter) / duration / thread_num);
return;
}
/*
* LEMSimpleBenchmark() - Benchmark how LocalWriteEM works without workload -
* just announce entry & exit and it's all
*/
void LEMSimpleBenchmark(uint64_t thread_num,
uint64_t op_num,
uint64_t workload) {
PrintTestName("LEMSimpleBenchmark");
// Note that we use the number of counters equal to the number of threads
// rather than number of cores, i.e. one core could have multiple counters
LEM *em = new LEM{thread_num};
auto func = [em, op_num, workload](uint64_t id) {
// This is the core ID this thread is logically pinned to
// physically we do not make any constraint here
uint64_t core_id = id % CoreNum;
// This avoids scheduling problem
// Without this function the performance will be very
// unstable especially when # of threads does not match
// number of core
PinToCore(core_id);
const uint64_t random_workload = workload;
const uint64_t dev = workload >> 2;
SimpleInt64Random hasher{};
// If workload is large enough then make it random
// Otherwise just use the given workload
if(workload != 0 && dev != 0) {
const uint64_t sign = hasher(id, id + 1) % 2;
if(sign == 0) {
random_workload = workload + hasher(id, id) % dev;
} else {
random_workload = workload - hasher(id, id) % dev;
}
}
std::vector<uint64_t> v{};
v.reserve(1);
// And then announce entry on its own processor
for(uint64_t i = 0;i < op_num;i++) {
em->AnnounceEnter(core_id);
for(uint64_t j = 0;j < random_workload;j++) {
v[0] = j;
}
}
};
// Need to start GC thread to periodically increase global epoch
em->StartGCThread();
// Let timer start and then start threads
Timer t{true};
StartThreads(thread_num, func);
double duration = t.Stop();
delete em;
dbg_printf("Tests of %lu threads, %lu operations each took %f seconds\n",
thread_num,
op_num,
duration);
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(thread_num * op_num) / duration / (1024.0 * 1024.0));
dbg_printf(" Throughput Per Thread = %f M op/sec\n",
static_cast<double>(op_num) / duration / (1024.0 * 1024.0));
return;
}
/*
* GEMSimpleBenchmark() - Runs GlobalWriteEM repeatedly for benchmark numbers
*
* For global EM since it uses coarse grained reference counting, we have to
* increase and decrease the counter whenever a thread enters and leaves the
* epoch, which is two times the overhead a LocalWriteEM would have
*/
void GEMSimpleBenchmark(uint64_t thread_num,
uint64_t op_num,
uint64_t workload) {
PrintTestName("GEMSimpleBenchmark");
// This instance must be created by the factory
GEM *em = new GEM{};
auto func = [em, op_num](uint64_t id) {
// And then announce entry on its own processor
for(uint64_t i = 0;i < op_num;i++) {
auto epoch_node_p = em->JoinEpoch();
em->LeaveEpoch(epoch_node_p);
}
};
em->StartGCThread();
// Let timer start and then start threads
Timer t{true};
StartThreads(thread_num, func);
double duration = t.Stop();
delete em;
dbg_printf("Tests of %lu threads, %lu operations each took %f seconds\n",
thread_num,
op_num,
duration);
dbg_printf(" Epoch created = %lu; Epoch freed = %lu\n",
em->GetEpochCreated(),
em->GetEpochFreed());
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(thread_num * op_num) / duration / (1024.0 * 1024.0));
dbg_printf(" Throughput Per Thread = %f M op/sec\n",
static_cast<double>(op_num) / duration / (1024.0 * 1024.0));
return;
}
/*
* GetValueOrThrow() - Get an unsigned long typed value from args, or throw
* exception if the format for key-value is not correct
*
* This function throws integer constant 0 on error
*/
void GetValueAsULOrThrow(Argv &args,
const std::string &key,
unsigned long *value_p) {
bool ret = args.GetValueAsUL(key, value_p);
if(ret == false) {
dbg_printf("ERROR: Unrecognized value for key %s: \"%s\"\n",
key.c_str(),
args.GetValue("thread_num")->c_str());
throw 0;
}
return;
}
int main(int argc, char **argv) {
// This returns the number of logical CPUs
CoreNum = GetCoreNum();
dbg_printf("* # of cores (default thread_num) on the platform = %lu\n",
CoreNum);
if(CoreNum == 0) {
dbg_printf(" ...which is not supported\n");
exit(1);
}
// This will be overloaded if a thread_num is provided as argument
uint64_t thread_num = CoreNum;
// By default no workload is done
uint64_t workload = 0;
Argv args{argc, argv};
GetValueAsULOrThrow(args, "thread_num", &thread_num);
GetValueAsULOrThrow(args, "workload", &workload);
dbg_printf("* thread_num = %lu\n", thread_num);
dbg_printf("* workload = %lu\n", workload);
dbg_printf("* CoreNum = %lu\n", CoreNum);
if(argc == 1 || args.Exists("thread_affinity")) {
GetThreadAffinityBenchmark(thread_num);
}
if(argc == 1 || args.Exists("int_hash")) {
IntHasherRandBenchmark(100000000, 10);
}
if(argc == 1 || args.Exists("random_number")) {
RandomNumberBenchmark(thread_num, 100000000);
}
if(argc == 1 || args.Exists("lem_simple")) {
LEMSimpleBenchmark(thread_num, 1024 * 1024 * 30);
}
if(argc == 1 || args.Exists("gem_simple")) {
GEMSimpleBenchmark(thread_num, 1024 * 1024 * 10);
}
return 0;
}
<commit_msg>Adding workload to GEM benchmark<commit_after>
/*
* benchmark.cpp - Contains benchmark code for measuring performance related
* numbers in this project
*
* This module should be compiled with all possible optimization flags, and
* also with libc debugging flag turned off
*/
#include "../src/AtomicStack.h"
#include "../src/LocalWriteEM.h"
#include "../src/GlobalWriteEM.h"
#include "test_suite.h"
using namespace peloton;
using namespace index;
// Number of cores we test EM on (this does not have to match the number
// of cores on the testing machine since we only test correctness but
// not performance)
uint64_t CoreNum;
// Declear stack and its node type here
using StackType = AtomicStack<uint64_t>;
using NodeType = typename StackType::NodeType;
// EM type declaration
using LEM = LocalWriteEM<NodeType>;
using GEM = GlobalWriteEM<NodeType>;
/*
* IntHasherRandBenchmark() - Benchmarks integer number hash function from
* Murmurhash3, which is then used as a random
* number generator
*/
void IntHasherRandBenchmark(uint64_t iter, uint64_t salt_num) {
PrintTestName("IntHasherRandBenchmark");
std::vector<uint64_t> v{};
v.reserve(1);
SimpleInt64Random<0, 10000000> r{};
Timer t{true};
for(uint64_t salt = 0;salt < salt_num;salt++) {
for(uint64_t i = 0;i < iter;i++) {
v[0] = r(i, salt);
}
}
double duration = t.Stop();
dbg_printf("Iteration = %lu, Duration = %f\n",
iter * salt_num,
duration);
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(iter * salt_num) / duration / 1024.0 / 1024.0);
return;
}
/*
* RandomNumberBenchmark() - Benchmark random number genrator inside C++11
*/
void RandomNumberBenchmark(int thread_num, int iter) {
PrintTestName("RandomNumberBenchmark");
auto f = [thread_num, iter](uint64_t id) -> void {
Random<uint64_t, 0, -1> r{};
// Avoid optimization
std::vector<uint64_t> v{};
v.reserve(1);
// Bring it into the cache such that we do not suffer from cache miss
v[0] = 1;
for(int i = 0;i < iter;i++) {
uint64_t num = r();
// This should be a cached write, so super fast
v[0] = num;
}
return;
};
Timer t{true};
StartThreads(thread_num, f);
double duration = t.Stop();
dbg_printf("Thread num = %d, Iteration = %d, Duration = %f\n",
thread_num,
iter,
duration);
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(iter) / duration / 1024.0 / 1024.0);
dbg_printf(" Throughput = %f M op/(sec * thread)\n",
static_cast<double>(iter) / duration / 1024.0 / 1024.0 / thread_num);
return;
}
/*
* GetThreadAffinityBenchmark() - Measures how fast we could call this function
*/
void GetThreadAffinityBenchmark(uint64_t thread_num) {
PrintTestName("GetThreadAffinityBenchmark");
constexpr int iter = 10000000;
auto f = [iter](uint64_t thread_id) {
// We need this to avoid the following loop being optimized out
std::vector<int> v{};
v.reserve(10);
for(int i = 0;i < iter;i++) {
int core_id = GetThreadAffinity();
v[0] = core_id;
}
return;
};
// Start Threads and timer
Timer t{true};
StartThreads(thread_num, f);
double duration = t.Stop();
dbg_printf("Time usage (iter %d, thread %lu) = %f\n",
iter,
thread_num,
duration);
dbg_printf(" Throughput = %f op/second\n",
static_cast<double>(iter) / duration);
dbg_printf(" Throughput = %f op/(second * thread)\n",
static_cast<double>(iter) / duration / thread_num);
return;
}
/*
* LEMSimpleBenchmark() - Benchmark how LocalWriteEM works without workload -
* just announce entry & exit and it's all
*/
void LEMSimpleBenchmark(uint64_t thread_num,
uint64_t op_num,
uint64_t workload) {
PrintTestName("LEMSimpleBenchmark");
// Note that we use the number of counters equal to the number of threads
// rather than number of cores, i.e. one core could have multiple counters
LEM *em = new LEM{thread_num};
auto func = [em, op_num, workload](uint64_t id) {
// This is the core ID this thread is logically pinned to
// physically we do not make any constraint here
uint64_t core_id = id % CoreNum;
// This avoids scheduling problem
// Without this function the performance will be very
// unstable especially when # of threads does not match
// number of core
PinToCore(core_id);
const uint64_t random_workload = workload;
const uint64_t dev = workload >> 2;
SimpleInt64Random hasher{};
// If workload is large enough then make it random
// Otherwise just use the given workload
if(workload != 0 && dev != 0) {
const uint64_t sign = hasher(id, id + 1) % 2;
if(sign == 0) {
random_workload = workload + hasher(id, id) % dev;
} else {
random_workload = workload - hasher(id, id) % dev;
}
}
std::vector<uint64_t> v{};
v.reserve(1);
// And then announce entry on its own processor
for(uint64_t i = 0;i < op_num;i++) {
em->AnnounceEnter(core_id);
for(uint64_t j = 0;j < random_workload;j++) {
v[0] = j;
}
}
return;
};
// Need to start GC thread to periodically increase global epoch
em->StartGCThread();
// Let timer start and then start threads
Timer t{true};
StartThreads(thread_num, func);
double duration = t.Stop();
delete em;
dbg_printf("Tests of %lu threads, %lu operations each took %f seconds\n",
thread_num,
op_num,
duration);
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(thread_num * op_num) / duration / (1024.0 * 1024.0));
dbg_printf(" Throughput Per Thread = %f M op/sec\n",
static_cast<double>(op_num) / duration / (1024.0 * 1024.0));
return;
}
/*
* GEMSimpleBenchmark() - Runs GlobalWriteEM repeatedly for benchmark numbers
*
* For global EM since it uses coarse grained reference counting, we have to
* increase and decrease the counter whenever a thread enters and leaves the
* epoch, which is two times the overhead a LocalWriteEM would have
*/
void GEMSimpleBenchmark(uint64_t thread_num,
uint64_t op_num,
uint64_t workload) {
PrintTestName("GEMSimpleBenchmark");
// This instance must be created by the factory
GEM *em = new GEM{};
auto func = [em, op_num](uint64_t id) {
const uint64_t random_workload = workload;
const uint64_t dev = workload >> 2;
SimpleInt64Random hasher{};
// If workload is large enough then make it random
// Otherwise just use the given workload
if(workload != 0 && dev != 0) {
const uint64_t sign = hasher(id, id + 1) % 2;
if(sign == 0) {
random_workload = workload + hasher(id, id) % dev;
} else {
random_workload = workload - hasher(id, id) % dev;
}
}
std::vector<uint64_t> v{};
v.reserve(1);
// And then announce entry on its own processor
for(uint64_t i = 0;i < op_num;i++) {
void *epoch_node_p = em->JoinEpoch(core_id);
// Actual workload is protected by epoch manager
for(uint64_t j = 0;j < random_workload;j++) {
v[0] = j;
}
em->LeaveEpoch(epoch_node_p);
}
return;
};
em->StartGCThread();
// Let timer start and then start threads
Timer t{true};
StartThreads(thread_num, func);
double duration = t.Stop();
delete em;
dbg_printf("Tests of %lu threads, %lu operations each took %f seconds\n",
thread_num,
op_num,
duration);
dbg_printf(" Epoch created = %lu; Epoch freed = %lu\n",
em->GetEpochCreated(),
em->GetEpochFreed());
dbg_printf(" Throughput = %f M op/sec\n",
static_cast<double>(thread_num * op_num) / duration / (1024.0 * 1024.0));
dbg_printf(" Throughput Per Thread = %f M op/sec\n",
static_cast<double>(op_num) / duration / (1024.0 * 1024.0));
return;
}
/*
* GetValueOrThrow() - Get an unsigned long typed value from args, or throw
* exception if the format for key-value is not correct
*
* This function throws integer constant 0 on error
*/
void GetValueAsULOrThrow(Argv &args,
const std::string &key,
unsigned long *value_p) {
bool ret = args.GetValueAsUL(key, value_p);
if(ret == false) {
dbg_printf("ERROR: Unrecognized value for key %s: \"%s\"\n",
key.c_str(),
args.GetValue("thread_num")->c_str());
throw 0;
}
return;
}
int main(int argc, char **argv) {
// This returns the number of logical CPUs
CoreNum = GetCoreNum();
dbg_printf("* # of cores (default thread_num) on the platform = %lu\n",
CoreNum);
if(CoreNum == 0) {
dbg_printf(" ...which is not supported\n");
exit(1);
}
// This will be overloaded if a thread_num is provided as argument
uint64_t thread_num = CoreNum;
// By default no workload is done
uint64_t workload = 0;
Argv args{argc, argv};
GetValueAsULOrThrow(args, "thread_num", &thread_num);
GetValueAsULOrThrow(args, "workload", &workload);
dbg_printf("* thread_num = %lu\n", thread_num);
dbg_printf("* workload = %lu\n", workload);
dbg_printf("* CoreNum = %lu\n", CoreNum);
if(argc == 1 || args.Exists("thread_affinity")) {
GetThreadAffinityBenchmark(thread_num);
}
if(argc == 1 || args.Exists("int_hash")) {
IntHasherRandBenchmark(100000000, 10);
}
if(argc == 1 || args.Exists("random_number")) {
RandomNumberBenchmark(thread_num, 100000000);
}
if(argc == 1 || args.Exists("lem_simple")) {
LEMSimpleBenchmark(thread_num, 1024 * 1024 * 30, workload);
}
if(argc == 1 || args.Exists("gem_simple")) {
GEMSimpleBenchmark(thread_num, 1024 * 1024 * 10, workload);
}
return 0;
}
<|endoftext|> |
<commit_before>#include "catch.hpp"
#include <scope.h>
using namespace shl;
TEST_CASE("Scope Name Test") {
SECTION("default contructor create a empty ScopeName") {
ScopeName name;
REQUIRE(name.name() == "");
REQUIRE(name.breakdown().size() == 0);
}
SECTION("scope name can be constructed by string") {
ScopeName name("source.control.c.if");
REQUIRE(name.name() == "source.control.c.if");
vector<string> elem = {"source", "control", "c", "if"};
REQUIRE(name.breakdown().size() == elem.size());
for (unsigned i = 0; i < elem.size(); i++) {
REQUIRE(name.breakdown()[i] == elem[i]);
}
}
SECTION("a empty ScopeName can be contructed by \"\"") {
ScopeName name("");
REQUIRE(name.name() == "");
REQUIRE(name.breakdown().size() == 0);
}
}
<commit_msg>add test for Scope<commit_after>#include "catch.hpp"
#include <scope.h>
using namespace shl;
TEST_CASE("Scope Name Test") {
SECTION("default contructor create a empty ScopeName") {
ScopeName name;
REQUIRE(name.name() == "");
REQUIRE(name.breakdown().size() == 0);
}
SECTION("scope name can be constructed by string") {
ScopeName name("source.control.c.if");
REQUIRE(name.name() == "source.control.c.if");
vector<string> elem = {"source", "control", "c", "if"};
REQUIRE(name.breakdown().size() == elem.size());
for (unsigned i = 0; i < elem.size(); i++) {
REQUIRE(name.breakdown()[i] == elem[i]);
}
}
SECTION("a empty ScopeName can be contructed by \"\"") {
ScopeName name("");
REQUIRE(name.name() == "");
REQUIRE(name.breakdown().size() == 0);
}
SECTION("scope can be compared") {
ScopeName name1("source.control.c.if");
ScopeName name2("haha");
ScopeName name3 = name1;
REQUIRE(name1 != name2);
REQUIRE_FALSE(name1 == name2);
REQUIRE(name1 == name3);
}
}
TEST_CASE("Scope Test") {
SECTION("scope be constructed from string") {
Scope s(" source punctuation.definition.string.end.c variable.parameter.preprocessor.c ");
REQUIRE(s.size() == 3);
REQUIRE(s[0].name() == "source");
REQUIRE(s[1].name() == "punctuation.definition.string.end.c");
REQUIRE(s[2].name() == "variable.parameter.preprocessor.c");
}
SECTION("scope name is normalized") {
Scope s(" source punctuation.definition.string.end.c variable.parameter.preprocessor.c ");
REQUIRE(s.name() == "source punctuation.definition.string.end.c variable.parameter.preprocessor.c");
}
SECTION("scope will be broken up into ScopeNames") {
Scope s("source punctuation.definition.string.end.c variable.parameter.preprocessor.c");
REQUIRE(s.size() == 3);
REQUIRE(s[0].name() == "source");
REQUIRE(s[1].name() == "punctuation.definition.string.end.c");
}
SECTION("scope can be compared") {
Scope s1("source punctuation.definition.string.end.c variable.parameter.preprocessor.c");
Scope s2 = s1;
Scope s3("ource punctuation.definition.string.end.c variable.parameter.preprocessor.c");
REQUIRE(s1 == s2);
REQUIRE(s1 != s3);
REQUIRE_FALSE(s1 != s2);
REQUIRE_FALSE(s1 == s3);
}
}
<|endoftext|> |
<commit_before>//=======================================================================
// Copyright (c) 2014-2016 Baptiste Wicht // Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
#include "test_light.hpp"
#include <cmath>
// Init tests
TEMPLATE_TEST_CASE_2("slice/1", "[slice]", Z, float, double) {
etl::fast_matrix<Z, 2, 3> test_matrix = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
auto s1 = slice(test_matrix, 0, 1);
REQUIRE(etl::size(s1) == 3);
REQUIRE(etl::dim<0>(s1) == 1);
REQUIRE(etl::dim<1>(s1) == 3);
REQUIRE(etl::dimensions(s1) == 2);
REQUIRE(s1(0, 0) == 1);
REQUIRE(s1(0, 1) == 2);
REQUIRE(s1(0, 2) == 3);
auto s2 = slice(test_matrix, 1, 2);
REQUIRE(etl::size(s2) == 3);
REQUIRE(etl::dim<0>(s2) == 1);
REQUIRE(etl::dim<1>(s2) == 3);
REQUIRE(etl::dimensions(s2) == 2);
REQUIRE(s2(0, 0) == 4);
REQUIRE(s2(0, 1) == 5);
REQUIRE(s2(0, 2) == 6);
auto s3 = slice(test_matrix, 0, 2);
REQUIRE(etl::size(s3) == 6);
REQUIRE(etl::dim<0>(s3) == 2);
REQUIRE(etl::dim<1>(s3) == 3);
REQUIRE(etl::dimensions(s3) == 2);
REQUIRE(s3(0, 0) == 1);
REQUIRE(s3(0, 1) == 2);
REQUIRE(s3(0, 2) == 3);
REQUIRE(s3(1, 0) == 4);
REQUIRE(s3(1, 1) == 5);
REQUIRE(s3(1, 2) == 6);
}
<commit_msg>More tests<commit_after>//=======================================================================
// Copyright (c) 2014-2016 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
#include "test_light.hpp"
TEMPLATE_TEST_CASE_2("slice/1", "[slice]", Z, float, double) {
etl::fast_matrix<Z, 2, 3> a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
auto s1 = slice(a, 0, 1);
REQUIRE(etl::size(s1) == 3);
REQUIRE(etl::dim<0>(s1) == 1);
REQUIRE(etl::dim<1>(s1) == 3);
REQUIRE(etl::dimensions(s1) == 2);
REQUIRE(s1(0, 0) == 1);
REQUIRE(s1(0, 1) == 2);
REQUIRE(s1(0, 2) == 3);
auto s2 = slice(a, 1, 2);
REQUIRE(etl::size(s2) == 3);
REQUIRE(etl::dim<0>(s2) == 1);
REQUIRE(etl::dim<1>(s2) == 3);
REQUIRE(etl::dimensions(s2) == 2);
REQUIRE(s2(0, 0) == 4);
REQUIRE(s2(0, 1) == 5);
REQUIRE(s2(0, 2) == 6);
auto s3 = slice(a, 0, 2);
REQUIRE(etl::size(s3) == 6);
REQUIRE(etl::dim<0>(s3) == 2);
REQUIRE(etl::dim<1>(s3) == 3);
REQUIRE(etl::dimensions(s3) == 2);
REQUIRE(s3(0, 0) == 1);
REQUIRE(s3(0, 1) == 2);
REQUIRE(s3(0, 2) == 3);
REQUIRE(s3(1, 0) == 4);
REQUIRE(s3(1, 1) == 5);
REQUIRE(s3(1, 2) == 6);
}
TEMPLATE_TEST_CASE_2("slice/2", "[slice]", Z, float, double) {
etl::fast_matrix<Z, 5, 8, 2, 3> a;
auto s1 = slice(a, 3, 5);
REQUIRE(etl::size(s1) == 2 * 8 * 2 * 3);
REQUIRE(etl::dim<0>(s1) == 2);
REQUIRE(etl::dim<1>(s1) == 8);
REQUIRE(etl::dim<2>(s1) == 2);
REQUIRE(etl::dim<3>(s1) == 3);
REQUIRE(etl::dimensions(s1) == 4);
auto s2 = slice(a, 1, 2);
REQUIRE(etl::size(s2) == 1 * 8 * 2 * 3);
REQUIRE(etl::dim<0>(s2) == 1);
REQUIRE(etl::dim<1>(s2) == 8);
REQUIRE(etl::dim<2>(s2) == 2);
REQUIRE(etl::dim<3>(s2) == 3);
REQUIRE(etl::dimensions(s2) == 4);
auto s3 = slice(a, 0, 5);
REQUIRE(etl::size(s3) == 5 * 8 * 2 * 3);
REQUIRE(etl::dim<0>(s3) == 5);
REQUIRE(etl::dim<1>(s3) == 8);
REQUIRE(etl::dim<2>(s3) == 2);
REQUIRE(etl::dim<3>(s3) == 3);
REQUIRE(etl::dimensions(s3) == 4);
}
TEMPLATE_TEST_CASE_2("slice/3", "[slice]", Z, float, double) {
etl::fast_matrix<Z, 2, 3> a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
etl::fast_matrix<Z, 1, 3> b;
b = etl::slice(a, 0, 1) + etl::slice(a, 1, 2);
REQUIRE(b(0, 0) == 5.0);
REQUIRE(b(0, 1) == 7.0);
REQUIRE(b(0, 2) == 9.0);
}
TEMPLATE_TEST_CASE_2("slice/4", "[slice]", Z, float, double) {
etl::fast_matrix<Z, 2, 1, 3> a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
etl::fast_matrix<Z, 1, 1, 3> b;
b = etl::slice(a, 0, 1) + etl::slice(a, 1, 2);
REQUIRE(b(0, 0, 0) == 5.0);
REQUIRE(b(0, 0, 1) == 7.0);
REQUIRE(b(0, 0, 2) == 9.0);
}
TEMPLATE_TEST_CASE_2("slice/5", "[slice]", Z, float, double) {
etl::fast_matrix<Z, 2, 1, 3> a;
etl::slice(a, 0, 1) = 1.0;
etl::slice(a, 1, 2) = 2.0;
REQUIRE(a(0, 0, 0) == 1.0);
REQUIRE(a(0, 0, 1) == 1.0);
REQUIRE(a(0, 0, 2) == 1.0);
REQUIRE(a(1, 0, 0) == 2.0);
REQUIRE(a(1, 0, 1) == 2.0);
REQUIRE(a(1, 0, 2) == 2.0);
etl::slice(a, 0, 2) = 3.0;
REQUIRE(a(0, 0, 0) == 3.0);
REQUIRE(a(0, 0, 1) == 3.0);
REQUIRE(a(0, 0, 2) == 3.0);
REQUIRE(a(1, 0, 0) == 3.0);
REQUIRE(a(1, 0, 1) == 3.0);
REQUIRE(a(1, 0, 2) == 3.0);
}
<|endoftext|> |
<commit_before>// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// Eigen 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 3 of the License, or (at your option) any later version.
//
// Alternatively, 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.
//
// Eigen 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 or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.
#include "main.h"
#include <Eigen/StdVector>
#include <Eigen/Geometry>
template<typename MatrixType>
void check_stdvector_matrix(const MatrixType& m)
{
int rows = m.rows();
int cols = m.cols();
MatrixType x = MatrixType::Random(rows,cols), y = MatrixType::Random(rows,cols);
std::vector<MatrixType,Eigen::aligned_allocator<MatrixType> > v(10, MatrixType(rows,cols)), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(MatrixType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
MatrixType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i]==w[(i-23)%w.size()]);
}
}
template<typename TransformType>
void check_stdvector_transform(const TransformType&)
{
typedef typename TransformType::MatrixType MatrixType;
TransformType x(MatrixType::Random()), y(MatrixType::Random());
std::vector<TransformType,Eigen::aligned_allocator<TransformType> > v(10), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(TransformType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
TransformType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i].matrix()==w[(i-23)%w.size()].matrix());
}
}
template<typename QuaternionType>
void check_stdvector_quaternion(const QuaternionType&)
{
typedef typename QuaternionType::Coefficients Coefficients;
QuaternionType x(Coefficients::Random()), y(Coefficients::Random());
std::vector<QuaternionType,Eigen::aligned_allocator<QuaternionType> > v(10), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(QuaternionType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
QuaternionType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i].coeffs()==w[(i-23)%w.size()].coeffs());
}
}
void test_stdvector()
{
// some non vectorizable fixed sizes
CALL_SUBTEST(check_stdvector_matrix(Vector2f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix3f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix3d()));
// some vectorizable fixed sizes
CALL_SUBTEST(check_stdvector_matrix(Matrix2f()));
CALL_SUBTEST(check_stdvector_matrix(Vector4f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix4f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix4d()));
// some dynamic sizes
CALL_SUBTEST(check_stdvector_matrix(MatrixXd(1,1)));
CALL_SUBTEST(check_stdvector_matrix(VectorXd(20)));
CALL_SUBTEST(check_stdvector_matrix(RowVectorXf(20)));
CALL_SUBTEST(check_stdvector_matrix(MatrixXcf(10,10)));
// some Transform
CALL_SUBTEST(check_stdvector_transform(Transform2f()));
CALL_SUBTEST(check_stdvector_transform(Transform3f()));
CALL_SUBTEST(check_stdvector_transform(Transform3d()));
//CALL_SUBTEST(check_stdvector_transform(Transform4d()));
// some Quaternion
CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
}
<commit_msg>fix typo<commit_after>// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// Eigen 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 3 of the License, or (at your option) any later version.
//
// Alternatively, 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.
//
// Eigen 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 or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.
#include "main.h"
#include <Eigen/StdVector>
#include <Eigen/Geometry>
template<typename MatrixType>
void check_stdvector_matrix(const MatrixType& m)
{
int rows = m.rows();
int cols = m.cols();
MatrixType x = MatrixType::Random(rows,cols), y = MatrixType::Random(rows,cols);
std::vector<MatrixType,Eigen::aligned_allocator<MatrixType> > v(10, MatrixType(rows,cols)), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(MatrixType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
MatrixType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i]==w[(i-23)%w.size()]);
}
}
template<typename TransformType>
void check_stdvector_transform(const TransformType&)
{
typedef typename TransformType::MatrixType MatrixType;
TransformType x(MatrixType::Random()), y(MatrixType::Random());
std::vector<TransformType,Eigen::aligned_allocator<TransformType> > v(10), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(TransformType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
TransformType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i].matrix()==w[(i-23)%w.size()].matrix());
}
}
template<typename QuaternionType>
void check_stdvector_quaternion(const QuaternionType&)
{
typedef typename QuaternionType::Coefficients Coefficients;
QuaternionType x(Coefficients::Random()), y(Coefficients::Random());
std::vector<QuaternionType,Eigen::aligned_allocator<QuaternionType> > v(10), w(20, y);
v[5] = x;
w[6] = v[5];
VERIFY_IS_APPROX(w[6], v[5]);
v = w;
for(int i = 0; i < 20; i++)
{
VERIFY_IS_APPROX(w[i], v[i]);
}
v.resize(21);
v[20] = x;
VERIFY_IS_APPROX(v[20], x);
v.resize(22,y);
VERIFY_IS_APPROX(v[21], y);
v.push_back(x);
VERIFY_IS_APPROX(v[22], x);
VERIFY((size_t)&(v[22]) == (size_t)&(v[21]) + sizeof(QuaternionType));
// do a lot of push_back such that the vector gets internally resized
// (with memory reallocation)
QuaternionType* ref = &w[0];
for(int i=0; i<30 || ((ref==&w[0]) && i<300); ++i)
v.push_back(w[i%w.size()]);
for(unsigned int i=23; i<v.size(); ++i)
{
VERIFY(v[i].coeffs()==w[(i-23)%w.size()].coeffs());
}
}
void test_stdvector()
{
// some non vectorizable fixed sizes
CALL_SUBTEST(check_stdvector_matrix(Vector2f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix3f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix3d()));
// some vectorizable fixed sizes
CALL_SUBTEST(check_stdvector_matrix(Matrix2f()));
CALL_SUBTEST(check_stdvector_matrix(Vector4f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix4f()));
CALL_SUBTEST(check_stdvector_matrix(Matrix4d()));
// some dynamic sizes
CALL_SUBTEST(check_stdvector_matrix(MatrixXd(1,1)));
CALL_SUBTEST(check_stdvector_matrix(VectorXd(20)));
CALL_SUBTEST(check_stdvector_matrix(RowVectorXf(20)));
CALL_SUBTEST(check_stdvector_matrix(MatrixXcf(10,10)));
// some Transform
CALL_SUBTEST(check_stdvector_transform(Transform2f()));
CALL_SUBTEST(check_stdvector_transform(Transform3f()));
CALL_SUBTEST(check_stdvector_transform(Transform3d()));
//CALL_SUBTEST(check_stdvector_transform(Transform4d()));
// some Quaternion
CALL_SUBTEST(check_stdvector_quaternion(Quaternionf()));
CALL_SUBTEST(check_stdvector_quaternion(Quaterniond()));
}
<|endoftext|> |
<commit_before>#include "gtest/gtest.h"
#include <tuple>
#include "../include/spica.h"
using namespace spica;
// -----------------------------------------------------------------------------
// Color class test
// -----------------------------------------------------------------------------
class ColorTest : public ::testing::Test {
protected:
ColorTest() {}
virtual ~ColorTest() {}
};
class ColorTestWithParam : public ColorTest, public ::testing::WithParamInterface<std::tuple<double, double, double> > {
protected:
double d0, d1, d2;
protected:
ColorTestWithParam() {
auto t = GetParam();
d0 = std::get<0>(t);
d1 = std::get<1>(t);
d2 = std::get<2>(t);
}
virtual ~ColorTestWithParam() {
}
};
TEST_P(ColorTestWithParam, DefaultInstance) {
Color c0;
EXPECT_EQ(0.0, c0.red());
EXPECT_EQ(0.0, c0.green());
EXPECT_EQ(0.0, c0.blue());
}
TEST_P(ColorTestWithParam, InstanceWithParams) {
Color c1(d0, d1, d2);
EXPECT_EQ(d0, c1.red());
EXPECT_EQ(d1, c1.green());
EXPECT_EQ(d2, c1.blue());
}
TEST_P(ColorTestWithParam, CopyConstructor) {
Color c0(d0, d1, d2);
Color c1(c0);
EXPECT_EQ(d0, c1.red());
EXPECT_EQ(d1, c1.green());
EXPECT_EQ(d2, c1.blue());
}
TEST_P(ColorTestWithParam, Assignment) {
Color c;
c = Color(d0, d1, d2);
EXPECT_EQ(d0, c.red());
EXPECT_EQ(d1, c.green());
EXPECT_EQ(d2, c.blue());
double lum = c.red() * 0.2126 + c.green() * 0.7152 + c.blue() * 0.0722;
EXPECT_DOUBLE_EQ(lum, c.luminance());
}
TEST_P(ColorTestWithParam, ValidSqrt) {
Color u(d0, d1, d2);
Color v = Color::sqrt(u);
EXPECT_EQ(sqrt(u.red()), v.red());
EXPECT_EQ(sqrt(u.green()), v.green());
EXPECT_EQ(sqrt(u.blue()), v.blue());
}
TEST_F(ColorTest, InvalidSqrt) {
Color c(-1.0, 2.0, 3.0);
ASSERT_DEATH(Color::sqrt(c), "");
}
TEST_P(ColorTestWithParam, ExpTest) {
Color u(d0, d1, d2);
Color v = Color::exp(u);
EXPECT_EQ(exp(u.red()), v.red());
EXPECT_EQ(exp(u.green()), v.green());
EXPECT_EQ(exp(u.blue()), v.blue());
}
const std::vector<double> values = { 0.0, 0.25, 0.50, 0.75 };
INSTANTIATE_TEST_CASE_P(, ColorTestWithParam,
::testing::Combine(::testing::ValuesIn(values),
::testing::ValuesIn(values),
::testing::ValuesIn(values)));
<commit_msg>Add unit tests for the Color class.<commit_after>#include "gtest/gtest.h"
#include <tuple>
#include "../include/spica.h"
using namespace spica;
// -----------------------------------------------------------------------------
// Color class test
// -----------------------------------------------------------------------------
using ColorPair = std::tuple<Color, Color>;
//! Fixture class for non-parametric tests
class ColorTest : public ::testing::Test {
protected:
ColorTest() {}
virtual ~ColorTest() {}
};
//! Fixture class for value-parameterized tests
class ColorTestWithParam : public ColorTest, public ::testing::WithParamInterface<ColorPair> {
protected:
Color c1, c2;
protected:
ColorTestWithParam() {}
virtual ~ColorTestWithParam() {}
void SetUp() {
c1 = std::get<0>(GetParam());
c2 = std::get<1>(GetParam());
}
};
TEST_F(ColorTest, DefaultInstance) {
Color c0;
EXPECT_EQ(0.0, c0.red());
EXPECT_EQ(0.0, c0.green());
EXPECT_EQ(0.0, c0.blue());
}
TEST_P(ColorTestWithParam, InstanceWithParams) {
Color c(c1.red(), c1.green(), c1.blue());
EXPECT_EQ(c1.red(), c.red());
EXPECT_EQ(c1.green(), c.green());
EXPECT_EQ(c1.blue(), c.blue());
}
TEST_P(ColorTestWithParam, CopyConstructor) {
Color c(c1);
EXPECT_EQ(c1.red(), c.red());
EXPECT_EQ(c1.green(), c.green());
EXPECT_EQ(c1.blue(), c.blue());
}
TEST_P(ColorTestWithParam, Assignment) {
Color c;
c = c1;
EXPECT_EQ(c1.red(), c.red());
EXPECT_EQ(c1.green(), c.green());
EXPECT_EQ(c1.blue(), c.blue());
const double lum = c.red() * 0.2126 +
c.green() * 0.7152 +
c.blue() * 0.0722;
EXPECT_DOUBLE_EQ(lum, c.luminance());
}
TEST_P(ColorTestWithParam, PlusOperator) {
Color c3 = c1 + c2;
EXPECT_EQ(c1.red() + c2.red(), c3.red());
EXPECT_EQ(c1.green() + c2.green(), c3.green());
EXPECT_EQ(c1.blue() + c2.blue(), c3.blue());
}
TEST_P(ColorTestWithParam, MinusOperator) {
Color c3 = c1 + c2;
EXPECT_EQ(c1.red() + c2.red(), c3.red());
EXPECT_EQ(c1.green() + c2.green(), c3.green());
EXPECT_EQ(c1.blue() + c2.blue(), c3.blue());
}
TEST_P(ColorTestWithParam, ScalarMultiplication) {
const double d = c2.red();
const Color c = c1 * d;
EXPECT_EQ(c1.red() * d, c.red());
EXPECT_EQ(c1.green() * d, c.green());
EXPECT_EQ(c1.blue() * d, c.blue());
}
TEST_P(ColorTestWithParam, ComponentWiseMultiplication) {
Color c3 = c1 * c2;
EXPECT_EQ(c1.red() * c2.red(), c3.red());
EXPECT_EQ(c1.green() * c2.green(), c3.green());
EXPECT_EQ(c1.blue() * c2.blue(), c3.blue());
}
TEST_P(ColorTestWithParam, Division) {
const double d = c2.red();
if (d != 0.0) {
Color c = c1 / d;
EXPECT_EQ(c1.red() / d, c.red());
EXPECT_EQ(c1.green() / d, c.green());
EXPECT_EQ(c1.blue() / d, c.blue());
} else {
ASSERT_DEATH(c1 / d, "");
}
}
TEST_P(ColorTestWithParam, Norm) {
const double sqnrm = c1.red() * c1.red() +
c1.green() * c1.green() +
c1.blue() * c1.blue();
EXPECT_EQ(sqnrm, c1.squaredNorm());
EXPECT_EQ(sqrt(sqnrm), c1.norm());
}
TEST_P(ColorTestWithParam, MinimumAndMaximum) {
const Color c3 = Color::minimum(c1, c2);
EXPECT_EQ(std::min(c1.red(), c2.red()), c3.red());
EXPECT_EQ(std::min(c1.green(), c2.green()), c3.green());
EXPECT_EQ(std::min(c1.blue(), c2.blue()), c3.blue());
const Color c4 = Color::maximum(c1, c2);
EXPECT_EQ(std::max(c1.red(), c2.red()), c4.red());
EXPECT_EQ(std::max(c1.green(), c2.green()), c4.green());
EXPECT_EQ(std::max(c1.blue(), c2.blue()), c4.blue());
}
TEST_P(ColorTestWithParam, ComponentWiseSqrt) {
if (c1.red() >= 0.0 && c1.green() >= 0.0 && c1.blue() >= 0.0) {
Color v = Color::sqrt(c1);
EXPECT_EQ(sqrt(c1.red()), v.red());
EXPECT_EQ(sqrt(c1.green()), v.green());
EXPECT_EQ(sqrt(c1.blue()), v.blue());
} else {
ASSERT_DEATH(Color::sqrt(c1), "");
}
}
TEST_P(ColorTestWithParam, ExpTest) {
const Color v = Color::exp(c1);
EXPECT_EQ(exp(c1.red()), v.red());
EXPECT_EQ(exp(c1.green()), v.green());
EXPECT_EQ(exp(c1.blue()), v.blue());
}
std::vector<Color> colors = {
Color(0.0, 1.0, 2.0),
Color(-2.0, -1.0, 0.0),
Color(3.14, 1.59, 2.65),
Color(1.0e8, 1.0e8, 1.0e8),
Color(1.0e-8, 1.0e-8, 1.0e-8)
};
INSTANTIATE_TEST_CASE_P(, ColorTestWithParam,
::testing::Combine(::testing::ValuesIn(colors),
::testing::ValuesIn(colors)));
<|endoftext|> |
<commit_before>/*
Copyright (c) 2012, Arvid Norberg
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 author 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 "libtorrent/file.hpp"
#include "test.hpp"
#include "setup_transfer.hpp" // for test_sleep
#include <string.h> // for strcmp
#include <vector>
#include <set>
using namespace libtorrent;
int touch_file(std::string const& filename, int size)
{
using namespace libtorrent;
std::vector<char> v;
v.resize(size);
for (int i = 0; i < size; ++i)
v[i] = i & 255;
file f;
error_code ec;
if (!f.open(filename, file::write_only, ec)) return -1;
if (ec) return -1;
file::iovec_t b = {&v[0], v.size()};
size_type written = f.writev(0, &b, 1, ec);
if (written != int(v.size())) return -3;
if (ec) return -3;
return 0;
}
void test_create_directory()
{
error_code ec;
create_directory("__foobar__", ec);
TEST_CHECK(!ec);
file_status st;
stat_file("__foobar__", &st, ec);
TEST_CHECK(!ec);
TEST_CHECK(st.mode & file_status::directory);
remove("__foobar__", ec);
TEST_CHECK(!ec);
}
void test_stat()
{
error_code ec;
// test that the modification timestamps
touch_file("__test_timestamp__", 10);
file_status st1;
stat_file("__test_timestamp__", &st1, ec);
TEST_CHECK(!ec);
// sleep for 3 seconds and then make sure the difference in timestamp is
// between 2-4 seconds after touching it again
test_sleep(3000);
touch_file("__test_timestamp__", 10);
file_status st2;
stat_file("__test_timestamp__", &st2, ec);
TEST_CHECK(!ec);
int diff = int(st2.mtime - st1.mtime);
fprintf(stderr, "timestamp difference: %d seconds. expected approx. 3 seconds\n"
, diff);
TEST_CHECK(diff >= 2 && diff <= 4);
}
int test_main()
{
test_create_directory();
test_stat();
error_code ec;
create_directory("file_test_dir", ec);
if (ec) fprintf(stderr, "create_directory: %s\n", ec.message().c_str());
TEST_CHECK(!ec);
std::string cwd = current_working_directory();
touch_file(combine_path("file_test_dir", "abc"), 10);
touch_file(combine_path("file_test_dir", "def"), 100);
touch_file(combine_path("file_test_dir", "ghi"), 1000);
std::set<std::string> files;
for (directory i("file_test_dir", ec); !i.done(); i.next(ec))
{
std::string f = i.file();
TEST_CHECK(files.count(f) == 0);
files.insert(f);
fprintf(stderr, " %s\n", f.c_str());
}
TEST_CHECK(files.count("abc") == 1);
TEST_CHECK(files.count("def") == 1);
TEST_CHECK(files.count("ghi") == 1);
TEST_CHECK(files.count("..") == 1);
TEST_CHECK(files.count(".") == 1);
files.clear();
recursive_copy("file_test_dir", "file_test_dir2", ec);
for (directory i("file_test_dir2", ec); !i.done(); i.next(ec))
{
std::string f = i.file();
TEST_CHECK(files.count(f) == 0);
files.insert(f);
fprintf(stderr, " %s\n", f.c_str());
}
remove_all("file_test_dir", ec);
if (ec) fprintf(stderr, "remove_all: %s\n", ec.message().c_str());
remove_all("file_test_dir2", ec);
if (ec) fprintf(stderr, "remove_all: %s\n", ec.message().c_str());
// test path functions
TEST_EQUAL(combine_path("test1/", "test2"), "test1/test2");
#ifdef TORRENT_WINDOWS
TEST_EQUAL(combine_path("test1\\", "test2"), "test1\\test2");
TEST_EQUAL(combine_path("test1", "test2"), "test1\\test2");
#else
TEST_EQUAL(combine_path("test1", "test2"), "test1/test2");
#endif
#if TORRENT_USE_UNC_PATHS
TEST_EQUAL(canonicalize_path("c:\\a\\..\\b"), "c:\\b");
TEST_EQUAL(canonicalize_path("a\\..\\b"), "b");
TEST_EQUAL(canonicalize_path("a\\..\\.\\b"), "b");
TEST_EQUAL(canonicalize_path("\\.\\a"), "\\a");
TEST_EQUAL(canonicalize_path("\\\\bla\\.\\a"), "\\\\bla\\a");
TEST_EQUAL(canonicalize_path("c:\\bla\\a"), "c:\\bla\\a");
#endif
TEST_EQUAL(extension("blah"), "");
TEST_EQUAL(extension("blah.exe"), ".exe");
TEST_EQUAL(extension("blah.foo.bar"), ".bar");
TEST_EQUAL(extension("blah.foo."), ".");
TEST_EQUAL(extension("blah.foo/bar"), "");
TEST_EQUAL(remove_extension("blah"), "blah");
TEST_EQUAL(remove_extension("blah.exe"), "blah");
TEST_EQUAL(remove_extension("blah.foo.bar"), "blah.foo");
TEST_EQUAL(remove_extension("blah.foo."), "blah.foo");
TEST_EQUAL(filename("blah"), "blah");
TEST_EQUAL(filename("/blah/foo/bar"), "bar");
TEST_EQUAL(filename("/blah/foo/bar/"), "bar");
TEST_EQUAL(filename("blah/"), "blah");
#ifdef TORRENT_WINDOWS
TEST_EQUAL(is_root_path("c:\\blah"), false);
TEST_EQUAL(is_root_path("c:\\"), true);
TEST_EQUAL(is_root_path("\\\\"), true);
TEST_EQUAL(is_root_path("\\\\foobar"), true);
TEST_EQUAL(is_root_path("\\\\foobar\\"), true);
TEST_EQUAL(is_root_path("\\\\foobar/"), true);
TEST_EQUAL(is_root_path("\\\\foo/bar"), false);
TEST_EQUAL(is_root_path("\\\\foo\\bar\\"), false);
#else
TEST_EQUAL(is_root_path("/blah"), false);
TEST_EQUAL(is_root_path("/"), true);
#endif
// if has_parent_path() returns false
// parent_path() should return the empty string
TEST_EQUAL(parent_path("blah"), "");
TEST_EQUAL(has_parent_path("blah"), false);
TEST_EQUAL(parent_path("/blah/foo/bar"), "/blah/foo/");
TEST_EQUAL(has_parent_path("/blah/foo/bar"), true);
TEST_EQUAL(parent_path("/blah/foo/bar/"), "/blah/foo/");
TEST_EQUAL(has_parent_path("/blah/foo/bar/"), true);
TEST_EQUAL(parent_path("/a"), "/");
TEST_EQUAL(has_parent_path("/a"), true);
TEST_EQUAL(parent_path("/"), "");
TEST_EQUAL(has_parent_path("/"), false);
TEST_EQUAL(parent_path(""), "");
TEST_EQUAL(has_parent_path(""), false);
#ifdef TORRENT_WINDOWS
TEST_EQUAL(parent_path("\\\\"), "");
TEST_EQUAL(has_parent_path("\\\\"), false);
TEST_EQUAL(parent_path("c:\\"), "");
TEST_EQUAL(has_parent_path("c:\\"), false);
TEST_EQUAL(parent_path("c:\\a"), "c:\\");
TEST_EQUAL(has_parent_path("c:\\a"), true);
TEST_EQUAL(has_parent_path("\\\\a"), false);
TEST_EQUAL(has_parent_path("\\\\foobar/"), false);
TEST_EQUAL(has_parent_path("\\\\foobar\\"), false);
TEST_EQUAL(has_parent_path("\\\\foo/bar\\"), true);
#endif
#ifdef TORRENT_WINDOWS
TEST_EQUAL(is_complete("c:\\"), true);
TEST_EQUAL(is_complete("c:\\foo\\bar"), true);
TEST_EQUAL(is_complete("\\\\foo\\bar"), true);
TEST_EQUAL(is_complete("foo/bar"), false);
TEST_EQUAL(is_complete("\\\\"), true);
#else
TEST_EQUAL(is_complete("/foo/bar"), true);
TEST_EQUAL(is_complete("foo/bar"), false);
TEST_EQUAL(is_complete("/"), true);
TEST_EQUAL(is_complete(""), false);
#endif
// test split_string
char const* tags[10];
char tags_str[] = " this is\ta test\t string\x01to be split and it cannot "
"extend over the limit of elements \t";
int ret = split_string(tags, 10, tags_str);
TEST_CHECK(ret == 10);
TEST_CHECK(strcmp(tags[0], "this") == 0);
TEST_CHECK(strcmp(tags[1], "is") == 0);
TEST_CHECK(strcmp(tags[2], "a") == 0);
TEST_CHECK(strcmp(tags[3], "test") == 0);
TEST_CHECK(strcmp(tags[4], "string") == 0);
TEST_CHECK(strcmp(tags[5], "to") == 0);
TEST_CHECK(strcmp(tags[6], "be") == 0);
TEST_CHECK(strcmp(tags[7], "split") == 0);
TEST_CHECK(strcmp(tags[8], "and") == 0);
TEST_CHECK(strcmp(tags[9], "it") == 0);
// replace_extension
std::string test = "foo.bar";
replace_extension(test, "txt");
TEST_EQUAL(test, "foo.txt");
test = "_";
replace_extension(test, "txt");
TEST_EQUAL(test, "_.txt");
test = "1.2.3/_";
replace_extension(test, "txt");
TEST_EQUAL(test, "1.2.3/_.txt");
// file class
file f;
#if TORRENT_USE_UNC_PATHS || !defined WIN32
TEST_CHECK(f.open("con", file::read_write, ec));
#else
TEST_CHECK(f.open("test_file", file::read_write, ec));
#endif
TEST_CHECK(!ec);
if (ec) fprintf(stderr, "%s\n", ec.message().c_str());
file::iovec_t b = {(void*)"test", 4};
TEST_CHECK(f.writev(0, &b, 1, ec) == 4);
TEST_CHECK(!ec);
char test_buf[5] = {0};
b.iov_base = test_buf;
b.iov_len = 4;
TEST_CHECK(f.readv(0, &b, 1, ec) == 4);
TEST_CHECK(!ec);
TEST_CHECK(strcmp(test_buf, "test") == 0);
f.close();
return 0;
}
<commit_msg>extend path tests<commit_after>/*
Copyright (c) 2012, Arvid Norberg
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 author 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 "libtorrent/file.hpp"
#include "test.hpp"
#include "setup_transfer.hpp" // for test_sleep
#include <string.h> // for strcmp
#include <vector>
#include <set>
using namespace libtorrent;
int touch_file(std::string const& filename, int size)
{
using namespace libtorrent;
std::vector<char> v;
v.resize(size);
for (int i = 0; i < size; ++i)
v[i] = i & 255;
file f;
error_code ec;
if (!f.open(filename, file::write_only, ec)) return -1;
if (ec) return -1;
file::iovec_t b = {&v[0], v.size()};
size_type written = f.writev(0, &b, 1, ec);
if (written != int(v.size())) return -3;
if (ec) return -3;
return 0;
}
void test_create_directory()
{
error_code ec;
create_directory("__foobar__", ec);
TEST_CHECK(!ec);
file_status st;
stat_file("__foobar__", &st, ec);
TEST_CHECK(!ec);
TEST_CHECK(st.mode & file_status::directory);
remove("__foobar__", ec);
TEST_CHECK(!ec);
}
void test_stat()
{
error_code ec;
// test that the modification timestamps
touch_file("__test_timestamp__", 10);
file_status st1;
stat_file("__test_timestamp__", &st1, ec);
TEST_CHECK(!ec);
// sleep for 3 seconds and then make sure the difference in timestamp is
// between 2-4 seconds after touching it again
test_sleep(3000);
touch_file("__test_timestamp__", 10);
file_status st2;
stat_file("__test_timestamp__", &st2, ec);
TEST_CHECK(!ec);
int diff = int(st2.mtime - st1.mtime);
fprintf(stderr, "timestamp difference: %d seconds. expected approx. 3 seconds\n"
, diff);
TEST_CHECK(diff >= 2 && diff <= 4);
}
int test_main()
{
test_create_directory();
test_stat();
error_code ec;
create_directory("file_test_dir", ec);
if (ec) fprintf(stderr, "create_directory: %s\n", ec.message().c_str());
TEST_CHECK(!ec);
std::string cwd = current_working_directory();
touch_file(combine_path("file_test_dir", "abc"), 10);
touch_file(combine_path("file_test_dir", "def"), 100);
touch_file(combine_path("file_test_dir", "ghi"), 1000);
std::set<std::string> files;
for (directory i("file_test_dir", ec); !i.done(); i.next(ec))
{
std::string f = i.file();
TEST_CHECK(files.count(f) == 0);
files.insert(f);
fprintf(stderr, " %s\n", f.c_str());
}
TEST_CHECK(files.count("abc") == 1);
TEST_CHECK(files.count("def") == 1);
TEST_CHECK(files.count("ghi") == 1);
TEST_CHECK(files.count("..") == 1);
TEST_CHECK(files.count(".") == 1);
files.clear();
recursive_copy("file_test_dir", "file_test_dir2", ec);
for (directory i("file_test_dir2", ec); !i.done(); i.next(ec))
{
std::string f = i.file();
TEST_CHECK(files.count(f) == 0);
files.insert(f);
fprintf(stderr, " %s\n", f.c_str());
}
remove_all("file_test_dir", ec);
if (ec) fprintf(stderr, "remove_all: %s\n", ec.message().c_str());
remove_all("file_test_dir2", ec);
if (ec) fprintf(stderr, "remove_all: %s\n", ec.message().c_str());
// test path functions
TEST_EQUAL(combine_path("test1/", "test2"), "test1/test2");
TEST_EQUAL(combine_path("test1", "."), "test1");
TEST_EQUAL(combine_path(".", "test1"), "test1");
#ifdef TORRENT_WINDOWS
TEST_EQUAL(combine_path("test1\\", "test2"), "test1\\test2");
TEST_EQUAL(combine_path("test1", "test2"), "test1\\test2");
#else
TEST_EQUAL(combine_path("test1", "test2"), "test1/test2");
#endif
#if TORRENT_USE_UNC_PATHS
TEST_EQUAL(canonicalize_path("c:\\a\\..\\b"), "c:\\b");
TEST_EQUAL(canonicalize_path("a\\..\\b"), "b");
TEST_EQUAL(canonicalize_path("a\\..\\.\\b"), "b");
TEST_EQUAL(canonicalize_path("\\.\\a"), "\\a");
TEST_EQUAL(canonicalize_path("\\\\bla\\.\\a"), "\\\\bla\\a");
TEST_EQUAL(canonicalize_path("c:\\bla\\a"), "c:\\bla\\a");
#endif
TEST_EQUAL(extension("blah"), "");
TEST_EQUAL(extension("blah.exe"), ".exe");
TEST_EQUAL(extension("blah.foo.bar"), ".bar");
TEST_EQUAL(extension("blah.foo."), ".");
TEST_EQUAL(extension("blah.foo/bar"), "");
TEST_EQUAL(remove_extension("blah"), "blah");
TEST_EQUAL(remove_extension("blah.exe"), "blah");
TEST_EQUAL(remove_extension("blah.foo.bar"), "blah.foo");
TEST_EQUAL(remove_extension("blah.foo."), "blah.foo");
TEST_EQUAL(filename("blah"), "blah");
TEST_EQUAL(filename("/blah/foo/bar"), "bar");
TEST_EQUAL(filename("/blah/foo/bar/"), "bar");
TEST_EQUAL(filename("blah/"), "blah");
#ifdef TORRENT_WINDOWS
TEST_EQUAL(is_root_path("c:\\blah"), false);
TEST_EQUAL(is_root_path("c:\\"), true);
TEST_EQUAL(is_root_path("\\\\"), true);
TEST_EQUAL(is_root_path("\\\\foobar"), true);
TEST_EQUAL(is_root_path("\\\\foobar\\"), true);
TEST_EQUAL(is_root_path("\\\\foobar/"), true);
TEST_EQUAL(is_root_path("\\\\foo/bar"), false);
TEST_EQUAL(is_root_path("\\\\foo\\bar\\"), false);
#else
TEST_EQUAL(is_root_path("/blah"), false);
TEST_EQUAL(is_root_path("/"), true);
#endif
// if has_parent_path() returns false
// parent_path() should return the empty string
TEST_EQUAL(parent_path("blah"), "");
TEST_EQUAL(has_parent_path("blah"), false);
TEST_EQUAL(parent_path("/blah/foo/bar"), "/blah/foo/");
TEST_EQUAL(has_parent_path("/blah/foo/bar"), true);
TEST_EQUAL(parent_path("/blah/foo/bar/"), "/blah/foo/");
TEST_EQUAL(has_parent_path("/blah/foo/bar/"), true);
TEST_EQUAL(parent_path("/a"), "/");
TEST_EQUAL(has_parent_path("/a"), true);
TEST_EQUAL(parent_path("/"), "");
TEST_EQUAL(has_parent_path("/"), false);
TEST_EQUAL(parent_path(""), "");
TEST_EQUAL(has_parent_path(""), false);
#ifdef TORRENT_WINDOWS
TEST_EQUAL(parent_path("\\\\"), "");
TEST_EQUAL(has_parent_path("\\\\"), false);
TEST_EQUAL(parent_path("c:\\"), "");
TEST_EQUAL(has_parent_path("c:\\"), false);
TEST_EQUAL(parent_path("c:\\a"), "c:\\");
TEST_EQUAL(has_parent_path("c:\\a"), true);
TEST_EQUAL(has_parent_path("\\\\a"), false);
TEST_EQUAL(has_parent_path("\\\\foobar/"), false);
TEST_EQUAL(has_parent_path("\\\\foobar\\"), false);
TEST_EQUAL(has_parent_path("\\\\foo/bar\\"), true);
#endif
#ifdef TORRENT_WINDOWS
TEST_EQUAL(is_complete("c:\\"), true);
TEST_EQUAL(is_complete("c:\\foo\\bar"), true);
TEST_EQUAL(is_complete("\\\\foo\\bar"), true);
TEST_EQUAL(is_complete("foo/bar"), false);
TEST_EQUAL(is_complete("\\\\"), true);
#else
TEST_EQUAL(is_complete("/foo/bar"), true);
TEST_EQUAL(is_complete("foo/bar"), false);
TEST_EQUAL(is_complete("/"), true);
TEST_EQUAL(is_complete(""), false);
#endif
TEST_EQUAL(complete("."), current_working_directory());
// test split_string
char const* tags[10];
char tags_str[] = " this is\ta test\t string\x01to be split and it cannot "
"extend over the limit of elements \t";
int ret = split_string(tags, 10, tags_str);
TEST_CHECK(ret == 10);
TEST_CHECK(strcmp(tags[0], "this") == 0);
TEST_CHECK(strcmp(tags[1], "is") == 0);
TEST_CHECK(strcmp(tags[2], "a") == 0);
TEST_CHECK(strcmp(tags[3], "test") == 0);
TEST_CHECK(strcmp(tags[4], "string") == 0);
TEST_CHECK(strcmp(tags[5], "to") == 0);
TEST_CHECK(strcmp(tags[6], "be") == 0);
TEST_CHECK(strcmp(tags[7], "split") == 0);
TEST_CHECK(strcmp(tags[8], "and") == 0);
TEST_CHECK(strcmp(tags[9], "it") == 0);
// replace_extension
std::string test = "foo.bar";
replace_extension(test, "txt");
TEST_EQUAL(test, "foo.txt");
test = "_";
replace_extension(test, "txt");
TEST_EQUAL(test, "_.txt");
test = "1.2.3/_";
replace_extension(test, "txt");
TEST_EQUAL(test, "1.2.3/_.txt");
// file class
file f;
#if TORRENT_USE_UNC_PATHS || !defined WIN32
TEST_CHECK(f.open("con", file::read_write, ec));
#else
TEST_CHECK(f.open("test_file", file::read_write, ec));
#endif
TEST_CHECK(!ec);
if (ec) fprintf(stderr, "%s\n", ec.message().c_str());
file::iovec_t b = {(void*)"test", 4};
TEST_CHECK(f.writev(0, &b, 1, ec) == 4);
TEST_CHECK(!ec);
char test_buf[5] = {0};
b.iov_base = test_buf;
b.iov_len = 4;
TEST_CHECK(f.readv(0, &b, 1, ec) == 4);
TEST_CHECK(!ec);
TEST_CHECK(strcmp(test_buf, "test") == 0);
f.close();
return 0;
}
<|endoftext|> |
<commit_before>#include "../include/optics/optics.h"
#include <vector>
void test_1(){
static const int N = 2;
typedef std::array<double, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { {100,100}, {102,100}, {101,101}, //cluster 1
{-1,0}, {1,0}, {0,1}, //cluster 2
{-100,-100}, {-102,-100}, {-101,-101} //cluster 3
};
auto reach_dists = optics::compute_reachability_dists( points, 2, 10 );
for( const auto& x : reach_dists){
std::cout << x.to_string() << "; ";
}
auto clusters = optics::get_cluster_indices(reach_dists, 10);
assert(clusters.size() == 3);
assert( ( fplus::sort( clusters[0] ) == std::vector <std::size_t>({ 0,1,2 }) ) );
assert( ( fplus::sort( clusters[1] ) == std::vector <std::size_t>({ 3,4,5 }) ) );
assert( ( fplus::sort( clusters[2] ) == std::vector <std::size_t>({ 6,7,8 }) ) );
double epsilon_est = optics::epsilon_estimation( points, 2 );
std::cout << "Epsilon-Estimation: " << epsilon_est << std::endl;
}
void test_2() {
static const int N = 2;
typedef std::array<int, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { { 100,100 },{ 102,100 },{ 101,101 }, //cluster 1
{ -1,0 },{ 1,0 },{ 0,1 }, //cluster 2
{ -100,-100 },{ -102,-100 },{ -101,-101 } //cluster 3
};
auto reach_dists = optics::compute_reachability_dists( points, 2 );
for ( const auto& x : reach_dists ) {
std::cout << x.to_string() << "; ";
}
auto clusters = optics::get_cluster_indices( reach_dists, 2 );
assert( clusters.size() == 3 );
assert( (fplus::sort( clusters[0] ) == std::vector <std::size_t>( { 0,1,2 } )) );
assert( (fplus::sort( clusters[1] ) == std::vector <std::size_t>( { 3,4,5 } )) );
assert( (fplus::sort( clusters[2] ) == std::vector <std::size_t>( { 6,7,8 } )) );
double epsilon_est = optics::epsilon_estimation( points, 2 );
std::cout << "Epsilon-Estimation: " << epsilon_est << std::endl;
optics::draw_reachability_plot( reach_dists, "ReachabilityPlot" );
}
void test_3(){
static const int N = 2;
typedef std::array<unsigned char, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { {100,100}, {102,100}, {101,101}, //cluster 1
{1,1}, {1,0}, {0,1}, //cluster 2
{200,100}, {202,100}, {201,101} //cluster 3
};
auto reach_dists = optics::compute_reachability_dists( points, 2, 10 );
auto clusters = optics::get_cluster_indices( reach_dists, 10 );
assert( clusters.size() == 3 );
assert( (fplus::sort( clusters[0] ) == std::vector <std::size_t>( { 0,1,2 } )) );
assert( (fplus::sort( clusters[1] ) == std::vector <std::size_t>( { 3,4,5 } )) );
assert( (fplus::sort( clusters[2] ) == std::vector <std::size_t>( { 6,7,8 } )) );
auto cluster_points = optics::get_cluster_points(reach_dists, 10, points);
auto img = optics::draw_2d_clusters(cluster_points);
img.save("Clusters2d");
}
void test_4() {
static const int N = 2;
typedef std::array<double, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { { 0,0 },{ 1,0 },{ 0,1 },
{ 10,0 },{ 0,10 },{ 6,6 },{ 4,4 },
{ 10,10 },{ 9,10 },{ 10,9 }
};
double epsilon_est = optics::epsilon_estimation( points, 3 );
assert( epsilon_est <3.090196 && epsilon_est >3.09019 );
}
void test_5() {
static const int N = 3;
typedef std::array<double, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { { 0,0,0 },{ 1,0,0 },{ 0,0,1 },{ 0,1,0 },
{ 5,0,0 },{ 0,5,0 },{ 0,0,5 },{ 5,5,5 }
};
double epsilon_est = optics::epsilon_estimation( points, 3 );
assert( epsilon_est >2.236750 && epsilon_est <2.236751 );
}
void test_6(){
std::vector<optics::reachability_dist> reach_dists = {
{1,10.0}, {2,9.0}, {3,9.0}, {4, 5.0},//SDA
{5,5.49}, {6,5.0},//Cluster1
{7, 6.5},//SUA
{8,3.0},//SDA
{9, 2.9}, {10, 2.8},//Cluster2
{11, 10.0},{12, 12.0}//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>({ {2, 5}, {0, 10}, { 6,10 } }) ) );
}
void test_7() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,10.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 12.0 },//SUA
{13, 4.0},//SDA
{14, 4.1}, {15,4.0},{ 16,3.9 },//Cluster3
{17,5.0}//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 10 },{ 6,10 }, {11,16} } )) );
}
void test_8() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,11.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
{ 17,12.0 }//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{ 11,16 } } )) );
}
void test_9() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,12.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
{ 17,11.0 }//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{ 11,16 } } )) );
}
void test_10() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,12.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
{ 17,12.0 }//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{0,16},{ 11,16 } } )) );
}
int main()
{
test_1();
test_2();
test_3();
test_4();
test_5();
test_6();
test_7();
test_8();
test_9();
test_10();
}
<commit_msg>tests<commit_after>#include "../include/optics/optics.h"
#include <vector>
void test_1(){
static const int N = 2;
typedef std::array<double, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { {100,100}, {102,100}, {101,101}, //cluster 1
{-1,0}, {1,0}, {0,1}, //cluster 2
{-100,-100}, {-102,-100}, {-101,-101} //cluster 3
};
auto reach_dists = optics::compute_reachability_dists( points, 2, 10 );
for( const auto& x : reach_dists){
std::cout << x.to_string() << "; ";
}
auto clusters = optics::get_cluster_indices(reach_dists, 10);
assert(clusters.size() == 3);
assert( ( fplus::sort( clusters[0] ) == std::vector <std::size_t>({ 0,1,2 }) ) );
assert( ( fplus::sort( clusters[1] ) == std::vector <std::size_t>({ 3,4,5 }) ) );
assert( ( fplus::sort( clusters[2] ) == std::vector <std::size_t>({ 6,7,8 }) ) );
double epsilon_est = optics::epsilon_estimation( points, 2 );
std::cout << "Epsilon-Estimation: " << epsilon_est << std::endl;
}
void test_2() {
static const int N = 2;
typedef std::array<int, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { { 100,100 },{ 102,100 },{ 101,101 }, //cluster 1
{ -1,0 },{ 1,0 },{ 0,1 }, //cluster 2
{ -100,-100 },{ -102,-100 },{ -101,-101 } //cluster 3
};
auto reach_dists = optics::compute_reachability_dists( points, 2 );
for ( const auto& x : reach_dists ) {
std::cout << x.to_string() << "; ";
}
auto clusters = optics::get_cluster_indices( reach_dists, 2 );
assert( clusters.size() == 3 );
assert( (fplus::sort( clusters[0] ) == std::vector <std::size_t>( { 0,1,2 } )) );
assert( (fplus::sort( clusters[1] ) == std::vector <std::size_t>( { 3,4,5 } )) );
assert( (fplus::sort( clusters[2] ) == std::vector <std::size_t>( { 6,7,8 } )) );
double epsilon_est = optics::epsilon_estimation( points, 2 );
std::cout << "Epsilon-Estimation: " << epsilon_est << std::endl;
optics::draw_reachability_plot( reach_dists, "ReachabilityPlot" );
}
void test_3(){
static const int N = 2;
typedef std::array<unsigned char, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { {100,100}, {102,100}, {101,101}, //cluster 1
{1,1}, {1,0}, {0,1}, //cluster 2
{200,100}, {202,100}, {201,101} //cluster 3
};
auto reach_dists = optics::compute_reachability_dists( points, 2, 10 );
auto clusters = optics::get_cluster_indices( reach_dists, 10 );
assert( clusters.size() == 3 );
assert( (fplus::sort( clusters[0] ) == std::vector <std::size_t>( { 0,1,2 } )) );
assert( (fplus::sort( clusters[1] ) == std::vector <std::size_t>( { 3,4,5 } )) );
assert( (fplus::sort( clusters[2] ) == std::vector <std::size_t>( { 6,7,8 } )) );
auto cluster_points = optics::get_cluster_points(reach_dists, 10, points);
auto img = optics::draw_2d_clusters(cluster_points);
img.save("Clusters2d");
}
void test_4() {
static const int N = 2;
typedef std::array<double, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { { 0,0 },{ 1,0 },{ 0,1 },
{ 10,0 },{ 0,10 },{ 6,6 },{ 4,4 },
{ 10,10 },{ 9,10 },{ 10,9 }
};
double epsilon_est = optics::epsilon_estimation( points, 3 );
assert( epsilon_est <3.090196 && epsilon_est >3.09019 );
}
void test_5() {
static const int N = 3;
typedef std::array<double, N> point; //A list of N cartesian coordinates makes a point
std::vector<point> points; //Your list of points goes here
points = { { 0,0,0 },{ 1,0,0 },{ 0,0,1 },{ 0,1,0 },
{ 5,0,0 },{ 0,5,0 },{ 0,0,5 },{ 5,5,5 }
};
double epsilon_est = optics::epsilon_estimation( points, 3 );
assert( epsilon_est >2.236750 && epsilon_est <2.236751 );
}
void test_6(){
std::vector<optics::reachability_dist> reach_dists = {
{1,10.0}, {2,9.0}, {3,9.0}, {4, 5.0},//SDA
{5,5.49}, {6,5.0},//Cluster1
{7, 6.5},//SUA
{8,3.0},//SDA
{9, 2.9}, {10, 2.8},//Cluster2
{11, 10.0},{12, 12.0}//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>({ {2, 5}, {0, 10}, { 6,10 } }) ) );
}
void test_7() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,10.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 12.0 },//SUA
{13, 4.0},//SDA
{14, 4.1}, {15,4.0},{ 16,3.9 },//Cluster3
{17,5.0}//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 10 },{ 6,10 }, {11,16} } )) );
}
void test_8() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,11.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
{ 17,12.0 }//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{ 11,16 } } )) );
}
void test_9() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,12.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
{ 17,11.0 }//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{ 11,16 } } )) );
}
void test_10() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,12.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
{ 17,12.0 }//SUA
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{0,16},{ 11,16 } } )) );
}
void test_11() {
std::vector<optics::reachability_dist> reach_dists = {
{ 1,12.0 },{ 2,9.0 },{ 3,9.0 },{ 4, 5.0 },//SDA
{ 5,5.49 },{ 6,5.0 },//Cluster1
{ 7, 6.5 },//SUA
{ 8,3.0 },//SDA
{ 9, 2.9 },{ 10, 2.8 },//Cluster2
{ 11, 10.0 },{ 12, 10.0 },//SUA
{ 13, 4.0 },//SDA
{ 14, 4.1 },{ 15,4.0 },{ 16,3.9 },//Cluster3
};
double chi = 0.1;
std::size_t min_pts = 4;
auto clusters = optics::get_chi_clusters( reach_dists, chi, min_pts );
assert( (clusters == std::vector<std::pair<std::size_t, std::size_t>>( { { 2, 5 },{ 0, 9 },{ 6,10 },{0,16},{ 11,16 } } )) );
}
int main()
{
test_1();
test_2();
test_3();
test_4();
test_5();
test_6();
test_7();
test_8();
test_9();
test_10();
test_11();
}
<|endoftext|> |
<commit_before>/*******************************************************************************
The MIT License (MIT)
Copyright (c) 2015 Manuel Freiberger
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.
*******************************************************************************/
#ifndef FSM11_TESTUTILS_HPP
#define FSM11_TESTUTILS_HPP
#include "catch.hpp"
#include <array>
#include <atomic>
#include <set>
#include <tuple>
template <typename T>
bool isActive(const T& sm,
const std::set<const typename T::state_type*>& expected)
{
for (const auto& state : sm.pre_order_subtree())
{
auto iter = expected.find(&state);
if (iter != expected.end())
REQUIRE(state.isActive());
else
REQUIRE(!state.isActive());
}
return true;
}
template <typename TBase>
class TrackingState : public TBase
{
// TODO: Can I has an index_sequence<>, please?
template <std::size_t I, std::size_t N, typename T>
bool all(const T& t, std::true_type) const
{
return std::get<I>(t) == counters.at(I)
&& all<I+1, N>(t, std::integral_constant<bool, (I + 1 < N)>());
}
template <std::size_t I, std::size_t N, typename T>
bool all(const T&, std::false_type) const
{
return true;
}
public:
using event_type = typename TBase::event_type;
template <typename T>
explicit TrackingState(const char* name, T* parent = nullptr)
: TBase(name, parent),
entered(counters[0]),
left(counters[1]),
enteredInvoke(counters[2]),
leftInvoke(counters[3])
{
for (auto& cnt : counters)
cnt = 0;
}
template <typename... TArgs>
bool operator==(const std::tuple<TArgs...>& t) const
{
return all<0, sizeof...(TArgs)>(
t, std::integral_constant<bool, sizeof...(TArgs)>());
}
virtual void onEntry(event_type event) override
{
++entered;
TBase::onEntry(event);
}
virtual void onExit(event_type event) override
{
++left;
TBase::onExit(event);
}
virtual void enterInvoke() override
{
REQUIRE(isInvoked.exchange(true) == false);
++enteredInvoke;
TBase::enterInvoke();
}
virtual std::exception_ptr exitInvoke() override
{
REQUIRE(isInvoked.exchange(false) == true);
++leftInvoke;
return TBase::exitInvoke();
}
std::atomic_bool isInvoked{false};
// The number of onEntry(), onExit(), enterInvoke(), exitInvoke() calls.
std::array<std::atomic_int, 4> counters;
std::atomic_int& entered;
std::atomic_int& left;
std::atomic_int& enteredInvoke;
std::atomic_int& leftInvoke;
};
#endif // FSM11_TESTUTILS_HPP
<commit_msg>Added pattern matching for the TrackingState.<commit_after>/*******************************************************************************
The MIT License (MIT)
Copyright (c) 2015 Manuel Freiberger
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.
*******************************************************************************/
#ifndef FSM11_TESTUTILS_HPP
#define FSM11_TESTUTILS_HPP
#include "catch.hpp"
#include <array>
#include <atomic>
#include <map>
#include <set>
#include <tuple>
template <typename T>
bool isActive(const T& sm,
const std::set<const typename T::state_type*>& expected)
{
for (const auto& state : sm.pre_order_subtree())
{
auto iter = expected.find(&state);
if (iter != expected.end())
REQUIRE(state.isActive());
else
REQUIRE(!state.isActive());
}
return true;
}
struct DontCareTag
{
};
constexpr static DontCareTag X;
struct Pattern
{
constexpr Pattern(int id)
: m_id(id)
{
}
bool operator<(Pattern other) const
{
return m_id < other.m_id;
}
int m_id;
};
constexpr static Pattern Y(1), Z(2);
template <typename TBase>
class TrackingState : public TBase
{
typedef std::map<Pattern, int> PatternMap;
static bool compare(PatternMap&, int a, int b)
{
return a == b;
}
static bool compare(PatternMap&, DontCareTag, int)
{
return true;
}
static bool compare(PatternMap& m, Pattern t, int v)
{
auto it = m.find(t);
if (it != m.end())
return it->second == v;
m[t] = v;
return true;
}
// TODO: Can I has an index_sequence<>, please?
template <std::size_t I, std::size_t N, typename T>
bool all(PatternMap& m, const T& t, std::true_type) const
{
return compare(m, std::get<I>(t), counters.at(I))
&& all<I+1, N>(m, t, std::integral_constant<bool, (I + 1 < N)>());
}
template <std::size_t I, std::size_t N, typename T>
bool all(PatternMap&, const T&, std::false_type) const
{
return true;
}
public:
using event_type = typename TBase::event_type;
template <typename T>
explicit TrackingState(const char* name, T* parent = nullptr)
: TBase(name, parent),
entered(counters[0]),
left(counters[1]),
enteredInvoke(counters[2]),
leftInvoke(counters[3])
{
for (auto& cnt : counters)
cnt = 0;
}
template <typename... TArgs>
bool operator==(const std::tuple<TArgs...>& t) const
{
PatternMap map;
return all<0, sizeof...(TArgs)>(
map, t, std::integral_constant<bool, sizeof...(TArgs)>());
}
virtual void onEntry(event_type event) override
{
++entered;
TBase::onEntry(event);
}
virtual void onExit(event_type event) override
{
++left;
TBase::onExit(event);
}
virtual void enterInvoke() override
{
REQUIRE(isInvoked.exchange(true) == false);
++enteredInvoke;
TBase::enterInvoke();
}
virtual std::exception_ptr exitInvoke() override
{
REQUIRE(isInvoked.exchange(false) == true);
++leftInvoke;
return TBase::exitInvoke();
}
std::atomic_bool isInvoked{false};
// The number of onEntry(), onExit(), enterInvoke(), exitInvoke() calls.
std::array<std::atomic_int, 4> counters;
std::atomic_int& entered;
std::atomic_int& left;
std::atomic_int& enteredInvoke;
std::atomic_int& leftInvoke;
};
#endif // FSM11_TESTUTILS_HPP
<|endoftext|> |
<commit_before>/*
*
* Copyright 2015, Google Inc.
* 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 Google Inc. 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 <string.h>
#include <node.h>
#include <nan.h>
#include "grpc/grpc.h"
#include "grpc/byte_buffer_reader.h"
#include "grpc/support/slice.h"
#include "byte_buffer.h"
namespace grpc {
namespace node {
using v8::Context;
using v8::Function;
using v8::Local;
using v8::Object;
using v8::Number;
using v8::Value;
grpc_byte_buffer *BufferToByteBuffer(Local<Value> buffer) {
Nan::HandleScope scope;
int length = ::node::Buffer::Length(buffer);
char *data = ::node::Buffer::Data(buffer);
gpr_slice slice = gpr_slice_malloc(length);
memcpy(GPR_SLICE_START_PTR(slice), data, length);
grpc_byte_buffer *byte_buffer(grpc_raw_byte_buffer_create(&slice, 1));
gpr_slice_unref(slice);
return byte_buffer;
}
Local<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) {
Nan::EscapableHandleScope scope;
if (buffer == NULL) {
return scope.Escape(Nan::Null());
}
size_t length = grpc_byte_buffer_length(buffer);
char *result = reinterpret_cast<char *>(calloc(length, sizeof(char)));
size_t offset = 0;
grpc_byte_buffer_reader reader;
grpc_byte_buffer_reader_init(&reader, buffer);
gpr_slice next;
while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
memcpy(result + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
offset += GPR_SLICE_LENGTH(next);
}
return scope.Escape(MakeFastBuffer(
Nan::NewBuffer(result, length).ToLocalChecked()));
}
Local<Value> MakeFastBuffer(Local<Value> slowBuffer) {
Nan::EscapableHandleScope scope;
Local<Object> globalObj = Nan::GetCurrentContext()->Global();
Local<Function> bufferConstructor = Local<Function>::Cast(
globalObj->Get(Nan::New("Buffer").ToLocalChecked()));
Local<Value> consArgs[3] = {
slowBuffer,
Nan::New<Number>(::node::Buffer::Length(slowBuffer)),
Nan::New<Number>(0)
};
Local<Object> fastBuffer = bufferConstructor->NewInstance(3, consArgs);
return scope.Escape(fastBuffer);
}
} // namespace node
} // namespace grpc
<commit_msg>Fixes memory leak when receiving data<commit_after>/*
*
* Copyright 2015, Google Inc.
* 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 Google Inc. 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 <string.h>
#include <node.h>
#include <nan.h>
#include "grpc/grpc.h"
#include "grpc/byte_buffer_reader.h"
#include "grpc/support/slice.h"
#include "byte_buffer.h"
namespace grpc {
namespace node {
using v8::Context;
using v8::Function;
using v8::Local;
using v8::Object;
using v8::Number;
using v8::Value;
grpc_byte_buffer *BufferToByteBuffer(Local<Value> buffer) {
Nan::HandleScope scope;
int length = ::node::Buffer::Length(buffer);
char *data = ::node::Buffer::Data(buffer);
gpr_slice slice = gpr_slice_malloc(length);
memcpy(GPR_SLICE_START_PTR(slice), data, length);
grpc_byte_buffer *byte_buffer(grpc_raw_byte_buffer_create(&slice, 1));
gpr_slice_unref(slice);
return byte_buffer;
}
Local<Value> ByteBufferToBuffer(grpc_byte_buffer *buffer) {
Nan::EscapableHandleScope scope;
if (buffer == NULL) {
return scope.Escape(Nan::Null());
}
size_t length = grpc_byte_buffer_length(buffer);
char *result = reinterpret_cast<char *>(calloc(length, sizeof(char)));
size_t offset = 0;
grpc_byte_buffer_reader reader;
grpc_byte_buffer_reader_init(&reader, buffer);
gpr_slice next;
while (grpc_byte_buffer_reader_next(&reader, &next) != 0) {
memcpy(result + offset, GPR_SLICE_START_PTR(next), GPR_SLICE_LENGTH(next));
offset += GPR_SLICE_LENGTH(next);
gpr_slice_unref(next);
}
return scope.Escape(MakeFastBuffer(
Nan::NewBuffer(result, length).ToLocalChecked()));
}
Local<Value> MakeFastBuffer(Local<Value> slowBuffer) {
Nan::EscapableHandleScope scope;
Local<Object> globalObj = Nan::GetCurrentContext()->Global();
Local<Function> bufferConstructor = Local<Function>::Cast(
globalObj->Get(Nan::New("Buffer").ToLocalChecked()));
Local<Value> consArgs[3] = {
slowBuffer,
Nan::New<Number>(::node::Buffer::Length(slowBuffer)),
Nan::New<Number>(0)
};
Local<Object> fastBuffer = bufferConstructor->NewInstance(3, consArgs);
return scope.Escape(fastBuffer);
}
} // namespace node
} // namespace grpc
<|endoftext|> |
<commit_before>#include <QMessageBox>
#include "sharefolderwindow.h"
#include "ui_sharefolderwindow.h"
#include "binapi.h"
#include "pcloudapp.h"
#include "common.h"
ShareFolderWindow::ShareFolderWindow(PCloudApp *a, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::ShareFolderWindow)
{
app=a;
setWindowIcon(QIcon(WINDOW_ICON));
ui->setupUi(this);
connect(ui->cancelbutton, SIGNAL(clicked()), this, SLOT(hide()));
connect(ui->sharebutton, SIGNAL(clicked()), this, SLOT(shareFolder()));
connect(ui->dirtree, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), this, SLOT(dirSelected(QTreeWidgetItem *)));
}
ShareFolderWindow::~ShareFolderWindow()
{
delete ui;
}
void ShareFolderWindow::closeEvent(QCloseEvent *event)
{
hide();
event->ignore();
}
static QList<QTreeWidgetItem *> binresToQList(binresult *res){
QList<QTreeWidgetItem *> items;
QTreeWidgetItem *item;
binresult *e;
quint32 i;
for (i=0; i<res->length; i++){
e=res->array[i];
item=new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(find_res(e, "name")->str)));
item->setData(1, Qt::UserRole, (qulonglong)find_res(e, "folderid")->num);
item->addChildren(binresToQList(find_res(e, "contents")));
items.append(item);
}
return items;
}
void ShareFolderWindow::showEvent(QShowEvent *)
{
apisock *conn;
binresult *res, *result;
QByteArray auth=app->settings->get("auth").toUtf8();
if (!(conn=app->getAPISock())){
showError("Could not connect to server. Check your Internet connection.");
return;
}
ui->dirtree->clear();
ui->dirtree->setColumnCount(1);
ui->dirtree->setHeaderLabels(QStringList("Name"));
res=send_command(conn, "listfolder",
P_LSTR("auth", auth.constData(), auth.size()),
P_STR("filtermeta", "contents,folderid,name"),
P_NUM("folderid", 0),
P_BOOL("recursive", 1),
P_BOOL("nofiles", 1),
P_BOOL("noshares", 1));
api_close(conn);
result=find_res(res, "result");
if (!result){
showError("Could not connect to server. Check your Internet connection.");
free(res);
return;
}
if (result->num!=0){
showError(find_res(res, "error")->str);
free(res);
return;
}
result=find_res(find_res(res, "metadata"), "contents");
ui->dirtree->insertTopLevelItems(0, binresToQList(result));
free(res);
}
void ShareFolderWindow::showError(const QString &err){
ui->error->setText(err);
}
void ShareFolderWindow::verifyEmail(apisock *conn){
QMessageBox::StandardButton reply;
reply=QMessageBox::question(this, "Please verify your e-mail address",
"E-mail address verification is required to share folders. Send verification email now?",
QMessageBox::Yes|QMessageBox::No);
if (reply==QMessageBox::Yes){
QByteArray auth=app->settings->get("auth").toUtf8();
binresult *res;
res=send_command(conn, "sendverificationemail",
P_LSTR("auth", auth.constData(), auth.size()));
free(res);
QMessageBox::information(this, "Please check your e-mail", "E-mail verification sent to: "+app->username);
}
}
void ShareFolderWindow::shareFolder()
{
QByteArray auth=app->settings->get("auth").toUtf8();
QStringList mails=ui->email->text().split(",");
QByteArray name=ui->sharename->text().toUtf8();
quint64 folderid=ui->dirtree->currentItem()->data(1, Qt::UserRole).toULongLong();
quint64 perms=(ui->permCreate->isChecked()?1:0)+
(ui->permModify->isChecked()?2:0)+
(ui->permDelete->isChecked()?4:0);
apisock *conn=app->getAPISock();
binresult *res, *result;
if (!conn){
showError("Could not connect to server. Check your Internet connection.");
return;
}
while (!mails.empty()){
QByteArray mail=mails[0].trimmed().toUtf8();
ui->email->setText(mails.join(","));
res=send_command(conn, "sharefolder",
P_LSTR("auth", auth.constData(), auth.size()),
P_LSTR("mail", mail.constData(), mail.size()),
P_LSTR("name", name.constData(), name.size()),
P_NUM("folderid", folderid),
P_NUM("permissions", perms));
result=find_res(res, "result");
if (!result){
showError("Could not connect to server. Check your Internet connection.");
free(res);
api_close(conn);
return;
}
if (result->num==2014){
free(res);
verifyEmail(conn);
api_close(conn);
return;
}
if (result->num!=0){
showError(find_res(res, "error")->str);
api_close(conn);
free(res);
return;
}
free(res);
mails.removeFirst();
}
api_close(conn);
ui->error->setText("");
ui->email->setText("");
hide();
}
void ShareFolderWindow::dirSelected(QTreeWidgetItem *dir)
{
ui->sharename->setText(dir->text(0));
}
<commit_msg>Fix for share folder crash<commit_after>#include <QMessageBox>
#include "sharefolderwindow.h"
#include "ui_sharefolderwindow.h"
#include "binapi.h"
#include "pcloudapp.h"
#include "common.h"
ShareFolderWindow::ShareFolderWindow(PCloudApp *a, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::ShareFolderWindow)
{
app=a;
setWindowIcon(QIcon(WINDOW_ICON));
ui->setupUi(this);
connect(ui->cancelbutton, SIGNAL(clicked()), this, SLOT(hide()));
connect(ui->sharebutton, SIGNAL(clicked()), this, SLOT(shareFolder()));
connect(ui->dirtree, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)), this, SLOT(dirSelected(QTreeWidgetItem *)));
}
ShareFolderWindow::~ShareFolderWindow()
{
delete ui;
}
void ShareFolderWindow::closeEvent(QCloseEvent *event)
{
hide();
event->ignore();
}
static QList<QTreeWidgetItem *> binresToQList(binresult *res){
QList<QTreeWidgetItem *> items;
QTreeWidgetItem *item;
binresult *e;
quint32 i;
for (i=0; i<res->length; i++){
e=res->array[i];
item=new QTreeWidgetItem((QTreeWidget*)0, QStringList(QString(find_res(e, "name")->str)));
item->setData(1, Qt::UserRole, (qulonglong)find_res(e, "folderid")->num);
item->addChildren(binresToQList(find_res(e, "contents")));
items.append(item);
}
return items;
}
void ShareFolderWindow::showEvent(QShowEvent *)
{
apisock *conn;
binresult *res, *result;
QByteArray auth=app->settings->get("auth").toUtf8();
if (!(conn=app->getAPISock())){
showError("Could not connect to server. Check your Internet connection.");
return;
}
ui->dirtree->clear();
ui->dirtree->setColumnCount(1);
ui->dirtree->setHeaderLabels(QStringList("Name"));
res=send_command(conn, "listfolder",
P_LSTR("auth", auth.constData(), auth.size()),
P_STR("filtermeta", "contents,folderid,name"),
P_NUM("folderid", 0),
P_BOOL("recursive", 1),
P_BOOL("nofiles", 1),
P_BOOL("noshares", 1));
api_close(conn);
result=find_res(res, "result");
if (!result){
showError("Could not connect to server. Check your Internet connection.");
free(res);
return;
}
if (result->num!=0){
showError(find_res(res, "error")->str);
free(res);
return;
}
result=find_res(find_res(res, "metadata"), "contents");
ui->dirtree->insertTopLevelItems(0, binresToQList(result));
free(res);
}
void ShareFolderWindow::showError(const QString &err){
ui->error->setText(err);
}
void ShareFolderWindow::verifyEmail(apisock *conn){
QMessageBox::StandardButton reply;
reply=QMessageBox::question(this, "Please verify your e-mail address",
"E-mail address verification is required to share folders. Send verification email now?",
QMessageBox::Yes|QMessageBox::No);
if (reply==QMessageBox::Yes){
QByteArray auth=app->settings->get("auth").toUtf8();
binresult *res;
res=send_command(conn, "sendverificationemail",
P_LSTR("auth", auth.constData(), auth.size()));
free(res);
QMessageBox::information(this, "Please check your e-mail", "E-mail verification sent to: "+app->username);
}
}
void ShareFolderWindow::shareFolder()
{
QByteArray auth=app->settings->get("auth").toUtf8();
QStringList mails=ui->email->text().split(",");
QByteArray name=ui->sharename->text().toUtf8();
quint64 folderid=ui->dirtree->currentItem()->data(1, Qt::UserRole).toULongLong();
quint64 perms=(ui->permCreate->isChecked()?1:0)+
(ui->permModify->isChecked()?2:0)+
(ui->permDelete->isChecked()?4:0);
apisock *conn=app->getAPISock();
binresult *res, *result;
if (!conn){
showError("Could not connect to server. Check your Internet connection.");
return;
}
while (!mails.empty()){
QByteArray mail=mails[0].trimmed().toUtf8();
ui->email->setText(mails.join(","));
res=send_command(conn, "sharefolder",
P_LSTR("auth", auth.constData(), auth.size()),
P_LSTR("mail", mail.constData(), mail.size()),
P_LSTR("name", name.constData(), name.size()),
P_NUM("folderid", folderid),
P_NUM("permissions", perms));
result=find_res(res, "result");
if (!result){
showError("Could not connect to server. Check your Internet connection.");
free(res);
api_close(conn);
return;
}
if (result->num==2014){
free(res);
verifyEmail(conn);
api_close(conn);
return;
}
if (result->num!=0){
showError(find_res(res, "error")->str);
api_close(conn);
free(res);
return;
}
free(res);
mails.removeFirst();
}
api_close(conn);
ui->error->setText("");
ui->email->setText("");
hide();
}
void ShareFolderWindow::dirSelected(QTreeWidgetItem *dir)
{
if (dir)
ui->sharename->setText(dir->text(0));
}
<|endoftext|> |
<commit_before>/*****************************************************************************
* Media.hpp: Media API
*****************************************************************************
* Copyright © 2015 libvlcpp authors & VideoLAN
*
* Authors: Alexey Sokolov <alexey+vlc@asokolov.org>
* Hugo Beauzée-Luyssen <hugo@beauzee.fr>
*
* This program 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) 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser 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.
*****************************************************************************/
#ifndef LIBVLC_CXX_MEDIA_H
#define LIBVLC_CXX_MEDIA_H
#include "common.hpp"
#include <vector>
#include <stdexcept>
namespace VLC
{
class MediaPlayer;
class MediaEventManager;
class Instance;
class MediaList;
class Media : public Internal<libvlc_media_t>
{
public:
enum class FromType
{
/**
* Create a media for a certain file path.
*/
FromPath,
/**
* Create a media with a certain given media resource location,
* for instance a valid URL.
*
* \note To refer to a local file with this function,
* the file://... URI syntax <b>must</b> be used (see IETF RFC3986).
* We recommend using FromPath instead when dealing with
* local files.
*/
FromLocation,
/**
* Create a media as an empty node with a given name.
*/
AsNode,
};
// To be able to write Media::FromLocation
#if !defined(_MSC_VER) || _MSC_VER >= 1900
constexpr static FromType FromPath = FromType::FromPath;
constexpr static FromType FromLocation = FromType::FromLocation;
constexpr static FromType AsNode = FromType::AsNode;
#else
static const FromType FromPath = FromType::FromPath;
static const FromType FromLocation = FromType::FromLocation;
static const FromType AsNode = FromType::AsNode;
#endif
/**
* @brief Media Constructs a libvlc Media instance
* @param instance A libvlc instance
* @param mrl A path, location, or node name, depending on the 3rd parameter
* @param type The type of the 2nd argument. \sa{FromType}
*/
Media(Instance& instance, const std::string& mrl, FromType type)
: Internal{ libvlc_media_release }
{
InternalPtr ptr = nullptr;
switch (type)
{
case FromLocation:
ptr = libvlc_media_new_location( getInternalPtr<libvlc_instance_t>( instance ), mrl.c_str() );
break;
case FromPath:
ptr = libvlc_media_new_path( getInternalPtr<libvlc_instance_t>( instance ), mrl.c_str() );
break;
case AsNode:
ptr = libvlc_media_new_as_node( getInternalPtr<libvlc_instance_t>( instance ), mrl.c_str() );
break;
default:
break;
}
if ( ptr == nullptr )
throw std::runtime_error("Failed to construct a media");
m_obj.reset( ptr, libvlc_media_release );
}
/**
* Create a media for an already open file descriptor.
* The file descriptor shall be open for reading (or reading and writing).
*
* Regular file descriptors, pipe read descriptors and character device
* descriptors (including TTYs) are supported on all platforms.
* Block device descriptors are supported where available.
* Directory descriptors are supported on systems that provide fdopendir().
* Sockets are supported on all platforms where they are file descriptors,
* i.e. all except Windows.
*
* \note This library will <b>not</b> automatically close the file descriptor
* under any circumstance. Nevertheless, a file descriptor can usually only be
* rendered once in a media player. To render it a second time, the file
* descriptor should probably be rewound to the beginning with lseek().
*
* \param p_instance the instance
* \param fd open file descriptor
* \return the newly created media or NULL on error
*/
Media(Instance& instance, int fd)
: Internal { libvlc_media_new_fd( getInternalPtr<libvlc_instance_t>( instance ), fd ),
libvlc_media_release }
{
}
/**
* Get media instance from this media list instance. This action will increase
* the refcount on the media instance.
* The libvlc_media_list_lock should NOT be held upon entering this function.
*
* \param p_ml a media list instance
* \return media instance
*/
Media(MediaList& list)
: Internal{ libvlc_media_list_media( getInternalPtr<libvlc_media_list_t>( list ) ),
libvlc_media_release }
{
}
explicit Media( Internal::InternalPtr ptr, bool incrementRefCount)
: Internal{ ptr, libvlc_media_release }
{
if ( incrementRefCount && ptr != nullptr )
retain();
}
/**
* Create an empty VLC Media instance.
*
* Calling any method on such an instance is undefined.
*/
Media() = default;
/**
* Check if 2 Media objects contain the same libvlc_media_t.
* \param another another Media
* \return true if they contain the same libvlc_media_t
*/
bool operator==(const Media& another) const
{
return m_obj == another.m_obj;
}
/**
* Add an option to the media.
*
* This option will be used to determine how the media_player will read
* the media. This allows to use VLC's advanced reading/streaming options
* on a per-media basis.
*
* \note The options are listed in 'vlc long-help' from the command line,
* e.g. "-sout-all". Keep in mind that available options and their
* semantics vary across LibVLC versions and builds.
*
* \warning Not all options affects libvlc_media_t objects: Specifically,
* due to architectural issues most audio and video options, such as text
* renderer options, have no effects on an individual media. These
* options must be set through Instance::Instance() instead.
*
* \param psz_options the options (as a string)
*/
void addOption(const std::string& psz_options)
{
libvlc_media_add_option(*this,psz_options.c_str());
}
/**
* Add an option to the media with configurable flags.
*
* This option will be used to determine how the media_player will read
* the media. This allows to use VLC's advanced reading/streaming options
* on a per-media basis.
*
* The options are detailed in vlc long-help, for instance "--sout-all".
* Note that all options are not usable on medias: specifically, due to
* architectural issues, video-related options such as text renderer
* options cannot be set on a single media. They must be set on the whole
* libvlc instance instead.
*
* \param psz_options the options (as a string)
*
* \param i_flags the flags for this option
*/
void addOptionFlag(const std::string& psz_options, unsigned i_flags)
{
libvlc_media_add_option_flag(*this,psz_options.c_str(), i_flags);
}
/**
* Get the media resource locator (mrl) from a media descriptor object
*
* \return string with mrl of media descriptor object
*/
std::string mrl()
{
auto str = wrapCStr( libvlc_media_get_mrl(*this) );
if ( str == nullptr )
return {};
return str.get();
}
/**
* Duplicate a media descriptor object.
*/
MediaPtr duplicate()
{
auto obj = libvlc_media_duplicate(*this);
return std::make_shared<Media>( obj, false );
}
/**
* Read the meta of the media.
*
* If the media has not yet been parsed this will return NULL.
*
* This methods automatically calls parseAsync() , so after
* calling it you may receive a libvlc_MediaMetaChanged event. If you
* prefer a synchronous version ensure that you call parse()
* before get_meta().
*
* \see parse()
*
* \see parseAsync()
*
* \see libvlc_MediaMetaChanged
*
* \param e_meta the meta to read
*
* \return the media's meta
*/
std::string meta(libvlc_meta_t e_meta)
{
auto str = wrapCStr(libvlc_media_get_meta(*this, e_meta) );
if ( str == nullptr )
return {};
return str.get();
}
/**
* Set the meta of the media (this function will not save the meta, call
* libvlc_media_save_meta in order to save the meta)
*
* \param e_meta the meta to write
*
* \param psz_value the media's meta
*/
void setMeta(libvlc_meta_t e_meta, const std::string& psz_value)
{
libvlc_media_set_meta(*this, e_meta, psz_value.c_str());
}
/**
* Save the meta previously set
*
* \return true if the write operation was successful
*/
int saveMeta()
{
return libvlc_media_save_meta(*this);
}
/**
* Get current state of media descriptor object. Possible media states
* are defined in libvlc_structures.c ( libvlc_NothingSpecial=0,
* libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused,
* libvlc_Stopped, libvlc_Ended, libvlc_Error).
*
* \see libvlc_state_t
*
* \return state of media descriptor object
*/
libvlc_state_t state()
{
return libvlc_media_get_state(*this);
}
/**
* Get the current statistics about the media
*
* \param p_stats structure that contain the statistics about the media
* (this structure must be allocated by the caller)
*
* \return true if the statistics are available, false otherwise
*/
bool stats(libvlc_media_stats_t * p_stats)
{
return libvlc_media_get_stats(*this, p_stats) != 0;
}
/**
* Get event manager from media descriptor object. NOTE: this function
* doesn't increment reference counting.
*
* \return event manager object
*/
MediaEventManager& eventManager()
{
if ( m_eventManager == NULL )
{
libvlc_event_manager_t* obj = libvlc_media_event_manager(*this);
m_eventManager = std::make_shared<MediaEventManager>( obj );
}
return *m_eventManager;
}
/**
* Get duration (in ms) of media descriptor object item.
*
* \return duration of media item or -1 on error
*/
libvlc_time_t duration()
{
return libvlc_media_get_duration(*this);
}
/**
* Parse a media.
*
* This fetches (local) meta data and tracks information. The method is
* synchronous.
*
* \see parseAsync()
*
* \see meta()
*
* \see tracksInfo()
*/
void parse()
{
libvlc_media_parse(*this);
}
/**
* Parse a media.
*
* This fetches (local) meta data and tracks information. The method is
* the asynchronous of parse() .
*
* To track when this is over you can listen to libvlc_MediaParsedChanged
* event. However if the media was already parsed you will not receive
* this event.
*
* \see parse()
*
* \see libvlc_MediaParsedChanged
*
* \see meta()
*
* \see tracks()
*/
void parseAsync()
{
libvlc_media_parse_async(*this);
}
/**
* Get Parsed status for media descriptor object.
*
* \see libvlc_MediaParsedChanged
*
* \return true if media object has been parsed otherwise it returns
* false
*/
bool isParsed()
{
return libvlc_media_is_parsed(*this) != 0;
}
/**
* Sets media descriptor's user_data. user_data is specialized data
* accessed by the host application, VLC.framework uses it as a pointer
* to an native object that references a libvlc_media_t pointer
*
* \param p_new_user_data pointer to user data
*/
void setUserData(void * p_new_user_data)
{
libvlc_media_set_user_data(*this, p_new_user_data);
}
/**
* Get media descriptor's user_data. user_data is specialized data
* accessed by the host application, VLC.framework uses it as a pointer
* to an native object that references a libvlc_media_t pointer
*/
void* userData()
{
return libvlc_media_get_user_data(*this);
}
/**
* Get media descriptor's elementary streams description
*
* Note, you need to call parse() or play the media at least once
* before calling this function. Not doing this will result in an empty
* array.
*
* \version LibVLC 2.1.0 and later.
*
* \return a vector containing all tracks
*/
std::vector<MediaTrack> tracks()
{
libvlc_media_track_t** tracks;
uint32_t nbTracks = libvlc_media_tracks_get(*this, &tracks);
std::vector<MediaTrack> res;
if ( nbTracks == 0 )
return res;
for ( uint32_t i = 0; i < nbTracks; ++i )
res.emplace_back( tracks[i] );
libvlc_media_tracks_release( tracks, nbTracks );
return res;
}
private:
/**
* Retain a reference to a media descriptor object (libvlc_media_t). Use
* release() to decrement the reference count of a media
* descriptor object.
*/
void retain()
{
if ( isValid() )
libvlc_media_retain(*this);
}
private:
std::shared_ptr<MediaEventManager> m_eventManager;
};
} // namespace VLC
#endif
<commit_msg>Media: Remove unneeded forward declaration<commit_after>/*****************************************************************************
* Media.hpp: Media API
*****************************************************************************
* Copyright © 2015 libvlcpp authors & VideoLAN
*
* Authors: Alexey Sokolov <alexey+vlc@asokolov.org>
* Hugo Beauzée-Luyssen <hugo@beauzee.fr>
*
* This program 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) 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser 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.
*****************************************************************************/
#ifndef LIBVLC_CXX_MEDIA_H
#define LIBVLC_CXX_MEDIA_H
#include "common.hpp"
#include <vector>
#include <stdexcept>
namespace VLC
{
class MediaEventManager;
class Instance;
class MediaList;
class Media : public Internal<libvlc_media_t>
{
public:
enum class FromType
{
/**
* Create a media for a certain file path.
*/
FromPath,
/**
* Create a media with a certain given media resource location,
* for instance a valid URL.
*
* \note To refer to a local file with this function,
* the file://... URI syntax <b>must</b> be used (see IETF RFC3986).
* We recommend using FromPath instead when dealing with
* local files.
*/
FromLocation,
/**
* Create a media as an empty node with a given name.
*/
AsNode,
};
// To be able to write Media::FromLocation
#if !defined(_MSC_VER) || _MSC_VER >= 1900
constexpr static FromType FromPath = FromType::FromPath;
constexpr static FromType FromLocation = FromType::FromLocation;
constexpr static FromType AsNode = FromType::AsNode;
#else
static const FromType FromPath = FromType::FromPath;
static const FromType FromLocation = FromType::FromLocation;
static const FromType AsNode = FromType::AsNode;
#endif
/**
* @brief Media Constructs a libvlc Media instance
* @param instance A libvlc instance
* @param mrl A path, location, or node name, depending on the 3rd parameter
* @param type The type of the 2nd argument. \sa{FromType}
*/
Media(Instance& instance, const std::string& mrl, FromType type)
: Internal{ libvlc_media_release }
{
InternalPtr ptr = nullptr;
switch (type)
{
case FromLocation:
ptr = libvlc_media_new_location( getInternalPtr<libvlc_instance_t>( instance ), mrl.c_str() );
break;
case FromPath:
ptr = libvlc_media_new_path( getInternalPtr<libvlc_instance_t>( instance ), mrl.c_str() );
break;
case AsNode:
ptr = libvlc_media_new_as_node( getInternalPtr<libvlc_instance_t>( instance ), mrl.c_str() );
break;
default:
break;
}
if ( ptr == nullptr )
throw std::runtime_error("Failed to construct a media");
m_obj.reset( ptr, libvlc_media_release );
}
/**
* Create a media for an already open file descriptor.
* The file descriptor shall be open for reading (or reading and writing).
*
* Regular file descriptors, pipe read descriptors and character device
* descriptors (including TTYs) are supported on all platforms.
* Block device descriptors are supported where available.
* Directory descriptors are supported on systems that provide fdopendir().
* Sockets are supported on all platforms where they are file descriptors,
* i.e. all except Windows.
*
* \note This library will <b>not</b> automatically close the file descriptor
* under any circumstance. Nevertheless, a file descriptor can usually only be
* rendered once in a media player. To render it a second time, the file
* descriptor should probably be rewound to the beginning with lseek().
*
* \param p_instance the instance
* \param fd open file descriptor
* \return the newly created media or NULL on error
*/
Media(Instance& instance, int fd)
: Internal { libvlc_media_new_fd( getInternalPtr<libvlc_instance_t>( instance ), fd ),
libvlc_media_release }
{
}
/**
* Get media instance from this media list instance. This action will increase
* the refcount on the media instance.
* The libvlc_media_list_lock should NOT be held upon entering this function.
*
* \param p_ml a media list instance
* \return media instance
*/
Media(MediaList& list)
: Internal{ libvlc_media_list_media( getInternalPtr<libvlc_media_list_t>( list ) ),
libvlc_media_release }
{
}
explicit Media( Internal::InternalPtr ptr, bool incrementRefCount)
: Internal{ ptr, libvlc_media_release }
{
if ( incrementRefCount && ptr != nullptr )
retain();
}
/**
* Create an empty VLC Media instance.
*
* Calling any method on such an instance is undefined.
*/
Media() = default;
/**
* Check if 2 Media objects contain the same libvlc_media_t.
* \param another another Media
* \return true if they contain the same libvlc_media_t
*/
bool operator==(const Media& another) const
{
return m_obj == another.m_obj;
}
/**
* Add an option to the media.
*
* This option will be used to determine how the media_player will read
* the media. This allows to use VLC's advanced reading/streaming options
* on a per-media basis.
*
* \note The options are listed in 'vlc long-help' from the command line,
* e.g. "-sout-all". Keep in mind that available options and their
* semantics vary across LibVLC versions and builds.
*
* \warning Not all options affects libvlc_media_t objects: Specifically,
* due to architectural issues most audio and video options, such as text
* renderer options, have no effects on an individual media. These
* options must be set through Instance::Instance() instead.
*
* \param psz_options the options (as a string)
*/
void addOption(const std::string& psz_options)
{
libvlc_media_add_option(*this,psz_options.c_str());
}
/**
* Add an option to the media with configurable flags.
*
* This option will be used to determine how the media_player will read
* the media. This allows to use VLC's advanced reading/streaming options
* on a per-media basis.
*
* The options are detailed in vlc long-help, for instance "--sout-all".
* Note that all options are not usable on medias: specifically, due to
* architectural issues, video-related options such as text renderer
* options cannot be set on a single media. They must be set on the whole
* libvlc instance instead.
*
* \param psz_options the options (as a string)
*
* \param i_flags the flags for this option
*/
void addOptionFlag(const std::string& psz_options, unsigned i_flags)
{
libvlc_media_add_option_flag(*this,psz_options.c_str(), i_flags);
}
/**
* Get the media resource locator (mrl) from a media descriptor object
*
* \return string with mrl of media descriptor object
*/
std::string mrl()
{
auto str = wrapCStr( libvlc_media_get_mrl(*this) );
if ( str == nullptr )
return {};
return str.get();
}
/**
* Duplicate a media descriptor object.
*/
MediaPtr duplicate()
{
auto obj = libvlc_media_duplicate(*this);
return std::make_shared<Media>( obj, false );
}
/**
* Read the meta of the media.
*
* If the media has not yet been parsed this will return NULL.
*
* This methods automatically calls parseAsync() , so after
* calling it you may receive a libvlc_MediaMetaChanged event. If you
* prefer a synchronous version ensure that you call parse()
* before get_meta().
*
* \see parse()
*
* \see parseAsync()
*
* \see libvlc_MediaMetaChanged
*
* \param e_meta the meta to read
*
* \return the media's meta
*/
std::string meta(libvlc_meta_t e_meta)
{
auto str = wrapCStr(libvlc_media_get_meta(*this, e_meta) );
if ( str == nullptr )
return {};
return str.get();
}
/**
* Set the meta of the media (this function will not save the meta, call
* libvlc_media_save_meta in order to save the meta)
*
* \param e_meta the meta to write
*
* \param psz_value the media's meta
*/
void setMeta(libvlc_meta_t e_meta, const std::string& psz_value)
{
libvlc_media_set_meta(*this, e_meta, psz_value.c_str());
}
/**
* Save the meta previously set
*
* \return true if the write operation was successful
*/
int saveMeta()
{
return libvlc_media_save_meta(*this);
}
/**
* Get current state of media descriptor object. Possible media states
* are defined in libvlc_structures.c ( libvlc_NothingSpecial=0,
* libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused,
* libvlc_Stopped, libvlc_Ended, libvlc_Error).
*
* \see libvlc_state_t
*
* \return state of media descriptor object
*/
libvlc_state_t state()
{
return libvlc_media_get_state(*this);
}
/**
* Get the current statistics about the media
*
* \param p_stats structure that contain the statistics about the media
* (this structure must be allocated by the caller)
*
* \return true if the statistics are available, false otherwise
*/
bool stats(libvlc_media_stats_t * p_stats)
{
return libvlc_media_get_stats(*this, p_stats) != 0;
}
/**
* Get event manager from media descriptor object. NOTE: this function
* doesn't increment reference counting.
*
* \return event manager object
*/
MediaEventManager& eventManager()
{
if ( m_eventManager == NULL )
{
libvlc_event_manager_t* obj = libvlc_media_event_manager(*this);
m_eventManager = std::make_shared<MediaEventManager>( obj );
}
return *m_eventManager;
}
/**
* Get duration (in ms) of media descriptor object item.
*
* \return duration of media item or -1 on error
*/
libvlc_time_t duration()
{
return libvlc_media_get_duration(*this);
}
/**
* Parse a media.
*
* This fetches (local) meta data and tracks information. The method is
* synchronous.
*
* \see parseAsync()
*
* \see meta()
*
* \see tracksInfo()
*/
void parse()
{
libvlc_media_parse(*this);
}
/**
* Parse a media.
*
* This fetches (local) meta data and tracks information. The method is
* the asynchronous of parse() .
*
* To track when this is over you can listen to libvlc_MediaParsedChanged
* event. However if the media was already parsed you will not receive
* this event.
*
* \see parse()
*
* \see libvlc_MediaParsedChanged
*
* \see meta()
*
* \see tracks()
*/
void parseAsync()
{
libvlc_media_parse_async(*this);
}
/**
* Get Parsed status for media descriptor object.
*
* \see libvlc_MediaParsedChanged
*
* \return true if media object has been parsed otherwise it returns
* false
*/
bool isParsed()
{
return libvlc_media_is_parsed(*this) != 0;
}
/**
* Sets media descriptor's user_data. user_data is specialized data
* accessed by the host application, VLC.framework uses it as a pointer
* to an native object that references a libvlc_media_t pointer
*
* \param p_new_user_data pointer to user data
*/
void setUserData(void * p_new_user_data)
{
libvlc_media_set_user_data(*this, p_new_user_data);
}
/**
* Get media descriptor's user_data. user_data is specialized data
* accessed by the host application, VLC.framework uses it as a pointer
* to an native object that references a libvlc_media_t pointer
*/
void* userData()
{
return libvlc_media_get_user_data(*this);
}
/**
* Get media descriptor's elementary streams description
*
* Note, you need to call parse() or play the media at least once
* before calling this function. Not doing this will result in an empty
* array.
*
* \version LibVLC 2.1.0 and later.
*
* \return a vector containing all tracks
*/
std::vector<MediaTrack> tracks()
{
libvlc_media_track_t** tracks;
uint32_t nbTracks = libvlc_media_tracks_get(*this, &tracks);
std::vector<MediaTrack> res;
if ( nbTracks == 0 )
return res;
for ( uint32_t i = 0; i < nbTracks; ++i )
res.emplace_back( tracks[i] );
libvlc_media_tracks_release( tracks, nbTracks );
return res;
}
private:
/**
* Retain a reference to a media descriptor object (libvlc_media_t). Use
* release() to decrement the reference count of a media
* descriptor object.
*/
void retain()
{
if ( isValid() )
libvlc_media_retain(*this);
}
private:
std::shared_ptr<MediaEventManager> m_eventManager;
};
} // namespace VLC
#endif
<|endoftext|> |
<commit_before>/*
* Copyright (C) 2013 Pascal Giorgi
*
* Written by Pascal Giorgi <pascal.giorgi@lirmm.fr>
*
* ========LICENCE========
* This file is part of the library LinBox.
*
* LinBox 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) any later version.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
* ========LICENCE========
*/
#include "linbox/linbox-config.h"
#include "linbox/algorithms/polynomial-matrix/fft.h"
#include "linbox/randiter/random-fftprime.h"
#include "linbox/ring/modular.h"
#include <givaro/modular-extended.h>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using namespace LinBox;
using Givaro::Modular;
using Givaro::ModularExtended;
/* For pretty printing type */
template<typename...> const char *TypeName();
template<template <typename...> class> const char *TypeName();
#define REGISTER_TYPE_NAME(type) \
template<> const char *TypeName<type>(){return #type;}
REGISTER_TYPE_NAME(float);
REGISTER_TYPE_NAME(double);
REGISTER_TYPE_NAME(uint16_t);
REGISTER_TYPE_NAME(uint32_t);
REGISTER_TYPE_NAME(uint64_t);
REGISTER_TYPE_NAME(uint128_t);
REGISTER_TYPE_NAME(Modular);
REGISTER_TYPE_NAME(ModularExtended);
/******************************************************************************/
/* Basic class to access and test protected method of FFT class */
template<typename Field, typename Simd>
class FFT_checker : public FFT<Field, Simd> {
private:
using base = FFT<Field, Simd>;
public:
using base::DIF;
using base::DIT;
using base::DIF_reversed;
using base::DIT_reversed;
using base::base;
};
template<typename Field>
struct Checker {
typedef typename Field::Element Elt;
typedef AlignedAllocator<Elt, Alignment::DEFAULT> _Alignement;
typedef typename std::vector<Elt, _Alignement> EltVector;
const Field& _F;
size_t _k;
size_t _n;
/* ctor */
Checker (const Field& F, size_t k) : _F(F), _k(k), _n(1<<k) {
}
/* compute r = P evaluated at x using Horner method */
void horner_eval (Elt& r, EltVector& P, Elt& x) {
_F.assign (r, _F.zero);
for (auto ptr = P.rbegin(); ptr != P.rend(); ptr++ ) {
_F.mulin (r, x);
_F.addin (r, *ptr);
}
}
/* return i with its first _k bits reversed */
size_t bitreversed (size_t i) {
size_t r = 0;
for (size_t j = 0; j < _k; j++, i>>=1)
{
r <<= 1;
r |= i & 1;
}
return r;
}
template<typename Simd>
void
print_result_line (const char *name, bool b) {
size_t t = strlen(name) + Simd::type_string().size() + 40 + 10;
cout << " " << string (80-t, ' ') << name << "<"
<< Simd::type_string() << "> " << string (40, '.')
<< (b ? " success" : " failure") << endl;
}
/* check DIF and DIT */
template<typename Simd>
bool actual_check (FFT_checker<Field, Simd> &fft, const EltVector& in,
const EltVector& in_br, const EltVector& out,
const EltVector& out_br) {
EltVector v(_n);
/* DIF : natural order => bitreversed order */
v = in;
fft.DIF (v.data());
bool bf = equal (v.begin(), v.end(), out_br.begin());
print_result_line<Simd> ("DIF", bf);
/* DIF : bitreversed order => natural order */
v = in_br;
fft.DIF_reversed (v.data());
bool bf2 = equal (v.begin(), v.end(), out.begin());
print_result_line<Simd> ("DIF_reversed", bf2);
/* DIT : bitreversed order => natural order */
v = in_br;
fft.DIT (v.data());
bool bt = equal (v.begin(), v.end(), out.begin());
print_result_line<Simd> ("DIT", bt);
/* DIT : natural order => bitreversed order */
v = in;
fft.DIT_reversed (v.data());
bool bt2 = equal (v.begin(), v.end(), out_br.begin());
print_result_line<Simd> ("DIT_reversed", bt2);
/* FFT_direct : natural order => bitreversed order */
v = in;
fft.FFT_direct (v.data());
bool bd = equal (v.begin(), v.end(), out_br.begin());
print_result_line<Simd> ("FFT_direct", bd);
/* FFT_inverse: bitreversed order => natural order */
v = in_br;
fft.FFT_inverse (v.data());
bool bi = equal (v.begin(), v.end(), out.begin());
print_result_line<Simd> ("FFT_inverse", bi);
bool b = bt & bf & bt2 & bf2 & bd & bi;
return b;
}
/* draw random vector and check DIF and DIT for all available SIMD implem */
bool check (unsigned long seed) {
bool passed = true;
EltVector in(_n), in_br(_n), out(_n), out_br(_n);
FFT_checker<Field, NoSimd<Elt>> fft_nosimd (_F, _k);
/* Generate random input */
typename Field::RandIter Gen (_F, 0, seed+_k); /*0 has no meaning here*/
for (auto v = in.begin(); v < in.end(); v++)
Gen.random (*v);
/* Compute the out vector using a naive polynomial evaluation and set
* the bitreversed version of in and out */
Elt x(1);
const Elt & w = fft_nosimd.root ();
for (size_t i = 0; i < _n; _F.mulin (x, w), i++) {
size_t i_br = bitreversed (i);
in_br[i_br] = in[i];
horner_eval (out[i], in, x);
out_br[i_br] = out[i];
}
/* NoSimd */
passed &= actual_check (fft_nosimd, in, in_br, out, out_br);
/* Simd128 */
#if defined(__FFLASFFPACK_HAVE_SSE4_1_INSTRUCTIONS)
FFT_checker<Field, Simd128<Elt>> fft_simd128 (_F, _k, w);
passed &= actual_check (fft_simd128, in, in_br, out, out_br);
#endif
/* Simd256 */
#if defined(__FFLASFFPACK_HAVE_AVX2_INSTRUCTIONS)
FFT_checker<Field, Simd256<Elt>> fft_simd256 (_F, _k, w);
passed &= actual_check (fft_simd256, in, in_br, out, out_br);
#endif
// FIXME Simd512: which macro should be used to discriminate against
// simd512 for both floating and integral type ?
return passed;
}
};
/* Test FFT on polynomial with coefficients in ModImplem<Elt, C...> (i.e.,
* Modular<Elt, C> or ModularExtended<Elt>) with a random prime p with the
* required number of bits and such that 2^k divides p-1
*/
template<template<typename, typename...> class ModImplem, typename Elt, typename... C>
bool test_one_modular_implem (uint64_t bits, size_t k, unsigned long seed)
{
integer p;
if (!RandomFFTPrime::randomPrime (p, integer(1)<<bits, k))
throw LinboxError ("RandomFFTPrime::randomPrime failed");
ModImplem<Elt, C...> GFp ((Elt) p);
cout << endl << string (80, '*') << endl;
cout << "Test FFT with " << TypeName<ModImplem>() << "<" << TypeName<Elt>();
if (sizeof...(C) > 0)
cout << ", " << TypeName<C...>();
cout << ">, p=" << GFp.cardinality() << " (" << bits << " bits, 2^" << k;
cout << " divides p-1)" << endl;
bool b = true;
for (size_t kc = 1; kc <= k; kc++) {
cout << "** with n=2^" << kc << endl;
Checker<ModImplem<Elt, C...>> Test(GFp, kc);
b &= Test.check (seed);
}
return b;
}
/******************************************************************************/
/************************************ main ************************************/
/******************************************************************************/
int main (int argc, char *argv[]) {
bool pass = true;
unsigned long seed = time (NULL);
Argument args[] = {
{ 's', "-s seed", "set the seed.", TYPE_INT, &seed },
END_OF_ARGUMENTS
};
parseArguments (argc, argv, args);
cout << "# To rerun this test: test-fft-new -s " << seed << endl;
cout << "# seed = " << seed << endl;
/* Test with Modular<float,double> */
/* with a 11-bit prime and k=7 */
pass &= test_one_modular_implem<Modular,float,double> (11, 7, seed);
/* Test with Modular<double> */
/* with a 22-bit prime and k=9 */
pass &= test_one_modular_implem<Modular,double> (22, 9, seed);
/* with a 26-bit prime and k=10 */
//XXX FAIL? pass &= test_one_modular_implem<Modular,double> (30, 10, seed);
/* Test with ModularExtended<double> */
// XXX limit is 2^50-1
/* with a 51-bit prime and k=11 */
pass &= test_one_modular_implem<ModularExtended,double> (51, 11, seed);
/* with a 51-bit prime and k=11 */
// XXX FAIL pass &= test_one_modular_implem<ModularExtended,double> (51, 11, seed);
/* Test with Modular<uint16_t,uint32_t> */
/* with a 11-bit prime and k=7 */
pass &= test_one_modular_implem<Modular,uint16_t,uint32_t> (11, 7, seed);
/* with a 16-bit prime and k=9 */
// XXX FAIL?
//pass &= test_one_modular_implem<Modular,uint16_t,uint32_t> (16, 9, seed);
/* Test with Modular<uint32_t, uint64_t> */
/* with a 27-bit prime and k=10 */
pass &= test_one_modular_implem<Modular,uint32_t,uint64_t> (27, 10, seed);
/* with a 32-bit prime and k=10 */
// XXX FAIL? pass &= test_one_modular_implem<Modular,uint32_t,uint64_t> (32, 10, seed);
#ifdef __FFLASFFPACK_HAVE_INT128
/* Test with Modular<uint64_t,uint128_t> */
/* with a 59-bit prime and k=11 */
pass &= test_one_modular_implem<Modular,uint64_t,uint128_t> (59, 11, seed);
/* with a 64-bit prime and k=11 */
//XXX FAIL? pass &= test_one_modular_implem<Modular,uint64_t,uint128_t> (64, 11, seed);
#endif
cout << endl << "Test " << (pass ? "passed" : "failed") << endl;
return pass ? 0 : 1;
}
// Local Variables:
// mode: C++
// tab-width: 4
// indent-tabs-mode: nil
// c-basic-offset: 4
// End:
// vim:sts=4:sw=4:ts=4:et:sr:cino=>s,f0,{0,g0,(0,\:0,t0,+0,=s
<commit_msg>FFT: do tests with maximal bit size<commit_after>/*
* Copyright (C) 2013 Pascal Giorgi
*
* Written by Pascal Giorgi <pascal.giorgi@lirmm.fr>
*
* ========LICENCE========
* This file is part of the library LinBox.
*
* LinBox 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) any later version.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
* ========LICENCE========
*/
#include "linbox/linbox-config.h"
#include "linbox/algorithms/polynomial-matrix/fft.h"
#include "linbox/randiter/random-fftprime.h"
#include "linbox/ring/modular.h"
#include <givaro/modular-extended.h>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using namespace LinBox;
using Givaro::Modular;
using Givaro::ModularExtended;
/* For pretty printing type */
template<typename...> const char *TypeName();
template<template <typename...> class> const char *TypeName();
#define REGISTER_TYPE_NAME(type) \
template<> const char *TypeName<type>(){return #type;}
REGISTER_TYPE_NAME(float);
REGISTER_TYPE_NAME(double);
REGISTER_TYPE_NAME(uint16_t);
REGISTER_TYPE_NAME(uint32_t);
REGISTER_TYPE_NAME(uint64_t);
REGISTER_TYPE_NAME(uint128_t);
REGISTER_TYPE_NAME(Modular);
REGISTER_TYPE_NAME(ModularExtended);
/******************************************************************************/
/* Basic class to access and test protected method of FFT class */
template<typename Field, typename Simd>
class FFT_checker : public FFT<Field, Simd> {
private:
using base = FFT<Field, Simd>;
public:
using base::DIF;
using base::DIT;
using base::DIF_reversed;
using base::DIT_reversed;
using base::base;
};
template<typename Field>
struct Checker {
typedef typename Field::Element Elt;
typedef AlignedAllocator<Elt, Alignment::DEFAULT> _Alignement;
typedef typename std::vector<Elt, _Alignement> EltVector;
const Field& _F;
size_t _k;
size_t _n;
/* ctor */
Checker (const Field& F, size_t k) : _F(F), _k(k), _n(1<<k) {
}
/* compute r = P evaluated at x using Horner method */
void horner_eval (Elt& r, EltVector& P, Elt& x) {
_F.assign (r, _F.zero);
for (auto ptr = P.rbegin(); ptr != P.rend(); ptr++ ) {
_F.mulin (r, x);
_F.addin (r, *ptr);
}
}
/* return i with its first _k bits reversed */
size_t bitreversed (size_t i) {
size_t r = 0;
for (size_t j = 0; j < _k; j++, i>>=1)
{
r <<= 1;
r |= i & 1;
}
return r;
}
template<typename Simd>
void
print_result_line (const char *name, bool b) {
size_t t = strlen(name) + Simd::type_string().size() + 40 + 10;
cout << " " << string (80-t, ' ') << name << "<"
<< Simd::type_string() << "> " << string (40, '.')
<< (b ? " success" : " failure") << endl;
}
/* check DIF and DIT */
template<typename Simd>
bool actual_check (FFT_checker<Field, Simd> &fft, const EltVector& in,
const EltVector& in_br, const EltVector& out,
const EltVector& out_br) {
EltVector v(_n);
/* DIF : natural order => bitreversed order */
v = in;
fft.DIF (v.data());
bool bf = equal (v.begin(), v.end(), out_br.begin());
print_result_line<Simd> ("DIF", bf);
/* DIF : bitreversed order => natural order */
v = in_br;
fft.DIF_reversed (v.data());
bool bf2 = equal (v.begin(), v.end(), out.begin());
print_result_line<Simd> ("DIF_reversed", bf2);
/* DIT : bitreversed order => natural order */
v = in_br;
fft.DIT (v.data());
bool bt = equal (v.begin(), v.end(), out.begin());
print_result_line<Simd> ("DIT", bt);
/* DIT : natural order => bitreversed order */
v = in;
fft.DIT_reversed (v.data());
bool bt2 = equal (v.begin(), v.end(), out_br.begin());
print_result_line<Simd> ("DIT_reversed", bt2);
/* FFT_direct : natural order => bitreversed order */
v = in;
fft.FFT_direct (v.data());
bool bd = equal (v.begin(), v.end(), out_br.begin());
print_result_line<Simd> ("FFT_direct", bd);
/* FFT_inverse: bitreversed order => natural order */
v = in_br;
fft.FFT_inverse (v.data());
bool bi = equal (v.begin(), v.end(), out.begin());
print_result_line<Simd> ("FFT_inverse", bi);
bool b = bt & bf & bt2 & bf2 & bd & bi;
return b;
}
/* draw random vector and check DIF and DIT for all available SIMD implem */
bool check (unsigned long seed) {
bool passed = true;
EltVector in(_n), in_br(_n), out(_n), out_br(_n);
FFT_checker<Field, NoSimd<Elt>> fft_nosimd (_F, _k);
/* Generate random input */
typename Field::RandIter Gen (_F, 0, seed+_k); /*0 has no meaning here*/
for (auto v = in.begin(); v < in.end(); v++)
Gen.random (*v);
/* Compute the out vector using a naive polynomial evaluation and set
* the bitreversed version of in and out */
Elt x(1);
const Elt & w = fft_nosimd.root ();
for (size_t i = 0; i < _n; _F.mulin (x, w), i++) {
size_t i_br = bitreversed (i);
in_br[i_br] = in[i];
horner_eval (out[i], in, x);
out_br[i_br] = out[i];
}
/* NoSimd */
passed &= actual_check (fft_nosimd, in, in_br, out, out_br);
/* Simd128 */
#if defined(__FFLASFFPACK_HAVE_SSE4_1_INSTRUCTIONS)
FFT_checker<Field, Simd128<Elt>> fft_simd128 (_F, _k, w);
passed &= actual_check (fft_simd128, in, in_br, out, out_br);
#endif
/* Simd256 */
#if defined(__FFLASFFPACK_HAVE_AVX2_INSTRUCTIONS)
FFT_checker<Field, Simd256<Elt>> fft_simd256 (_F, _k, w);
passed &= actual_check (fft_simd256, in, in_br, out, out_br);
#endif
// FIXME Simd512: which macro should be used to discriminate against
// simd512 for both floating and integral type ?
return passed;
}
};
/* Test FFT on polynomial with coefficients in ModImplem<Elt, C...> (i.e.,
* Modular<Elt, C> or ModularExtended<Elt>) with a random prime p with the
* required number of bits and such that 2^k divides p-1
*/
template<template<typename, typename...> class ModImplem, typename Elt, typename... C>
bool test_one_modular_implem (uint64_t bits, size_t k, unsigned long seed)
{
integer p;
if (!RandomFFTPrime::randomPrime (p, integer(1)<<bits, k))
throw LinboxError ("RandomFFTPrime::randomPrime failed");
ModImplem<Elt, C...> GFp ((Elt) p);
cout << endl << string (80, '*') << endl;
cout << "Test FFT with " << TypeName<ModImplem>() << "<" << TypeName<Elt>();
if (sizeof...(C) > 0)
cout << ", " << TypeName<C...>();
cout << ">, p=" << GFp.cardinality() << " (" << bits << " bits, 2^" << k;
cout << " divides p-1)" << endl;
bool b = true;
for (size_t kc = 1; kc <= k; kc++) {
cout << "** with n=2^" << kc << endl;
Checker<ModImplem<Elt, C...>> Test(GFp, kc);
b &= Test.check (seed);
}
return b;
}
/******************************************************************************/
/************************************ main ************************************/
/******************************************************************************/
int main (int argc, char *argv[]) {
bool pass = true;
unsigned long seed = time (NULL);
Argument args[] = {
{ 's', "-s seed", "set the seed.", TYPE_INT, &seed },
END_OF_ARGUMENTS
};
parseArguments (argc, argv, args);
cout << "# To rerun this test: test-fft-new -s " << seed << endl;
cout << "# seed = " << seed << endl;
/* Test with Modular<float>, a 12-bit prime and k=7 */
pass &= test_one_modular_implem<Modular,float> (12, 7, seed);
/* Test with Modular<float,double>, a 23-bit prime and k=10 */
pass &= test_one_modular_implem<Modular,float,double> (23, 10, seed);
// FIXME: next line fails: instead an exception should be raised if modulus
// is too large
// pass &= test_one_modular_implem<Modular,float,double> (24, 10, seed);
/* Test with Modular<double>, a 26-bit prime and k=10 */
pass &= test_one_modular_implem<Modular,double> (26, 10, seed);
/* Test with ModularExtended<double>, a 51-bit prime and k=11 */
pass &= test_one_modular_implem<ModularExtended,double> (50, 11, seed);
/* Test with Modular<uint16_t,uint32_t>, a 14-bit prime and k=8 */
pass &= test_one_modular_implem<Modular,uint16_t,uint32_t> (14, 8, seed);
// FIXME: next line fails: instead an exception should be raised if modulus
// is too large (true for all Modular<uintN_t, uint2N_t>)
// pass &= test_one_modular_implem<Modular,uint16_t,uint32_t> (16, 9, seed);
/* Test with Modular<uint32_t>, a 16-bit prime and k=9 */
pass &= test_one_modular_implem<Modular,uint32_t> (14, 9, seed);
// FIXME: next line fails: instead an exception should be raised if modulus
// is too large (true for all Modular<uintN_t, uintN_t>)
// pass &= test_one_modular_implem<Modular,uint32_t> (16, 9, seed);
/* Test with Modular<uint32_t, uint64_t>, a 30-bit prime and k=10 */
pass &= test_one_modular_implem<Modular,uint32_t,uint64_t> (30, 10, seed);
#ifdef __FFLASFFPACK_HAVE_INT128
/* Test with Modular<uint64_t,uint128_t>, a 62-bit prime and k=11 */
pass &= test_one_modular_implem<Modular,uint64_t,uint128_t> (62, 11, seed);
#endif
cout << endl << "Test " << (pass ? "passed" : "failed") << endl;
return pass ? 0 : 1;
}
// Local Variables:
// mode: C++
// tab-width: 4
// indent-tabs-mode: nil
// c-basic-offset: 4
// End:
// vim:sts=4:sw=4:ts=4:et:sr:cino=>s,f0,{0,g0,(0,\:0,t0,+0,=s
<|endoftext|> |
<commit_before>#ifndef CPPCHAN_CHANNEL_H
#define CPPCHAN_CHANNEL_H
#include <queue>
#include <future>
#include <mutex>
template <typename T>
class channel
{
public:
channel( int capacity = 0 );
void operator<<( const T & val );
void operator>>( T& retVal);
private:
void sync_set( const T & val );
T sync_get( );
private:
int m_capacity;
std::queue<T> m_values;
std::promise<T> m_uniqueValue;
std::promise<void> m_wantsValuePromise;
std::mutex m_queueMutex;
};
template <typename T>
channel<T>::channel( int capacity ) :
m_capacity( capacity )
{ }
template <typename T>
void
channel<T>::operator<<( const T & val )
{
if ( m_capacity == 0 )
{
sync_set( val );
return;
}
bool pushed = false;
m_queueMutex.lock( );
if ( m_values.size( ) <= (size_t) m_capacity )
{
m_values.push( val );
pushed = true;
}
m_queueMutex.unlock( );
if ( pushed )
return;
sync_set( val );
}
template <typename T>
void channel<T>::operator>>( T & retVal )
{
if ( m_capacity == 0 )
{
retVal = sync_get( );
return;
}
bool pulled = false;
T res;
m_queueMutex.lock( );
if ( m_values.size( ) > 0 )
{
res = m_values.front( );
m_values.pop( );
pulled = true;
}
m_queueMutex.unlock( );
if ( pulled )
{
retVal = res;
return;
}
retVal = sync_get( );
return;
}
template <typename T>
void
channel<T>::sync_set( const T & val )
{
// wait until there is a reader
auto wantsValueFuture = m_wantsValuePromise.get_future( );
wantsValueFuture.get( );
m_uniqueValue.set_value( val );
// reset the reader/writter sync
std::promise<void> newPromise;
std::swap( m_wantsValuePromise, newPromise );
}
template <typename T>
T
channel<T>::sync_get( )
{
// inform we are reading
m_wantsValuePromise.set_value( );
auto resFuture = m_uniqueValue.get_future( );
T res = resFuture.get( );
// reset the unique value store
std::promise<T> newPromise;
std::swap( m_uniqueValue, newPromise );
return res;
}
#endif // CPPCHAN_CHANNEL_H
<commit_msg>attempting to get the channel working with capacity > 0<commit_after>#ifndef CPPCHAN_CHANNEL_H
#define CPPCHAN_CHANNEL_H
#include <queue>
#include <future>
#include <mutex>
template <typename T>
class channel
{
public:
channel( int capacity = 0 );
void operator<<( const T & val );
void operator>>( T& retVal);
private:
void sync_set( const T & val );
T sync_get( );
private:
int m_capacity;
std::queue<T> m_values;
std::promise<T> m_uniqueValue;
std::promise<void> m_wantsValuePromise;
std::mutex m_queueMutex;
};
template <typename T>
channel<T>::channel( int capacity ) :
m_capacity( capacity )
{ }
template <typename T>
void
channel<T>::operator<<( const T & val )
{
if ( m_capacity == 0 )
{
sync_set( val );
return;
}
bool pushed = false;
m_queueMutex.lock( );
if ( m_values.size( ) < (size_t) m_capacity )
{
if ( m_values.size( ) == 0 )
{
// unblock the getter..
}
m_values.push( val );
pushed = true;
}
m_queueMutex.unlock( );
if ( pushed )
return;
// TODO: we should not wait for the stack to expire...
sync_set( val );
}
template <typename T>
void channel<T>::operator>>( T & retVal )
{
if ( m_capacity == 0 )
{
retVal = sync_get( );
return;
}
bool pulled = false;
T res;
m_queueMutex.lock( );
if ( m_values.size( ) > 0 )
{
if ( m_values.size( ) == m_capacity )
{
// unblock the setter by getting its value
T blockingVal = sync_get( );
m_values.push( blockingVal );
}
res = m_values.front( );
m_values.pop( );
pulled = true;
}
m_queueMutex.unlock( );
if ( pulled )
{
retVal = res;
return;
}
retVal = sync_get( );
return;
}
template <typename T>
void
channel<T>::sync_set( const T & val )
{
// wait until there is a reader
auto wantsValueFuture = m_wantsValuePromise.get_future( );
wantsValueFuture.get( );
m_uniqueValue.set_value( val );
// reset the reader/writter sync
std::promise<void> newPromise;
std::swap( m_wantsValuePromise, newPromise );
}
template <typename T>
T
channel<T>::sync_get( )
{
// inform we are reading
m_wantsValuePromise.set_value( );
auto resFuture = m_uniqueValue.get_future( );
T res = resFuture.get( );
// reset the unique value store
std::promise<T> newPromise;
std::swap( m_uniqueValue, newPromise );
return res;
}
#endif // CPPCHAN_CHANNEL_H
<|endoftext|> |
<commit_before>#include "settings.hh"
// ----------------------------------------------------------------------
static const char* const SETTINGS_DEFAULT = R"(
{
"apply": [
"all_grey",
"egg",
"vaccines"
]
}
)";
rjson::value settings_default()
{
try {
return rjson::parse_string(SETTINGS_DEFAULT, rjson::remove_comments::No);
}
catch (std::exception& err) {
std::cerr << "ERROR: parsing SETTINGS_DEFAULT: " << err.what() << '\n';
throw;
}
}
// ----------------------------------------------------------------------
static const char* const SETTINGS_BUILTIN_MODS = R"(
{
"mods": {
"all_grey": [
{"N": "antigens", "select": "test", "outline": "grey80", "fill": "grey80"},
{"N": "antigens", "select": "reference", "outline": "grey80", "fill": "transparent"},
{"N": "sera", "select": "all", "outline": "grey80", "fill": "transparent"}
],
"egg": [
{"N": "antigens", "select": {"passage": "egg"}, "aspect": 0.75},
{"N": "antigens", "select": {"passage": "reassortant"}, "aspect": 0.75, "rotation": 0.5}
],
"vaccines": [
{"N": "antigens", "select": "vaccine", "report": true, "outline": "black", "fill": "blue", "size": 15, "order": "raise"}
]
}
}
)";
rjson::value settings_builtin_mods()
{
try {
return rjson::parse_string(SETTINGS_BUILTIN_MODS, rjson::remove_comments::No);
}
catch (std::exception& err) {
std::cerr << "ERROR: parsing SETTINGS_BUILTIN_MODS: " << err.what() << '\n';
throw;
}
}
// ----------------------------------------------------------------------
static const char* const SETTINGS_HELP_MODS = R"(
{"N": "antigens", "select": {<select>},
"outline": "black", "fill": "red", "aspect": 1.0, "rotation": 0.0,
"size": 1.0, "outline_width": 1.0,
"show": true, "shape": "circle|box|triangle",
"order": "raise|lower",
"report": false}
{"N": "sera", "select": {<select>},
"outline": "black", "fill": "red", "aspect": 1.0, "rotation": 0.0,
"size": 1.0, "outline_width": 1.0,
"show": true, "shape": "circle|box|triangle",
"order": "raise|lower",
"report": false}
"all_grey"
// flip
// value: [0, 1]
// ew
// ns
// rotate_degrees angle:
// rotate_radians angle:
// viewport value:
// use_chart_plot_spec
// point_scale
// {"N": "background", "color": "white"},
// {"N": "grid", "color": "grey80", "line_width": 1},
// {"N": "border", "color": "black", "line_width": 1},
// title size: background: border_color: border_width: display_name: []
// legend data:[{"label": {<label-data>} "display_name": "163-del", "outline": "black", "fill": "#03569b"}] "offset": [-10, -10], "show": True, "size": 50, "label_size": 8, "point_size": 5
//
// antigens
// show
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// {"N": "aa_substitutions", "positions": [159], "legend": {"show": True, "offset": [-10, -10], "point_count": True, "background": "grey99", "border_color": "black", "border_width": 0.1, "label_size": 12, "point_size": 8}},
// {"N": "aa_substitution_groups", "groups": [{"pos_aa": ["121K", "144K"], "color": "cornflowerblue"}]},
//
// sera
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// serum_circle
// serum_coverage
//
// arrow
// line
// rectangle corner1: corner2:
// circle center: radius: aspect: rotation:
//
// Application
// lab
// labs
// lineage
//
// Derived:
// continents
)";
const char* settings_help_mods()
{
return SETTINGS_HELP_MODS;
}
// ----------------------------------------------------------------------
static const char* const SETTINGS_HELP_SELECT = R"(
Antigens:
---------
"all",
"reference",
"test",
"egg", "cell", "reassortant",
{"passage": "egg"}, {"passage": "cell"}, {"passage": "reassortant"},
{"date_range": ["2016-01-01", "2016-09-01"]},
{"date_range": ["", "2016-09-01"]}, {"date_range": ["2016-01-01", ""]},
{"older_than_days": 365}, {"younger_than_days": 365},
{"index": 11}, {"indices": [55, 66]},
{"country": "sweden"}, {"continent": "europe"},
"sequenced", "not_sequenced", {"clade": "3C3a"},
{"name": "SWITZERLAND/9715293/2013"}, {"name": "SWITZERLAND/9715293/2013", "passage": "reassortant"},
{"full_name": "A(H1N1)/MICHIGAN/2/2009 MDCK1"},
"vaccine", {"vaccine": {"type": "previous", "no": 0, "passage": "egg", "name": "SWITZERLAND"}},
{"in_rectangle": {"c1": [0.0, 0.0], "c2": [1.0, 1.0]}}, {"in_circle": {"center": [2.0, 2.0], "radius": 5.0}}
Sera:
-----
"all",
{"serum_id": "CDC 2016-003"},
{"index": 11}, {"indices": [55, 66]},
{"country": "sweden"}, {"continent": "europe"},
{"name": "SWITZERLAND/9715293/2013"},
{"full_name": "A(H1N1)/MICHIGAN/2/2009 CDC 2015-121"},
)";
const char* settings_help_select()
{
return SETTINGS_HELP_SELECT;
}
// ----------------------------------------------------------------------
// static const char* const DEFAULT_SETTINGS_JSON =
// {
// "mods": {
// "all_red": [
// {"N": "antigens", "select": "test", "outline": "black", "fill": "red"},
// {"N": "antigens", "select": "reference", "outline": "red", "fill": "transparent"}
// ]
// },
// "clade_fill": {
// "?": "H3",
// "3C3": "cornflowerblue",
// "3C2a": "red",
// "3C2a1": "darkred",
// "3C3a": "green",
// "3C3b": "blue",
// "?": "H1pdm",
// "6B1": "blue",
// "6B2": "red",
// "?": "B/Yam",
// "Y2": "cornflowerblue",
// "Y3": "red",
// "?": "B/Vic",
// "1": "blue",
// "1A": "cornflowerblue",
// "1B": "red",
// "DEL2017": "#000080",
// "TRIPLEDEL2017": "#46f0f0"
// }
// }
// ----------------------------------------------------------------------
// flip
// value: [0, 1]
// ew
// ns
// rotate_degrees angle:
// rotate_radians angle:
// viewport value:
// use_chart_plot_spec
// point_scale
// {"N": "background", "color": "white"},
// {"N": "grid", "color": "grey80", "line_width": 1},
// {"N": "border", "color": "black", "line_width": 1},
// title size: background: border_color: border_width: display_name: []
// legend data:[{"label": {<label-data>} "display_name": "163-del", "outline": "black", "fill": "#03569b"}] "offset": [-10, -10], "show": True, "size": 50, "label_size": 8, "point_size": 5
//
// antigens
// show
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// {"N": "aa_substitutions", "positions": [159], "legend": {"show": True, "offset": [-10, -10], "point_count": True, "background": "grey99", "border_color": "black", "border_width": 0.1, "label_size": 12, "point_size": 8}},
// {"N": "aa_substitution_groups", "groups": [{"pos_aa": ["121K", "144K"], "color": "cornflowerblue"}]},
//
// sera
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// serum_circle
// serum_coverage
//
// arrow
// line
// rectangle corner1: corner2:
// circle center: radius: aspect: rotation:
//
// Application
// lab
// labs
// lineage
//
// Derived:
// all-grey
// continents
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
<commit_msg>mod: "vaccines"<commit_after>#include "settings.hh"
// ----------------------------------------------------------------------
static const char* const SETTINGS_DEFAULT = R"(
{
"apply": [
"all_grey",
"egg",
"vaccines"
]
}
)";
rjson::value settings_default()
{
try {
return rjson::parse_string(SETTINGS_DEFAULT, rjson::remove_comments::No);
}
catch (std::exception& err) {
std::cerr << "ERROR: parsing SETTINGS_DEFAULT: " << err.what() << '\n';
throw;
}
}
// ----------------------------------------------------------------------
static const char* const SETTINGS_BUILTIN_MODS = R"(
{
"mods": {
"all_grey": [
{"N": "antigens", "select": "test", "outline": "grey80", "fill": "grey80"},
{"N": "antigens", "select": "reference", "outline": "grey80", "fill": "transparent"},
{"N": "sera", "select": "all", "outline": "grey80", "fill": "transparent"}
],
"egg": [
{"N": "antigens", "select": {"passage": "egg"}, "aspect": 0.75},
{"N": "antigens", "select": {"passage": "reassortant"}, "aspect": 0.75, "rotation": 0.5}
],
"vaccines": [
{"N": "antigens", "select": {"vaccine": {"type": "previous"}}, "report": true, "outline": "black", "fill": "blue", "size": 15, "order": "raise"},
{"N": "antigens", "select": {"vaccine": {"type": "current", "passage": "cell"}}, "report": true, "outline": "black", "fill": "red", "size": 15, "order": "raise"},
{"N": "antigens", "select": {"vaccine": {"type": "current", "passage": "egg"}}, "report": true, "outline": "black", "fill": "red", "size": 15, "order": "raise"},
{"N": "antigens", "select": {"vaccine": {"type": "current", "passage": "reassortant"}}, "report": true, "outline": "black", "fill": "green", "size": 15, "order": "raise"},
{"N": "antigens", "select": {"vaccine": {"type": "surrogate"}}, "report": true, "outline": "black", "fill": "pink", "size": 15, "order": "raise"}
]
}
}
)";
rjson::value settings_builtin_mods()
{
try {
return rjson::parse_string(SETTINGS_BUILTIN_MODS, rjson::remove_comments::No);
}
catch (std::exception& err) {
std::cerr << "ERROR: parsing SETTINGS_BUILTIN_MODS: " << err.what() << '\n';
throw;
}
}
// ----------------------------------------------------------------------
static const char* const SETTINGS_HELP_MODS = R"(
{"N": "antigens", "select": {<select>},
"outline": "black", "fill": "red", "aspect": 1.0, "rotation": 0.0,
"size": 1.0, "outline_width": 1.0,
"show": true, "shape": "circle|box|triangle",
"order": "raise|lower",
"report": false}
{"N": "sera", "select": {<select>},
"outline": "black", "fill": "red", "aspect": 1.0, "rotation": 0.0,
"size": 1.0, "outline_width": 1.0,
"show": true, "shape": "circle|box|triangle",
"order": "raise|lower",
"report": false}
"all_grey"
// flip
// value: [0, 1]
// ew
// ns
// rotate_degrees angle:
// rotate_radians angle:
// viewport value:
// use_chart_plot_spec
// point_scale
// {"N": "background", "color": "white"},
// {"N": "grid", "color": "grey80", "line_width": 1},
// {"N": "border", "color": "black", "line_width": 1},
// title size: background: border_color: border_width: display_name: []
// legend data:[{"label": {<label-data>} "display_name": "163-del", "outline": "black", "fill": "#03569b"}] "offset": [-10, -10], "show": True, "size": 50, "label_size": 8, "point_size": 5
//
// antigens
// show
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// {"N": "aa_substitutions", "positions": [159], "legend": {"show": True, "offset": [-10, -10], "point_count": True, "background": "grey99", "border_color": "black", "border_width": 0.1, "label_size": 12, "point_size": 8}},
// {"N": "aa_substitution_groups", "groups": [{"pos_aa": ["121K", "144K"], "color": "cornflowerblue"}]},
//
// sera
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// serum_circle
// serum_coverage
//
// arrow
// line
// rectangle corner1: corner2:
// circle center: radius: aspect: rotation:
//
// Application
// lab
// labs
// lineage
//
// Derived:
// continents
)";
const char* settings_help_mods()
{
return SETTINGS_HELP_MODS;
}
// ----------------------------------------------------------------------
static const char* const SETTINGS_HELP_SELECT = R"(
Antigens:
---------
"all",
"reference",
"test",
"egg", "cell", "reassortant",
{"passage": "egg"}, {"passage": "cell"}, {"passage": "reassortant"},
{"date_range": ["2016-01-01", "2016-09-01"]},
{"date_range": ["", "2016-09-01"]}, {"date_range": ["2016-01-01", ""]},
{"older_than_days": 365}, {"younger_than_days": 365},
{"index": 11}, {"indices": [55, 66]},
{"country": "sweden"}, {"continent": "europe"},
"sequenced", "not_sequenced", {"clade": "3C3a"},
{"name": "SWITZERLAND/9715293/2013"}, {"name": "SWITZERLAND/9715293/2013", "passage": "reassortant"},
{"full_name": "A(H1N1)/MICHIGAN/2/2009 MDCK1"},
"vaccine", {"vaccine": {"type": "previous", "no": 0, "passage": "egg", "name": "SWITZERLAND"}},
{"in_rectangle": {"c1": [0.0, 0.0], "c2": [1.0, 1.0]}}, {"in_circle": {"center": [2.0, 2.0], "radius": 5.0}}
Sera:
-----
"all",
{"serum_id": "CDC 2016-003"},
{"index": 11}, {"indices": [55, 66]},
{"country": "sweden"}, {"continent": "europe"},
{"name": "SWITZERLAND/9715293/2013"},
{"full_name": "A(H1N1)/MICHIGAN/2/2009 CDC 2015-121"},
)";
const char* settings_help_select()
{
return SETTINGS_HELP_SELECT;
}
// ----------------------------------------------------------------------
// static const char* const DEFAULT_SETTINGS_JSON =
// {
// "mods": {
// "all_red": [
// {"N": "antigens", "select": "test", "outline": "black", "fill": "red"},
// {"N": "antigens", "select": "reference", "outline": "red", "fill": "transparent"}
// ]
// },
// "clade_fill": {
// "?": "H3",
// "3C3": "cornflowerblue",
// "3C2a": "red",
// "3C2a1": "darkred",
// "3C3a": "green",
// "3C3b": "blue",
// "?": "H1pdm",
// "6B1": "blue",
// "6B2": "red",
// "?": "B/Yam",
// "Y2": "cornflowerblue",
// "Y3": "red",
// "?": "B/Vic",
// "1": "blue",
// "1A": "cornflowerblue",
// "1B": "red",
// "DEL2017": "#000080",
// "TRIPLEDEL2017": "#46f0f0"
// }
// }
// ----------------------------------------------------------------------
// flip
// value: [0, 1]
// ew
// ns
// rotate_degrees angle:
// rotate_radians angle:
// viewport value:
// use_chart_plot_spec
// point_scale
// {"N": "background", "color": "white"},
// {"N": "grid", "color": "grey80", "line_width": 1},
// {"N": "border", "color": "black", "line_width": 1},
// title size: background: border_color: border_width: display_name: []
// legend data:[{"label": {<label-data>} "display_name": "163-del", "outline": "black", "fill": "#03569b"}] "offset": [-10, -10], "show": True, "size": 50, "label_size": 8, "point_size": 5
//
// antigens
// show
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// {"N": "aa_substitutions", "positions": [159], "legend": {"show": True, "offset": [-10, -10], "point_count": True, "background": "grey99", "border_color": "black", "border_width": 0.1, "label_size": 12, "point_size": 8}},
// {"N": "aa_substitution_groups", "groups": [{"pos_aa": ["121K", "144K"], "color": "cornflowerblue"}]},
//
// sera
// size, shape, fill, outline, outline_width, aspect, rotation, raise_ (order: raise, lower, no-change), report, report_names_threshold
// label: name_type, offset, display_name, color, size, weight, slant, font_family
// serum_circle
// serum_coverage
//
// arrow
// line
// rectangle corner1: corner2:
// circle center: radius: aspect: rotation:
//
// Application
// lab
// labs
// lineage
//
// Derived:
// all-grey
// continents
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
<|endoftext|> |
<commit_before>#include "client.hpp"
#include "ircd.hpp"
#include "tokens.hpp"
#include "modes.hpp"
void Client::send_motd()
{
send(RPL_MOTDSTART, ":- " + server.name() + " Message of the day - ");
const auto& motd = server.get_motd();
for (const auto& line : motd)
send(RPL_MOTD, ":" + line);
send(RPL_ENDOFMOTD, ":End of MOTD command");
}
void Client::send_lusers()
{
send(RPL_LUSERCLIENT, ":There are " + std::to_string(server.get_counter(STAT_TOTAL_USERS)) +
" and 0 services on 1 servers");
send(RPL_LUSEROP, std::to_string(server.get_counter(STAT_OPERATORS)) + " :operator(s) online");
send(RPL_LUSERCHANNELS, std::to_string(server.get_counter(STAT_CHANNELS)) + " :channels formed");
send(RPL_LUSERME, ":I have " + std::to_string(server.get_counter(STAT_LOCAL_USERS)) + " clients and 1 servers");
std::string mu = std::to_string(server.get_counter(STAT_MAX_USERS));
std::string tc = std::to_string(server.get_counter(STAT_TOTAL_CONNS));
send(250, "Highest connection count: " + mu + " (" + mu + " clients) (" + tc + " connections received)");
}
void Client::send_modes()
{
send_raw(":" + nickuserhost() + " " + TK_MODE + " " + nick() + " :+" + this->mode_string());
}
void Client::send_quit(const std::string& reason)
{
// inform everyone what happened
handle_quit(reason);
// close connection after write
std::string text = ":" + nickuserhost() + " " + TK_QUIT + " :" + reason + "\r\n";
conn->write(text.data(), text.size(),
[this] (size_t) {
conn->close();
});
}
<commit_msg>Improve RPL_LUSERCLIENT reply<commit_after>#include "client.hpp"
#include "ircd.hpp"
#include "tokens.hpp"
#include "modes.hpp"
void Client::send_motd()
{
send(RPL_MOTDSTART, ":- " + server.name() + " Message of the day - ");
const auto& motd = server.get_motd();
for (const auto& line : motd)
send(RPL_MOTD, ":" + line);
send(RPL_ENDOFMOTD, ":End of MOTD command");
}
void Client::send_lusers()
{
send(RPL_LUSERCLIENT, ":There are " + std::to_string(server.get_counter(STAT_TOTAL_USERS)) +
" users and 0 services on 1 servers");
send(RPL_LUSEROP, std::to_string(server.get_counter(STAT_OPERATORS)) + " :operator(s) online");
send(RPL_LUSERCHANNELS, std::to_string(server.get_counter(STAT_CHANNELS)) + " :channels formed");
send(RPL_LUSERME, ":I have " + std::to_string(server.get_counter(STAT_LOCAL_USERS)) + " clients and 1 servers");
std::string mu = std::to_string(server.get_counter(STAT_MAX_USERS));
std::string tc = std::to_string(server.get_counter(STAT_TOTAL_CONNS));
send(250, "Highest connection count: " + mu + " (" + mu + " clients) (" + tc + " connections received)");
}
void Client::send_modes()
{
send_raw(":" + nickuserhost() + " " + TK_MODE + " " + nick() + " :+" + this->mode_string());
}
void Client::send_quit(const std::string& reason)
{
// inform everyone what happened
handle_quit(reason);
// close connection after write
std::string text = ":" + nickuserhost() + " " + TK_QUIT + " :" + reason + "\r\n";
conn->write(text.data(), text.size(),
[this] (size_t) {
conn->close();
});
}
<|endoftext|> |
<commit_before>//-*- Mode: C++; indent-tabs-mode: nil; tab-width: 4 -*-
/* The MIT License (MIT)
*
* Copyright (c) 2017 Brandon Schaefer
* brandontschaefer@gmail.com
*
* 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 <gtest/gtest.h>
#include <gmock/gmock.h>
#include "cpu.h"
#include "mocks/ppu.h"
namespace
{
struct TestCPU : ::testing::Test
{
TestCPU() :
cpu(&ppu)
{
}
MockPPU ppu;
emulator::CPU cpu;
};
}
TEST_F(TestCPU, test_read8_write8)
{
cpu.write8(0x0, 0x10);
EXPECT_EQ(cpu.read8(0x0), 0x10);
}
TEST_F(TestCPU, test_read16_write8)
{
cpu.write8(0x0, 0x10);
cpu.write8(0x1, 0x05);
EXPECT_EQ(cpu.read16(0x0), 0x10 | 0x05 << 8);
}
TEST_F(TestCPU, test_set_get_program_counter)
{
cpu.set_program_counter(0x20);
EXPECT_EQ(cpu.program_counter(), 0x20);
}
TEST_F(TestCPU, test_set_get_x_register)
{
cpu.set_x_register(0x20);
EXPECT_EQ(cpu.x_register(), 0x20);
}
TEST_F(TestCPU, test_set_get_y_register)
{
cpu.set_y_register(0x20);
EXPECT_EQ(cpu.y_register(), 0x20);
}
TEST_F(TestCPU, test_set_get_stack)
{
cpu.set_stack(0x20);
EXPECT_EQ(cpu.stack(), 0x20);
}
TEST_F(TestCPU, test_update_get_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
cpu.update_flags([] { return true; }, emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::carry);
}
TEST_F(TestCPU, test_update_get_multiple_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
cpu.update_flags([] { return true; }, emulator::carry | emulator::overflow);
EXPECT_TRUE(cpu.status() & emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::overflow);
}
TEST_F(TestCPU, test_add_get_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
cpu.add_flags(emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::carry);
}
TEST_F(TestCPU, test_add_multiple_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
cpu.add_flags(emulator::carry | emulator::overflow);
EXPECT_TRUE(cpu.status() & emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::overflow);
}
TEST_F(TestCPU, test_add_remove_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
cpu.add_flags(emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::carry);
cpu.remove_flags(emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::carry);
}
TEST_F(TestCPU, test_add_remove_multiple_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
cpu.add_flags(emulator::carry | emulator::overflow);
EXPECT_TRUE(cpu.status() & emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::overflow);
cpu.remove_flags(emulator::carry | emulator::overflow);
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
}
TEST_F(TestCPU, test_push_pop)
{
cpu.push(0x1);
EXPECT_EQ(cpu.pop(), 0x1);
}
<commit_msg>* Add tests for step + step and interrupt<commit_after>//-*- Mode: C++; indent-tabs-mode: nil; tab-width: 4 -*-
/* The MIT License (MIT)
*
* Copyright (c) 2017 Brandon Schaefer
* brandontschaefer@gmail.com
*
* 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 <gtest/gtest.h>
#include <gmock/gmock.h>
#include "cpu.h"
#include "cpu_instructions.h"
#include "mocks/ppu.h"
namespace
{
struct TestCPU : ::testing::Test
{
TestCPU() :
cpu(&ppu)
{
}
MockPPU ppu;
emulator::CPU cpu;
};
}
TEST_F(TestCPU, test_read8_write8)
{
cpu.write8(0x0, 0x10);
EXPECT_EQ(cpu.read8(0x0), 0x10);
}
TEST_F(TestCPU, test_read16_write8)
{
cpu.write8(0x0, 0x10);
cpu.write8(0x1, 0x05);
EXPECT_EQ(cpu.read16(0x0), 0x10 | 0x05 << 8);
}
TEST_F(TestCPU, test_set_get_program_counter)
{
cpu.set_program_counter(0x20);
EXPECT_EQ(cpu.program_counter(), 0x20);
}
TEST_F(TestCPU, test_set_get_x_register)
{
cpu.set_x_register(0x20);
EXPECT_EQ(cpu.x_register(), 0x20);
}
TEST_F(TestCPU, test_set_get_y_register)
{
cpu.set_y_register(0x20);
EXPECT_EQ(cpu.y_register(), 0x20);
}
TEST_F(TestCPU, test_set_get_stack)
{
cpu.set_stack(0x20);
EXPECT_EQ(cpu.stack(), 0x20);
}
TEST_F(TestCPU, test_update_get_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
cpu.update_flags([] { return true; }, emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::carry);
}
TEST_F(TestCPU, test_update_get_multiple_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
cpu.update_flags([] { return true; }, emulator::carry | emulator::overflow);
EXPECT_TRUE(cpu.status() & emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::overflow);
}
TEST_F(TestCPU, test_add_get_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
cpu.add_flags(emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::carry);
}
TEST_F(TestCPU, test_add_multiple_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
cpu.add_flags(emulator::carry | emulator::overflow);
EXPECT_TRUE(cpu.status() & emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::overflow);
}
TEST_F(TestCPU, test_add_remove_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
cpu.add_flags(emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::carry);
cpu.remove_flags(emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::carry);
}
TEST_F(TestCPU, test_add_remove_multiple_status)
{
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
cpu.add_flags(emulator::carry | emulator::overflow);
EXPECT_TRUE(cpu.status() & emulator::carry);
EXPECT_TRUE(cpu.status() & emulator::overflow);
cpu.remove_flags(emulator::carry | emulator::overflow);
EXPECT_FALSE(cpu.status() & emulator::carry);
EXPECT_FALSE(cpu.status() & emulator::overflow);
}
TEST_F(TestCPU, test_push_pop)
{
cpu.push(0x1);
EXPECT_EQ(cpu.pop(), 0x1);
}
TEST_F(TestCPU, test_step)
{
// op code ADC - immediate
auto op = emulator::instruction[0x69];
cpu.write8(0x0, 0x69);
cpu.write8(0x1, 0x05);
EXPECT_EQ(cpu.step(), op.number_cycles);
}
TEST_F(TestCPU, test_step_with_interrupt)
{
cpu.handle_non_maskable_interrupt();
// op code ADC - immediate
auto op = emulator::instruction[0x69];
cpu.write8(0x0, 0x69);
cpu.write8(0x1, 0x05);
// Interrupts are 7 cycles, lets set one and check we get an extra 7 to our step count
EXPECT_EQ(cpu.step(), op.number_cycles + 7);
EXPECT_TRUE(cpu.status() & emulator::interrupt);
}
<|endoftext|> |
<commit_before>/**
* @file clitest.cpp
* @brief Brief description of file.
*
*/
#include <pthread.h>
#include <string>
#include <map>
#include <queue>
#include "tcp.h"
#include "messages.h"
#include "data.h"
#include "time.h"
namespace diamondapparatus {
/// this is the database the client writes stuff to from its thread
static std::map<std::string,Topic *> topics;
/// primary mutex
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
/// condition used in get-wait
static pthread_cond_t getcond = PTHREAD_COND_INITIALIZER;
static bool running=false;
inline void lock(const char *n){
dprintf("+++Attemping to lock: %s\n",n);
pthread_mutex_lock(&mutex);
}
inline void unlock(const char *n){
dprintf("---Unlocking: %s\n",n);
pthread_mutex_unlock(&mutex);
}
// the states the client can be in
enum ClientState {
ST_IDLE,
ST_AWAITACK
};
class MyClient : public TCPClient {
ClientState state;
public:
MyClient(const char *host,int port) : TCPClient(host,port){
state = ST_IDLE;
}
void setState(ClientState s){
dprintf("====> state = %d\n",s);
state = s;
}
// the topic I'm waiting for in get(), if any.
const char *waittopic;
void notify(const char *d){
dprintf("notify at %p\n",d);
const char *name = Topic::getNameFromMsg(d);
if(topics.find(std::string(name)) == topics.end()){
fprintf(stderr,"Topic %s not in client set, ignoring\n",name);
return;
}
Topic *t = topics[name];
t->fromMessage(d);
t->state =Topic::Changed;
t->timeLastSet = Time::now();
// if we were waiting for this, signal.
if(waittopic && !strcmp(name,waittopic)){
pthread_cond_signal(&getcond);
waittopic=NULL; // and zero the wait topic.
}
}
virtual void process(uint32_t packetsize,void *packet){
lock("msgrecv");
char *p = (char *)packet;
SCAck *ack;
uint32_t type = ntohl(*(uint32_t *)p);
dprintf("Packet type %d at %p\n",type,packet);
if(type == SC_KILLCLIENT){
fprintf(stderr,"force exit\n");
running=false;
}
switch(state){
case ST_IDLE:
if(type == SC_NOTIFY){
notify(p);
}
break;
case ST_AWAITACK:
ack = (SCAck *)p;
if(type != SC_ACK)
throw "unexpected packet in awaiting ack";
else if(ack->code){
dprintf("Ack code %d: %s\n",ntohs(ack->code),ack->msg);
throw "bad code from ack";
} else
dprintf("Acknowledged\n");
setState(ST_IDLE);
break;
}
unlock("msgrecv");
}
void subscribe(const char *name){
lock("subscribe");
StrMsg p;
p.type = htonl(CS_SUBSCRIBE);
strcpy(p.msg,name);
request(&p,sizeof(StrMsg));
//TODO - ADD TIMEOUT
setState(ST_AWAITACK);
unlock("subscribe");
}
void publish(const char *name,Topic& d){
lock("publish");
int size;
const char *p = d.toMessage(&size,CS_PUBLISH,name);
request(p,size);
//TODO - ADD TIMEOUT
setState(ST_AWAITACK);
free((void *)p);
unlock("publish");
}
void simpleMsg(int msg){
lock("smlmsg");
NoDataMsg p;
p.type = htonl(msg);
request(&p,sizeof(NoDataMsg));
unlock("smlmsg");
}
bool isIdle(){
lock("isidle");
bool e = (state == ST_IDLE);
dprintf("Is idle? state=%d, so %s\n",state,e?"true":"false");
unlock("isidle");
return e;
}
};
/*
*
*
* Threading stuff
*
*
*/
static pthread_t thread;
static MyClient *client;
static void *threadfunc(void *parameter){
running = true;
while(running){
// deal with requests
if(!client->update())break;
}
dprintf("LOOP EXITING\n");
delete client;
running = false;
};
static void waitForIdle(){
while(running && !client->isIdle()){
usleep(100000);
}
dprintf("Wait done, running=%s, isidle=%s\n",running?"T":"F",
client->isIdle()?"T":"F");
}
/*
*
*
* Interface code
*
*
*/
void init(){
// get environment data or defaults
const char *hn = getenv("DIAMOND_HOST");
char *hostname = NULL;
if(hn)hostname = strdup(hn);
const char *pr = getenv("DIAMOND_PORT");
int port = pr?atoi(pr):DEFAULTPORT;
client = new MyClient(hostname?hostname:"localhost",port);
pthread_create(&thread,NULL,threadfunc,NULL);
if(hostname)free(hostname);
while(!running){} // wait for thread
}
void destroy(){
running=false;// assume atomic :)
pthread_cond_destroy(&getcond);
pthread_mutex_destroy(&mutex);
}
void subscribe(const char *n){
if(!running)throw DiamondException("not connected");
Topic *t = new Topic();
topics[n]=t;
client->subscribe(n);
waitForIdle(); // wait for the ack
}
void publish(const char *name,Topic& t){
if(!running)throw DiamondException("not connected");
client->publish(name,t);
waitForIdle(); // wait for the ack
}
void killServer(){
if(!running)throw DiamondException("not connected");
client->simpleMsg(CS_KILLSERVER);
}
void clearServer(){
if(!running)throw DiamondException("not connected");
client->simpleMsg(CS_CLEARSERVER);
}
bool isRunning(){
return running;
}
Topic get(const char *n,int wait){
Topic rv;
if(!running){
rv.state = Topic::NotConnected;
return rv;
}
if(topics.find(n) == topics.end()){
// topic not subscribed to
rv.state = Topic::NotFound;
return rv;
}
// we are connected and subscribed to this topic
lock("gettopic");
Topic *t = topics[n];
if(t->state == Topic::NoData){
// if WaitAny, wait for data
if(wait == GetWaitAny){
dprintf("No data present : entering wait\n");
while(t->state == Topic::NoData){
client->waittopic = n;
// stalls until new data arrives, but unlocks mutex
pthread_cond_wait(&getcond,&mutex);
dprintf("Data apparently arrived!\n");
}
// should now have data and mutex locked again
} else {
rv.state = Topic::NotFound;
return rv;
}
}
if(wait == GetWaitNew){
while(t->state != Topic::Changed){
client->waittopic = n;
// stalls until new data arrives, but unlocks mutex
pthread_cond_wait(&getcond,&mutex);
}
// should now have data and mutex locked again
}
rv = *t;
t->state = Topic::Unchanged;
unlock("gettopic");
return rv;
}
}
<commit_msg>running flag and topics map now volatile (oops) and code altered to use non-vol ref when accessed. Seems to work in release now.<commit_after>/**
* @file clitest.cpp
* @brief Brief description of file.
*
*/
#include <pthread.h>
#include <string>
#include <map>
#include <queue>
#include "tcp.h"
#include "messages.h"
#include "data.h"
#include "time.h"
namespace diamondapparatus {
/// this is the database the client writes stuff to from its thread
typedef std::map<std::string,Topic *> TopicMap;
static volatile TopicMap topics;
/// primary mutex
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
/// condition used in get-wait
static pthread_cond_t getcond = PTHREAD_COND_INITIALIZER;
static bool volatile running=false;
inline void lock(const char *n){
dprintf("+++Attemping to lock: %s\n",n);
pthread_mutex_lock(&mutex);
}
inline void unlock(const char *n){
dprintf("---Unlocking: %s\n",n);
pthread_mutex_unlock(&mutex);
}
// the states the client can be in
enum ClientState {
ST_IDLE,
ST_AWAITACK
};
class MyClient : public TCPClient {
ClientState state;
public:
MyClient(const char *host,int port) : TCPClient(host,port){
state = ST_IDLE;
}
void setState(ClientState s){
dprintf("====> state = %d\n",s);
state = s;
}
// the topic I'm waiting for in get(), if any.
const char *waittopic;
void notify(const char *d){
dprintf("notify at %p\n",d);
const char *name = Topic::getNameFromMsg(d);
TopicMap& tm = (TopicMap &)topics; // lose the volatile
if(tm.find(std::string(name)) == tm.end()){
fprintf(stderr,"Topic %s not in client set, ignoring\n",name);
return;
}
Topic *t = tm[name];
t->fromMessage(d);
t->state =Topic::Changed;
t->timeLastSet = Time::now();
// if we were waiting for this, signal.
if(waittopic && !strcmp(name,waittopic)){
pthread_cond_signal(&getcond);
waittopic=NULL; // and zero the wait topic.
}
}
virtual void process(uint32_t packetsize,void *packet){
lock("msgrecv");
char *p = (char *)packet;
SCAck *ack;
uint32_t type = ntohl(*(uint32_t *)p);
dprintf("Packet type %d at %p\n",type,packet);
if(type == SC_KILLCLIENT){
fprintf(stderr,"force exit\n");
running=false;
}
switch(state){
case ST_IDLE:
if(type == SC_NOTIFY){
notify(p);
}
break;
case ST_AWAITACK:
ack = (SCAck *)p;
if(type != SC_ACK)
throw "unexpected packet in awaiting ack";
else if(ack->code){
dprintf("Ack code %d: %s\n",ntohs(ack->code),ack->msg);
throw "bad code from ack";
} else
dprintf("Acknowledged\n");
setState(ST_IDLE);
break;
}
unlock("msgrecv");
}
void subscribe(const char *name){
lock("subscribe");
Topic *t = new Topic();
TopicMap& tm = (TopicMap &)topics; // lose the volatile
tm[name]=t;
StrMsg p;
p.type = htonl(CS_SUBSCRIBE);
strcpy(p.msg,name);
request(&p,sizeof(StrMsg));
//TODO - ADD TIMEOUT
setState(ST_AWAITACK);
unlock("subscribe");
}
void publish(const char *name,Topic& d){
lock("publish");
int size;
const char *p = d.toMessage(&size,CS_PUBLISH,name);
request(p,size);
//TODO - ADD TIMEOUT
setState(ST_AWAITACK);
free((void *)p);
unlock("publish");
}
void simpleMsg(int msg){
lock("smlmsg");
NoDataMsg p;
p.type = htonl(msg);
request(&p,sizeof(NoDataMsg));
unlock("smlmsg");
}
bool isIdle(){
lock("isidle");
bool e = (state == ST_IDLE);
dprintf("Is idle? state=%d, so %s\n",state,e?"true":"false");
unlock("isidle");
return e;
}
};
/*
*
*
* Threading stuff
*
*
*/
static pthread_t thread;
static MyClient *client;
static void *threadfunc(void *parameter){
running = true;
dprintf("STARTED THREAD\n");
while(running){
// deal with requests
if(!client->update())break;
}
dprintf("LOOP EXITING\n");
delete client;
running = false;
};
static void waitForIdle(){
while(running && !client->isIdle()){
usleep(100000);
}
dprintf("Wait done, running=%s, isidle=%s\n",running?"T":"F",
client->isIdle()?"T":"F");
}
/*
*
*
* Interface code
*
*
*/
void init(){
// get environment data or defaults
const char *hn = getenv("DIAMOND_HOST");
char *hostname = NULL;
if(hn)hostname = strdup(hn);
const char *pr = getenv("DIAMOND_PORT");
int port = pr?atoi(pr):DEFAULTPORT;
client = new MyClient(hostname?hostname:"localhost",port);
pthread_create(&thread,NULL,threadfunc,NULL);
if(hostname)free(hostname);
while(!running){} // wait for thread
}
void destroy(){
running=false;// assume atomic :)
pthread_cond_destroy(&getcond);
pthread_mutex_destroy(&mutex);
}
void subscribe(const char *n){
if(!running)throw DiamondException("not connected");
client->subscribe(n);
waitForIdle(); // wait for the ack
}
void publish(const char *name,Topic& t){
if(!running)throw DiamondException("not connected");
client->publish(name,t);
waitForIdle(); // wait for the ack
}
void killServer(){
if(!running)throw DiamondException("not connected");
client->simpleMsg(CS_KILLSERVER);
}
void clearServer(){
if(!running)throw DiamondException("not connected");
client->simpleMsg(CS_CLEARSERVER);
}
bool isRunning(){
return running;
}
Topic get(const char *n,int wait){
Topic rv;
if(!running){
rv.state = Topic::NotConnected;
return rv;
}
lock("gettopic");
TopicMap& tm = (TopicMap &)topics; // lose the volatile
if(tm.find(n) == tm.end()){
// topic not subscribed to
rv.state = Topic::NotFound;
unlock("gettopic");
return rv;
}
// we are connected and subscribed to this topic
Topic *t = tm[n];
if(t->state == Topic::NoData){
// if WaitAny, wait for data
if(wait == GetWaitAny){
dprintf("No data present : entering wait\n");
while(t->state == Topic::NoData){
client->waittopic = n;
// stalls until new data arrives, but unlocks mutex
pthread_cond_wait(&getcond,&mutex);
dprintf("Data apparently arrived!\n");
}
// should now have data and mutex locked again
} else {
rv.state = Topic::NotFound;
return rv;
}
}
if(wait == GetWaitNew){
while(t->state != Topic::Changed){
client->waittopic = n;
// stalls until new data arrives, but unlocks mutex
pthread_cond_wait(&getcond,&mutex);
}
// should now have data and mutex locked again
}
rv = *t;
t->state = Topic::Unchanged;
unlock("gettopic");
return rv;
}
}
<|endoftext|> |
<commit_before>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <boost/lexical_cast.hpp>
#include "packet.h"
#define BUFSIZE 122
#define FILENAME "Testfile"
#define TEST_FILENAME "Testfile2"
#define PORT 10038
#define PAKSIZE 129
#define ACK 0
#define NAK 1
#define WIN_SIZE 16
using namespace std;
bool gremlin(Packet * pack, int corruptProb, int lossProb);
bool init(int argc, char** argv);
bool loadFile();
bool sendFile();
bool getFile();
char * recvPkt();
bool isvpack(unsigned char * p);
Packet createPacket(int index);
bool sendPacket();
bool isAck();
void handleAck();
void handleNak(int& x);
int seqNum;
int probCorrupt;
int probLoss;
string hs;
short int port;
char * file;
unsigned char* window[16]; //packet window
int base; //used to determine position in window of arriving packets
int length;
struct sockaddr_in a;
struct sockaddr_in sa;
socklen_t salen;
string fstr;
bool dropPck;
Packet p;
int delayT;
int s;
unsigned char b[BUFSIZE];
int main(int argc, char** argv) {
if(!init(argc, argv)) return -1;
if(sendto(s, "GET Testfile", BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
getFile();
return 0;
}
bool init(int argc, char** argv) {
base = 0; //initialize base
s = 0;
hs = string("131.204.14.") + argv[1]; /* Needs to be updated? Might be a string like "tux175.engr.auburn.edu." */
port = 10038; /* Can be any port within 10038-10041, inclusive. */
char* delayTStr = argv[2];
delayT = boost::lexical_cast<int>(delayTStr);
/*if(!loadFile()) {
cout << "Loading file failed. (filename FILENAME)" << endl;
return false;
}*/
if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
cout << "Socket creation failed. (socket s)" << endl;
return false;
}
memset((char *)&a, 0, sizeof(a));
a.sin_family = AF_INET;
a.sin_addr.s_addr = htonl(INADDR_ANY); //why does this always give us 0?
a.sin_port = htons(0);
if (bind(s, (struct sockaddr *)&a, sizeof(a)) < 0){
cout << "Socket binding failed. (socket s, address a)" << endl;
return false;
}
memset((char *)&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
inet_pton(AF_INET, hs.c_str(), &(sa.sin_addr));
cout << endl;
cout << "Server address (inet mode): " << inet_ntoa(sa.sin_addr) << endl;
cout << "Port: " << ntohs(sa.sin_port) << endl;
cout << endl << endl;
/*fstr = string(file);
cout << "File: " << endl << fstr << endl << endl;*/
seqNum = 0;
dropPck = false;
return true;
}
bool loadFile() {
ifstream is (FILENAME, ifstream::binary);
if(is) {
is.seekg(0, is.end);
length = is.tellg();
is.seekg(0, is.beg);
file = new char[length];
cout << "Reading " << length << " characters..." << endl;
is.read(file, length);
if(!is) { cout << "File reading failed. (filename " << FILENAME << "). Only " << is.gcount() << " could be read."; return false; }
is.close();
}
return true;
}
bool sendFile() {
for(int x = 0; x <= length / BUFSIZE; x++) {
p = createPacket(x);
if(!sendPacket()) continue;
if(isAck()) {
handleAck();
} else {
handleNak(x);
}
memset(b, 0, BUFSIZE);
}
return true;
}
Packet createPacket(int index){
cout << endl;
cout << "=== TRANSMISSION START" << endl;
string mstr = fstr.substr(index * BUFSIZE, BUFSIZE);
if(index * BUFSIZE + BUFSIZE > length) {
mstr[length - (index * BUFSIZE)] = '\0';
}
return Packet (seqNum, mstr.c_str());
}
bool sendPacket(){
int pc = probCorrupt; int pl = probLoss;
if((dropPck = gremlin(&p, pc, pl)) == false){
if(sendto(s, p.str(), BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
return true;
} else return false;
}
bool isAck() {
recvfrom(s, b, BUFSIZE + 7, 0, (struct sockaddr *)&sa, &salen);
cout << endl << "=== SERVER RESPONSE TEST" << endl;
cout << "Data: " << b << endl;
if(b[6] == '0') return true;
else return false;
}
void handleAck() {
}
void handleNak(int& x) {
char * sns = new char[2];
memcpy(sns, &b[0], 1);
sns[1] = '\0';
char * css = new char[5];
memcpy(css, &b[1], 5);
char * db = new char[BUFSIZE + 1];
memcpy(db, &b[2], BUFSIZE);
db[BUFSIZE] = '\0';
cout << "Sequence number: " << sns << endl;
cout << "Checksum: " << css << endl;
Packet pk (0, db);
pk.setSequenceNum(boost::lexical_cast<int>(sns));
pk.setCheckSum(boost::lexical_cast<int>(css));
if(!pk.chksm()) x--;
else x = (x - 2 > 0) ? x - 2 : 0;
}
bool gremlin(Packet * pack, int corruptProb, int lossProb){
bool dropPacket = false;
int r = rand() % 100;
cout << "Corruption probability: " << corruptProb << endl;
cout << "Random number: " << r << endl;
if(r <= (lossProb)){
dropPacket = true;
cout << "Dropped!" << endl;
}
else if(r <= (corruptProb)){
cout << "Corrupted!" << endl;
pack->loadDataBuffer((char*)"GREMLIN LOL");
}
else seqNum = (seqNum) ? false : true;
cout << "Seq. num: " << pack->getSequenceNum() << endl;
cout << "Checksum: " << pack->getCheckSum() << endl;
cout << "Message: " << pack->getDataBuffer() << endl;
return dropPacket;
}
bool isvpack(unsigned char * p) {
char * sns = new char[3];
memcpy(sns, &p[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &p[2], 5);
css[5] = '\0';
char * db = new char[BUFSIZE + 1];
memcpy(db, &p[8], BUFSIZE);
db[BUFSIZE] = '\0';
int sn = boost::lexical_cast<int>(sns);
int cs = boost::lexical_cast<int>(css);
Packet pk (0, db);
pk.setSequenceNum(sn);
cout << "base: " << base << endl;
cout << "sn: " << sn << endl;
cout << "base + WIN_SIZE: " << base + WIN_SIZE << endl;
if(!(sn >= (base % 32) && sn <= (base + WIN_SIZE) % 32 + WIN_SIZE)) return false;
if(cs != pk.generateCheckSum()) return false;
return true;
}
bool getFile(){
/* Loop forever, waiting for messages from a client. */
cout << "Waiting on port " << PORT << "..." << endl;
ofstream file("Dumpfile");
int rlen;
int ack;
for (;;) {
unsigned char packet[PAKSIZE + 1];
unsigned char dataPull[PAKSIZE - 7 + 1];
rlen = recvfrom(s, packet, PAKSIZE, 0, (struct sockaddr *)&sa, &salen);
for(int x = 0; x < PAKSIZE - 8; x++) {
dataPull[x] = packet[x + 8];
}
dataPull[PAKSIZE - 8] = '\0';
packet[PAKSIZE] = '\0';
if (rlen > 0) {
char * sns = new char[3];
memcpy(sns, &packet[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &packet[2], 5);
css[5] = '\0';
cout << endl << endl << "=== RECEIPT" << endl;
cout << "Seq. num: " << sns << endl;
cout << "Checksum: " << css << endl;
cout << "Received message: " << dataPull << endl;
int pid = boost::lexical_cast<int>(sns);
if(isvpack(packet)) {
if(pid == base) {
base++; //increment base of window
file << dataPull;
file.flush();
}
} else cout << "%%% ERROR IN PACKET " << pid << "%%%" << endl;
cout << "Sent response: ";
cout << "ACK " << base << endl;
if(packet[6] == '1') usleep(delayT*1000);
string wbs = to_string((long long)base);
const char * ackval = wbs.c_str();
if(sendto(s, ackval, 5, 0, (struct sockaddr *)&sa, salen) < 0) {
cout << "Acknowledgement failed. (socket s, acknowledgement message ack, client address ca, client address length calen)" << endl;
perror("sendto()");
return 0;
}
delete sns;
delete css;
}
}
file.close();
return true;
}
<commit_msg>I think this'll work<commit_after>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <boost/lexical_cast.hpp>
#include "packet.h"
#define BUFSIZE 122
#define FILENAME "Testfile"
#define TEST_FILENAME "Testfile2"
#define PORT 10038
#define PAKSIZE 129
#define ACK 0
#define NAK 1
#define WIN_SIZE 16
using namespace std;
bool gremlin(Packet * pack, int corruptProb, int lossProb);
bool init(int argc, char** argv);
bool loadFile();
bool sendFile();
bool getFile();
char * recvPkt();
bool isvpack(unsigned char * p);
Packet createPacket(int index);
bool sendPacket();
bool isAck();
void handleAck();
void handleNak(int& x);
int seqNum;
int probCorrupt;
int probLoss;
string hs;
short int port;
char * file;
unsigned char* window[16]; //packet window
int base; //used to determine position in window of arriving packets
int length;
struct sockaddr_in a;
struct sockaddr_in sa;
socklen_t salen;
string fstr;
bool dropPck;
Packet p;
int delayT;
int s;
unsigned char b[BUFSIZE];
int main(int argc, char** argv) {
if(!init(argc, argv)) return -1;
if(sendto(s, "GET Testfile", BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
getFile();
return 0;
}
bool init(int argc, char** argv) {
base = 0; //initialize base
s = 0;
hs = string("131.204.14.") + argv[1]; /* Needs to be updated? Might be a string like "tux175.engr.auburn.edu." */
port = 10038; /* Can be any port within 10038-10041, inclusive. */
char* delayTStr = argv[2];
delayT = boost::lexical_cast<int>(delayTStr);
/*if(!loadFile()) {
cout << "Loading file failed. (filename FILENAME)" << endl;
return false;
}*/
if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
cout << "Socket creation failed. (socket s)" << endl;
return false;
}
memset((char *)&a, 0, sizeof(a));
a.sin_family = AF_INET;
a.sin_addr.s_addr = htonl(INADDR_ANY); //why does this always give us 0?
a.sin_port = htons(0);
if (bind(s, (struct sockaddr *)&a, sizeof(a)) < 0){
cout << "Socket binding failed. (socket s, address a)" << endl;
return false;
}
memset((char *)&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
inet_pton(AF_INET, hs.c_str(), &(sa.sin_addr));
cout << endl;
cout << "Server address (inet mode): " << inet_ntoa(sa.sin_addr) << endl;
cout << "Port: " << ntohs(sa.sin_port) << endl;
cout << endl << endl;
/*fstr = string(file);
cout << "File: " << endl << fstr << endl << endl;*/
seqNum = 0;
dropPck = false;
return true;
}
bool loadFile() {
ifstream is (FILENAME, ifstream::binary);
if(is) {
is.seekg(0, is.end);
length = is.tellg();
is.seekg(0, is.beg);
file = new char[length];
cout << "Reading " << length << " characters..." << endl;
is.read(file, length);
if(!is) { cout << "File reading failed. (filename " << FILENAME << "). Only " << is.gcount() << " could be read."; return false; }
is.close();
}
return true;
}
bool sendFile() {
for(int x = 0; x <= length / BUFSIZE; x++) {
p = createPacket(x);
if(!sendPacket()) continue;
if(isAck()) {
handleAck();
} else {
handleNak(x);
}
memset(b, 0, BUFSIZE);
}
return true;
}
Packet createPacket(int index){
cout << endl;
cout << "=== TRANSMISSION START" << endl;
string mstr = fstr.substr(index * BUFSIZE, BUFSIZE);
if(index * BUFSIZE + BUFSIZE > length) {
mstr[length - (index * BUFSIZE)] = '\0';
}
return Packet (seqNum, mstr.c_str());
}
bool sendPacket(){
int pc = probCorrupt; int pl = probLoss;
if((dropPck = gremlin(&p, pc, pl)) == false){
if(sendto(s, p.str(), BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
return true;
} else return false;
}
bool isAck() {
recvfrom(s, b, BUFSIZE + 7, 0, (struct sockaddr *)&sa, &salen);
cout << endl << "=== SERVER RESPONSE TEST" << endl;
cout << "Data: " << b << endl;
if(b[6] == '0') return true;
else return false;
}
void handleAck() {
}
void handleNak(int& x) {
char * sns = new char[2];
memcpy(sns, &b[0], 1);
sns[1] = '\0';
char * css = new char[5];
memcpy(css, &b[1], 5);
char * db = new char[BUFSIZE + 1];
memcpy(db, &b[2], BUFSIZE);
db[BUFSIZE] = '\0';
cout << "Sequence number: " << sns << endl;
cout << "Checksum: " << css << endl;
Packet pk (0, db);
pk.setSequenceNum(boost::lexical_cast<int>(sns));
pk.setCheckSum(boost::lexical_cast<int>(css));
if(!pk.chksm()) x--;
else x = (x - 2 > 0) ? x - 2 : 0;
}
bool gremlin(Packet * pack, int corruptProb, int lossProb){
bool dropPacket = false;
int r = rand() % 100;
cout << "Corruption probability: " << corruptProb << endl;
cout << "Random number: " << r << endl;
if(r <= (lossProb)){
dropPacket = true;
cout << "Dropped!" << endl;
}
else if(r <= (corruptProb)){
cout << "Corrupted!" << endl;
pack->loadDataBuffer((char*)"GREMLIN LOL");
}
else seqNum = (seqNum) ? false : true;
cout << "Seq. num: " << pack->getSequenceNum() << endl;
cout << "Checksum: " << pack->getCheckSum() << endl;
cout << "Message: " << pack->getDataBuffer() << endl;
return dropPacket;
}
bool isvpack(unsigned char * p) {
char * sns = new char[3];
memcpy(sns, &p[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &p[2], 5);
css[5] = '\0';
char * db = new char[BUFSIZE + 1];
memcpy(db, &p[8], BUFSIZE);
db[BUFSIZE] = '\0';
int sn = boost::lexical_cast<int>(sns);
int cs = boost::lexical_cast<int>(css);
Packet pk (0, db);
pk.setSequenceNum(sn);
cout << "base: " << base << endl;
cout << "sn: " << sn << endl;
cout << "base + WIN_SIZE: " << base + WIN_SIZE << endl;
if(!(sn >= (base % 32) && sn <= ((base + WIN_SIZE) % 32 + WIN_SIZE) + 1)) return false;
if(cs != pk.generateCheckSum()) return false;
return true;
}
bool getFile(){
/* Loop forever, waiting for messages from a client. */
cout << "Waiting on port " << PORT << "..." << endl;
ofstream file("Dumpfile");
int rlen;
int ack;
for (;;) {
unsigned char packet[PAKSIZE + 1];
unsigned char dataPull[PAKSIZE - 7 + 1];
rlen = recvfrom(s, packet, PAKSIZE, 0, (struct sockaddr *)&sa, &salen);
for(int x = 0; x < PAKSIZE - 8; x++) {
dataPull[x] = packet[x + 8];
}
dataPull[PAKSIZE - 8] = '\0';
packet[PAKSIZE] = '\0';
if (rlen > 0) {
char * sns = new char[3];
memcpy(sns, &packet[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &packet[2], 5);
css[5] = '\0';
cout << endl << endl << "=== RECEIPT" << endl;
cout << "Seq. num: " << sns << endl;
cout << "Checksum: " << css << endl;
cout << "Received message: " << dataPull << endl;
int pid = boost::lexical_cast<int>(sns);
if(isvpack(packet)) {
if(pid == base) {
base++; //increment base of window
file << dataPull;
file.flush();
}
} else cout << "%%% ERROR IN PACKET " << pid << "%%%" << endl;
cout << "Sent response: ";
cout << "ACK " << base << endl;
if(packet[6] == '1') usleep(delayT*1000);
string wbs = to_string((long long)base);
const char * ackval = wbs.c_str();
if(sendto(s, ackval, 5, 0, (struct sockaddr *)&sa, salen) < 0) {
cout << "Acknowledgement failed. (socket s, acknowledgement message ack, client address ca, client address length calen)" << endl;
perror("sendto()");
return 0;
}
delete sns;
delete css;
}
}
file.close();
return true;
}
<|endoftext|> |
<commit_before>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <boost/lexical_cast.hpp>
#include "packet.h"
#define BUFSIZE 122
#define FILENAME "Testfile"
#define TEST_FILENAME "Testfile2"
#define PORT 10038
#define PAKSIZE 129
#define ACK 0
#define NAK 1
#define WIN_SIZE 16
using namespace std;
bool gremlin(Packet * pack, int corruptProb, int lossProb);
bool init(int argc, char** argv);
bool loadFile();
bool sendFile();
bool getFile();
char * recvPkt();
bool isvpack(unsigned char * p);
Packet createPacket(int index);
bool sendPacket();
bool isAck();
void handleAck();
void handleNak(int& x);
int seqNum;
int probCorrupt;
int probLoss;
string hs;
short int port;
char * file;
unsigned char* window[16]; //packet window
int base; //used to determine position in window of arriving packets
int length;
struct sockaddr_in a;
struct sockaddr_in sa;
socklen_t salen;
string fstr;
bool dropPck;
Packet p;
int delayT;
int s;
unsigned char b[BUFSIZE];
int main(int argc, char** argv) {
if(!init(argc, argv)) return -1;
if(sendto(s, "GET Testfile", BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
getFile();
return 0;
}
bool init(int argc, char** argv) {
base = 0; //initialize base
s = 0;
hs = string("131.204.14.") + argv[1]; /* Needs to be updated? Might be a string like "tux175.engr.auburn.edu." */
port = 10038; /* Can be any port within 10038-10041, inclusive. */
char* delayTStr = argv[2];
delayT = boost::lexical_cast<int>(delayTStr);
/*if(!loadFile()) {
cout << "Loading file failed. (filename FILENAME)" << endl;
return false;
}*/
if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
cout << "Socket creation failed. (socket s)" << endl;
return false;
}
memset((char *)&a, 0, sizeof(a));
a.sin_family = AF_INET;
a.sin_addr.s_addr = htonl(INADDR_ANY); //why does this always give us 0?
a.sin_port = htons(0);
if (bind(s, (struct sockaddr *)&a, sizeof(a)) < 0){
cout << "Socket binding failed. (socket s, address a)" << endl;
return false;
}
memset((char *)&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
inet_pton(AF_INET, hs.c_str(), &(sa.sin_addr));
cout << endl;
cout << "Server address (inet mode): " << inet_ntoa(sa.sin_addr) << endl;
cout << "Port: " << ntohs(sa.sin_port) << endl;
cout << endl << endl;
/*fstr = string(file);
cout << "File: " << endl << fstr << endl << endl;*/
seqNum = 0;
dropPck = false;
return true;
}
bool loadFile() {
ifstream is (FILENAME, ifstream::binary);
if(is) {
is.seekg(0, is.end);
length = is.tellg();
is.seekg(0, is.beg);
file = new char[length];
cout << "Reading " << length << " characters..." << endl;
is.read(file, length);
if(!is) { cout << "File reading failed. (filename " << FILENAME << "). Only " << is.gcount() << " could be read."; return false; }
is.close();
}
return true;
}
bool sendFile() {
for(int x = 0; x <= length / BUFSIZE; x++) {
p = createPacket(x);
if(!sendPacket()) continue;
if(isAck()) {
handleAck();
} else {
handleNak(x);
}
memset(b, 0, BUFSIZE);
}
return true;
}
Packet createPacket(int index){
cout << endl;
cout << "=== TRANSMISSION START" << endl;
string mstr = fstr.substr(index * BUFSIZE, BUFSIZE);
if(index * BUFSIZE + BUFSIZE > length) {
mstr[length - (index * BUFSIZE)] = '\0';
}
return Packet (seqNum, mstr.c_str());
}
bool sendPacket(){
int pc = probCorrupt; int pl = probLoss;
if((dropPck = gremlin(&p, pc, pl)) == false){
if(sendto(s, p.str(), BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
return true;
} else return false;
}
bool isAck() {
recvfrom(s, b, BUFSIZE + 7, 0, (struct sockaddr *)&sa, &salen);
cout << endl << "=== SERVER RESPONSE TEST" << endl;
cout << "Data: " << b << endl;
if(b[6] == '0') return true;
else return false;
}
void handleAck() {
}
void handleNak(int& x) {
char * sns = new char[2];
memcpy(sns, &b[0], 1);
sns[1] = '\0';
char * css = new char[5];
memcpy(css, &b[1], 5);
char * db = new char[BUFSIZE + 1];
memcpy(db, &b[2], BUFSIZE);
db[BUFSIZE] = '\0';
cout << "Sequence number: " << sns << endl;
cout << "Checksum: " << css << endl;
Packet pk (0, db);
pk.setSequenceNum(boost::lexical_cast<int>(sns));
pk.setCheckSum(boost::lexical_cast<int>(css));
if(!pk.chksm()) x--;
else x = (x - 2 > 0) ? x - 2 : 0;
}
bool gremlin(Packet * pack, int corruptProb, int lossProb){
bool dropPacket = false;
int r = rand() % 100;
cout << "Corruption probability: " << corruptProb << endl;
cout << "Random number: " << r << endl;
if(r <= (lossProb)){
dropPacket = true;
cout << "Dropped!" << endl;
}
else if(r <= (corruptProb)){
cout << "Corrupted!" << endl;
pack->loadDataBuffer((char*)"GREMLIN LOL");
}
else seqNum = (seqNum) ? false : true;
cout << "Seq. num: " << pack->getSequenceNum() << endl;
cout << "Checksum: " << pack->getCheckSum() << endl;
cout << "Message: " << pack->getDataBuffer() << endl;
return dropPacket;
}
bool isvpack(unsigned char * p) {
char * sns = new char[3];
memcpy(sns, &p[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &p[2], 5);
css[5] = '\0';
char * db = new char[BUFSIZE + 1];
memcpy(db, &p[8], BUFSIZE);
db[BUFSIZE] = '\0';
int sn = boost::lexical_cast<int>(sns);
int cs = boost::lexical_cast<int>(css);
Packet pk (0, db);
pk.setSequenceNum(sn);
if(!(sn >= (base % 32) && sn <= (base % 32) + WIN_SIZE - 1)) { cout << "Bad sequence number." << endl; return false; }
if(cs != pk.generateCheckSum()) { cout << "Bad checksum." << endl; return false; }
return true;
}
bool getFile(){
/* Loop forever, waiting for messages from a client. */
cout << "Waiting on port " << PORT << "..." << endl;
ofstream file("Dumpfile");
int rlen;
int ack;
for (;;) {
unsigned char packet[PAKSIZE + 1];
unsigned char dataPull[BUFSIZE];
rlen = recvfrom(s, packet, PAKSIZE + 1, 0, (struct sockaddr *)&sa, &salen);
cout << "packet[0] is null terminator: " << packet[0] == '\0' << endl;
if(packet == '\0') break;
for(int x = 0; x < BUFSIZE; x++) {
dataPull[x] = packet[x + 8];
}
dataPull[BUFSIZE] = '\0';
if (rlen > 0) {
char * sns = new char[3];
memcpy(sns, &packet[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &packet[2], 5);
css[5] = '\0';
cout << endl << endl << "=== RECEIPT" << endl;
cout << "Seq. num: " << sns << endl;
cout << "Checksum: " << css << endl;
cout << "Received message: " << dataPull << endl;
int pid = boost::lexical_cast<int>(sns);
if(isvpack(packet)) {
if(pid == base % 32) {
base++; //increment base of window
file << dataPull;
file.flush();
}
} else cout << "%%% ERROR IN PACKET " << pid << "%%%" << endl;
cout << "Sent response: ";
cout << "ACK " << base << endl;
if(packet[6] == '1') usleep(delayT*1000);
string wbs = to_string((long long)base);
const char * ackval = wbs.c_str();
if(sendto(s, ackval, 10, 0, (struct sockaddr *)&sa, salen) < 0) {
cout << "Acknowledgement failed. (socket s, acknowledgement message ack, client address ca, client address length calen)" << endl;
perror("sendto()");
return 0;
}
delete sns;
delete css;
}
}
cout << "GET Testfile into Dumpfile complete." << endl;
file.close();
return true;
}
<commit_msg>Fix test<commit_after>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <boost/lexical_cast.hpp>
#include "packet.h"
#define BUFSIZE 122
#define FILENAME "Testfile"
#define TEST_FILENAME "Testfile2"
#define PORT 10038
#define PAKSIZE 129
#define ACK 0
#define NAK 1
#define WIN_SIZE 16
using namespace std;
bool gremlin(Packet * pack, int corruptProb, int lossProb);
bool init(int argc, char** argv);
bool loadFile();
bool sendFile();
bool getFile();
char * recvPkt();
bool isvpack(unsigned char * p);
Packet createPacket(int index);
bool sendPacket();
bool isAck();
void handleAck();
void handleNak(int& x);
int seqNum;
int probCorrupt;
int probLoss;
string hs;
short int port;
char * file;
unsigned char* window[16]; //packet window
int base; //used to determine position in window of arriving packets
int length;
struct sockaddr_in a;
struct sockaddr_in sa;
socklen_t salen;
string fstr;
bool dropPck;
Packet p;
int delayT;
int s;
unsigned char b[BUFSIZE];
int main(int argc, char** argv) {
if(!init(argc, argv)) return -1;
if(sendto(s, "GET Testfile", BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
getFile();
return 0;
}
bool init(int argc, char** argv) {
base = 0; //initialize base
s = 0;
hs = string("131.204.14.") + argv[1]; /* Needs to be updated? Might be a string like "tux175.engr.auburn.edu." */
port = 10038; /* Can be any port within 10038-10041, inclusive. */
char* delayTStr = argv[2];
delayT = boost::lexical_cast<int>(delayTStr);
/*if(!loadFile()) {
cout << "Loading file failed. (filename FILENAME)" << endl;
return false;
}*/
if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
cout << "Socket creation failed. (socket s)" << endl;
return false;
}
memset((char *)&a, 0, sizeof(a));
a.sin_family = AF_INET;
a.sin_addr.s_addr = htonl(INADDR_ANY); //why does this always give us 0?
a.sin_port = htons(0);
if (bind(s, (struct sockaddr *)&a, sizeof(a)) < 0){
cout << "Socket binding failed. (socket s, address a)" << endl;
return false;
}
memset((char *)&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
inet_pton(AF_INET, hs.c_str(), &(sa.sin_addr));
cout << endl;
cout << "Server address (inet mode): " << inet_ntoa(sa.sin_addr) << endl;
cout << "Port: " << ntohs(sa.sin_port) << endl;
cout << endl << endl;
/*fstr = string(file);
cout << "File: " << endl << fstr << endl << endl;*/
seqNum = 0;
dropPck = false;
return true;
}
bool loadFile() {
ifstream is (FILENAME, ifstream::binary);
if(is) {
is.seekg(0, is.end);
length = is.tellg();
is.seekg(0, is.beg);
file = new char[length];
cout << "Reading " << length << " characters..." << endl;
is.read(file, length);
if(!is) { cout << "File reading failed. (filename " << FILENAME << "). Only " << is.gcount() << " could be read."; return false; }
is.close();
}
return true;
}
bool sendFile() {
for(int x = 0; x <= length / BUFSIZE; x++) {
p = createPacket(x);
if(!sendPacket()) continue;
if(isAck()) {
handleAck();
} else {
handleNak(x);
}
memset(b, 0, BUFSIZE);
}
return true;
}
Packet createPacket(int index){
cout << endl;
cout << "=== TRANSMISSION START" << endl;
string mstr = fstr.substr(index * BUFSIZE, BUFSIZE);
if(index * BUFSIZE + BUFSIZE > length) {
mstr[length - (index * BUFSIZE)] = '\0';
}
return Packet (seqNum, mstr.c_str());
}
bool sendPacket(){
int pc = probCorrupt; int pl = probLoss;
if((dropPck = gremlin(&p, pc, pl)) == false){
if(sendto(s, p.str(), BUFSIZE + 7, 0, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
cout << "Package sending failed. (socket s, server address sa, message m)" << endl;
return false;
}
return true;
} else return false;
}
bool isAck() {
recvfrom(s, b, BUFSIZE + 7, 0, (struct sockaddr *)&sa, &salen);
cout << endl << "=== SERVER RESPONSE TEST" << endl;
cout << "Data: " << b << endl;
if(b[6] == '0') return true;
else return false;
}
void handleAck() {
}
void handleNak(int& x) {
char * sns = new char[2];
memcpy(sns, &b[0], 1);
sns[1] = '\0';
char * css = new char[5];
memcpy(css, &b[1], 5);
char * db = new char[BUFSIZE + 1];
memcpy(db, &b[2], BUFSIZE);
db[BUFSIZE] = '\0';
cout << "Sequence number: " << sns << endl;
cout << "Checksum: " << css << endl;
Packet pk (0, db);
pk.setSequenceNum(boost::lexical_cast<int>(sns));
pk.setCheckSum(boost::lexical_cast<int>(css));
if(!pk.chksm()) x--;
else x = (x - 2 > 0) ? x - 2 : 0;
}
bool gremlin(Packet * pack, int corruptProb, int lossProb){
bool dropPacket = false;
int r = rand() % 100;
cout << "Corruption probability: " << corruptProb << endl;
cout << "Random number: " << r << endl;
if(r <= (lossProb)){
dropPacket = true;
cout << "Dropped!" << endl;
}
else if(r <= (corruptProb)){
cout << "Corrupted!" << endl;
pack->loadDataBuffer((char*)"GREMLIN LOL");
}
else seqNum = (seqNum) ? false : true;
cout << "Seq. num: " << pack->getSequenceNum() << endl;
cout << "Checksum: " << pack->getCheckSum() << endl;
cout << "Message: " << pack->getDataBuffer() << endl;
return dropPacket;
}
bool isvpack(unsigned char * p) {
char * sns = new char[3];
memcpy(sns, &p[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &p[2], 5);
css[5] = '\0';
char * db = new char[BUFSIZE + 1];
memcpy(db, &p[8], BUFSIZE);
db[BUFSIZE] = '\0';
int sn = boost::lexical_cast<int>(sns);
int cs = boost::lexical_cast<int>(css);
Packet pk (0, db);
pk.setSequenceNum(sn);
if(!(sn >= (base % 32) && sn <= (base % 32) + WIN_SIZE - 1)) { cout << "Bad sequence number." << endl; return false; }
if(cs != pk.generateCheckSum()) { cout << "Bad checksum." << endl; return false; }
return true;
}
bool getFile(){
/* Loop forever, waiting for messages from a client. */
cout << "Waiting on port " << PORT << "..." << endl;
ofstream file("Dumpfile");
int rlen;
int ack;
for (;;) {
unsigned char packet[PAKSIZE + 1];
unsigned char dataPull[BUFSIZE];
rlen = recvfrom(s, packet, PAKSIZE + 1, 0, (struct sockaddr *)&sa, &salen);
cout << "packet[0] is null terminator: " << (packet[0] == '\0') << endl;
if(packet == '\0') break;
for(int x = 0; x < BUFSIZE; x++) {
dataPull[x] = packet[x + 8];
}
dataPull[BUFSIZE] = '\0';
if (rlen > 0) {
char * sns = new char[3];
memcpy(sns, &packet[0], 3);
sns[2] = '\0';
char * css = new char[6];
memcpy(css, &packet[2], 5);
css[5] = '\0';
cout << endl << endl << "=== RECEIPT" << endl;
cout << "Seq. num: " << sns << endl;
cout << "Checksum: " << css << endl;
cout << "Received message: " << dataPull << endl;
int pid = boost::lexical_cast<int>(sns);
if(isvpack(packet)) {
if(pid == base % 32) {
base++; //increment base of window
file << dataPull;
file.flush();
}
} else cout << "%%% ERROR IN PACKET " << pid << "%%%" << endl;
cout << "Sent response: ";
cout << "ACK " << base << endl;
if(packet[6] == '1') usleep(delayT*1000);
string wbs = to_string((long long)base);
const char * ackval = wbs.c_str();
if(sendto(s, ackval, 10, 0, (struct sockaddr *)&sa, salen) < 0) {
cout << "Acknowledgement failed. (socket s, acknowledgement message ack, client address ca, client address length calen)" << endl;
perror("sendto()");
return 0;
}
delete sns;
delete css;
}
}
cout << "GET Testfile into Dumpfile complete." << endl;
file.close();
return true;
}
<|endoftext|> |
<commit_before>#include "core/table.h"
#include "catch.hpp"
TEST_CASE("table-from_csv_default", "[table]")
{
const auto firstcol = Column{"a", "1"};
const auto firstcolstring = Column{"a b", "1"};
const auto secondcol = Column{"b", "2"};
SECTION("not ending with newline")
{
const auto table = TableFromCsv("a,b\n1,2");
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("ending with newlines")
{
const auto table = TableFromCsv("a,b\n\n\n1,2\n\n");
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("strings")
{
const auto table = TableFromCsv("\"a b\",b\n1,2");
REQUIRE(table.size()==2);
CHECK(table[0] == firstcolstring);
CHECK(table[1] == secondcol);
}
SECTION("not ending strings single col")
{
const auto table = TableFromCsv("\"a b");
const auto errorcol = Column{"a b"};
REQUIRE(table.size()==1);
CHECK(table[0] == errorcol);
}
SECTION("not ending strings 2 cols")
{
const auto table = TableFromCsv("err,\"a b");
const auto errorcol1 = Column{"err"};
const auto errorcol2 = Column{"a b"};
REQUIRE(table.size()==2);
CHECK(table[0] == errorcol1);
CHECK(table[1] == errorcol2);
}
SECTION("string with quote")
{
const auto table = TableFromCsv("\"a \"\" b\"");
const auto col = Column{"a \" b"};
REQUIRE(table.size()==1);
CHECK(table[0] == col);
}
}
TEST_CASE("table-from_csv_not_default", "[table]")
{
const auto firstcol = Column{"a", "1"};
const auto firstcolstring = Column{"a b", "1"};
const auto secondcol = Column{"b", "2"};
const auto comma = 'c';
const auto string = 's';
SECTION("not ending with newline")
{
const auto table = TableFromCsv("acb\n1c2", comma, string);
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("ending with newlines")
{
const auto table = TableFromCsv("acb\n\n\n1c2\n\n", comma, string);
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("strings")
{
const auto table = TableFromCsv("sa bscb\n1c2", comma, string);
REQUIRE(table.size()==2);
CHECK(table[0] == firstcolstring);
CHECK(table[1] == secondcol);
}
SECTION("not ending strings single col")
{
const auto table = TableFromCsv("sa b", comma, string);
const auto errorcol = Column{"a b"};
REQUIRE(table.size()==1);
CHECK(table[0] == errorcol);
}
SECTION("not ending strings 2 cols")
{
const auto table = TableFromCsv("errcsa b", comma, string);
const auto errorcol1 = Column{"err"};
const auto errorcol2 = Column{"a b"};
REQUIRE(table.size()==2);
CHECK(table[0] == errorcol1);
CHECK(table[1] == errorcol2);
}
SECTION("string with quote")
{
const auto table = TableFromCsv("sa ss bs", comma, string);
const auto col = Column{"a s b"};
REQUIRE(table.size()==1);
CHECK(table[0] == col);
}
}
<commit_msg>table generator test<commit_after>#include "core/table.h"
#include "catch.hpp"
TEST_CASE("table-generator", "[table]")
{
struct Person { std::string first; std::string last; } ;
const auto persons = std::vector<Person> {
Person{"Jerry", "Seinfeld"},
Person{"Elaine", "Benes"},
Person{"Cosmo", "Kramer"},
Person{"George", "Costanza"}
};
SECTION("first and last names")
{
const auto table = TableGenerator<Person>(persons)
.Add("First name", [](const Person& p) -> std::string {return p.first;} )
.Add("Last name", [](const Person& p) -> std::string {return p.last;} )
.table;
REQUIRE(table.size() == 2);
const auto first = Column{"First name", "Jerry", "Elaine", "Cosmo", "George"};
const auto last = Column{"Last name", "Seinfeld", "Benes", "Kramer", "Costanza"};
CHECK(table[0]==first);
CHECK(table[1]==last);
// todo: add print tests
// PrintTable(std::cout, table);
}
}
TEST_CASE("table-from_csv_default", "[table]")
{
const auto firstcol = Column{"a", "1"};
const auto firstcolstring = Column{"a b", "1"};
const auto secondcol = Column{"b", "2"};
SECTION("not ending with newline")
{
const auto table = TableFromCsv("a,b\n1,2");
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("ending with newlines")
{
const auto table = TableFromCsv("a,b\n\n\n1,2\n\n");
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("strings")
{
const auto table = TableFromCsv("\"a b\",b\n1,2");
REQUIRE(table.size()==2);
CHECK(table[0] == firstcolstring);
CHECK(table[1] == secondcol);
}
SECTION("not ending strings single col")
{
const auto table = TableFromCsv("\"a b");
const auto errorcol = Column{"a b"};
REQUIRE(table.size()==1);
CHECK(table[0] == errorcol);
}
SECTION("not ending strings 2 cols")
{
const auto table = TableFromCsv("err,\"a b");
const auto errorcol1 = Column{"err"};
const auto errorcol2 = Column{"a b"};
REQUIRE(table.size()==2);
CHECK(table[0] == errorcol1);
CHECK(table[1] == errorcol2);
}
SECTION("string with quote")
{
const auto table = TableFromCsv("\"a \"\" b\"");
const auto col = Column{"a \" b"};
REQUIRE(table.size()==1);
CHECK(table[0] == col);
}
}
TEST_CASE("table-from_csv_not_default", "[table]")
{
const auto firstcol = Column{"a", "1"};
const auto firstcolstring = Column{"a b", "1"};
const auto secondcol = Column{"b", "2"};
const auto comma = 'c';
const auto string = 's';
SECTION("not ending with newline")
{
const auto table = TableFromCsv("acb\n1c2", comma, string);
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("ending with newlines")
{
const auto table = TableFromCsv("acb\n\n\n1c2\n\n", comma, string);
REQUIRE(table.size()==2);
CHECK(table[0] == firstcol);
CHECK(table[1] == secondcol);
}
SECTION("strings")
{
const auto table = TableFromCsv("sa bscb\n1c2", comma, string);
REQUIRE(table.size()==2);
CHECK(table[0] == firstcolstring);
CHECK(table[1] == secondcol);
}
SECTION("not ending strings single col")
{
const auto table = TableFromCsv("sa b", comma, string);
const auto errorcol = Column{"a b"};
REQUIRE(table.size()==1);
CHECK(table[0] == errorcol);
}
SECTION("not ending strings 2 cols")
{
const auto table = TableFromCsv("errcsa b", comma, string);
const auto errorcol1 = Column{"err"};
const auto errorcol2 = Column{"a b"};
REQUIRE(table.size()==2);
CHECK(table[0] == errorcol1);
CHECK(table[1] == errorcol2);
}
SECTION("string with quote")
{
const auto table = TableFromCsv("sa ss bs", comma, string);
const auto col = Column{"a s b"};
REQUIRE(table.size()==1);
CHECK(table[0] == col);
}
}
<|endoftext|> |
<commit_before>#include "mainwindow.h"
#include <QApplication>
#include <QSplashScreen>
#include <QThread>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
QSplashScreen *splash = new QSplashScreen(QPixmap("ucm.png"),Qt::WindowStaysOnTopHint | Qt::SplashScreen);
splash->show();
//splash->showMessage("Iniciando ventana principal ...");
w.upOctave();
//splash->showMessage("Cargando modulos ...", Qt::TopRightSection, Qt::white);
//splash->showMessage("Estableciendo conexiones ...", Qt::AlignRight | Qt::AlignTop,Qt::white);
QThread::sleep(5);
w.show();
splash->finish(&w);
delete splash;
return a.exec();
}
<commit_msg>proyecto<commit_after>#include "mainwindow.h"
#include <QApplication>
#include <QSplashScreen>
#include <QThread>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
QSplashScreen *splash = new QSplashScreen(QPixmap("/home/cesar/Git/appSignal/ucm.png"),Qt::WindowStaysOnTopHint | Qt::SplashScreen);
splash->show();
//splash->showMessage("Iniciando ventana principal ...");
w.upOctave();
//splash->showMessage("Cargando modulos ...", Qt::TopRightSection, Qt::white);
//splash->showMessage("Estableciendo conexiones ...", Qt::AlignRight | Qt::AlignTop,Qt::white);
QThread::sleep(5);
w.show();
splash->finish(&w);
delete splash;
return a.exec();
}
<|endoftext|> |
<commit_before>// TasksFrame.cpp : implmentation of the CTasksFrame class
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#include "aboutdlg.h"
#include "TasksView.h"
#include "TasksFrame.h"
#include <jira/jira.hpp>
#include <jira/server.hpp>
#include <net/utf8.hpp>
#include <net/xhr.hpp>
#include <sstream>
#include <thread>
#include "AppSettings.h"
#include "wincrypt.h"
#pragma comment(lib, "crypt32.lib")
std::string contents(LPCWSTR path)
{
std::unique_ptr<FILE, decltype(&fclose)> f{ _wfopen(path, L"r"), fclose };
if (!f)
return std::string();
std::string out;
char buffer[8192];
int read = 0;
while ((read = fread(buffer, 1, sizeof(buffer), f.get())) > 0)
out.append(buffer, buffer + read);
return out;
}
void print(FILE* f, const std::string& s)
{
fwrite(s.c_str(), 1, s.length(), f);
}
void print(FILE* f, const char* s)
{
if (!s)
return;
fwrite(s, 1, strlen(s), f);
}
template <size_t length>
void print(FILE* f, const char(&s)[length])
{
if (!s)
return;
fwrite(s, 1, strlen(s), f);
}
BOOL CTasksFrame::PreTranslateMessage(MSG* pMsg)
{
if (CFameSuper::PreTranslateMessage(pMsg))
return TRUE;
return m_view.PreTranslateMessage(pMsg);
}
BOOL CTasksFrame::OnIdle()
{
UIUpdateToolBar();
return FALSE;
}
LRESULT CTasksFrame::OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
// Check if Common Controls 6.0 are used. If yes, use 32-bit (alpha) images
// for the toolbar and command bar. If not, use the old, 4-bit images.
UINT uResID = IDR_MAINFRAME_OLD;
DWORD dwMajor = 0;
DWORD dwMinor = 0;
HRESULT hRet = AtlGetCommCtrlVersion(&dwMajor, &dwMinor);
if (SUCCEEDED(hRet) && dwMajor >= 6)
uResID = IDR_MAINFRAME;
CreateSimpleToolBar(uResID);
m_view.m_model = m_model;
m_hWndClient = m_view.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0);
m_font = AtlCreateControlFont();
m_view.SetFont(m_font);
// register object for message filtering and idle updates
CMessageLoop* pLoop = _Module.GetMessageLoop();
ATLASSERT(pLoop != NULL);
pLoop->AddMessageFilter(this);
pLoop->AddIdleHandler(this);
m_taskIcon.Install(m_hWnd, 1, IDR_TASKBAR);
auto hwnd = m_hWnd;
m_model->startup();
#if 0
for (auto& server : m_servers) {
auto url = server->url();
auto jql = server->view().jql().empty() ? jira::search_def::standard.jql() : server->view().jql();
server->search([hwnd, url, server, jql](int status, jira::report&& dataset) {
std::ostringstream o;
std::unique_ptr<FILE, decltype(&fclose)> f{ fopen("issues.html", "w"), fclose };
if (!f)
return;
print(f.get(), R"(<style>
body, td, tr {
font-family: Arial, sans-serif;
font-size: 12px
}
a {
color: #3b73af;
text-decoration: none;
}
a:hover {
text-decoration: underline;
}
</style>
)");
o << "<h1>" << url << "</h1>\n"
<< "<p>Response status: " << status << "</p>\n"
<< "<p>Query: <code>" << jql << "</code></p>\n"
<< "<p>Issues " << (dataset.startAt + 1)
<< '-' << (dataset.startAt + dataset.data.size())
<< " of " << dataset.total << ":</p>\n<table>\n";
print(f.get(), o.str()); o.str("");
{
print(f.get(), " <tr>\n <th>");
bool first = true;
for (auto& col : dataset.schema.cols()) {
if (first) first = false;
else print(f.get(), "</th>\n <th>");
print(f.get(), col->title());
}
print(f.get(), "</th>\n </tr>\n");
}
for (auto&& row : dataset.data)
print(f.get(), " <tr>\n <td>" + row.html("</td>\n <td>") + "</td>\n </tr>\n");
print(f.get(), "</table>\n");
}, false);
}
#endif
return 0;
}
LRESULT CTasksFrame::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
// unregister message filtering and idle updates
CMessageLoop* pLoop = _Module.GetMessageLoop();
ATLASSERT(pLoop != NULL);
pLoop->RemoveMessageFilter(this);
pLoop->RemoveIdleHandler(this);
bHandled = FALSE;
return 1;
}
LRESULT CTasksFrame::OnTaskIconClick(LPARAM /*uMsg*/, BOOL& /*bHandled*/)
{
return 0;
}
LRESULT CTasksFrame::OnFileExit(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
PostMessage(WM_CLOSE);
return 0;
}
LRESULT CTasksFrame::OnFileNew(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
// TODO: add code to initialize document
return 0;
}
LRESULT CTasksFrame::OnAppAbout(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
CAboutDlg dlg;
dlg.DoModal();
return 0;
}
<commit_msg>Removing obsolete code<commit_after>// TasksFrame.cpp : implmentation of the CTasksFrame class
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#include "aboutdlg.h"
#include "TasksView.h"
#include "TasksFrame.h"
#include <jira/jira.hpp>
#include <jira/server.hpp>
#include <net/utf8.hpp>
#include <net/xhr.hpp>
#include <sstream>
#include <thread>
#include "AppSettings.h"
#include "wincrypt.h"
#pragma comment(lib, "crypt32.lib")
std::string contents(LPCWSTR path)
{
std::unique_ptr<FILE, decltype(&fclose)> f{ _wfopen(path, L"r"), fclose };
if (!f)
return std::string();
std::string out;
char buffer[8192];
int read = 0;
while ((read = fread(buffer, 1, sizeof(buffer), f.get())) > 0)
out.append(buffer, buffer + read);
return out;
}
void print(FILE* f, const std::string& s)
{
fwrite(s.c_str(), 1, s.length(), f);
}
void print(FILE* f, const char* s)
{
if (!s)
return;
fwrite(s, 1, strlen(s), f);
}
template <size_t length>
void print(FILE* f, const char(&s)[length])
{
if (!s)
return;
fwrite(s, 1, strlen(s), f);
}
BOOL CTasksFrame::PreTranslateMessage(MSG* pMsg)
{
if (CFameSuper::PreTranslateMessage(pMsg))
return TRUE;
return m_view.PreTranslateMessage(pMsg);
}
BOOL CTasksFrame::OnIdle()
{
UIUpdateToolBar();
return FALSE;
}
LRESULT CTasksFrame::OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
// Check if Common Controls 6.0 are used. If yes, use 32-bit (alpha) images
// for the toolbar and command bar. If not, use the old, 4-bit images.
UINT uResID = IDR_MAINFRAME_OLD;
DWORD dwMajor = 0;
DWORD dwMinor = 0;
HRESULT hRet = AtlGetCommCtrlVersion(&dwMajor, &dwMinor);
if (SUCCEEDED(hRet) && dwMajor >= 6)
uResID = IDR_MAINFRAME;
CreateSimpleToolBar(uResID);
m_view.m_model = m_model;
m_hWndClient = m_view.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0);
m_font = AtlCreateControlFont();
m_view.SetFont(m_font);
// register object for message filtering and idle updates
CMessageLoop* pLoop = _Module.GetMessageLoop();
ATLASSERT(pLoop != NULL);
pLoop->AddMessageFilter(this);
pLoop->AddIdleHandler(this);
m_taskIcon.Install(m_hWnd, 1, IDR_TASKBAR);
auto hwnd = m_hWnd;
m_model->startup();
return 0;
}
LRESULT CTasksFrame::OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
// unregister message filtering and idle updates
CMessageLoop* pLoop = _Module.GetMessageLoop();
ATLASSERT(pLoop != NULL);
pLoop->RemoveMessageFilter(this);
pLoop->RemoveIdleHandler(this);
bHandled = FALSE;
return 1;
}
LRESULT CTasksFrame::OnTaskIconClick(LPARAM /*uMsg*/, BOOL& /*bHandled*/)
{
return 0;
}
LRESULT CTasksFrame::OnFileExit(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
PostMessage(WM_CLOSE);
return 0;
}
LRESULT CTasksFrame::OnFileNew(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
// TODO: add code to initialize document
return 0;
}
LRESULT CTasksFrame::OnAppAbout(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
CAboutDlg dlg;
dlg.DoModal();
return 0;
}
<|endoftext|> |
<commit_before>#ifndef WEBSOCKET_HPP
#define WEBSOCKET_HPP
#include <functional>
#include "buffer.h"
#include "websock.h"
namespace websock
{
using Handshake = websock_handshake;
using Message = websock_message;
enum Error
{
UnexpectedDisconnect,
ReadFailed,
WriteFailed,
HandshakeFailed,
UnmaskedMessage,
TooLongMessage
};
constexpr const char *ErrorText[] =
{
[UnexpectedDisconnect] = "unexpected disconnect",
[ReadFailed] = "read failed",
[WriteFailed] = "write failed",
[HandshakeFailed] = "handshake failed",
[UnmaskedMessage] = "received unmasked message",
[TooLongMessage] = "received too long message"
};
struct Connection
{
Buffer in, out;
bool connected = true;
bool established = false;
bool allowUnmasked = false;
/// should return the number of bytes read, -1 on error and 0 on disconnect (like POSIX recv)
std::function<ptrdiff_t(char*, size_t)> read;
/// should return the number of bytes sent and -1 on error (like POSIX send)
std::function<ptrdiff_t(const char*, size_t)> write;
std::function<void(const Handshake&)> onConnect;
std::function<void(const Message&)> onMessage;
std::function<void(const Message&)> onClose;
std::function<void(Error)> onError;
Connection(size_t maxMsgLen = 2048) : in(maxMsgLen), out(maxMsgLen) {}
void error(Error code)
{
if(onError) onError(code);
connected = false;
}
void process()
{
if(!connected) return;
if(read)
{
in.shrink();
if(!in.spaceLeft())
return error(established ? TooLongMessage : HandshakeFailed);
ptrdiff_t available = read(in.end(), in.spaceLeft());
if(available > 0)
in.write(0, available);
else
return error(available ? ReadFailed : UnexpectedDisconnect);
}
if(!established)
{
Handshake hs;
size_t n = websocket_parse_handshake(in.begin(), in.size(), &hs);
if(!n) return;
in.skip(n);
out.setEnd(websock_accept_handshake(out.end(), hs.sec_key, hs.sec_key_len));
established = true;
if(onConnect) onConnect(hs);
}
while(1)
{
Message msg;
size_t n = websocket_decode_message(in.begin(), in.size(), &msg);
if(!n) return;
in.skip(n);
if(!allowUnmasked && !msg.masked)
return error(UnmaskedMessage);
switch(msg.opcode)
{
case websock_opcode_ping:
send(msg.data, msg.len, websock_opcode_pong);
break;
case websock_opcode_close:
connected = false;
if(onClose) onClose(msg);
break;
default:
if(onMessage) onMessage(msg);
}
}
}
void flush()
{
if(!connected || !out.size()) return;
ptrdiff_t sent = write(out.begin(), out.size());
if(sent == -1) return error(WriteFailed);
out.skip(sent);
out.shrink();
}
void send(const char* data, size_t len, uint8_t opcode = websock_opcode_binary)
{
out.reserve(len);
out.setEnd(websocket_write_message(out.end(), data, len, opcode | websock_final_mask));
}
};
}
#endif
<commit_msg>Fixed onClosed<commit_after>#ifndef WEBSOCKET_HPP
#define WEBSOCKET_HPP
#include <functional>
#include "buffer.h"
#include "websock.h"
namespace websock
{
using Handshake = websock_handshake;
using Message = websock_message;
enum Error
{
UnexpectedDisconnect,
ReadFailed,
WriteFailed,
HandshakeFailed,
UnmaskedMessage,
TooLongMessage
};
constexpr const char *ErrorText[] =
{
[UnexpectedDisconnect] = "unexpected disconnect",
[ReadFailed] = "read failed",
[WriteFailed] = "write failed",
[HandshakeFailed] = "handshake failed",
[UnmaskedMessage] = "received unmasked message",
[TooLongMessage] = "received too long message"
};
struct Connection
{
Buffer in, out;
bool connected = true;
bool established = false;
bool allowUnmasked = false;
/// should return the number of bytes read, -1 on error and 0 on disconnect (like POSIX recv)
std::function<ptrdiff_t(char*, size_t)> read;
/// should return the number of bytes sent and -1 on error (like POSIX send)
std::function<ptrdiff_t(const char*, size_t)> write;
std::function<void(const Handshake&)> onConnect;
std::function<void(const Message&)> onMessage;
std::function<void(Error)> onError;
std::function<void()> onClose;
Connection(size_t maxMsgLen = 2048) : in(maxMsgLen), out(maxMsgLen) {}
void close()
{
if(!connected) return;
if(onClose) onClose();
connected = false;
}
void error(Error code)
{
if(onError) onError(code);
close();
}
void process()
{
if(!connected) return;
if(read)
{
in.shrink();
if(!in.spaceLeft())
return error(established ? TooLongMessage : HandshakeFailed);
ptrdiff_t available = read(in.end(), in.spaceLeft());
if(available > 0)
in.write(0, available);
else
return error(available ? ReadFailed : UnexpectedDisconnect);
}
if(!established)
{
Handshake hs;
size_t n = websocket_parse_handshake(in.begin(), in.size(), &hs);
if(!n) return;
in.skip(n);
out.setEnd(websock_accept_handshake(out.end(), hs.sec_key, hs.sec_key_len));
established = true;
if(onConnect) onConnect(hs);
}
while(1)
{
Message msg;
size_t n = websocket_decode_message(in.begin(), in.size(), &msg);
if(!n) return;
in.skip(n);
if(!allowUnmasked && !msg.masked)
return error(UnmaskedMessage);
switch(msg.opcode)
{
case websock_opcode_ping:
send(msg.data, msg.len, websock_opcode_pong);
break;
case websock_opcode_close:
return close();
default:
if(onMessage) onMessage(msg);
}
}
}
void flush()
{
if(!connected || !out.size()) return;
ptrdiff_t sent = write(out.begin(), out.size());
if(sent == -1) return error(WriteFailed);
out.skip(sent);
out.shrink();
}
void send(const char* data, size_t len, uint8_t opcode = websock_opcode_binary)
{
out.reserve(len);
out.setEnd(websocket_write_message(out.end(), data, len, opcode | websock_final_mask));
}
};
}
#endif
<|endoftext|> |
<commit_before>#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <sys/stat.h>
#include <math.h>
#include <algorithm>
#include <string.h>
#include <stdint.h>
#include <sstream>
#include <iomanip>
#include <gdal_priv.h>
#include <cpl_conv.h>
#include <ogr_spatialref.h>
using namespace std;
//to compile: c++ raster_math.cpp -o raster_math -lgdal
// ./dead_wood_c_stock.exe 00N_000E_biomass.tif 00N_000E_res_ecozone.tif 00N_000E_res_srtm.tif 00N_000E_res_srtm.tif test.tif > values.txt
int main(int argc, char* argv[])
{
//passing arguments
if (argc != 2){cout << "Use <program name> <tile_id>" << endl; return 1;}
string tile_id = argv[1];
// carbon pools
string bgc_name = tile_id + "_bgc.tif";
string agc_name = tile_id + "_carbon.tif";
string deadc_name = tile_id + "_deadwood.tif";
string soilc_name = tile_id + "_soil.tif";
string litterc_name = tile_id + "_litter.tif";
// aux data
string lossyear_name = tile_id + "_loss.tif";
string lossclass_name = tile_id + "_res_forest_model.tif";
string peatdran_name = tile_id + "_res_peatdrainage.tif";
string hist_name = tile_id + "_res_hwsd_histosoles.tif";
string climate_name = tile_id + "_res_climate_zone.tif";
// set output file name
string out_wildfire_name = tile_id + "_wildfire.tif";
string out_forestry_name = tile_id + "_forestry.tif";
//setting variables
int x, y;
int xsize, ysize;
double GeoTransform[6]; double ulx, uly; double pixelsize;
//initialize GDAL for reading
GDALAllRegister();
GDALDataset *INGDAL; GDALRasterBand *INBAND;
GDALDataset *INGDAL2; GDALRasterBand *INBAND2;
GDALDataset *INGDAL3; GDALRasterBand *INBAND3;
GDALDataset *INGDAL4; GDALRasterBand *INBAND4;
GDALDataset *INGDAL5; GDALRasterBand *INBAND5;
GDALDataset *INGDAL6; GDALRasterBand *INBAND6; //loss
GDALDataset *INGDAL7; GDALRasterBand *INBAND7; // lossclass
GDALDataset *INGDAL8; GDALRasterBand *INBAND8; // peatdran
GDALDataset *INGDAL9; GDALRasterBand *INBAND9; // histosoles
GDALDataset *INGDAL10; GDALRasterBand *INBAND10; // climate
//open file and get extent and projection
INGDAL = (GDALDataset *) GDALOpen(bgc_name.c_str(), GA_ReadOnly );
INBAND = INGDAL->GetRasterBand(1);
xsize=INBAND->GetXSize();
ysize=INBAND->GetYSize();
INGDAL->GetGeoTransform(GeoTransform);
ulx=GeoTransform[0];
uly=GeoTransform[3];
pixelsize=GeoTransform[1];
cout << xsize <<", "<< ysize <<", "<< ulx <<", "<< uly << ", "<< pixelsize << endl;
INGDAL2 = (GDALDataset *) GDALOpen(agc_name.c_str(), GA_ReadOnly );
INBAND2 = INGDAL2->GetRasterBand(1);
INGDAL3 = (GDALDataset *) GDALOpen(deadc_name.c_str(), GA_ReadOnly );
INBAND3 = INGDAL3->GetRasterBand(1);
INGDAL4 = (GDALDataset *) GDALOpen(litterc_name.c_str(), GA_ReadOnly );
INBAND4 = INGDAL4->GetRasterBand(1);
INGDAL5 = (GDALDataset *) GDALOpen(soilc_name.c_str(), GA_ReadOnly );
INBAND5 = INGDAL5->GetRasterBand(1);
INGDAL6 = (GDALDataset *) GDALOpen(lossyear_name.c_str(), GA_ReadOnly );
INBAND6 = INGDAL6->GetRasterBand(1);
INGDAL7 = (GDALDataset *) GDALOpen(lossclass_name.c_str(), GA_ReadOnly );
INBAND7 = INGDAL7->GetRasterBand(1);
INGDAL8 = (GDALDataset *) GDALOpen(peatdran_name.c_str(), GA_ReadOnly );
INBAND8 = INGDAL8->GetRasterBand(1);
INGDAL9 = (GDALDataset *) GDALOpen(hist_name.c_str(), GA_ReadOnly );
INBAND9 = INGDAL9->GetRasterBand(1);
INGDAL10 = (GDALDataset *) GDALOpen(climate_name.c_str(), GA_ReadOnly );
INBAND10 = INGDAL10->GetRasterBand(1);
//initialize GDAL for writing
GDALDriver *OUTDRIVER;
GDALDataset *OUTGDAL;
GDALRasterBand *OUTBAND1;
GDALRasterBand *OUTBAND2;
OGRSpatialReference oSRS;
char *OUTPRJ = NULL;
char **papszOptions = NULL;
papszOptions = CSLSetNameValue( papszOptions, "COMPRESS", "LZW" );
OUTDRIVER = GetGDALDriverManager()->GetDriverByName("GTIFF");
if( OUTDRIVER == NULL ) {cout << "no driver" << endl; exit( 1 );};
oSRS.SetWellKnownGeogCS( "WGS84" );
oSRS.exportToWkt( &OUTPRJ );
double adfGeoTransform[6] = { ulx, pixelsize, 0, uly, 0, -1*pixelsize };
OUTGDAL = OUTDRIVER->Create( out_wildfire_name.c_str(), xsize, ysize, 1, GDT_Float32, papszOptions );
OUTGDAL->SetGeoTransform(adfGeoTransform); OUTGDAL->SetProjection(OUTPRJ);
OUTBAND1 = OUTGDAL->GetRasterBand(1);
OUTBAND1->SetNoDataValue(-9999);
OUTGDAL = OUTDRIVER->Create( out_forestry_name.c_str(), xsize, ysize, 1, GDT_Float32, papszOptions );
OUTGDAL->SetGeoTransform(adfGeoTransform); OUTGDAL->SetProjection(OUTPRJ);
OUTBAND2 = OUTGDAL->GetRasterBand(1);
OUTBAND2->SetNoDataValue(-9999);
//read/write data
float bgc_data[xsize];
float agc_data[xsize];
float deadc_data[xsize];
float litterc_data[xsize];
float soilc_data[xsize];
float loss_data[xsize];
float lossclass_data[xsize];
float peatdran_data[xsize];
float hist_data[xsize];
float climate_data[xsize];
float out_wildfire_data[xsize];
float out_forestry_data[xsize];
for(y=0; y<ysize; y++) {
INBAND->RasterIO(GF_Read, 0, y, xsize, 1, bgc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND2->RasterIO(GF_Read, 0, y, xsize, 1, agc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND3->RasterIO(GF_Read, 0, y, xsize, 1, deadc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND4->RasterIO(GF_Read, 0, y, xsize, 1, litterc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND5->RasterIO(GF_Read, 0, y, xsize, 1, soilc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND6->RasterIO(GF_Read, 0, y, xsize, 1, loss_data, xsize, 1, GDT_Float32, 0, 0);
INBAND7->RasterIO(GF_Read, 0, y, xsize, 1, lossclass_data, xsize, 1, GDT_Float32, 0, 0);
INBAND8->RasterIO(GF_Read, 0, y, xsize, 1, peatdran_data, xsize, 1, GDT_Float32, 0, 0);
INBAND9->RasterIO(GF_Read, 0, y, xsize, 1, hist_data, xsize, 1, GDT_Float32, 0, 0);
INBAND10->RasterIO(GF_Read, 0, y, xsize, 1, climate_data, xsize, 1, GDT_Float32, 0, 0);
for(x=0; x<xsize; x++) {
if (loss_data[x] > 0)
{
if (peatdran_data[x] != -9999)
{
if (peatdran_data[x] != -9999)// change to burned areas once I get the data
{
out_wildfire_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * peatdran_data[x]) + 917;
}
else
{
out_wildfire_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * peatdran_data[x]);
}
}
else
{
if (hist_data[x] != -9999)
{
if (climate_data[x] = 1) // tropics
{
out_wildfire_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * 55);
}
if (climate_data[x] = 2) // boreal
{
out_wildfire_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * 2.16);
}
if (climate_data[x] = 3) // temperate
{
out_wildfire_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * 6.27);
}
}
else
{
out_wildfire_data[x] = -9999;
}
}
}
else {
out_wildfire_data[x] = -9999;
}
//closes for x loop
}
OUTBAND1->RasterIO( GF_Write, 0, y, xsize, 1, out_wildfire_data, xsize, 1, GDT_Float32, 0, 0 );
OUTBAND2->RasterIO( GF_Write, 0, y, xsize, 1, out_forestry_data, xsize, 1, GDT_Float32, 0, 0 );
//closes for y loop
}
//close GDAL
GDALClose(INGDAL);
GDALClose((GDALDatasetH)OUTGDAL);
return 0;
}
<commit_msg>change names to forestry, arrange else statement<commit_after>#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <sys/stat.h>
#include <math.h>
#include <algorithm>
#include <string.h>
#include <stdint.h>
#include <sstream>
#include <iomanip>
#include <gdal_priv.h>
#include <cpl_conv.h>
#include <ogr_spatialref.h>
using namespace std;
//to compile: c++ raster_math.cpp -o raster_math -lgdal
// ./dead_wood_c_stock.exe 00N_000E_biomass.tif 00N_000E_res_ecozone.tif 00N_000E_res_srtm.tif 00N_000E_res_srtm.tif test.tif > values.txt
int main(int argc, char* argv[])
{
//passing arguments
if (argc != 2){cout << "Use <program name> <tile_id>" << endl; return 1;}
string tile_id = argv[1];
// carbon pools
string bgc_name = tile_id + "_bgc.tif";
string agc_name = tile_id + "_carbon.tif";
string deadc_name = tile_id + "_deadwood.tif";
string soilc_name = tile_id + "_soil.tif";
string litterc_name = tile_id + "_litter.tif";
// aux data
string lossyear_name = tile_id + "_loss.tif";
string lossclass_name = tile_id + "_res_forest_model.tif";
string peatdran_name = tile_id + "_res_peatdrainage.tif";
string hist_name = tile_id + "_res_hwsd_histosoles.tif";
string climate_name = tile_id + "_res_climate_zone.tif";
// set output file name
string out_wildfire_name = tile_id + "_wildfire.tif";
string out_forestry_name = tile_id + "_forestry.tif";
//setting variables
int x, y;
int xsize, ysize;
double GeoTransform[6]; double ulx, uly; double pixelsize;
//initialize GDAL for reading
GDALAllRegister();
GDALDataset *INGDAL; GDALRasterBand *INBAND;
GDALDataset *INGDAL2; GDALRasterBand *INBAND2;
GDALDataset *INGDAL3; GDALRasterBand *INBAND3;
GDALDataset *INGDAL4; GDALRasterBand *INBAND4;
GDALDataset *INGDAL5; GDALRasterBand *INBAND5;
GDALDataset *INGDAL6; GDALRasterBand *INBAND6; //loss
GDALDataset *INGDAL7; GDALRasterBand *INBAND7; // lossclass
GDALDataset *INGDAL8; GDALRasterBand *INBAND8; // peatdran
GDALDataset *INGDAL9; GDALRasterBand *INBAND9; // histosoles
GDALDataset *INGDAL10; GDALRasterBand *INBAND10; // climate
//open file and get extent and projection
INGDAL = (GDALDataset *) GDALOpen(bgc_name.c_str(), GA_ReadOnly );
INBAND = INGDAL->GetRasterBand(1);
xsize=INBAND->GetXSize();
ysize=INBAND->GetYSize();
INGDAL->GetGeoTransform(GeoTransform);
ulx=GeoTransform[0];
uly=GeoTransform[3];
pixelsize=GeoTransform[1];
cout << xsize <<", "<< ysize <<", "<< ulx <<", "<< uly << ", "<< pixelsize << endl;
INGDAL2 = (GDALDataset *) GDALOpen(agc_name.c_str(), GA_ReadOnly );
INBAND2 = INGDAL2->GetRasterBand(1);
INGDAL3 = (GDALDataset *) GDALOpen(deadc_name.c_str(), GA_ReadOnly );
INBAND3 = INGDAL3->GetRasterBand(1);
INGDAL4 = (GDALDataset *) GDALOpen(litterc_name.c_str(), GA_ReadOnly );
INBAND4 = INGDAL4->GetRasterBand(1);
INGDAL5 = (GDALDataset *) GDALOpen(soilc_name.c_str(), GA_ReadOnly );
INBAND5 = INGDAL5->GetRasterBand(1);
INGDAL6 = (GDALDataset *) GDALOpen(lossyear_name.c_str(), GA_ReadOnly );
INBAND6 = INGDAL6->GetRasterBand(1);
INGDAL7 = (GDALDataset *) GDALOpen(lossclass_name.c_str(), GA_ReadOnly );
INBAND7 = INGDAL7->GetRasterBand(1);
INGDAL8 = (GDALDataset *) GDALOpen(peatdran_name.c_str(), GA_ReadOnly );
INBAND8 = INGDAL8->GetRasterBand(1);
INGDAL9 = (GDALDataset *) GDALOpen(hist_name.c_str(), GA_ReadOnly );
INBAND9 = INGDAL9->GetRasterBand(1);
INGDAL10 = (GDALDataset *) GDALOpen(climate_name.c_str(), GA_ReadOnly );
INBAND10 = INGDAL10->GetRasterBand(1);
//initialize GDAL for writing
GDALDriver *OUTDRIVER;
GDALDataset *OUTGDAL;
GDALRasterBand *OUTBAND1;
GDALRasterBand *OUTBAND2;
OGRSpatialReference oSRS;
char *OUTPRJ = NULL;
char **papszOptions = NULL;
papszOptions = CSLSetNameValue( papszOptions, "COMPRESS", "LZW" );
OUTDRIVER = GetGDALDriverManager()->GetDriverByName("GTIFF");
if( OUTDRIVER == NULL ) {cout << "no driver" << endl; exit( 1 );};
oSRS.SetWellKnownGeogCS( "WGS84" );
oSRS.exportToWkt( &OUTPRJ );
double adfGeoTransform[6] = { ulx, pixelsize, 0, uly, 0, -1*pixelsize };
OUTGDAL = OUTDRIVER->Create( out_wildfire_name.c_str(), xsize, ysize, 1, GDT_Float32, papszOptions );
OUTGDAL->SetGeoTransform(adfGeoTransform); OUTGDAL->SetProjection(OUTPRJ);
OUTBAND1 = OUTGDAL->GetRasterBand(1);
OUTBAND1->SetNoDataValue(-9999);
OUTGDAL = OUTDRIVER->Create( out_forestry_name.c_str(), xsize, ysize, 1, GDT_Float32, papszOptions );
OUTGDAL->SetGeoTransform(adfGeoTransform); OUTGDAL->SetProjection(OUTPRJ);
OUTBAND2 = OUTGDAL->GetRasterBand(1);
OUTBAND2->SetNoDataValue(-9999);
//read/write data
float bgc_data[xsize];
float agc_data[xsize];
float deadc_data[xsize];
float litterc_data[xsize];
float soilc_data[xsize];
float loss_data[xsize];
float lossclass_data[xsize];
float peatdran_data[xsize];
float hist_data[xsize];
float climate_data[xsize];
float out_wildfire_data[xsize];
float out_forestry_data[xsize];
for(y=0; y<ysize; y++) {
INBAND->RasterIO(GF_Read, 0, y, xsize, 1, bgc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND2->RasterIO(GF_Read, 0, y, xsize, 1, agc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND3->RasterIO(GF_Read, 0, y, xsize, 1, deadc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND4->RasterIO(GF_Read, 0, y, xsize, 1, litterc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND5->RasterIO(GF_Read, 0, y, xsize, 1, soilc_data, xsize, 1, GDT_Float32, 0, 0);
INBAND6->RasterIO(GF_Read, 0, y, xsize, 1, loss_data, xsize, 1, GDT_Float32, 0, 0);
INBAND7->RasterIO(GF_Read, 0, y, xsize, 1, lossclass_data, xsize, 1, GDT_Float32, 0, 0);
INBAND8->RasterIO(GF_Read, 0, y, xsize, 1, peatdran_data, xsize, 1, GDT_Float32, 0, 0);
INBAND9->RasterIO(GF_Read, 0, y, xsize, 1, hist_data, xsize, 1, GDT_Float32, 0, 0);
INBAND10->RasterIO(GF_Read, 0, y, xsize, 1, climate_data, xsize, 1, GDT_Float32, 0, 0);
for(x=0; x<xsize; x++) {
if (loss_data[x] > 0)
{
if (lossclass_data[x] = 1) // forestry
{
if (peatdran_data[x] != -9999)
{
if (peatdran_data[x] != -9999)// change to burned areas once I get the data
{
out_forestry_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * peatdran_data[x]) + 917; // qc'd this with 10N_100E - passed
}
else
{
out_forestry_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * peatdran_data[x]);
}
}
else
{
if (hist_data[x] != -9999)
{
if (climate_data[x] = 1) // tropics
{
out_forestry_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * 55);
}
if (climate_data[x] = 2) // boreal
{
out_forestry_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * 2.16);
}
if (climate_data[x] = 3) // temperate
{
out_forestry_data[x] = ((agc_data[x] + bgc_data[x]) * 3.67) + (15 - loss_data[x] * 6.27);
}
}
else
{
out_forestry_data[x] = -9999;
}
}
}
else
{
out_forestry_data[x] = -9999;
}
//closes for x loop
}
OUTBAND1->RasterIO( GF_Write, 0, y, xsize, 1, out_forestry_data, xsize, 1, GDT_Float32, 0, 0 );
OUTBAND2->RasterIO( GF_Write, 0, y, xsize, 1, out_forestry_data, xsize, 1, GDT_Float32, 0, 0 );
//closes for y loop
}
//close GDAL
GDALClose(INGDAL);
GDALClose((GDALDatasetH)OUTGDAL);
return 0;
}
<|endoftext|> |
<commit_before>/****************************************************************************
This file is part of the GLC-lib library.
Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
Version 1.0.0, packaged on August, 2008.
http://glc-lib.sourceforge.net
GLC-lib 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.
GLC-lib 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 GLC-lib; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*****************************************************************************/
//! \file glc_camera.cpp Implementation of the GLC_Camera class.
#include "glc_camera.h"
#include "glc_openglexception.h"
#include <QtDebug>
using namespace glc;
//////////////////////////////////////////////////////////////////////
// Constructor Destructor
//////////////////////////////////////////////////////////////////////
GLC_Camera::GLC_Camera()
: GLC_Object("Camera")
, m_Eye(0,0,1)
, m_Target()
, m_VectUp(0,1,0)
{
}
GLC_Camera::GLC_Camera(const GLC_Point4d &Eye, const GLC_Point4d &Target, const GLC_Vector4d &Up)
: GLC_Object("Camera")
, m_Eye()
, m_Target()
, m_VectUp()
{
setCam(Eye, Target, Up);
createMatComp();
}
// Copy constructor
GLC_Camera::GLC_Camera(const GLC_Camera& cam)
: GLC_Object(cam)
, m_Eye(cam.m_Eye)
, m_Target(cam.m_Target)
, m_VectUp(cam.m_VectUp)
, m_MatCompOrbit(cam.m_MatCompOrbit)
{
}
/////////////////////////////////////////////////////////////////////
// Get Functions
/////////////////////////////////////////////////////////////////////
// Get the distance between the eye and the target of camera
double GLC_Camera::getDistEyeTarget(void) const
{
return (m_Eye - m_Target).getNorm();
}
// Get camera's eye coordinate point
const GLC_Point4d GLC_Camera::getEye(void) const
{
return m_Eye;
}
// Get camera's target coordinate point
const GLC_Point4d GLC_Camera::getTarget(void) const
{
return m_Target;
}
// Get camera's Up vector
const GLC_Vector4d GLC_Camera::getVectUp(void) const
{
return m_VectUp;
}
// Get camera's Vector (from eye to target)
GLC_Vector4d GLC_Camera::getVectCam(void) const
{
return m_Eye - m_Target;
}
// Get camera's orbit composition matrix
const GLC_Matrix4x4 GLC_Camera::getMatCompOrbit(void) const
{
return m_MatCompOrbit;
}
// equality operator
bool GLC_Camera::operator==(const GLC_Camera& cam) const
{
return (m_Eye == cam.m_Eye) && (m_Target == cam.m_Target)
&& (m_VectUp == cam.m_VectUp);
}
/////////////////////////////////////////////////////////////////////
// Set Functions
/////////////////////////////////////////////////////////////////////
void GLC_Camera::orbit(GLC_Vector4d VectOldPoss, GLC_Vector4d VectCurPoss)
{
// Map Vectors
VectOldPoss= m_MatCompOrbit * VectOldPoss;
VectCurPoss= m_MatCompOrbit * VectCurPoss;
// Compute rotation matrix
const GLC_Vector4d VectAxeRot(VectCurPoss ^ VectOldPoss);
// Check if rotation vector is not null
if (!VectAxeRot.isNull())
{ // Ok, is not null
const double Angle= acos(VectCurPoss * VectOldPoss);
const GLC_Matrix4x4 MatOrbit(VectAxeRot, Angle);
// Camera transformation
m_Eye= (MatOrbit * (m_Eye - m_Target)) + m_Target;
m_VectUp= MatOrbit * m_VectUp;
m_MatCompOrbit= MatOrbit * m_MatCompOrbit;
}
}
void GLC_Camera::pan(GLC_Vector4d VectDep)
{
// Vector mapping
VectDep= m_MatCompOrbit * VectDep;
// Camera transformation
m_Eye= m_Eye + VectDep;
m_Target= m_Target + VectDep;
}
void GLC_Camera::zoom(double factor)
{
Q_ASSERT(factor > 0);
// Eye->target vector
GLC_Vector4d VectCam(m_Eye - m_Target);
// Compute new vector length
const double Norme= VectCam.getNorm() * 1 / factor;
VectCam.setNormal(Norme);
m_Eye= VectCam + m_Target;
}
void GLC_Camera::move(const GLC_Matrix4x4 &MatMove)
{
m_Eye= MatMove * m_Eye;
m_Target= MatMove * m_Target;
// Up vector computation
// In case of translation in matrix
const GLC_Vector4d VectOrigine(0,0,0);
// Backup m_VectUp
const GLC_Vector4d VectUpOld(m_VectUp);
m_VectUp= (MatMove * VectUpOld) - (MatMove * VectOrigine); // Up Vector Origin must be equal to 0,0,0
createMatComp();
}
void GLC_Camera::translate(const GLC_Vector4d &VectTrans)
{
m_Eye= m_Eye + VectTrans;
m_Target= m_Target + VectTrans;
}
void GLC_Camera::setEyeCam(const GLC_Point4d &Eye)
{
// Old camera's vector
GLC_Vector4d VectOldCam(m_Eye - m_Target);
// New camera's vector
GLC_Vector4d VectCam(Eye - m_Target);
if ( !(VectOldCam - VectCam).isNull() )
{
VectOldCam.setNormal(1);
VectCam.setNormal(1);
const double Angle= acos(VectOldCam * VectCam);
if ( (Angle > EPSILON) && ( (PI - Angle) > EPSILON) )
{
const GLC_Vector4d VectAxeRot(VectOldCam ^ VectCam);
const GLC_Matrix4x4 MatRot(VectAxeRot, Angle);
m_VectUp= MatRot * m_VectUp;
}
else
{
if ( (PI - Angle) < EPSILON)
{ // Angle de 180�
m_VectUp.setInv();
}
}
setCam(Eye, m_Target, m_VectUp);
}
}
void GLC_Camera::setTargetCam(const GLC_Point4d &Target)
{
// Old camera's vector
GLC_Vector4d VectOldCam(m_Eye - m_Target);
// New camera's vector
GLC_Vector4d VectCam(m_Eye - Target);
if ( !(VectOldCam - VectCam).isNull() )
{
VectOldCam.setNormal(1);
VectCam.setNormal(1);
const double Angle= acos(VectOldCam * VectCam);
if ( (Angle > EPSILON) && ( (PI - Angle) > EPSILON) )
{
const GLC_Vector4d VectAxeRot(VectOldCam ^ VectCam);
const GLC_Matrix4x4 MatRot(VectAxeRot, Angle);
m_VectUp= MatRot * m_VectUp;
}
else
{
if ( (PI - Angle) < EPSILON)
{ // Angle of 180�
m_VectUp.setInv();
}
}
setCam(m_Eye, Target, m_VectUp);
}
}
void GLC_Camera::setUpCam(const GLC_Vector4d &Up)
{
if ( !(m_VectUp - Up).isNull() )
{
setCam(m_Eye, m_Target, Up);
}
}
void GLC_Camera::setCam(GLC_Point4d Eye, GLC_Point4d Target, GLC_Vector4d Up)
{
Up.setNormal(1);
const GLC_Vector4d VectCam((Eye - Target).setNormal(1));
const double Angle= acos(VectCam * Up);
/* m_VectUp and VectCam could not be parallel
* m_VectUp could not be NULL
* VectCam could not be NULL */
//Q_ASSERT((Angle > EPSILON) && ((PI - Angle) > EPSILON));
if ( fabs(Angle - (PI / 2)) > EPSILON)
{ // Angle not equal to 90�
const GLC_Vector4d AxeRot(VectCam ^ Up);
GLC_Matrix4x4 MatRot(AxeRot, PI / 2);
Up= MatRot * VectCam;
}
m_Eye= Eye;
m_Target= Target;
m_VectUp= Up;
createMatComp();
}
//! Set the camera by copying another camera
void GLC_Camera::setCam(const GLC_Camera& cam)
{
m_Eye= cam.m_Eye;
m_Target= cam.m_Target;
m_VectUp= cam.m_VectUp;
m_MatCompOrbit= cam.m_MatCompOrbit;
}
void GLC_Camera::setDistEyeTarget(double Longueur)
{
GLC_Vector4d VectCam(m_Eye - m_Target);
VectCam.setNormal(Longueur);
m_Eye= VectCam + m_Target;
}
// Assignement operator
GLC_Camera &GLC_Camera::operator=(const GLC_Camera& cam)
{
GLC_Object::operator=(cam);
m_Eye= cam.m_Eye;
m_Target= cam.m_Target;
m_VectUp= cam.m_VectUp;
m_MatCompOrbit= cam.m_MatCompOrbit;
return *this;
}
//////////////////////////////////////////////////////////////////////
// OpenGL Functions
//////////////////////////////////////////////////////////////////////
void GLC_Camera::glExecute(GLenum Mode)
{
gluLookAt(m_Eye.getX(), m_Eye.getY(), m_Eye.getZ(),
m_Target.getX(), m_Target.getY(), m_Target.getZ(),
m_VectUp.getX(), m_VectUp.getY(), m_VectUp.getZ());
// OpenGL error handler
GLenum error= glGetError();
if (error != GL_NO_ERROR)
{
GLC_OpenGlException OpenGlException("GLC_Camera::GlExecute ", error);
throw(OpenGlException);
}
}
//////////////////////////////////////////////////////////////////////
// Private services Functions
//////////////////////////////////////////////////////////////////////
void GLC_Camera::createMatComp(void)
{
// Compute rotation matrix between Z axis and camera
const GLC_Vector4d VectCam((m_Eye - m_Target).setNormal(1));
if ( fabs( fabs(VectCam.getZ()) - 1.0 ) > EPSILON)
{ // Camera's vector not equal to Z axis
const GLC_Vector4d VectAxeRot= (AxeZ ^ VectCam);
const double Angle= acos(AxeZ * VectCam);
m_MatCompOrbit.setMatRot(VectAxeRot, Angle);
}
else // Camera's Vector equal to Z axis
{
if (VectCam.getZ() < 0)
{
m_MatCompOrbit.setMatRot(m_VectUp, PI);
}
else
m_MatCompOrbit.setToIdentity();
}
// Angle between InitVectUp and m_VectUp
GLC_Vector4d InitVectUp(0,1,0); // m_VectUp is Y by default
InitVectUp= m_MatCompOrbit * InitVectUp;
// Compute the angle if vector are not equal
if (InitVectUp != InitVectUp)
{
const double AngleVectUp= acos(InitVectUp * m_VectUp);
GLC_Matrix4x4 MatInt; // intermediate matrix
if (( AngleVectUp > EPSILON) && ( (PI - AngleVectUp) > EPSILON) )
{ // Angle not equal to 0 or 180
const GLC_Vector4d VectAxeRot(InitVectUp ^ m_VectUp);
MatInt.setMatRot(VectAxeRot, AngleVectUp);
}
else // Angle equal to 0 or 180
{
MatInt.setMatRot(VectCam, AngleVectUp);
}
qDebug() << "MatInt " << MatInt.toString();
m_MatCompOrbit= MatInt * m_MatCompOrbit;
}
}
<commit_msg>Fix a bug on windows plateform : Before calcul the angle between to vector, check if these vector are equal.<commit_after>/****************************************************************************
This file is part of the GLC-lib library.
Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
Version 1.0.0, packaged on August, 2008.
http://glc-lib.sourceforge.net
GLC-lib 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.
GLC-lib 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 GLC-lib; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*****************************************************************************/
//! \file glc_camera.cpp Implementation of the GLC_Camera class.
#include "glc_camera.h"
#include "glc_openglexception.h"
#include <QtDebug>
using namespace glc;
//////////////////////////////////////////////////////////////////////
// Constructor Destructor
//////////////////////////////////////////////////////////////////////
GLC_Camera::GLC_Camera()
: GLC_Object("Camera")
, m_Eye(0,0,1)
, m_Target()
, m_VectUp(0,1,0)
{
}
GLC_Camera::GLC_Camera(const GLC_Point4d &Eye, const GLC_Point4d &Target, const GLC_Vector4d &Up)
: GLC_Object("Camera")
, m_Eye()
, m_Target()
, m_VectUp()
{
setCam(Eye, Target, Up);
createMatComp();
}
// Copy constructor
GLC_Camera::GLC_Camera(const GLC_Camera& cam)
: GLC_Object(cam)
, m_Eye(cam.m_Eye)
, m_Target(cam.m_Target)
, m_VectUp(cam.m_VectUp)
, m_MatCompOrbit(cam.m_MatCompOrbit)
{
}
/////////////////////////////////////////////////////////////////////
// Get Functions
/////////////////////////////////////////////////////////////////////
// Get the distance between the eye and the target of camera
double GLC_Camera::getDistEyeTarget(void) const
{
return (m_Eye - m_Target).getNorm();
}
// Get camera's eye coordinate point
const GLC_Point4d GLC_Camera::getEye(void) const
{
return m_Eye;
}
// Get camera's target coordinate point
const GLC_Point4d GLC_Camera::getTarget(void) const
{
return m_Target;
}
// Get camera's Up vector
const GLC_Vector4d GLC_Camera::getVectUp(void) const
{
return m_VectUp;
}
// Get camera's Vector (from eye to target)
GLC_Vector4d GLC_Camera::getVectCam(void) const
{
return m_Eye - m_Target;
}
// Get camera's orbit composition matrix
const GLC_Matrix4x4 GLC_Camera::getMatCompOrbit(void) const
{
return m_MatCompOrbit;
}
// equality operator
bool GLC_Camera::operator==(const GLC_Camera& cam) const
{
return (m_Eye == cam.m_Eye) && (m_Target == cam.m_Target)
&& (m_VectUp == cam.m_VectUp);
}
/////////////////////////////////////////////////////////////////////
// Set Functions
/////////////////////////////////////////////////////////////////////
void GLC_Camera::orbit(GLC_Vector4d VectOldPoss, GLC_Vector4d VectCurPoss)
{
// Map Vectors
VectOldPoss= m_MatCompOrbit * VectOldPoss;
VectCurPoss= m_MatCompOrbit * VectCurPoss;
// Compute rotation matrix
const GLC_Vector4d VectAxeRot(VectCurPoss ^ VectOldPoss);
// Check if rotation vector is not null
if (!VectAxeRot.isNull())
{ // Ok, is not null
const double Angle= acos(VectCurPoss * VectOldPoss);
const GLC_Matrix4x4 MatOrbit(VectAxeRot, Angle);
// Camera transformation
m_Eye= (MatOrbit * (m_Eye - m_Target)) + m_Target;
m_VectUp= MatOrbit * m_VectUp;
m_MatCompOrbit= MatOrbit * m_MatCompOrbit;
}
}
void GLC_Camera::pan(GLC_Vector4d VectDep)
{
// Vector mapping
VectDep= m_MatCompOrbit * VectDep;
// Camera transformation
m_Eye= m_Eye + VectDep;
m_Target= m_Target + VectDep;
}
void GLC_Camera::zoom(double factor)
{
Q_ASSERT(factor > 0);
// Eye->target vector
GLC_Vector4d VectCam(m_Eye - m_Target);
// Compute new vector length
const double Norme= VectCam.getNorm() * 1 / factor;
VectCam.setNormal(Norme);
m_Eye= VectCam + m_Target;
}
void GLC_Camera::move(const GLC_Matrix4x4 &MatMove)
{
m_Eye= MatMove * m_Eye;
m_Target= MatMove * m_Target;
// Up vector computation
// In case of translation in matrix
const GLC_Vector4d VectOrigine(0,0,0);
// Backup m_VectUp
const GLC_Vector4d VectUpOld(m_VectUp);
m_VectUp= (MatMove * VectUpOld) - (MatMove * VectOrigine); // Up Vector Origin must be equal to 0,0,0
createMatComp();
}
void GLC_Camera::translate(const GLC_Vector4d &VectTrans)
{
m_Eye= m_Eye + VectTrans;
m_Target= m_Target + VectTrans;
}
void GLC_Camera::setEyeCam(const GLC_Point4d &Eye)
{
// Old camera's vector
GLC_Vector4d VectOldCam(m_Eye - m_Target);
// New camera's vector
GLC_Vector4d VectCam(Eye - m_Target);
if ( !(VectOldCam - VectCam).isNull() )
{
VectOldCam.setNormal(1);
VectCam.setNormal(1);
const double Angle= acos(VectOldCam * VectCam);
if ( (Angle > EPSILON) && ( (PI - Angle) > EPSILON) )
{
const GLC_Vector4d VectAxeRot(VectOldCam ^ VectCam);
const GLC_Matrix4x4 MatRot(VectAxeRot, Angle);
m_VectUp= MatRot * m_VectUp;
}
else
{
if ( (PI - Angle) < EPSILON)
{ // Angle de 180�
m_VectUp.setInv();
}
}
setCam(Eye, m_Target, m_VectUp);
}
}
void GLC_Camera::setTargetCam(const GLC_Point4d &Target)
{
// Old camera's vector
GLC_Vector4d VectOldCam(m_Eye - m_Target);
// New camera's vector
GLC_Vector4d VectCam(m_Eye - Target);
if ( !(VectOldCam - VectCam).isNull() )
{
VectOldCam.setNormal(1);
VectCam.setNormal(1);
const double Angle= acos(VectOldCam * VectCam);
if ( (Angle > EPSILON) && ( (PI - Angle) > EPSILON) )
{
const GLC_Vector4d VectAxeRot(VectOldCam ^ VectCam);
const GLC_Matrix4x4 MatRot(VectAxeRot, Angle);
m_VectUp= MatRot * m_VectUp;
}
else
{
if ( (PI - Angle) < EPSILON)
{ // Angle of 180�
m_VectUp.setInv();
}
}
setCam(m_Eye, Target, m_VectUp);
}
}
void GLC_Camera::setUpCam(const GLC_Vector4d &Up)
{
if ( !(m_VectUp - Up).isNull() )
{
setCam(m_Eye, m_Target, Up);
}
}
void GLC_Camera::setCam(GLC_Point4d Eye, GLC_Point4d Target, GLC_Vector4d Up)
{
Up.setNormal(1);
const GLC_Vector4d VectCam((Eye - Target).setNormal(1));
const double Angle= acos(VectCam * Up);
/* m_VectUp and VectCam could not be parallel
* m_VectUp could not be NULL
* VectCam could not be NULL */
//Q_ASSERT((Angle > EPSILON) && ((PI - Angle) > EPSILON));
if ( fabs(Angle - (PI / 2)) > EPSILON)
{ // Angle not equal to 90�
const GLC_Vector4d AxeRot(VectCam ^ Up);
GLC_Matrix4x4 MatRot(AxeRot, PI / 2);
Up= MatRot * VectCam;
}
m_Eye= Eye;
m_Target= Target;
m_VectUp= Up;
createMatComp();
}
//! Set the camera by copying another camera
void GLC_Camera::setCam(const GLC_Camera& cam)
{
m_Eye= cam.m_Eye;
m_Target= cam.m_Target;
m_VectUp= cam.m_VectUp;
m_MatCompOrbit= cam.m_MatCompOrbit;
}
void GLC_Camera::setDistEyeTarget(double Longueur)
{
GLC_Vector4d VectCam(m_Eye - m_Target);
VectCam.setNormal(Longueur);
m_Eye= VectCam + m_Target;
}
// Assignement operator
GLC_Camera &GLC_Camera::operator=(const GLC_Camera& cam)
{
GLC_Object::operator=(cam);
m_Eye= cam.m_Eye;
m_Target= cam.m_Target;
m_VectUp= cam.m_VectUp;
m_MatCompOrbit= cam.m_MatCompOrbit;
return *this;
}
//////////////////////////////////////////////////////////////////////
// OpenGL Functions
//////////////////////////////////////////////////////////////////////
void GLC_Camera::glExecute(GLenum Mode)
{
gluLookAt(m_Eye.getX(), m_Eye.getY(), m_Eye.getZ(),
m_Target.getX(), m_Target.getY(), m_Target.getZ(),
m_VectUp.getX(), m_VectUp.getY(), m_VectUp.getZ());
// OpenGL error handler
GLenum error= glGetError();
if (error != GL_NO_ERROR)
{
GLC_OpenGlException OpenGlException("GLC_Camera::GlExecute ", error);
throw(OpenGlException);
}
}
//////////////////////////////////////////////////////////////////////
// Private services Functions
//////////////////////////////////////////////////////////////////////
void GLC_Camera::createMatComp(void)
{
// Compute rotation matrix between Z axis and camera
const GLC_Vector4d VectCam((m_Eye - m_Target).setNormal(1));
if ( fabs( fabs(VectCam.getZ()) - 1.0 ) > EPSILON)
{ // Camera's vector not equal to Z axis
const GLC_Vector4d VectAxeRot= (AxeZ ^ VectCam);
const double Angle= acos(AxeZ * VectCam);
m_MatCompOrbit.setMatRot(VectAxeRot, Angle);
}
else // Camera's Vector equal to Z axis
{
if (VectCam.getZ() < 0)
{
m_MatCompOrbit.setMatRot(m_VectUp, PI);
}
else
m_MatCompOrbit.setToIdentity();
}
// Angle between InitVectUp and m_VectUp
GLC_Vector4d InitVectUp(0,1,0); // m_VectUp is Y by default
InitVectUp= m_MatCompOrbit * InitVectUp;
// Compute the angle if vector are not equal
if (InitVectUp != m_VectUp)
{
const double AngleVectUp= acos(InitVectUp * m_VectUp);
GLC_Matrix4x4 MatInt; // intermediate matrix
if (( AngleVectUp > EPSILON) && ( (PI - AngleVectUp) > EPSILON) )
{ // Angle not equal to 0 or 180
const GLC_Vector4d VectAxeRot(InitVectUp ^ m_VectUp);
MatInt.setMatRot(VectAxeRot, AngleVectUp);
}
else // Angle equal to 0 or 180
{
MatInt.setMatRot(VectCam, AngleVectUp);
}
qDebug() << "MatInt " << MatInt.toString();
m_MatCompOrbit= MatInt * m_MatCompOrbit;
}
}
<|endoftext|> |
<commit_before>
#include "common.h"
#include <iostream>
bool init_gl(
const int width,
const int height,
EGLDisplay& display,
EGLConfig& config,
EGLContext& context,
EGLSurface& surface
) {
const EGLint config_attribute_list[] =
{
//EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RED_SIZE, 4,
EGL_GREEN_SIZE, 4,
EGL_BLUE_SIZE, 4,
EGL_ALPHA_SIZE, 4,
EGL_CONFORMANT, EGL_OPENGL_ES3_BIT,
EGL_DEPTH_SIZE, 16,
EGL_NONE
};
const EGLint context_attrib_list[] =
{
EGL_CONTEXT_CLIENT_VERSION, 3,
EGL_NONE
};
const EGLint pbuffer_attrib_list[] =
{
EGL_WIDTH, width,
EGL_HEIGHT, height,
EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE,
EGL_TEXTURE_TARGET, EGL_NO_TEXTURE,
EGL_LARGEST_PBUFFER, EGL_TRUE,
EGL_NONE
};
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint major;
EGLint minor;
if(eglInitialize(display, &major, &minor) == EGL_FALSE) {
std::cerr << "eglInitialize failed." << std::endl;
return false;
}
EGLint num_config;
if(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config) == EGL_FALSE) {
std::cerr << "eglChooseConfig failed." << std::endl;
return false;
}
if(num_config != 1) {
std::cerr << "eglChooseConfig did not return 1 config." << std::endl;
return false;
}
context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attrib_list);
if(context == EGL_NO_CONTEXT) {
std::cerr << "eglCreateContext failed: " << std::hex << eglGetError() << std::endl;
return false;
}
surface = eglCreatePbufferSurface(display, config, pbuffer_attrib_list);
if(surface == EGL_NO_SURFACE) {
std::cerr << "eglCreatePbufferSurface failed: " << std::hex << eglGetError() << std::endl;
return false;
}
eglMakeCurrent(display, surface, surface, context);
return true;
}
<commit_msg>Add error code to failure to initialize display<commit_after>
#include "common.h"
#include <iostream>
const char *gl_error_to_str(EGLint error){
switch(error){
case EGL_SUCCESS: return "EGL_SUCCESS";
case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
default: return "BAD ERROR";
}
}
bool init_gl(
const int width,
const int height,
EGLDisplay& display,
EGLConfig& config,
EGLContext& context,
EGLSurface& surface
) {
const EGLint config_attribute_list[] =
{
//EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RED_SIZE, 4,
EGL_GREEN_SIZE, 4,
EGL_BLUE_SIZE, 4,
EGL_ALPHA_SIZE, 4,
EGL_CONFORMANT, EGL_OPENGL_ES3_BIT,
EGL_DEPTH_SIZE, 16,
EGL_NONE
};
const EGLint context_attrib_list[] =
{
EGL_CONTEXT_CLIENT_VERSION, 3,
EGL_NONE
};
const EGLint pbuffer_attrib_list[] =
{
EGL_WIDTH, width,
EGL_HEIGHT, height,
EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE,
EGL_TEXTURE_TARGET, EGL_NO_TEXTURE,
EGL_LARGEST_PBUFFER, EGL_TRUE,
EGL_NONE
};
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
EGLint major;
EGLint minor;
if(eglInitialize(display, &major, &minor) == EGL_FALSE) {
std::cerr << "eglInitialize failed with " << gl_error_to_str(eglGetError()) << std::endl;
return false;
}
EGLint num_config;
if(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config) == EGL_FALSE) {
std::cerr << "eglChooseConfig failed." << std::endl;
return false;
}
if(num_config != 1) {
std::cerr << "eglChooseConfig did not return 1 config." << std::endl;
return false;
}
context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attrib_list);
if(context == EGL_NO_CONTEXT) {
std::cerr << "eglCreateContext failed: " << std::hex << eglGetError() << std::endl;
return false;
}
surface = eglCreatePbufferSurface(display, config, pbuffer_attrib_list);
if(surface == EGL_NO_SURFACE) {
std::cerr << "eglCreatePbufferSurface failed: " << std::hex << eglGetError() << std::endl;
return false;
}
eglMakeCurrent(display, surface, surface, context);
return true;
}
<|endoftext|> |
<commit_before>/*
Copyright (C) 2001 by W.C.A. Wijngaards
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define SYSDEF_ALLOCA
#include "cssysdef.h"
#include "isomesh.h"
#include "ivideo/graph3d.h"
#include "csgeom/math2d.h"
#include "csgeom/polyclip.h"
#include "ivideo/material.h"
#include "ivideo/texture.h"
#include "ivideo/txtmgr.h"
#include "iengine/material.h"
#include "imesh/object.h"
#include "isys/system.h"
#include "qint.h"
#include "iengine/movable.h"
#include "iengine/rview.h"
#include "iengine/camera.h"
//------------- Fake 3d Interfaces -----------------------------
/// fake a movable for a MeshSprite
class csIsoFakeMovable : public iMovable
{
iIsoMeshSprite *isomesh;
/// a transform, for passing refs, information is kept in the mesh though.
csReversibleTransform obj;
long updatenumber;
public:
DECLARE_IBASE;
csIsoFakeMovable(iIsoMeshSprite *t) {isomesh = t; updatenumber = 0;}
virtual ~csIsoFakeMovable() {}
//----- iMovable -------------------------------
virtual iMovable* GetParent () const {return 0;}
virtual void SetSector (iSector* ) { updatenumber++; }
virtual void ClearSectors () { updatenumber++; }
virtual void AddSector (iSector* ) { updatenumber++; }
virtual const csVector& GetSectors () const {return *(csVector*)0;}
virtual iSector* GetSector (int ) const {return 0;}
virtual int GetSectorCount () const { return 0; }
virtual bool InSector () const {return true;}
virtual void SetPosition (iSector*, const csVector3& v)
{ isomesh->SetPosition(v); updatenumber++; }
virtual void SetPosition (const csVector3& v)
{
isomesh->SetPosition(v);
updatenumber++;
}
virtual const csVector3& GetPosition () const {return isomesh->GetPosition();}
virtual const csVector3 GetFullPosition () const {return isomesh->GetPosition();}
virtual void SetTransform (const csReversibleTransform& t)
{
isomesh->SetTransform(t.GetT2O());
isomesh->SetPosition(t.GetOrigin());
updatenumber++;
}
virtual csReversibleTransform& GetTransform ()
{
obj.SetT2O(isomesh->GetTransform());
obj.SetOrigin(isomesh->GetPosition());
return obj;
}
virtual csReversibleTransform GetFullTransform () const
{
csReversibleTransform obj;
obj.SetT2O(isomesh->GetTransform());
obj.SetOrigin(isomesh->GetPosition());
return obj;
}
virtual void MovePosition (const csVector3& v)
{
isomesh->MovePosition(v);
updatenumber++;
}
virtual void SetTransform (const csMatrix3& matrix)
{
isomesh->SetTransform( matrix );
updatenumber++;
}
virtual void Transform (const csMatrix3& matrix)
{
isomesh->SetTransform( matrix * isomesh->GetTransform() );
updatenumber++;
}
virtual void AddListener (iMovableListener* /*listener*/, void* /*userdata*/)
{
/// does not work
}
virtual void RemoveListener (iMovableListener* )
{
/// does not work
}
virtual void UpdateMove () { updatenumber++; }
virtual long GetUpdateNumber () const
{
return updatenumber;
}
};
IMPLEMENT_IBASE (csIsoFakeMovable)
IMPLEMENTS_INTERFACE (iMovable)
IMPLEMENT_IBASE_END
/// fake 3d render view ...
class csIsoFakeRenderView : public iRenderView {
iCamera *fakecam;
iIsoRenderView *isorview;
/**
* A callback function. If this is set then no drawing is done.
* Instead the callback function is called.
*/
iDrawFuncCallback* callback;
public:
DECLARE_IBASE;
csIsoFakeRenderView() {}
virtual ~csIsoFakeRenderView()
{
DEC_REF (callback);
}
/// set data to render an isometric mesh
void SetIsoData(iIsoRenderView *r, iCamera *cam)
{
isorview = r;
fakecam = cam;
}
//---------------- iRenderView -----------------------
virtual csRenderContext* GetRenderContext () {return 0;}
virtual void CreateRenderContext() {}
virtual void RestoreRenderContext (csRenderContext* ) {}
virtual iCamera* CreateNewCamera() {return fakecam;} //@@@ copy?
virtual iEngine* GetEngine () {return 0;}
virtual iGraphics2D* GetGraphics2D ()
{return isorview->GetG3D()->GetDriver2D();}
virtual iGraphics3D* GetGraphics3D () {return isorview->GetG3D();}
virtual void SetFrustum (float, float, float, float) {}
virtual void GetFrustum (float&, float&, float&, float&) {}
virtual iClipper2D* GetClipper () {return isorview->GetClipper();}
virtual void SetClipper (iClipper2D*) {}
virtual bool IsClipperRequired () {return false;}
virtual bool GetClipPlane (csPlane3& ) {return false;}
virtual csPlane3& GetClipPlane () {return *(csPlane3*)0;}
virtual void SetClipPlane (const csPlane3& ) {}
virtual void UseClipPlane (bool ) {}
virtual void UseClipFrustum (bool ) {}
virtual csFogInfo* GetFirstFogInfo () {return 0;}
virtual void SetFirstFogInfo (csFogInfo* ) {}
virtual bool AddedFogInfo () {return false;}
virtual void ResetFogInfo () {}
virtual iCamera* GetCamera () {return fakecam;}
virtual void CalculateFogPolygon (G3DPolygonDP& ) {}
virtual void CalculateFogPolygon (G3DPolygonDPFX& ) {}
virtual void CalculateFogMesh (const csTransform& , G3DTriangleMesh& ) {}
virtual bool ClipBBox (const csBox2& sbox, const csBox3& /*cbox*/,
int& clip_portal, int& clip_plane, int& clip_z_plane)
{
clip_plane = CS_CLIP_NOT;
/// test if chance that we must clip to a portal -> or the Toplevel clipper
/// better: only if it crosses that.
const csRect& rect = isorview->GetView()->GetRect();
if( (rect.xmin >= QInt(sbox.MinX())) || (rect.xmax <= QInt(sbox.MaxX())) ||
(rect.ymin >= QInt(sbox.MinY())) || (rect.ymax <= QInt(sbox.MaxY())) )
clip_portal = CS_CLIP_TOPLEVEL;
else clip_portal = CS_CLIP_NOT;
/// test if z becomes negative, should never happen
clip_z_plane = CS_CLIP_NOT;
return true;
}
virtual iSector* GetThisSector () {return 0;}
virtual void SetThisSector (iSector* ) {}
virtual iSector* GetPreviousSector () {return 0;}
virtual void SetPreviousSector (iSector* ) {}
virtual iPolygon3D* GetPortalPolygon () {return 0;}
virtual void SetPortalPolygon (iPolygon3D* ) {}
virtual int GetRenderRecursionLevel () {return 0;}
virtual void SetRenderRecursionLevel (int ) {}
virtual void AttachRenderContextData (void* key, iBase* data)
{
(void)key;
(void)data;
}
virtual iBase* FindRenderContextData (void* key)
{
(void)key;
return 0;
}
virtual void DeleteRenderContextData (void* key)
{
(void)key;
}
virtual void SetCallback (iDrawFuncCallback* cb)
{
if (callback)
callback->DecRef ();
callback = cb;
if (callback)
callback->IncRef ();
}
virtual iDrawFuncCallback* GetCallback ()
{
return callback;
}
virtual void CallCallback (int type, void* data)
{
callback->DrawFunc (this, type, data);
}
};
IMPLEMENT_IBASE (csIsoFakeRenderView)
IMPLEMENTS_INTERFACE (iRenderView)
IMPLEMENT_IBASE_END
//------------ IsoMeshSprite ------------------------------------
IMPLEMENT_IBASE (csIsoMeshSprite)
IMPLEMENTS_INTERFACE (iIsoMeshSprite)
IMPLEMENTS_INTERFACE (iIsoSprite)
IMPLEMENT_IBASE_END
csIsoMeshSprite::csIsoMeshSprite (iBase *iParent)
{
CONSTRUCT_IBASE (iParent);
position.Set(0,0,0);
transform.Identity();
grid = NULL;
gridcall = NULL;
gridcalldata = NULL;
mesh = NULL;
zbufmode = CS_ZBUF_USE;
}
csIsoMeshSprite::~csIsoMeshSprite ()
{
if(mesh) mesh->DecRef();
}
void csIsoMeshSprite::SetMeshObject(iMeshObject *mesh)
{
if(mesh) mesh->IncRef();
if(csIsoMeshSprite::mesh) csIsoMeshSprite::mesh->DecRef();
csIsoMeshSprite::mesh = mesh;
}
void csIsoMeshSprite::Draw(iIsoRenderView *rview)
{
//printf("isomeshsprite::Draw(%g, %g, %g)\n", position.x, position.y,
//position.z);
/// update animation
mesh->NextFrame(rview->GetView()->GetEngine()->GetSystem()->GetTime());
//iGraphics3D* g3d = rview->GetG3D ();
iIsoView* view = rview->GetView ();
// Prepare for rendering.
//g3d->SetRenderState (G3DRENDERSTATE_ZBUFFERMODE, zbufmode);
/// create a fake environment for the mesh so that it will render nicely.
/// the meshes use a perspective transform, and we do not want that.
/// but an approximation of the isometric transform can be given.
// It works like this:
// camera.x,y,z are a linear combination of x,y,z.
// -> this gives the fake camera transformation matrix.
// the fake camera z = iso.z-iso.x.
// The camera translation is then used to correct stuff.
// the z translation is set to -zlowerbound.
// Now the fov is set to iso.z - iso.x - zlowerbound.
// (for the iso coords of the center position).
// (this is why it is only an approximation).
//
// when the mesh object draws, the following will happen:
// the point is transformed using the given camera.
// iz = fov/z. (note that fov is almost equal to z, so iz is almost 1)
// sx = x*iz + shiftx;
// sy = y*iz + shifty;
// this will leave x,y almost unchanged, and shifted (as per iso camera).
// the depth buffer is filled with 1./z. , but this is (due to fake camera)
// equal to 1./(iso.z - iso.x - zlowerbound), which is exactly what the
// isometric engine uses as depth buffer values.
/// create fake moveable
csIsoFakeMovable* movable = new csIsoFakeMovable(this);
/// create fake camera
iCamera *fakecam = view->GetFakeCamera(position, rview);
/// create fake renderview
csIsoFakeRenderView *fakerview = new csIsoFakeRenderView();
fakerview->SetIsoData(rview, fakecam);
if(mesh->DrawTest(fakerview, movable))
{
//printf("mesh draw()\n");
/// UpdateLighting ....
iLight **lights = NULL;
int numlights = 0;
grid->GetFakeLights(position, lights, numlights);
mesh->UpdateLighting(lights, numlights, movable);
if(mesh->Draw(fakerview, movable, zbufmode))
{
//printf("mesh prob vis\n");
/// was probably visible
}
}
delete movable;
delete fakerview;
return;// true;
}
//------ further iIsoSprite compliance implementation ---------
int csIsoMeshSprite::GetVertexCount() const
{
return 0;
}
void csIsoMeshSprite::AddVertex(const csVector3& /*coord*/, float /*u*/,
float /*v*/)
{
/// no effect
}
void csIsoMeshSprite::SetPosition(const csVector3& newpos)
{
/// manage movement of the sprite, oldpos, newpos
csVector3 oldpos = position;
position = newpos; // already set, so it can be overridden
if(grid) grid->MoveSprite(this, oldpos, newpos);
}
void csIsoMeshSprite::MovePosition(const csVector3& delta)
{
SetPosition(position + delta);
}
void csIsoMeshSprite::SetMaterialWrapper(iMaterialWrapper * /*material*/)
{
// nothing
}
iMaterialWrapper* csIsoMeshSprite::GetMaterialWrapper() const
{
return NULL;
}
void csIsoMeshSprite::SetMixMode(UInt /*mode*/)
{
// nothing
}
UInt csIsoMeshSprite::GetMixMode() const
{
/// CS_FX_COPY -> rendered in main pass,
/// CS_FX_ADD -> in alpha pass
if((zbufmode == CS_ZBUF_USE)
||(zbufmode == CS_ZBUF_FILL))
return CS_FX_COPY;
return CS_FX_ADD;
}
void csIsoMeshSprite::SetGrid(iIsoGrid *grid)
{
if(csIsoMeshSprite::grid != grid)
{
csIsoMeshSprite::grid = grid;
if(gridcall) gridcall(this, gridcalldata);
}
}
void csIsoMeshSprite::SetAllColors(const csColor& /*color*/)
{
// nothing to happen
}
const csVector3& csIsoMeshSprite::GetVertexPosition(int /*i*/)
{
static csVector3 pos(0,0,0);
return pos;
}
void csIsoMeshSprite::AddToVertexColor(int /*i*/, const csColor& /*color*/)
{
/// nothing
}
void csIsoMeshSprite::ResetAllColors()
{
/// nothing
}
void csIsoMeshSprite::SetAllStaticColors(const csColor& /*color*/)
{
/// nothing
}
void csIsoMeshSprite::AddToVertexStaticColor(int /*i*/,
const csColor& /*color*/)
{
/// nothing
}
<commit_msg>callback initialization added, better for karma and crash prevention<commit_after>/*
Copyright (C) 2001 by W.C.A. Wijngaards
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define SYSDEF_ALLOCA
#include "cssysdef.h"
#include "isomesh.h"
#include "ivideo/graph3d.h"
#include "csgeom/math2d.h"
#include "csgeom/polyclip.h"
#include "ivideo/material.h"
#include "ivideo/texture.h"
#include "ivideo/txtmgr.h"
#include "iengine/material.h"
#include "imesh/object.h"
#include "isys/system.h"
#include "qint.h"
#include "iengine/movable.h"
#include "iengine/rview.h"
#include "iengine/camera.h"
//------------- Fake 3d Interfaces -----------------------------
/// fake a movable for a MeshSprite
class csIsoFakeMovable : public iMovable
{
iIsoMeshSprite *isomesh;
/// a transform, for passing refs, information is kept in the mesh though.
csReversibleTransform obj;
long updatenumber;
public:
DECLARE_IBASE;
csIsoFakeMovable(iIsoMeshSprite *t) {isomesh = t; updatenumber = 0;}
virtual ~csIsoFakeMovable() {}
//----- iMovable -------------------------------
virtual iMovable* GetParent () const {return 0;}
virtual void SetSector (iSector* ) { updatenumber++; }
virtual void ClearSectors () { updatenumber++; }
virtual void AddSector (iSector* ) { updatenumber++; }
virtual const csVector& GetSectors () const {return *(csVector*)0;}
virtual iSector* GetSector (int ) const {return 0;}
virtual int GetSectorCount () const { return 0; }
virtual bool InSector () const {return true;}
virtual void SetPosition (iSector*, const csVector3& v)
{ isomesh->SetPosition(v); updatenumber++; }
virtual void SetPosition (const csVector3& v)
{
isomesh->SetPosition(v);
updatenumber++;
}
virtual const csVector3& GetPosition () const {return isomesh->GetPosition();}
virtual const csVector3 GetFullPosition () const {return isomesh->GetPosition();}
virtual void SetTransform (const csReversibleTransform& t)
{
isomesh->SetTransform(t.GetT2O());
isomesh->SetPosition(t.GetOrigin());
updatenumber++;
}
virtual csReversibleTransform& GetTransform ()
{
obj.SetT2O(isomesh->GetTransform());
obj.SetOrigin(isomesh->GetPosition());
return obj;
}
virtual csReversibleTransform GetFullTransform () const
{
csReversibleTransform obj;
obj.SetT2O(isomesh->GetTransform());
obj.SetOrigin(isomesh->GetPosition());
return obj;
}
virtual void MovePosition (const csVector3& v)
{
isomesh->MovePosition(v);
updatenumber++;
}
virtual void SetTransform (const csMatrix3& matrix)
{
isomesh->SetTransform( matrix );
updatenumber++;
}
virtual void Transform (const csMatrix3& matrix)
{
isomesh->SetTransform( matrix * isomesh->GetTransform() );
updatenumber++;
}
virtual void AddListener (iMovableListener* /*listener*/, void* /*userdata*/)
{
/// does not work
}
virtual void RemoveListener (iMovableListener* )
{
/// does not work
}
virtual void UpdateMove () { updatenumber++; }
virtual long GetUpdateNumber () const
{
return updatenumber;
}
};
IMPLEMENT_IBASE (csIsoFakeMovable)
IMPLEMENTS_INTERFACE (iMovable)
IMPLEMENT_IBASE_END
/// fake 3d render view ...
class csIsoFakeRenderView : public iRenderView {
iCamera *fakecam;
iIsoRenderView *isorview;
/**
* A callback function. If this is set then no drawing is done.
* Instead the callback function is called.
*/
iDrawFuncCallback* callback;
public:
DECLARE_IBASE;
csIsoFakeRenderView()
{
callback = NULL;
}
virtual ~csIsoFakeRenderView()
{
DEC_REF (callback);
}
/// set data to render an isometric mesh
void SetIsoData(iIsoRenderView *r, iCamera *cam)
{
isorview = r;
fakecam = cam;
}
//---------------- iRenderView -----------------------
virtual csRenderContext* GetRenderContext () {return 0;}
virtual void CreateRenderContext() {}
virtual void RestoreRenderContext (csRenderContext* ) {}
virtual iCamera* CreateNewCamera() {return fakecam;} //@@@ copy?
virtual iEngine* GetEngine () {return 0;}
virtual iGraphics2D* GetGraphics2D ()
{return isorview->GetG3D()->GetDriver2D();}
virtual iGraphics3D* GetGraphics3D () {return isorview->GetG3D();}
virtual void SetFrustum (float, float, float, float) {}
virtual void GetFrustum (float&, float&, float&, float&) {}
virtual iClipper2D* GetClipper () {return isorview->GetClipper();}
virtual void SetClipper (iClipper2D*) {}
virtual bool IsClipperRequired () {return false;}
virtual bool GetClipPlane (csPlane3& ) {return false;}
virtual csPlane3& GetClipPlane () {return *(csPlane3*)0;}
virtual void SetClipPlane (const csPlane3& ) {}
virtual void UseClipPlane (bool ) {}
virtual void UseClipFrustum (bool ) {}
virtual csFogInfo* GetFirstFogInfo () {return 0;}
virtual void SetFirstFogInfo (csFogInfo* ) {}
virtual bool AddedFogInfo () {return false;}
virtual void ResetFogInfo () {}
virtual iCamera* GetCamera () {return fakecam;}
virtual void CalculateFogPolygon (G3DPolygonDP& ) {}
virtual void CalculateFogPolygon (G3DPolygonDPFX& ) {}
virtual void CalculateFogMesh (const csTransform& , G3DTriangleMesh& ) {}
virtual bool ClipBBox (const csBox2& sbox, const csBox3& /*cbox*/,
int& clip_portal, int& clip_plane, int& clip_z_plane)
{
clip_plane = CS_CLIP_NOT;
/// test if chance that we must clip to a portal -> or the Toplevel clipper
/// better: only if it crosses that.
const csRect& rect = isorview->GetView()->GetRect();
if( (rect.xmin >= QInt(sbox.MinX())) || (rect.xmax <= QInt(sbox.MaxX())) ||
(rect.ymin >= QInt(sbox.MinY())) || (rect.ymax <= QInt(sbox.MaxY())) )
clip_portal = CS_CLIP_TOPLEVEL;
else clip_portal = CS_CLIP_NOT;
/// test if z becomes negative, should never happen
clip_z_plane = CS_CLIP_NOT;
return true;
}
virtual iSector* GetThisSector () {return 0;}
virtual void SetThisSector (iSector* ) {}
virtual iSector* GetPreviousSector () {return 0;}
virtual void SetPreviousSector (iSector* ) {}
virtual iPolygon3D* GetPortalPolygon () {return 0;}
virtual void SetPortalPolygon (iPolygon3D* ) {}
virtual int GetRenderRecursionLevel () {return 0;}
virtual void SetRenderRecursionLevel (int ) {}
virtual void AttachRenderContextData (void* key, iBase* data)
{
(void)key;
(void)data;
}
virtual iBase* FindRenderContextData (void* key)
{
(void)key;
return 0;
}
virtual void DeleteRenderContextData (void* key)
{
(void)key;
}
virtual void SetCallback (iDrawFuncCallback* cb)
{
if (callback)
callback->DecRef ();
callback = cb;
if (callback)
callback->IncRef ();
}
virtual iDrawFuncCallback* GetCallback ()
{
return callback;
}
virtual void CallCallback (int type, void* data)
{
callback->DrawFunc (this, type, data);
}
};
IMPLEMENT_IBASE (csIsoFakeRenderView)
IMPLEMENTS_INTERFACE (iRenderView)
IMPLEMENT_IBASE_END
//------------ IsoMeshSprite ------------------------------------
IMPLEMENT_IBASE (csIsoMeshSprite)
IMPLEMENTS_INTERFACE (iIsoMeshSprite)
IMPLEMENTS_INTERFACE (iIsoSprite)
IMPLEMENT_IBASE_END
csIsoMeshSprite::csIsoMeshSprite (iBase *iParent)
{
CONSTRUCT_IBASE (iParent);
position.Set(0,0,0);
transform.Identity();
grid = NULL;
gridcall = NULL;
gridcalldata = NULL;
mesh = NULL;
zbufmode = CS_ZBUF_USE;
}
csIsoMeshSprite::~csIsoMeshSprite ()
{
if(mesh) mesh->DecRef();
}
void csIsoMeshSprite::SetMeshObject(iMeshObject *mesh)
{
if(mesh) mesh->IncRef();
if(csIsoMeshSprite::mesh) csIsoMeshSprite::mesh->DecRef();
csIsoMeshSprite::mesh = mesh;
}
void csIsoMeshSprite::Draw(iIsoRenderView *rview)
{
//printf("isomeshsprite::Draw(%g, %g, %g)\n", position.x, position.y,
//position.z);
/// update animation
mesh->NextFrame(rview->GetView()->GetEngine()->GetSystem()->GetTime());
//iGraphics3D* g3d = rview->GetG3D ();
iIsoView* view = rview->GetView ();
// Prepare for rendering.
//g3d->SetRenderState (G3DRENDERSTATE_ZBUFFERMODE, zbufmode);
/// create a fake environment for the mesh so that it will render nicely.
/// the meshes use a perspective transform, and we do not want that.
/// but an approximation of the isometric transform can be given.
// It works like this:
// camera.x,y,z are a linear combination of x,y,z.
// -> this gives the fake camera transformation matrix.
// the fake camera z = iso.z-iso.x.
// The camera translation is then used to correct stuff.
// the z translation is set to -zlowerbound.
// Now the fov is set to iso.z - iso.x - zlowerbound.
// (for the iso coords of the center position).
// (this is why it is only an approximation).
//
// when the mesh object draws, the following will happen:
// the point is transformed using the given camera.
// iz = fov/z. (note that fov is almost equal to z, so iz is almost 1)
// sx = x*iz + shiftx;
// sy = y*iz + shifty;
// this will leave x,y almost unchanged, and shifted (as per iso camera).
// the depth buffer is filled with 1./z. , but this is (due to fake camera)
// equal to 1./(iso.z - iso.x - zlowerbound), which is exactly what the
// isometric engine uses as depth buffer values.
/// create fake moveable
csIsoFakeMovable* movable = new csIsoFakeMovable(this);
/// create fake camera
iCamera *fakecam = view->GetFakeCamera(position, rview);
/// create fake renderview
csIsoFakeRenderView *fakerview = new csIsoFakeRenderView();
fakerview->SetIsoData(rview, fakecam);
if(mesh->DrawTest(fakerview, movable))
{
//printf("mesh draw()\n");
/// UpdateLighting ....
iLight **lights = NULL;
int numlights = 0;
grid->GetFakeLights(position, lights, numlights);
mesh->UpdateLighting(lights, numlights, movable);
if(mesh->Draw(fakerview, movable, zbufmode))
{
//printf("mesh prob vis\n");
/// was probably visible
}
}
delete movable;
delete fakerview;
return;// true;
}
//------ further iIsoSprite compliance implementation ---------
int csIsoMeshSprite::GetVertexCount() const
{
return 0;
}
void csIsoMeshSprite::AddVertex(const csVector3& /*coord*/, float /*u*/,
float /*v*/)
{
/// no effect
}
void csIsoMeshSprite::SetPosition(const csVector3& newpos)
{
/// manage movement of the sprite, oldpos, newpos
csVector3 oldpos = position;
position = newpos; // already set, so it can be overridden
if(grid) grid->MoveSprite(this, oldpos, newpos);
}
void csIsoMeshSprite::MovePosition(const csVector3& delta)
{
SetPosition(position + delta);
}
void csIsoMeshSprite::SetMaterialWrapper(iMaterialWrapper * /*material*/)
{
// nothing
}
iMaterialWrapper* csIsoMeshSprite::GetMaterialWrapper() const
{
return NULL;
}
void csIsoMeshSprite::SetMixMode(UInt /*mode*/)
{
// nothing
}
UInt csIsoMeshSprite::GetMixMode() const
{
/// CS_FX_COPY -> rendered in main pass,
/// CS_FX_ADD -> in alpha pass
if((zbufmode == CS_ZBUF_USE)
||(zbufmode == CS_ZBUF_FILL))
return CS_FX_COPY;
return CS_FX_ADD;
}
void csIsoMeshSprite::SetGrid(iIsoGrid *grid)
{
if(csIsoMeshSprite::grid != grid)
{
csIsoMeshSprite::grid = grid;
if(gridcall) gridcall(this, gridcalldata);
}
}
void csIsoMeshSprite::SetAllColors(const csColor& /*color*/)
{
// nothing to happen
}
const csVector3& csIsoMeshSprite::GetVertexPosition(int /*i*/)
{
static csVector3 pos(0,0,0);
return pos;
}
void csIsoMeshSprite::AddToVertexColor(int /*i*/, const csColor& /*color*/)
{
/// nothing
}
void csIsoMeshSprite::ResetAllColors()
{
/// nothing
}
void csIsoMeshSprite::SetAllStaticColors(const csColor& /*color*/)
{
/// nothing
}
void csIsoMeshSprite::AddToVertexStaticColor(int /*i*/,
const csColor& /*color*/)
{
/// nothing
}
<|endoftext|> |
<commit_before>/*
* 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 Library 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* KarateLight.cpp
* The KarateLight communication class
* Copyright (C) 2013 Carsten Presser
*/
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <sys/file.h>
#include <termios.h>
#include <iostream>
#include <string>
#include "ola/Logging.h"
#include "ola/DmxBuffer.h"
#include "plugins/karate/KarateLight.h"
namespace ola {
namespace plugin {
namespace karate {
/**
* Default constructor
* \param dev the filename of the device to use
*/
KarateLight::KarateLight(const string &dev)
:m_devname(dev),
m_fw_version(0),
m_hw_version(0),
m_nChannels(0),
m_use_memcmp(1),
m_active(false) {
}
/**
* Default desctuctor
* closes the device and does release the file-lock
*/
KarateLight::~KarateLight() {
// remove lock and close file
flock(m_fd, LOCK_UN);
tcflush(m_fd, TCIOFLUSH);
close(m_fd);
}
/**
* Sends color values previously set via
* \sa SetColor
* \returns KL_OK on success, a negative error value otherwise
*/
int KarateLight::UpdateColors() {
int j;
int chunks;
if (!m_active)
return KL_NOTACTIVE;
chunks = (m_nChannels + CHUNK_SIZE - 1)/CHUNK_SIZE;
// write colors
for (j = 0; j < chunks; j++) {
if ((memcmp(&m_color_buffer[j*CHUNK_SIZE], \
&m_color_buffer_old[j*CHUNK_SIZE], CHUNK_SIZE) == 0) \
&& (m_use_memcmp == 1)) {
continue;
}
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(j+CMD_SET_DATA_00, \
&m_color_buffer[j*CHUNK_SIZE], \
CHUNK_SIZE));
if (m_byteswritten != (CMD_DATA_START + CHUNK_SIZE)) {
OLA_WARN << "failed to write data to " << m_devname;
return KL_WRITEFAIL;
}
if (KarateLight::ReadBack() != KL_OK) {
return KL_WRITEFAIL;
}
}
// update old_values
memcpy(&m_color_buffer_old[0], &m_color_buffer[0], MAX_CHANNELS);
return KL_OK;
}
int KarateLight::SetColors(DmxBuffer da) {
unsigned int length;
length = da.Size();
if ((length + m_dmx_offset) > MAX_CHANNELS) {
length = MAX_CHANNELS - m_dmx_offset;
}
da.GetRange(m_dmx_offset, m_color_buffer, &length);
return KL_OK;
}
/**
* Sets all Channels to black and sends data to the device
* \returns KL_OK on success, a negative error value otherwise
*/
int KarateLight::Blank() {
// set channels to black
memset(m_color_buffer, 0, MAX_CHANNELS);
memset(m_color_buffer_old, 1, MAX_CHANNELS);
return KarateLight::UpdateColors();
}
/**
* Reads the a single byte from the eeprom
* \parm addr the eeprom location
* \return the eeprom byte, or a return-code <0 in case there is an error
*/
int KarateLight::ReadEeprom(uint8_t addr) {
unsigned int j;
if (!m_active)
return KL_NOTACTIVE;
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_READ_EEPROM, &addr, 1));
if (m_byteswritten != CMD_DATA_START+1) {
OLA_WARN << "failed to write data to " << m_devname;
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 1) {
return m_rd_buffer[CMD_DATA_START];
}
return j; // if j!=1 byte
}
/**
* Initialize the device
* 1. open the devicefile and get a file lock
* 2. read defaults (firmware, hardware, channels count)
* 3. set all channels to black
*/
int KarateLight::Init() {
int j, i;
struct termios options;
if (m_active)
return KL_NOTACTIVE;
m_fd = open(m_devname.c_str(), O_RDWR | O_NOCTTY);
if (m_fd < 0) {
OLA_FATAL << "failed to open " << m_devname;
return KL_ERROR;
}
/* Clear the line */
tcflush(m_fd, TCOFLUSH);
memset(&options, 0, sizeof(options));
cfsetispeed(&options, B115200);
cfsetospeed(&options, B115200);
// options.c_cflag = (CS8 | CSTOPB | CLOCAL | CREAD);
options.c_cflag = (CS8 | CLOCAL | CREAD);
// If MIN = 0 and TIME > 0, TIME serves as a timeout value. The read
// will be satisfied if a single character is read, or TIME is
// exceeded (t = TIME *0.1 s). If TIME is exceeded, no character will
// be returned.
options.c_cc[VTIME] = 1;
options.c_cc[VMIN] = 0; // always require at least one byte returned
// Update the options and do it NOW
if (tcsetattr(m_fd, TCSANOW, &options) != 0) {
OLA_FATAL << "tcsetattr failed on " << m_devname;
return KL_ERROR;
}
// clear possible junk data still in the systems fifo
m_bytesread = 1;
while (m_bytesread > 0) {
m_bytesread = read(m_fd, m_rd_buffer, 255);
}
// read firmware version
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_GET_VERSION, NULL, 0));
if (m_byteswritten != CMD_DATA_START) {
OLA_WARN << "failed to write data to " << m_devname;
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 1) {
m_fw_version = m_rd_buffer[CMD_DATA_START];
OLA_INFO << "Firmware-Version is " << std::hex << m_fw_version;
} else {
OLA_FATAL << "failed to read the firmware-version ";
return j;
}
// if an older Firware-Version is used. quit. the communication wont work
if (m_fw_version < 0x30) {
OLA_FATAL << "Firmware 0x" << m_fw_version << "is to old!";
return KL_ERROR;
}
m_active = true;
// read HW version
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_GET_HARDWARE, NULL, 0));
if (m_byteswritten != CMD_DATA_START) {
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 1) {
m_hw_version = m_rd_buffer[CMD_DATA_START];
} else {
return j;
}
// read number of channels
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_GET_N_CHANNELS, NULL, 0));
if (m_byteswritten != CMD_DATA_START) {
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 2) {
m_nChannels = m_rd_buffer[CMD_DATA_START] \
+ m_rd_buffer[CMD_DATA_START+1] * 256;
} else {
return j;
}
// stuff specific for the KarateLight8/16
if (m_hw_version == HW_ID_KARATE) {
// disable memcmp for the classic KarateLight Hardware
m_use_memcmp = 0;
j = KarateLight::ReadEeprom(0x03);
i = KarateLight::ReadEeprom(0x02);
if ((j >= 0) && (i >= 0)) {
m_dmx_offset = j*256;
m_dmx_offset += i;
} else {
OLA_WARN << "Error Reading EEPROM";
return j;
}
if (m_dmx_offset > 511) {
OLA_INFO << "DMX Offset to large" << std::dec \
<< m_dmx_offset << ". Setting it to 0";
m_dmx_offset = 0;
}
} else {
// KL-DMX-Device
m_dmx_offset = 0;
}
// set channels to zero
KarateLight::Blank();
OLA_INFO << "successfully initalized device " << m_devname \
<< " with firmware revision 0x" << std::hex << m_fw_version;
return KL_OK;
}
/*
PRIVATE FUNCTIONS
*/
/**
* Perform a checksum calculation of the command currently in the buffer
* The Checksum is a simple XOR over all bytes send, except the chechsum-byte.
* \param the lenght of the command to be processed
* \returns the lengh of the command
*/
int KarateLight::CalcChecksum(int len) {
int i;
// clear byte 2
m_wr_buffer[CMD_HD_CHECK] = 0;
for (i = 0; i < len; i++) {
if (i != CMD_HD_CHECK) {
m_wr_buffer[CMD_HD_CHECK]^= m_wr_buffer[i];
}
}
return len;
}
/**
* Creates and stores a command in the command buffer
* \param cmd the commandcode to be used
* \param data a pointer to a buffer containing data to be included in the command
* \param len number of bytes to be read from data
* \returns the lengh of the command, negative values indicate an error
*/
int KarateLight::CreateCommand(int cmd, uint8_t * data, int len) {
int i = 0;
// maximum command lenght
if (len > (CMD_MAX_LENGTH - CMD_DATA_START)) {
OLA_WARN << "Error: Command is to long (" << std::dec << len << " > "\
<< (CMD_MAX_LENGTH - CMD_DATA_START);
return KL_ERROR;
}
// build header
m_wr_buffer[CMD_HD_SYNC] = CMD_SYNC_SEND;
m_wr_buffer[CMD_HD_COMMAND] = cmd;
m_wr_buffer[CMD_HD_LEN] = len;
// copy data
while (len > i) {
m_wr_buffer[CMD_DATA_START+i] = data[i];
i++;
}
// calc checksum
i = KarateLight::CalcChecksum(CMD_DATA_START+len);
return i;
}
/**
* Tries to read an answer from the device
* \return the number of bytes read, or an error value <0
*/
int KarateLight::ReadBack() {
// read header (4 bytes)
m_bytesread = read(m_fd, m_rd_buffer, CMD_DATA_START);
if (m_bytesread != CMD_DATA_START) {
OLA_FATAL << "could not read 4 bytes (header) from " << m_devname;
return KL_ERROR;
}
// read sequential
if (m_rd_buffer[CMD_HD_LEN] > 0) {
m_bytesread = read(m_fd, &m_rd_buffer[CMD_DATA_START], \
m_rd_buffer[CMD_HD_LEN]);
} else {
m_bytesread = 0;
}
if (m_bytesread == m_rd_buffer[CMD_HD_LEN]) {
// TODO(cpresser) verify checksum
return (m_bytesread);
} else {
OLA_WARN << "number of bytes read" << m_bytesread \
<< "does not match number of bytes expected" \
<< m_rd_buffer[CMD_HD_LEN];
return KL_CHECKSUMFAIL;
}
}
} // namespace karate
} // namespace plugin
} // namespace ola
<commit_msg>cleanup<commit_after>/*
* 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 Library 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* KarateLight.cpp
* The KarateLight communication class
* Copyright (C) 2013 Carsten Presser
*/
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <sys/file.h>
#include <termios.h>
#include <iostream>
#include <string>
#include "ola/Logging.h"
#include "ola/DmxBuffer.h"
#include "plugins/karate/KarateLight.h"
namespace ola {
namespace plugin {
namespace karate {
/**
* Default constructor
* \param dev the filename of the device to use
*/
KarateLight::KarateLight(const string &dev)
:m_devname(dev),
m_fw_version(0),
m_hw_version(0),
m_nChannels(0),
m_use_memcmp(1),
m_active(false) {
}
/**
* Default desctuctor
* closes the device and does release the file-lock
*/
KarateLight::~KarateLight() {
// remove lock and close file
flock(m_fd, LOCK_UN);
tcflush(m_fd, TCIOFLUSH);
close(m_fd);
}
/**
* Sends color values previously set via
* \sa SetColor
* \returns KL_OK on success, a negative error value otherwise
*/
int KarateLight::UpdateColors() {
int j;
int chunks;
if (!m_active)
return KL_NOTACTIVE;
chunks = (m_nChannels + CHUNK_SIZE - 1)/CHUNK_SIZE;
// write colors
for (j = 0; j < chunks; j++) {
if ((memcmp(&m_color_buffer[j*CHUNK_SIZE], \
&m_color_buffer_old[j*CHUNK_SIZE], CHUNK_SIZE) == 0) \
&& (m_use_memcmp == 1)) {
continue;
}
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(j+CMD_SET_DATA_00, \
&m_color_buffer[j*CHUNK_SIZE], \
CHUNK_SIZE));
if (m_byteswritten != (CMD_DATA_START + CHUNK_SIZE)) {
OLA_WARN << "failed to write data to " << m_devname;
return KL_WRITEFAIL;
}
if (KarateLight::ReadBack() != KL_OK) {
return KL_WRITEFAIL;
}
}
// update old_values
memcpy(&m_color_buffer_old[0], &m_color_buffer[0], MAX_CHANNELS);
return KL_OK;
}
int KarateLight::SetColors(DmxBuffer da) {
unsigned int length = da.Size();
if ((length + m_dmx_offset) > MAX_CHANNELS) {
length = MAX_CHANNELS - m_dmx_offset;
}
da.GetRange(m_dmx_offset, m_color_buffer, &length);
return KarateLight::UpdateColors();
}
/**
* Sets all Channels to black and sends data to the device
* \returns KL_OK on success, a negative error value otherwise
*/
int KarateLight::Blank() {
// set channels to black
memset(m_color_buffer, 0, MAX_CHANNELS);
memset(m_color_buffer_old, 1, MAX_CHANNELS);
return KarateLight::UpdateColors();
}
/**
* Reads the a single byte from the eeprom
* \parm addr the eeprom location
* \return the eeprom byte, or a return-code <0 in case there is an error
*/
int KarateLight::ReadEeprom(uint8_t addr) {
unsigned int j;
if (!m_active)
return KL_NOTACTIVE;
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_READ_EEPROM, &addr, 1));
if (m_byteswritten != CMD_DATA_START+1) {
OLA_WARN << "failed to write data to " << m_devname;
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 1) {
return m_rd_buffer[CMD_DATA_START];
}
return j; // if j!=1 byte
}
/**
* Initialize the device
* 1. open the devicefile and get a file lock
* 2. read defaults (firmware, hardware, channels count)
* 3. set all channels to black
*/
int KarateLight::Init() {
int j, i;
struct termios options;
if (m_active)
return KL_NOTACTIVE;
m_fd = open(m_devname.c_str(), O_RDWR | O_NOCTTY);
if (m_fd < 0) {
OLA_FATAL << "failed to open " << m_devname;
return KL_ERROR;
}
/* Clear the line */
tcflush(m_fd, TCOFLUSH);
memset(&options, 0, sizeof(options));
cfsetispeed(&options, B115200);
cfsetospeed(&options, B115200);
// options.c_cflag = (CS8 | CSTOPB | CLOCAL | CREAD);
options.c_cflag = (CS8 | CLOCAL | CREAD);
// If MIN = 0 and TIME > 0, TIME serves as a timeout value. The read
// will be satisfied if a single character is read, or TIME is
// exceeded (t = TIME *0.1 s). If TIME is exceeded, no character will
// be returned.
options.c_cc[VTIME] = 1;
options.c_cc[VMIN] = 0; // always require at least one byte returned
// Update the options and do it NOW
if (tcsetattr(m_fd, TCSANOW, &options) != 0) {
OLA_FATAL << "tcsetattr failed on " << m_devname;
return KL_ERROR;
}
// clear possible junk data still in the systems fifo
m_bytesread = 1;
while (m_bytesread > 0) {
m_bytesread = read(m_fd, m_rd_buffer, 255);
}
// read firmware version
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_GET_VERSION, NULL, 0));
if (m_byteswritten != CMD_DATA_START) {
OLA_WARN << "failed to write data to " << m_devname;
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 1) {
m_fw_version = m_rd_buffer[CMD_DATA_START];
OLA_INFO << "Firmware-Version is " << std::hex << m_fw_version;
} else {
OLA_FATAL << "failed to read the firmware-version ";
return j;
}
// if an older Firware-Version is used. quit. the communication wont work
if (m_fw_version < 0x30) {
OLA_FATAL << "Firmware 0x" << m_fw_version << "is to old!";
return KL_ERROR;
}
m_active = true;
// read HW version
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_GET_HARDWARE, NULL, 0));
if (m_byteswritten != CMD_DATA_START) {
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 1) {
m_hw_version = m_rd_buffer[CMD_DATA_START];
} else {
return j;
}
// read number of channels
m_byteswritten = write(m_fd, m_wr_buffer, \
KarateLight::CreateCommand(CMD_GET_N_CHANNELS, NULL, 0));
if (m_byteswritten != CMD_DATA_START) {
return KL_WRITEFAIL;
}
j = KarateLight::ReadBack();
if (j == 2) {
m_nChannels = m_rd_buffer[CMD_DATA_START] \
+ m_rd_buffer[CMD_DATA_START+1] * 256;
} else {
return j;
}
// stuff specific for the KarateLight8/16
if (m_hw_version == HW_ID_KARATE) {
// disable memcmp for the classic KarateLight Hardware
m_use_memcmp = 0;
j = KarateLight::ReadEeprom(0x03);
i = KarateLight::ReadEeprom(0x02);
if ((j >= 0) && (i >= 0)) {
m_dmx_offset = j*256;
m_dmx_offset += i;
} else {
OLA_WARN << "Error Reading EEPROM";
return j;
}
if (m_dmx_offset > 511) {
OLA_INFO << "DMX Offset to large" << std::dec \
<< m_dmx_offset << ". Setting it to 0";
m_dmx_offset = 0;
}
} else {
// KL-DMX-Device
m_dmx_offset = 0;
}
// set channels to zero
KarateLight::Blank();
OLA_INFO << "successfully initalized device " << m_devname \
<< " with firmware revision 0x" << std::hex << m_fw_version;
return KL_OK;
}
/*
PRIVATE FUNCTIONS
*/
/**
* Perform a checksum calculation of the command currently in the buffer
* The Checksum is a simple XOR over all bytes send, except the chechsum-byte.
* \param the lenght of the command to be processed
* \returns the lengh of the command
*/
int KarateLight::CalcChecksum(int len) {
int i;
// clear byte 2
m_wr_buffer[CMD_HD_CHECK] = 0;
for (i = 0; i < len; i++) {
if (i != CMD_HD_CHECK) {
m_wr_buffer[CMD_HD_CHECK]^= m_wr_buffer[i];
}
}
return len;
}
/**
* Creates and stores a command in the command buffer
* \param cmd the commandcode to be used
* \param data a pointer to a buffer containing data to be included in the command
* \param len number of bytes to be read from data
* \returns the lengh of the command, negative values indicate an error
*/
int KarateLight::CreateCommand(int cmd, uint8_t * data, int len) {
int i = 0;
// maximum command lenght
if (len > (CMD_MAX_LENGTH - CMD_DATA_START)) {
OLA_WARN << "Error: Command is to long (" << std::dec << len << " > "\
<< (CMD_MAX_LENGTH - CMD_DATA_START);
return KL_ERROR;
}
// build header
m_wr_buffer[CMD_HD_SYNC] = CMD_SYNC_SEND;
m_wr_buffer[CMD_HD_COMMAND] = cmd;
m_wr_buffer[CMD_HD_LEN] = len;
// copy data
while (len > i) {
m_wr_buffer[CMD_DATA_START+i] = data[i];
i++;
}
// calc checksum
i = KarateLight::CalcChecksum(CMD_DATA_START+len);
return i;
}
/**
* Tries to read an answer from the device
* \return the number of bytes read, or an error value <0
*/
int KarateLight::ReadBack() {
// read header (4 bytes)
m_bytesread = read(m_fd, m_rd_buffer, CMD_DATA_START);
if (m_bytesread != CMD_DATA_START) {
OLA_FATAL << "could not read 4 bytes (header) from " << m_devname;
return KL_ERROR;
}
// read sequential
if (m_rd_buffer[CMD_HD_LEN] > 0) {
m_bytesread = read(m_fd, &m_rd_buffer[CMD_DATA_START], \
m_rd_buffer[CMD_HD_LEN]);
} else {
m_bytesread = 0;
}
if (m_bytesread == m_rd_buffer[CMD_HD_LEN]) {
// TODO(cpresser) verify checksum
return (m_bytesread);
} else {
OLA_WARN << "number of bytes read" << m_bytesread \
<< "does not match number of bytes expected" \
<< m_rd_buffer[CMD_HD_LEN];
return KL_CHECKSUMFAIL;
}
}
} // namespace karate
} // namespace plugin
} // namespace ola
<|endoftext|> |
<commit_before>// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2015 - 2017)
// Rene Milk (2016 - 2018)
// Tim Keil (2017)
// Tobias Leibner (2016 - 2017)
#ifndef DUNE_GDT_LOCAL_ASSEMLBER_HH
#define DUNE_GDT_LOCAL_ASSEMLBER_HH
#include <dune/common/dynmatrix.hh>
#include <dune/common/dynvector.hh>
#include <dune/xt/functions/interfaces/grid-function.hh>
#include <dune/xt/grid/walker/apply-on.hh>
#include <dune/xt/grid/walker/wrapper.hh>
#include <dune/xt/la/container/interfaces.hh>
#include <dune/gdt/discretefunction/default.hh>
#include <dune/gdt/local/discretefunction.hh>
#include <dune/gdt/local/operators/interfaces.hh>
#include <dune/gdt/local/functionals/interfaces.hh>
#include <dune/gdt/spaces/interface.hh>
#include <dune/gdt/type_traits.hh>
namespace Dune {
namespace GDT {
template <class GridLayerType, class LocalOperatorType, class SourceType, class RangeType>
class LocalOperatorApplicator : public XT::Grid::internal::Codim0Object<GridLayerType>
{
static_assert(is_local_operator<LocalOperatorType>::value,
"LocalOperatorType has to be derived from LocalOperatorInterface!");
static_assert(XT::Functions::is_localizable_function<SourceType>::value,
"SourceType has to be derived from XT::Functions::GridFunctionInterface!");
static_assert(is_discrete_function<RangeType>::value, "RangeType has to be a DiscreteFunctionDefault!");
typedef XT::Grid::internal::Codim0Object<GridLayerType> BaseType;
public:
using typename BaseType::EntityType;
LocalOperatorApplicator(const GridLayerType& grid_layer,
const LocalOperatorType& local_operator,
const SourceType& source,
RangeType& range,
const XT::Grid::ApplyOn::WhichEntity<GridLayerType>& where)
: grid_layer_(grid_layer)
, local_operator_(local_operator)
, source_(source)
, range_(range)
, where_(where)
{
}
virtual bool apply_on(const GridLayerType& grid_layer, const EntityType& entity) const
{
return where_.apply_on(grid_layer, entity);
}
virtual void apply_local(const EntityType& entity)
{
local_operator_.apply(source_, *range_.local_discrete_function(entity));
}
private:
const GridLayerType& grid_layer_;
const LocalOperatorType& local_operator_;
const SourceType& source_;
RangeType& range_;
const XT::Grid::ApplyOn::WhichEntity<GridLayerType>& where_;
}; // class LocalOperatorApplicator
template <class GridViewType, class LocalOperatorType, class SourceType, class RangeType>
class LocalOperatorJacobianAssembler : public XT::Grid::internal::Codim0Object<GridViewType>
{
static_assert(is_local_operator<LocalOperatorType>::value,
"LocalOperatorType has to be derived from LocalOperatorInterface!");
static_assert(XT::Functions::is_localizable_function<SourceType>::value,
"SourceType has to be derived from XT::Functions::GridFunctionInterface!");
static_assert(is_discrete_function<RangeType>::value, "RangeType has to be a DiscreteFunctionDefault!");
typedef XT::Grid::internal::Codim0Object<GridViewType> BaseType;
public:
using typename BaseType::EntityType;
LocalOperatorJacobianAssembler(const GridViewType& grid_view,
const LocalOperatorType& local_operator,
const SourceType& x,
const SourceType& source,
RangeType& range,
const XT::Grid::ApplyOn::WhichEntity<GridViewType>& where)
: grid_view_(grid_view)
, local_operator_(local_operator)
, x_(x)
, source_(source)
, range_(range)
, where_(where)
{
}
virtual bool apply_on(const GridViewType& grid_view, const EntityType& entity) const
{
return where_.apply_on(grid_view, entity);
}
virtual void apply_local(const EntityType& entity)
{
local_operator_.assemble_jacobian(x_, source_, *range_.local_discrete_function(entity));
}
private:
const GridViewType& grid_view_;
const LocalOperatorType& local_operator_;
const SourceType& x_;
const SourceType& source_;
RangeType& range_;
const XT::Grid::ApplyOn::WhichEntity<GridViewType>& where_;
}; // class LocalOperatorJacobianAssembler
template <class GridLayerType, class LocalOperatorType, class SourceType, class RangeType>
class LocalCouplingOperatorApplicator : public XT::Grid::internal::Codim1Object<GridLayerType>
{
static_assert(is_local_coupling_operator<LocalOperatorType>::value,
"LocalOperatorType has to be derived from LocalCouplingOperatorInterface!");
static_assert(XT::Functions::is_localizable_function<SourceType>::value,
"SourceType has to be derived from XT::Functions::GridFunctionInterface!");
static_assert(is_discrete_function<RangeType>::value, "RangeType has to be a DiscreteFunctionDefault!");
typedef XT::Grid::internal::Codim1Object<GridLayerType> BaseType;
public:
using typename BaseType::EntityType;
using typename BaseType::IntersectionType;
LocalCouplingOperatorApplicator(const GridLayerType& grid_layer,
const LocalOperatorType& local_operator,
const SourceType& source,
RangeType& range,
const XT::Grid::ApplyOn::WhichIntersection<GridLayerType>& where,
const XT::Common::Parameter& mu = {})
: grid_layer_(grid_layer)
, local_operator_(local_operator)
, source_(source)
, range_(range)
, where_(where)
, mu_(mu)
{
}
virtual bool apply_on(const GridLayerType& grid_layer, const IntersectionType& intersection) const
{
return where_.apply_on(grid_layer, intersection);
}
virtual void
apply_local(const IntersectionType& intersection, const EntityType& inside_entity, const EntityType& outside_entity)
{
local_operator_.apply(source_,
intersection,
*range_.local_discrete_function(inside_entity),
*range_.local_discrete_function(outside_entity),
mu_);
}
private:
const GridLayerType& grid_layer_;
const LocalOperatorType& local_operator_;
const SourceType& source_;
RangeType& range_;
const XT::Grid::ApplyOn::WhichIntersection<GridLayerType>& where_;
const XT::Common::Parameter& mu_;
}; // class LocalCouplingOperatorApplicator
template <class GridLayerType, class LocalOperatorType, class SourceType, class RangeType>
class LocalBoundaryOperatorApplicator : public XT::Grid::internal::Codim1Object<GridLayerType>
{
static_assert(is_local_boundary_operator<LocalOperatorType>::value,
"LocalOperatorType has to be derived from LocalCouplingOperatorInterface!");
static_assert(XT::Functions::is_localizable_function<SourceType>::value,
"SourceType has to be derived from XT::Functions::GridFunctionInterface!");
static_assert(is_discrete_function<RangeType>::value, "RangeType has to be a DiscreteFunctionDefault!");
typedef XT::Grid::internal::Codim1Object<GridLayerType> BaseType;
public:
using typename BaseType::EntityType;
using typename BaseType::IntersectionType;
LocalBoundaryOperatorApplicator(const GridLayerType& grid_layer,
const LocalOperatorType& local_operator,
const SourceType& source,
RangeType& range,
const XT::Grid::ApplyOn::WhichIntersection<GridLayerType>& where)
: grid_layer_(grid_layer)
, local_operator_(local_operator)
, source_(source)
, range_(range)
, where_(where)
{
}
virtual bool apply_on(const GridLayerType& grid_layer, const IntersectionType& intersection) const
{
return where_.apply_on(grid_layer, intersection);
}
virtual void apply_local(const IntersectionType& intersection,
const EntityType& inside_entity,
const EntityType& /*outside_entity*/)
{
local_operator_.apply(source_, intersection, *range_.local_discrete_function(inside_entity));
}
private:
const GridLayerType& grid_layer_;
const LocalOperatorType& local_operator_;
const SourceType& source_;
RangeType& range_;
const XT::Grid::ApplyOn::WhichIntersection<GridLayerType>& where_;
}; // class LocalBoundaryOperatorApplicator
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_LOCAL_ASSEMLBER_HH
<commit_msg>drop local/assembler.hh<commit_after><|endoftext|> |
<commit_before>// This file is part of the dune-stuff project:
// https://users.dune-project.org/projects/dune-stuff
// Copyright holders: Rene Milk, Felix Schindler
// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
//
// Contributors: Sven Kaulmann
#ifndef DUNE_STUFF_COMMON_MATRIX_HH
#define DUNE_STUFF_COMMON_MATRIX_HH
// dune-common
#include <dune/common/densematrix.hh>
#include <dune/stuff/common/debug.hh>
#include <dune/stuff/common/math.hh>
#if HAVE_DUNE_ISTL && HAVE_DUNE_FEM
// for dune-istl
#if defined(HAVE_BOOST)
#undef HAVE_BOOST
#define HAVE_BOOST 1
#endif
#include <dune/fem/operator/matrix/spmatrix.hh>
#include <dune/istl/operators.hh>
#include <dune/fem/operator/matrix/istlmatrix.hh>
#include <dune/fem/operator/matrix/preconditionerwrapper.hh>
#endif // if HAVE_DUNE_ISTL && HAVE_DUNE_FEM
namespace Dune {
namespace Stuff {
namespace Common {
// \todo doc
template< class MatrixImp >
inline void clear(Dune::DenseMatrix< MatrixImp >& matrix)
{
matrix *= typename Dune::DenseMatrix< MatrixImp >::value_type(0);
}
//! TODO
template< class MatrixImp >
struct PrecondionWrapperDummy
{
typedef typename MatrixImp::RowDiscreteFunctionType::DofStorageType X;
typedef typename MatrixImp::ColDiscreteFunctionType::DofStorageType Y;
void pre(X&, Y&) {}
void apply(X&, const Y&) {}
void post(X&) {}
}; // struct PrecondionWrapperDummy
/** \brief get the diagonal of a fieldMatrix into a fieldvector
* \note While in principle this might do for SparseRowMatrix as well, don't do it! SparseRowMatrix has specialised
*functions for this (putting the diagonal into DiscreteFunctions tho
**/
template< class FieldMatrixType >
class MatrixDiagonal
: public FieldVector< typename FieldMatrixType::field_type,
FieldMatrixType::rows >
{
public:
MatrixDiagonal(const FieldMatrixType& matrix) {
static_assert(FieldMatrixType::rows == FieldMatrixType::cols, "Matrix must be square!");
// CompileTimeChecker< FieldMatrixType::rows == FieldMatrixType::cols > matrix_must_be_square;
for (size_t i = 0; i < FieldMatrixType::rows; i++)
(*this)[i] = matrix[i][i];
}
}; // class MatrixDiagonal
//! returns Sum of matrix' diagonal entries
template< class FieldMatrixType >
typename FieldMatrixType::field_type matrixTrace(const FieldMatrixType& matrix) {
MatrixDiagonal< FieldMatrixType > diag(matrix);
typename FieldMatrixType::field_type trace = typename FieldMatrixType::field_type(0);
for (size_t i = 0; i < FieldMatrixType::rows; i++)
trace += diag[i];
return trace;
} // typename FieldMatrixType::field_type matrixTrace(const FieldMatrixType& matrix)
//! produces a NxN Identity matrix compatible with parent type
template< class MatrixType >
class IdentityMatrix
: public MatrixType
{
public:
IdentityMatrix(size_t N)
: MatrixType(N, N, 1) {
for (size_t i = 1; i < N; ++i)
MatrixType::set(i, i, 1.0);
}
const MatrixType& matrix() const { return *this; }
}; // class IdentityMatrix
//! produces a NxN Identity matrix object compatible with parent type
template< class MatrixObjectType >
class IdentityMatrixObject
: public MatrixObjectType
{
public:
IdentityMatrixObject(const typename MatrixObjectType::DomainSpaceType& domain_space,
const typename MatrixObjectType::RangeSpaceType& range_space)
: MatrixObjectType(domain_space, range_space) {
MatrixObjectType::reserve();
for (int i = 0; i < MatrixObjectType::matrix().rows(); ++i)
MatrixObjectType::matrix().set(i, i, 1.0);
}
};
//! adds the missing setDiag function to SparseRowMatrix
template< class DiscFuncType, class MatrixType >
void setMatrixDiag(MatrixType& matrix, DiscFuncType& diag) {
typedef typename DiscFuncType::DofIteratorType DofIteratorType;
//! we assume that the dimension of the functionspace of f is the same as
//! the size of the matrix
DofIteratorType it = diag.dbegin();
for (int row = 0; row < matrix.rows(); row++)
{
if (*it != 0.0)
matrix.set(row, row, *it);
++it;
}
return;
} // setMatrixDiag
//! return false if <pre>abs( a(row,col) - b(col,row) ) > tolerance<pre> for any col,row
template< class MatrixType >
bool areTransposed(const MatrixType& a, const MatrixType& b, const double tolerance = 1e-8) {
if ( ( a.rows() != b.cols() ) || ( b.rows() != a.cols() ) )
return false;
for (int row = 0; row < a.rows(); ++row)
{
for (int col = 0; col < a.cols(); ++col)
{
if (std::fabs( a(row, col) - b(col, row) ) > tolerance)
return false;
}
}
return true;
} // areTransposed
//! extern matrix addition that ignore 0 entries
template< class MatrixType >
void addMatrix(MatrixType& dest, const MatrixType& arg, const double eps = 1e-14) {
for (int i = 0; i < arg.rows(); ++i)
for (int j = 0; j < arg.cols(); ++j)
{
const double value = arg(i, j);
if (std::fabs(value) > eps)
dest.add(i, j, value);
}
} // addMatrix
/** @brief Write sparse matrix to given output stream
*
* @param[in] matrix The matrix to be written
* @param[in] out The outgoing stream
*/
template< class SparseMatrixImpl, class Output >
void writeSparseMatrix(const SparseMatrixImpl& matrix,
Output& out) {
const unsigned int nRows = matrix.rows();
const unsigned int nCols = matrix.cols();
for (int i = 0; i != nRows; ++i)
{
for (int j = 0; j != nCols; ++j)
{
if ( matrix.find(i, j) )
{
out << i << "," << j << ",";
out.precision(12);
out.setf(std::ios::scientific);
out << matrix(i, j) << std::endl;
}
}
}
return;
} // writeSparseMatrix
/** @brief Read sparse matrix from given inputstream
*
* @param[out] matrix The matrix to be read
* @param[in] in The ingoing stream
*/
template< class SparseMatrixImpl, class Input >
void readSparseMatrix(SparseMatrixImpl& matrix,
Input& in) {
matrix.clear();
std::string row;
while ( std::getline(in, row) )
{
size_t last_found = 0;
size_t found = row.find_first_of(",");
double temp;
std::vector< double > entryLine;
do {
if (found == std::string::npos)
found = row.size();
std::string subs = row.substr(last_found, found - last_found);
last_found = found + 1;
std::istringstream in(subs);
if (entryLine.size() == 2)
{
in.precision(12);
in.setf(std::ios::scientific);
} else {
in.precision(10);
in.setf(std::ios::fixed);
}
in >> temp;
entryLine.push_back(temp);
found = row.find_first_of(",", last_found);
} while (last_found != row.size() + 1);
assert(entryLine.size() == 3);
matrix.add(entryLine[0], entryLine[1], entryLine[2]);
}
} // readSparseMatrix
/**
* \brief multiplies rows of arg2 with arg1
* \todo doc
**/
template< class FieldMatrixImp >
FieldMatrixImp rowWiseMatrixMultiplication(const FieldMatrixImp& arg1,
const FieldMatrixImp& arg2) {
typedef FieldMatrixImp
FieldMatrixType;
typedef typename FieldMatrixType::row_type
RowType;
typedef typename FieldMatrixType::ConstRowIterator
ConstRowIteratorType;
typedef typename FieldMatrixType::RowIterator
RowIteratorType;
assert( arg2.rowdim() == arg1.coldim() );
FieldMatrixType ret(0.0);
ConstRowIteratorType arg2RowItEnd = arg2.end();
RowIteratorType retRowItEnd = ret.end();
RowIteratorType retRowIt = ret.begin();
for (ConstRowIteratorType arg2RowIt = arg2.begin();
arg2RowIt != arg2RowItEnd, retRowIt != retRowItEnd;
++arg2RowIt, ++retRowIt)
{
RowType row(0.0);
arg1.mv(*arg2RowIt, row);
*retRowIt = row;
}
return ret;
} // rowWiseMatrixMultiplication
//! prints actual memusage of matrix in kB
template< class MatrixType >
void printMemUsage(const MatrixType& matrix, std::ostream& stream, std::string name = "") {
long size = matrix.numberOfValues() * sizeof(typename MatrixType::Ttype) / 1024.f;
stream << "matrix size " << name << "\t\t" << size << std::endl;
}
//! prints actual memusage of matrixobject in kB
template< class MatrixObjectType>
void printMemUsageObject(const MatrixObjectType& matrix_object, std::ostream& stream, std::string name = "") {
printMemUsage(matrix_object.matrix(), stream, name);
}
template< class M >
void forceTranspose(const M& arg, M& dest) {
assert( arg.cols() == dest.rows() );
assert( dest.cols() == arg.rows() );
// dest.clear();
for (int i = 0; i < arg.cols(); ++i)
for (int j = 0; j < arg.rows(); ++j)
dest.set( j, i, arg(i, j) );
} // forceTranspose
} // namespace Common
} // namespace Stuff
} // namespace Dune
#endif // DUNE_STUFF_COMMON_MATRIX_HH
<commit_msg>[common.matrix] disable some external warnings<commit_after>// This file is part of the dune-stuff project:
// https://users.dune-project.org/projects/dune-stuff
// Copyright holders: Rene Milk, Felix Schindler
// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
//
// Contributors: Sven Kaulmann
#ifndef DUNE_STUFF_COMMON_MATRIX_HH
#define DUNE_STUFF_COMMON_MATRIX_HH
// dune-common
#include <dune/common/densematrix.hh>
#include <dune/stuff/common/debug.hh>
#include <dune/stuff/common/math.hh>
#if HAVE_DUNE_ISTL && HAVE_DUNE_FEM
// for dune-istl
# if defined(HAVE_BOOST)
# undef HAVE_BOOST
# define HAVE_BOOST 1
# endif
# include <dune/stuff/common/disable_warnings.hh>
# include <dune/fem/operator/matrix/spmatrix.hh>
# include <dune/stuff/common/reenable_warnings.hh>
# include <dune/istl/operators.hh>
# include <dune/fem/operator/matrix/istlmatrix.hh>
# include <dune/fem/operator/matrix/preconditionerwrapper.hh>
#endif // if HAVE_DUNE_ISTL && HAVE_DUNE_FEM
namespace Dune {
namespace Stuff {
namespace Common {
// \todo doc
template< class MatrixImp >
inline void clear(Dune::DenseMatrix< MatrixImp >& matrix)
{
matrix *= typename Dune::DenseMatrix< MatrixImp >::value_type(0);
}
//! TODO
template< class MatrixImp >
struct PrecondionWrapperDummy
{
typedef typename MatrixImp::RowDiscreteFunctionType::DofStorageType X;
typedef typename MatrixImp::ColDiscreteFunctionType::DofStorageType Y;
void pre(X&, Y&) {}
void apply(X&, const Y&) {}
void post(X&) {}
}; // struct PrecondionWrapperDummy
/** \brief get the diagonal of a fieldMatrix into a fieldvector
* \note While in principle this might do for SparseRowMatrix as well, don't do it! SparseRowMatrix has specialised
*functions for this (putting the diagonal into DiscreteFunctions tho
**/
template< class FieldMatrixType >
class MatrixDiagonal
: public FieldVector< typename FieldMatrixType::field_type,
FieldMatrixType::rows >
{
public:
MatrixDiagonal(const FieldMatrixType& matrix) {
static_assert(FieldMatrixType::rows == FieldMatrixType::cols, "Matrix must be square!");
// CompileTimeChecker< FieldMatrixType::rows == FieldMatrixType::cols > matrix_must_be_square;
for (size_t i = 0; i < FieldMatrixType::rows; i++)
(*this)[i] = matrix[i][i];
}
}; // class MatrixDiagonal
//! returns Sum of matrix' diagonal entries
template< class FieldMatrixType >
typename FieldMatrixType::field_type matrixTrace(const FieldMatrixType& matrix) {
MatrixDiagonal< FieldMatrixType > diag(matrix);
typename FieldMatrixType::field_type trace = typename FieldMatrixType::field_type(0);
for (size_t i = 0; i < FieldMatrixType::rows; i++)
trace += diag[i];
return trace;
} // typename FieldMatrixType::field_type matrixTrace(const FieldMatrixType& matrix)
//! produces a NxN Identity matrix compatible with parent type
template< class MatrixType >
class IdentityMatrix
: public MatrixType
{
public:
IdentityMatrix(size_t N)
: MatrixType(N, N, 1) {
for (size_t i = 1; i < N; ++i)
MatrixType::set(i, i, 1.0);
}
const MatrixType& matrix() const { return *this; }
}; // class IdentityMatrix
//! produces a NxN Identity matrix object compatible with parent type
template< class MatrixObjectType >
class IdentityMatrixObject
: public MatrixObjectType
{
public:
IdentityMatrixObject(const typename MatrixObjectType::DomainSpaceType& domain_space,
const typename MatrixObjectType::RangeSpaceType& range_space)
: MatrixObjectType(domain_space, range_space) {
MatrixObjectType::reserve();
for (int i = 0; i < MatrixObjectType::matrix().rows(); ++i)
MatrixObjectType::matrix().set(i, i, 1.0);
}
};
//! adds the missing setDiag function to SparseRowMatrix
template< class DiscFuncType, class MatrixType >
void setMatrixDiag(MatrixType& matrix, DiscFuncType& diag) {
typedef typename DiscFuncType::DofIteratorType DofIteratorType;
//! we assume that the dimension of the functionspace of f is the same as
//! the size of the matrix
DofIteratorType it = diag.dbegin();
for (int row = 0; row < matrix.rows(); row++)
{
if (*it != 0.0)
matrix.set(row, row, *it);
++it;
}
return;
} // setMatrixDiag
//! return false if <pre>abs( a(row,col) - b(col,row) ) > tolerance<pre> for any col,row
template< class MatrixType >
bool areTransposed(const MatrixType& a, const MatrixType& b, const double tolerance = 1e-8) {
if ( ( a.rows() != b.cols() ) || ( b.rows() != a.cols() ) )
return false;
for (int row = 0; row < a.rows(); ++row)
{
for (int col = 0; col < a.cols(); ++col)
{
if (std::fabs( a(row, col) - b(col, row) ) > tolerance)
return false;
}
}
return true;
} // areTransposed
//! extern matrix addition that ignore 0 entries
template< class MatrixType >
void addMatrix(MatrixType& dest, const MatrixType& arg, const double eps = 1e-14) {
for (int i = 0; i < arg.rows(); ++i)
for (int j = 0; j < arg.cols(); ++j)
{
const double value = arg(i, j);
if (std::fabs(value) > eps)
dest.add(i, j, value);
}
} // addMatrix
/** @brief Write sparse matrix to given output stream
*
* @param[in] matrix The matrix to be written
* @param[in] out The outgoing stream
*/
template< class SparseMatrixImpl, class Output >
void writeSparseMatrix(const SparseMatrixImpl& matrix,
Output& out) {
const unsigned int nRows = matrix.rows();
const unsigned int nCols = matrix.cols();
for (int i = 0; i != nRows; ++i)
{
for (int j = 0; j != nCols; ++j)
{
if ( matrix.find(i, j) )
{
out << i << "," << j << ",";
out.precision(12);
out.setf(std::ios::scientific);
out << matrix(i, j) << std::endl;
}
}
}
return;
} // writeSparseMatrix
/** @brief Read sparse matrix from given inputstream
*
* @param[out] matrix The matrix to be read
* @param[in] in The ingoing stream
*/
template< class SparseMatrixImpl, class Input >
void readSparseMatrix(SparseMatrixImpl& matrix,
Input& in) {
matrix.clear();
std::string row;
while ( std::getline(in, row) )
{
size_t last_found = 0;
size_t found = row.find_first_of(",");
double temp;
std::vector< double > entryLine;
do {
if (found == std::string::npos)
found = row.size();
std::string subs = row.substr(last_found, found - last_found);
last_found = found + 1;
std::istringstream in(subs);
if (entryLine.size() == 2)
{
in.precision(12);
in.setf(std::ios::scientific);
} else {
in.precision(10);
in.setf(std::ios::fixed);
}
in >> temp;
entryLine.push_back(temp);
found = row.find_first_of(",", last_found);
} while (last_found != row.size() + 1);
assert(entryLine.size() == 3);
matrix.add(entryLine[0], entryLine[1], entryLine[2]);
}
} // readSparseMatrix
/**
* \brief multiplies rows of arg2 with arg1
* \todo doc
**/
template< class FieldMatrixImp >
FieldMatrixImp rowWiseMatrixMultiplication(const FieldMatrixImp& arg1,
const FieldMatrixImp& arg2) {
typedef FieldMatrixImp
FieldMatrixType;
typedef typename FieldMatrixType::row_type
RowType;
typedef typename FieldMatrixType::ConstRowIterator
ConstRowIteratorType;
typedef typename FieldMatrixType::RowIterator
RowIteratorType;
assert( arg2.rowdim() == arg1.coldim() );
FieldMatrixType ret(0.0);
ConstRowIteratorType arg2RowItEnd = arg2.end();
RowIteratorType retRowItEnd = ret.end();
RowIteratorType retRowIt = ret.begin();
for (ConstRowIteratorType arg2RowIt = arg2.begin();
arg2RowIt != arg2RowItEnd, retRowIt != retRowItEnd;
++arg2RowIt, ++retRowIt)
{
RowType row(0.0);
arg1.mv(*arg2RowIt, row);
*retRowIt = row;
}
return ret;
} // rowWiseMatrixMultiplication
//! prints actual memusage of matrix in kB
template< class MatrixType >
void printMemUsage(const MatrixType& matrix, std::ostream& stream, std::string name = "") {
long size = matrix.numberOfValues() * sizeof(typename MatrixType::Ttype) / 1024.f;
stream << "matrix size " << name << "\t\t" << size << std::endl;
}
//! prints actual memusage of matrixobject in kB
template< class MatrixObjectType>
void printMemUsageObject(const MatrixObjectType& matrix_object, std::ostream& stream, std::string name = "") {
printMemUsage(matrix_object.matrix(), stream, name);
}
template< class M >
void forceTranspose(const M& arg, M& dest) {
assert( arg.cols() == dest.rows() );
assert( dest.cols() == arg.rows() );
// dest.clear();
for (int i = 0; i < arg.cols(); ++i)
for (int j = 0; j < arg.rows(); ++j)
dest.set( j, i, arg(i, j) );
} // forceTranspose
} // namespace Common
} // namespace Stuff
} // namespace Dune
#endif // DUNE_STUFF_COMMON_MATRIX_HH
<|endoftext|> |
<commit_before>#ifndef DUNE_STUFF_RANGES_RANGES_HH
#define DUNE_STUFF_RANGES_RANGES_HH
#ifdef HAVE_CMAKE_CONFIG
#include "cmake_config.h"
#else
#include "config.h"
#endif // ifdef HAVE_CMAKE_CONFIG
#if HAVE_DUNE_GRID
# include <dune/stuff/common/disable_warnings.hh>
# include <dune/grid/common/gridview.hh>
# include <dune/stuff/common/reenable_warnings.hh>
# include <dune/grid/common/geometry.hh>
# include <boost/serialization/static_warning.hpp>
# include <boost/iterator/iterator_facade.hpp>
#endif
#if HAVE_DUNE_FEM
#include <dune/fem/version.hh>
#include <dune/stuff/fem/namespace.hh>
#include <dune/stuff/common/disable_warnings.hh>
#include <dune/fem/function/common/discretefunction.hh>
#include <dune/stuff/common/reenable_warnings.hh>
#include <dune/fem/gridpart/common/gridpart.hh>
#if DUNE_FEM_IS_LOCALFUNCTIONS_COMPATIBLE
#include <dune/fem/space/lagrangespace/lagrangepoints.hh>
#else
#include <dune/fem/space/lagrange/lagrangepoints.hh>
#endif
#endif
#include <dune/stuff/common/math.hh>
#include <dune/stuff/fem/namespace.hh>
namespace Dune {
#if HAVE_DUNE_FEM
namespace Fem {
template < class DiscreteFunctionTraits >
auto begin( const Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dbegin())
{
return func.dbegin();
}
template < class DiscreteFunctionTraits >
auto end( const Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dend())
{
return func.dend();
}
template < class DiscreteFunctionTraits >
auto begin( Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dbegin())
{
return func.dbegin();
}
template < class DiscreteFunctionTraits >
auto end( Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dend())
{
return func.dend();
}
} // namespace Fem
#endif
} //namespace Dune
namespace Dune {
namespace Stuff {
namespace Common {
#if HAVE_DUNE_GRID
//! adapter enabling view usage in range-based for
template < class GridViewType, int codim = 0>
class ViewRange {
const GridViewType& view_;
public:
ViewRange(const GridViewType& view)
:view_(view)
{
BOOST_STATIC_WARNING(codim == 0 && "unnecessary ViewRange usage with codim 0");
}
typename GridViewType::template Codim< codim >::Iterator
begin() const {
return view_.template begin< codim >();
}
typename GridViewType::template Codim< codim >::Iterator
end() const {
return view_.template end< codim >();
}
};
template < class GridViewTraits, int codim = 0>
ViewRange<Dune::GridView<GridViewTraits>, codim> viewRange(const Dune::GridView<GridViewTraits>& view)
{
return ViewRange<Dune::GridView<GridViewTraits>, codim>(view);
}
/** adapter enabling intersectionniterator usage in range-based for
* works for GridParts and GridViews
*/
template < class GridAbstractionType, class EntityType >
class IntersectionRange {
const GridAbstractionType& view_;
const EntityType& entity_;
public:
IntersectionRange(const GridAbstractionType& view, const EntityType& entity)
: view_(view)
, entity_(entity)
{}
auto begin() const -> decltype(view_.ibegin(entity_)) {
return view_.ibegin(entity_);
}
auto end() const -> decltype(view_.iend(entity_)) {
return view_.iend(entity_);
}
};
template < class GridViewTraits>
IntersectionRange<Dune::GridView<GridViewTraits>,
typename Dune::GridView<GridViewTraits>::template Codim< 0 >::Entity>
intersectionRange(const Dune::GridView<GridViewTraits>& gridview,
const typename Dune::GridView<GridViewTraits>::template Codim< 0 >::Entity& entity)
{
return IntersectionRange<Dune::GridView<GridViewTraits>,
typename Dune::GridView<GridViewTraits>::template Codim< 0 >::Entity>(gridview, entity);
}
//! custom const iterator for \ref FixedMap
template <class GeometryType>
class ConstCornerIterator
: public boost::iterator_facade< ConstCornerIterator<GeometryType>
, const typename GeometryType::GlobalCoordinate
, boost::forward_traversal_tag >
{
typedef ConstCornerIterator<GeometryType> ThisType;
typedef typename GeometryType::GlobalCoordinate CornerType;
public:
ConstCornerIterator()
:index_(-1)
, geometry_(nullptr)
{}
explicit ConstCornerIterator(const GeometryType*const geometry, int i = 0)
: index_(i)
, geometry_(geometry)
{}
private:
friend class boost::iterator_core_access;
void increment() { index_++; }
bool equal(ThisType const& other) const
{
return this->geometry_ && (index_ == other.index_) && (this->geometry_ == other.geometry_);
}
const CornerType& dereference() const { return geometry_->corner(index_); }
int index_;
const GeometryType * const geometry_;
};
template <class GeometryType>
class CornerRange {
typedef ConstCornerIterator<GeometryType> IteratorType;
public:
CornerRange(const GeometryType& geometry)
: geometry_(geometry)
{}
IteratorType begin() const {
return IteratorType(geometry_, 0);
}
IteratorType end() const {
return IteratorType(geometry_, geometry_->corners());
}
private:
const GeometryType& geometry_;
};
template <int mydim, int cdim, class GridImp, template< int, int, class > class GeometryImp>
CornerRange<Dune::Geometry< mydim, cdim, GridImp, GeometryImp>> cornerRange(const Dune::Geometry< mydim, cdim, GridImp, GeometryImp>& geometry)
{
return CornerRange<Dune::Geometry< mydim, cdim, GridImp, GeometryImp>>(geometry);
}
template <int mydim, int cdim, class GridImp, template< int, int, class > class EntityImp>
auto cornerRange(const Dune::Entity< mydim, cdim, GridImp, EntityImp>& entity) -> ConstCornerIterator<decltype(entity.geometry())>
{
return CornerRange<decltype(entity.geometry())>(entity.geometry());
}
#endif //#if HAVE_DUNE_GRID
#if HAVE_DUNE_FEM
//! Range adapter for lagrange points from lagrange spaces
template < class GridPartType, int order, int faceCodim >
class LagrangePointSetRange {
typedef Dune::Fem::LagrangePointSet<GridPartType, order>
LagrangePointSetType;
typedef typename LagrangePointSetType::template Codim< faceCodim >::SubEntityIteratorType
SubEntityIteratorType;
const LagrangePointSetType& lp_set_;
const unsigned int subEntity_;
public:
/** the template isn't lazyness here, the underlying set is templated on it too
*/
template < class DiscreteFunctionspaceType, class EntityType >
LagrangePointSetRange(const DiscreteFunctionspaceType& space, const EntityType& entity, const unsigned int subEntity)
: lp_set_(space.lagrangePointSet(entity))
, subEntity_(subEntity)
{}
LagrangePointSetRange(const LagrangePointSetType& lp_set, const unsigned int subEntity)
: lp_set_(lp_set)
, subEntity_(subEntity)
{}
SubEntityIteratorType begin() const {
return lp_set_.template beginSubEntity< faceCodim >(subEntity_);
}
SubEntityIteratorType end() const {
return lp_set_.template endSubEntity< faceCodim >(subEntity_);
}
};
template < int codim, class DiscreteFunctionspaceType, class EntityType >
LagrangePointSetRange<typename DiscreteFunctionspaceType::GridPartType, DiscreteFunctionspaceType::polynomialOrder, codim>
lagrangePointSetRange(const DiscreteFunctionspaceType& space, const EntityType& entity, const int subEntity) {
return LagrangePointSetRange<typename DiscreteFunctionspaceType::GridPartType, DiscreteFunctionspaceType::polynomialOrder, codim>(space, entity, subEntity);
}
template < class LgPointSetType, int codim = 1 >
LagrangePointSetRange<typename LgPointSetType::GridPartType, LgPointSetType::polynomialOrder, codim>
lagrangePointSetRange(const LgPointSetType& lpset, const int subEntity) {
return LagrangePointSetRange<typename LgPointSetType::GridPartType, LgPointSetType::polynomialOrder, codim>(lpset, subEntity);
}
template < class GridPartTraits >
IntersectionRange<Dune::Fem::GridPartInterface<GridPartTraits>,
typename Dune::Fem::GridPartInterface<GridPartTraits>::template Codim< 0 >::EntityType>
intersectionRange(const Dune::Fem::GridPartInterface<GridPartTraits>& gridpart,
const typename Dune::Fem::GridPartInterface<GridPartTraits>::template Codim< 0 >::EntityType& entity)
{
return IntersectionRange<Dune::Fem::GridPartInterface<GridPartTraits>,
typename Dune::Fem::GridPartInterface<GridPartTraits>::template Codim< 0 >::EntityType>(gridpart, entity);
}
#endif //HAVE_DUNE_FEM
//! get a vector with values in [start : increment : end)
template < class T, class sequence = std::vector<T> >
sequence valueRange(const T start, const T end, const T increment = Epsilon<T>::value) {
// sadly, no overloaded version of std::abs is available for
// unsigned long long, so we compute the absolute value of increment
// ourselfs
const T incrementAbs = Dune::Stuff::Common::abs(increment);
sequence ret(typename sequence::size_type(((end>start) ? end-start : start-end)/incrementAbs), start);
typename sequence::size_type i = 0;
std::generate(std::begin(ret), std::end(ret), [&](){ return T(start + (increment * i++)); });
return ret;
}
//! get a vector with values in [0 : Epsilon<T> : end)
template < class T, class sequence = std::vector<T> >
sequence valueRange(const T end) {
return valueRange(T(0),end);
}
} // namespace Common
} // namespace Stuff
} // namespace Dune
#endif // DUNE_STUFF_RANGES_RANGES_HH
/** Copyright (c) 2012, Felix Albrecht, Rene Milk
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. 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 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.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of the FreeBSD Project.
**/
<commit_msg>[common.ranges] added missing includes<commit_after>#ifndef DUNE_STUFF_RANGES_RANGES_HH
#define DUNE_STUFF_RANGES_RANGES_HH
#ifdef HAVE_CMAKE_CONFIG
#include "cmake_config.h"
#else
#include "config.h"
#endif // ifdef HAVE_CMAKE_CONFIG
#if HAVE_DUNE_GRID
# include <dune/stuff/common/disable_warnings.hh>
# include <dune/grid/common/gridview.hh>
# include <dune/stuff/common/reenable_warnings.hh>
# include <dune/grid/common/geometry.hh>
# include <dune/grid/common/entity.hh>
# include <boost/serialization/static_warning.hpp>
# include <boost/iterator/iterator_facade.hpp>
#endif
#if HAVE_DUNE_FEM
#include <dune/fem/version.hh>
#include <dune/stuff/fem/namespace.hh>
#include <dune/stuff/common/disable_warnings.hh>
#include <dune/fem/function/common/discretefunction.hh>
#include <dune/stuff/common/reenable_warnings.hh>
#include <dune/fem/gridpart/common/gridpart.hh>
#if DUNE_FEM_IS_LOCALFUNCTIONS_COMPATIBLE
#include <dune/fem/space/lagrangespace/lagrangepoints.hh>
#else
#include <dune/fem/space/lagrange/lagrangepoints.hh>
#endif
#endif
#include <dune/stuff/common/math.hh>
#include <dune/stuff/fem/namespace.hh>
namespace Dune {
#if HAVE_DUNE_FEM
namespace Fem {
template < class DiscreteFunctionTraits >
auto begin( const Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dbegin())
{
return func.dbegin();
}
template < class DiscreteFunctionTraits >
auto end( const Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dend())
{
return func.dend();
}
template < class DiscreteFunctionTraits >
auto begin( Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dbegin())
{
return func.dbegin();
}
template < class DiscreteFunctionTraits >
auto end( Dune::Fem::DiscreteFunctionInterface< DiscreteFunctionTraits >& func )
-> decltype(func.dend())
{
return func.dend();
}
} // namespace Fem
#endif
} //namespace Dune
namespace Dune {
namespace Stuff {
namespace Common {
#if HAVE_DUNE_GRID
//! adapter enabling view usage in range-based for
template < class GridViewType, int codim = 0>
class ViewRange {
const GridViewType& view_;
public:
ViewRange(const GridViewType& view)
:view_(view)
{
BOOST_STATIC_WARNING(codim == 0 && "unnecessary ViewRange usage with codim 0");
}
typename GridViewType::template Codim< codim >::Iterator
begin() const {
return view_.template begin< codim >();
}
typename GridViewType::template Codim< codim >::Iterator
end() const {
return view_.template end< codim >();
}
};
template < class GridViewTraits, int codim = 0>
ViewRange<Dune::GridView<GridViewTraits>, codim> viewRange(const Dune::GridView<GridViewTraits>& view)
{
return ViewRange<Dune::GridView<GridViewTraits>, codim>(view);
}
/** adapter enabling intersectionniterator usage in range-based for
* works for GridParts and GridViews
*/
template < class GridAbstractionType, class EntityType >
class IntersectionRange {
const GridAbstractionType& view_;
const EntityType& entity_;
public:
IntersectionRange(const GridAbstractionType& view, const EntityType& entity)
: view_(view)
, entity_(entity)
{}
auto begin() const -> decltype(view_.ibegin(entity_)) {
return view_.ibegin(entity_);
}
auto end() const -> decltype(view_.iend(entity_)) {
return view_.iend(entity_);
}
};
template < class GridViewTraits>
IntersectionRange<Dune::GridView<GridViewTraits>,
typename Dune::GridView<GridViewTraits>::template Codim< 0 >::Entity>
intersectionRange(const Dune::GridView<GridViewTraits>& gridview,
const typename Dune::GridView<GridViewTraits>::template Codim< 0 >::Entity& entity)
{
return IntersectionRange<Dune::GridView<GridViewTraits>,
typename Dune::GridView<GridViewTraits>::template Codim< 0 >::Entity>(gridview, entity);
}
//! custom const iterator for \ref FixedMap
template <class GeometryType>
class ConstCornerIterator
: public boost::iterator_facade< ConstCornerIterator<GeometryType>
, const typename GeometryType::GlobalCoordinate
, boost::forward_traversal_tag >
{
typedef ConstCornerIterator<GeometryType> ThisType;
typedef typename GeometryType::GlobalCoordinate CornerType;
public:
ConstCornerIterator()
:index_(-1)
, geometry_(nullptr)
{}
explicit ConstCornerIterator(const GeometryType*const geometry, int i = 0)
: index_(i)
, geometry_(geometry)
{}
private:
friend class boost::iterator_core_access;
void increment() { index_++; }
bool equal(ThisType const& other) const
{
return this->geometry_ && (index_ == other.index_) && (this->geometry_ == other.geometry_);
}
const CornerType& dereference() const { return geometry_->corner(index_); }
int index_;
const GeometryType * const geometry_;
};
template <class GeometryType>
class CornerRange {
typedef ConstCornerIterator<GeometryType> IteratorType;
public:
CornerRange(const GeometryType& geometry)
: geometry_(geometry)
{}
IteratorType begin() const {
return IteratorType(geometry_, 0);
}
IteratorType end() const {
return IteratorType(geometry_, geometry_->corners());
}
private:
const GeometryType& geometry_;
};
template <int mydim, int cdim, class GridImp, template< int, int, class > class GeometryImp>
CornerRange<Dune::Geometry< mydim, cdim, GridImp, GeometryImp>> cornerRange(const Dune::Geometry< mydim, cdim, GridImp, GeometryImp>& geometry)
{
return CornerRange<Dune::Geometry< mydim, cdim, GridImp, GeometryImp>>(geometry);
}
template <int mydim, int cdim, class GridImp, template< int, int, class > class EntityImp>
auto cornerRange(const Dune::Entity< mydim, cdim, GridImp, EntityImp>& entity) -> ConstCornerIterator<decltype(entity.geometry())>
{
return CornerRange<decltype(entity.geometry())>(entity.geometry());
}
#endif //#if HAVE_DUNE_GRID
#if HAVE_DUNE_FEM
//! Range adapter for lagrange points from lagrange spaces
template < class GridPartType, int order, int faceCodim >
class LagrangePointSetRange {
typedef Dune::Fem::LagrangePointSet<GridPartType, order>
LagrangePointSetType;
typedef typename LagrangePointSetType::template Codim< faceCodim >::SubEntityIteratorType
SubEntityIteratorType;
const LagrangePointSetType& lp_set_;
const unsigned int subEntity_;
public:
/** the template isn't lazyness here, the underlying set is templated on it too
*/
template < class DiscreteFunctionspaceType, class EntityType >
LagrangePointSetRange(const DiscreteFunctionspaceType& space, const EntityType& entity, const unsigned int subEntity)
: lp_set_(space.lagrangePointSet(entity))
, subEntity_(subEntity)
{}
LagrangePointSetRange(const LagrangePointSetType& lp_set, const unsigned int subEntity)
: lp_set_(lp_set)
, subEntity_(subEntity)
{}
SubEntityIteratorType begin() const {
return lp_set_.template beginSubEntity< faceCodim >(subEntity_);
}
SubEntityIteratorType end() const {
return lp_set_.template endSubEntity< faceCodim >(subEntity_);
}
};
template < int codim, class DiscreteFunctionspaceType, class EntityType >
LagrangePointSetRange<typename DiscreteFunctionspaceType::GridPartType, DiscreteFunctionspaceType::polynomialOrder, codim>
lagrangePointSetRange(const DiscreteFunctionspaceType& space, const EntityType& entity, const int subEntity) {
return LagrangePointSetRange<typename DiscreteFunctionspaceType::GridPartType, DiscreteFunctionspaceType::polynomialOrder, codim>(space, entity, subEntity);
}
template < class LgPointSetType, int codim = 1 >
LagrangePointSetRange<typename LgPointSetType::GridPartType, LgPointSetType::polynomialOrder, codim>
lagrangePointSetRange(const LgPointSetType& lpset, const int subEntity) {
return LagrangePointSetRange<typename LgPointSetType::GridPartType, LgPointSetType::polynomialOrder, codim>(lpset, subEntity);
}
template < class GridPartTraits >
IntersectionRange<Dune::Fem::GridPartInterface<GridPartTraits>,
typename Dune::Fem::GridPartInterface<GridPartTraits>::template Codim< 0 >::EntityType>
intersectionRange(const Dune::Fem::GridPartInterface<GridPartTraits>& gridpart,
const typename Dune::Fem::GridPartInterface<GridPartTraits>::template Codim< 0 >::EntityType& entity)
{
return IntersectionRange<Dune::Fem::GridPartInterface<GridPartTraits>,
typename Dune::Fem::GridPartInterface<GridPartTraits>::template Codim< 0 >::EntityType>(gridpart, entity);
}
#endif //HAVE_DUNE_FEM
//! get a vector with values in [start : increment : end)
template < class T, class sequence = std::vector<T> >
sequence valueRange(const T start, const T end, const T increment = Epsilon<T>::value) {
// sadly, no overloaded version of std::abs is available for
// unsigned long long, so we compute the absolute value of increment
// ourselfs
const T incrementAbs = Dune::Stuff::Common::abs(increment);
sequence ret(typename sequence::size_type(((end>start) ? end-start : start-end)/incrementAbs), start);
typename sequence::size_type i = 0;
std::generate(std::begin(ret), std::end(ret), [&](){ return T(start + (increment * i++)); });
return ret;
}
//! get a vector with values in [0 : Epsilon<T> : end)
template < class T, class sequence = std::vector<T> >
sequence valueRange(const T end) {
return valueRange(T(0),end);
}
} // namespace Common
} // namespace Stuff
} // namespace Dune
#endif // DUNE_STUFF_RANGES_RANGES_HH
/** Copyright (c) 2012, Felix Albrecht, Rene Milk
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. 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 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.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of the FreeBSD Project.
**/
<|endoftext|> |
<commit_before>// Author: Enrico Guiraud, Danilo Piparo CERN 12/2016
/*************************************************************************
* Copyright (C) 1995-2016, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#ifndef ROOT_TDFUTILS
#define ROOT_TDFUTILS
#include "ROOT/TDataSource.hxx" // ColumnName2ColumnTypeName
#include "ROOT/TypeTraits.hxx"
#include "ROOT/TVec.hxx"
#include "ROOT/TSnapshotOptions.hxx"
#include "TH1.h"
#include "TTreeReaderArray.h"
#include "TTreeReaderValue.h"
#include <array>
#include <deque>
#include <functional>
#include <memory>
#include <string>
#include <type_traits> // std::decay
#include <vector>
class TTree;
class TTreeReader;
/// \cond HIDDEN_SYMBOLS
namespace ROOT {
// fwd declaration for IsV7Hist
namespace Experimental {
template <int D, typename P, template <int, typename, template <typename> class> class... S>
class THist;
} // ns Experimental
namespace Detail {
namespace TDF {
using ColumnNames_t = std::vector<std::string>;
// fwd decl for ColumnName2ColumnTypeName
class TCustomColumnBase;
// fwd decl for FindUnknownColumns
class TLoopManager;
// type used for tag dispatching
struct TInferType {
};
} // end ns Detail
} // end ns TDF
namespace Internal {
namespace TDF {
using namespace ROOT::TypeTraits;
using namespace ROOT::Detail::TDF;
using namespace ROOT::Experimental::TDF;
/// Compile-time integer sequence generator
/// e.g. calling GenStaticSeq<3>::type() instantiates a StaticSeq<0,1,2>
// TODO substitute all usages of StaticSeq and GenStaticSeq with std::index_sequence when it becomes available
template <int...>
struct StaticSeq {
};
template <int N, int... S>
struct GenStaticSeq : GenStaticSeq<N - 1, N - 1, S...> {
};
template <int... S>
struct GenStaticSeq<0, S...> {
using type = StaticSeq<S...>;
};
template <int... S>
using GenStaticSeq_t = typename GenStaticSeq<S...>::type;
const std::type_info &TypeName2TypeID(const std::string &name);
std::string TypeID2TypeName(const std::type_info &id);
std::string
ColumnName2ColumnTypeName(const std::string &colName, TTree *, TCustomColumnBase *, TDataSource * = nullptr);
char TypeName2ROOTTypeName(const std::string &b);
unsigned int GetNSlots();
/// `type` is TypeList if MustRemove is false, otherwise it is a TypeList with the first type removed
template <bool MustRemove, typename TypeList>
struct RemoveFirstParameterIf {
using type = TypeList;
};
template <typename TypeList>
struct RemoveFirstParameterIf<true, TypeList> {
using type = RemoveFirstParameter_t<TypeList>;
};
template <bool MustRemove, typename TypeList>
struct RemoveFirstTwoParametersIf {
using type = TypeList;
};
template <typename TypeList>
struct RemoveFirstTwoParametersIf<true, TypeList> {
using typeTmp = typename RemoveFirstParameterIf<true, TypeList>::type;
using type = typename RemoveFirstParameterIf<true, typeTmp>::type;
};
// Check the value_type type of a type with a SFINAE to allow compilation in presence
// fundamental types
template <typename T, bool IsContainer = IsContainer<typename std::decay<T>::type>::value>
struct ValueType {
using value_type = typename T::value_type;
};
template <typename T>
struct ValueType<T, false> {
using value_type = T;
};
template <typename T>
struct ValueType<ROOT::Experimental::VecOps::TVec<T>, false> {
using value_type = T;
};
} // end NS TDF
} // end NS Internal
} // end NS ROOT
/// \endcond
#endif // TDFUTILS
<commit_msg>[TDF][NFC] Remove obsolete forward declaration<commit_after>// Author: Enrico Guiraud, Danilo Piparo CERN 12/2016
/*************************************************************************
* Copyright (C) 1995-2016, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#ifndef ROOT_TDFUTILS
#define ROOT_TDFUTILS
#include "ROOT/TDataSource.hxx" // ColumnName2ColumnTypeName
#include "ROOT/TypeTraits.hxx"
#include "ROOT/TVec.hxx"
#include "ROOT/TSnapshotOptions.hxx"
#include "TH1.h"
#include "TTreeReaderArray.h"
#include "TTreeReaderValue.h"
#include <array>
#include <deque>
#include <functional>
#include <memory>
#include <string>
#include <type_traits> // std::decay
#include <vector>
class TTree;
class TTreeReader;
/// \cond HIDDEN_SYMBOLS
namespace ROOT {
// fwd declaration for IsV7Hist
namespace Experimental {
template <int D, typename P, template <int, typename, template <typename> class> class... S>
class THist;
} // ns Experimental
namespace Detail {
namespace TDF {
using ColumnNames_t = std::vector<std::string>;
// fwd decl for ColumnName2ColumnTypeName
class TCustomColumnBase;
// type used for tag dispatching
struct TInferType {
};
} // end ns Detail
} // end ns TDF
namespace Internal {
namespace TDF {
using namespace ROOT::TypeTraits;
using namespace ROOT::Detail::TDF;
using namespace ROOT::Experimental::TDF;
/// Compile-time integer sequence generator
/// e.g. calling GenStaticSeq<3>::type() instantiates a StaticSeq<0,1,2>
// TODO substitute all usages of StaticSeq and GenStaticSeq with std::index_sequence when it becomes available
template <int...>
struct StaticSeq {
};
template <int N, int... S>
struct GenStaticSeq : GenStaticSeq<N - 1, N - 1, S...> {
};
template <int... S>
struct GenStaticSeq<0, S...> {
using type = StaticSeq<S...>;
};
template <int... S>
using GenStaticSeq_t = typename GenStaticSeq<S...>::type;
const std::type_info &TypeName2TypeID(const std::string &name);
std::string TypeID2TypeName(const std::type_info &id);
std::string
ColumnName2ColumnTypeName(const std::string &colName, TTree *, TCustomColumnBase *, TDataSource * = nullptr);
char TypeName2ROOTTypeName(const std::string &b);
unsigned int GetNSlots();
/// `type` is TypeList if MustRemove is false, otherwise it is a TypeList with the first type removed
template <bool MustRemove, typename TypeList>
struct RemoveFirstParameterIf {
using type = TypeList;
};
template <typename TypeList>
struct RemoveFirstParameterIf<true, TypeList> {
using type = RemoveFirstParameter_t<TypeList>;
};
template <bool MustRemove, typename TypeList>
struct RemoveFirstTwoParametersIf {
using type = TypeList;
};
template <typename TypeList>
struct RemoveFirstTwoParametersIf<true, TypeList> {
using typeTmp = typename RemoveFirstParameterIf<true, TypeList>::type;
using type = typename RemoveFirstParameterIf<true, typeTmp>::type;
};
// Check the value_type type of a type with a SFINAE to allow compilation in presence
// fundamental types
template <typename T, bool IsContainer = IsContainer<typename std::decay<T>::type>::value>
struct ValueType {
using value_type = typename T::value_type;
};
template <typename T>
struct ValueType<T, false> {
using value_type = T;
};
template <typename T>
struct ValueType<ROOT::Experimental::VecOps::TVec<T>, false> {
using value_type = T;
};
} // end NS TDF
} // end NS Internal
} // end NS ROOT
/// \endcond
#endif // TDFUTILS
<|endoftext|> |
<commit_before>/**
* The MIT License (MIT)
*
* Copyright (c) 2016 Brad van der Laan
*
* 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 <QCoreApplication>
#include <QFileInfo>
#include <QDir>
#include "CommandLineInterface.hpp"
#include "InputArgument.hpp"
using namespace Taranis;
using action_callback = std::function<void()>;
Q_DECLARE_METATYPE(action_callback)
const QString CommandLineInterface::VERSIONARGUMENT = "version";
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface() :
CommandLineInterface(QStringLiteral(""))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface(const QString applicationName)
: CommandLineInterface(applicationName, QStringLiteral(""))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface(const QString applicationName, const QString version)
: CommandLineInterface( applicationName, version, QCoreApplication::arguments() )
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface(const QString applicationName, const QString version, QStringList arguments)
: m_acceptedArgumentPrefixs( { QStringLiteral("-"), QStringLiteral("--") } ),
m_applicationName(applicationName),
m_inputArguments( arguments )
{
if ( QDir::separator() != QChar('/') )
{
m_acceptedArgumentPrefixs.append( QStringLiteral("/") );
}
WithVersion( version );
WithHelp();
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::~CommandLineInterface()
{
// qDeleteAll( m_arguments );
m_arguments.clear();
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface& CommandLineInterface::WithVersion(const QString &version)
{
m_version = version;
if ( m_version.isEmpty() )
{
delete m_arguments.value(VERSIONARGUMENT);
m_arguments.remove(VERSIONARGUMENT);
}
else
{
action_callback versionCallback = std::bind( &CommandLineInterface::doVersionAction, this );
WithAction(VERSIONARGUMENT, "Display version information and exit", versionCallback);
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithHelp()
{
action_callback helpCallback = std::bind( &CommandLineInterface::doHelpAction, this );
WithAction("help", "Display this help and exit", helpCallback);
WithAction("?", "Display this help and exit", helpCallback);
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::name() const
{
return m_applicationName;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::version() const
{
return m_version;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::description() const
{
return m_description;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface& CommandLineInterface::process()
{
foreach( QString a, m_inputArguments )
{
InputArgument arg( a, m_acceptedArgumentPrefixs );
if ( arg.isValid() )
{
QString key = arg.argument().toLower();
if ( m_arguments.contains( key ) )
{
m_arguments[key]->callback()();
}
}
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QVariant CommandLineInterface::operator[](const QString key) const
{
if ( m_arguments.contains(key) )
{
return m_arguments[key]->value();
}
else
{
return QVariant();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithDescription(const QString &description)
{
m_description = description;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithFlag(const QString &flag, const QString &description)
{
addArgument( new Argument( flag, description, ArgumentType::Boolean, [this, flag](){
m_arguments[flag]->setValue(true);
}));
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithFlag(const QString &flag, const QString &description, std::function<void ()> action)
{
addArgument( new Argument( flag, description, ArgumentType::Boolean, action) );
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithAction(const QString &name, const QString &description, std::function<void ()> action)
{
addArgument( new Argument( name, description, ArgumentType::Action, action) );
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void CommandLineInterface::addArgument(Argument* arg)
{
m_arguments[arg->name()] = arg;
if ( arg->hasShortName() )
{
m_arguments[arg->shortName()] = arg;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::helpMessage() const
{
QString applicationExecutable = QFileInfo( QCoreApplication::applicationFilePath() ).fileName();
QString message = generateTitle();
if ( !message.isEmpty() )
{
message += QString(message.length()-1, '=') + QStringLiteral("\n");
}
if ( !m_description.isEmpty() )
{
message += m_description + QStringLiteral("\n\n");
}
message += QString("Usage: %1 [OPTION]\n\n").arg(applicationExecutable);
QStringList filterArgumentAliases;
foreach( Argument* arg, m_arguments.values() )
{
if ( filterArgumentAliases.contains( arg->name() ) ) continue;
if ( arg->hasShortName() )
{
message += QString( " -%1, --%2").arg(arg->shortName()).arg(arg->name());
}
else
{
message += QString( " -%1").arg(arg->name());
}
message += QString("\t%1\n").arg(arg->description());
filterArgumentAliases.append( arg->name());
}
return message;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::generateTitle() const
{
QString message;
if ( !m_applicationName.isEmpty() && !m_version.isEmpty() )
{
message += QString("%1 - Version %2\n").arg(m_applicationName).arg(m_version);
}
else if ( !m_applicationName.isEmpty() )
{
message += QString("%1\n").arg(m_applicationName);
}
else if ( !m_version.isEmpty() )
{
message += QString("Version %1\n").arg(m_version);
}
return message;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void CommandLineInterface::doHelpAction() const
{
printf( helpMessage().toLatin1().data() );
QCoreApplication::exit(0);
}
////////////////////////////////////////////////////////////////////////////////////////////////
void CommandLineInterface::doVersionAction() const
{
printf( generateTitle().toLatin1().data() );
QCoreApplication::exit(0);
}
<commit_msg>Fix compiler warning.<commit_after>/**
* The MIT License (MIT)
*
* Copyright (c) 2016 Brad van der Laan
*
* 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 <QCoreApplication>
#include <QFileInfo>
#include <QDir>
#include "CommandLineInterface.hpp"
#include "InputArgument.hpp"
using namespace Taranis;
using action_callback = std::function<void()>;
Q_DECLARE_METATYPE(action_callback)
const QString CommandLineInterface::VERSIONARGUMENT = "version";
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface() :
CommandLineInterface(QStringLiteral(""))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface(const QString applicationName)
: CommandLineInterface(applicationName, QStringLiteral(""))
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface(const QString applicationName, const QString version)
: CommandLineInterface( applicationName, version, QCoreApplication::arguments() )
{
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::CommandLineInterface(const QString applicationName, const QString version, QStringList arguments)
: m_acceptedArgumentPrefixs( { QStringLiteral("-"), QStringLiteral("--") } ),
m_applicationName(applicationName),
m_inputArguments( arguments )
{
if ( QDir::separator() != QChar('/') )
{
m_acceptedArgumentPrefixs.append( QStringLiteral("/") );
}
WithVersion( version );
WithHelp();
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface::~CommandLineInterface()
{
// qDeleteAll( m_arguments );
m_arguments.clear();
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface& CommandLineInterface::WithVersion(const QString &version)
{
m_version = version;
if ( m_version.isEmpty() )
{
delete m_arguments.value(VERSIONARGUMENT);
m_arguments.remove(VERSIONARGUMENT);
}
else
{
action_callback versionCallback = std::bind( &CommandLineInterface::doVersionAction, this );
WithAction(VERSIONARGUMENT, "Display version information and exit", versionCallback);
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithHelp()
{
action_callback helpCallback = std::bind( &CommandLineInterface::doHelpAction, this );
WithAction("help", "Display this help and exit", helpCallback);
WithAction("?", "Display this help and exit", helpCallback);
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::name() const
{
return m_applicationName;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::version() const
{
return m_version;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::description() const
{
return m_description;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface& CommandLineInterface::process()
{
foreach( QString a, m_inputArguments )
{
InputArgument arg( a, m_acceptedArgumentPrefixs );
if ( arg.isValid() )
{
QString key = arg.argument().toLower();
if ( m_arguments.contains( key ) )
{
m_arguments[key]->callback()();
}
}
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QVariant CommandLineInterface::operator[](const QString key) const
{
if ( m_arguments.contains(key) )
{
return m_arguments[key]->value();
}
else
{
return QVariant();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithDescription(const QString &description)
{
m_description = description;
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithFlag(const QString &flag, const QString &description)
{
addArgument( new Argument( flag, description, ArgumentType::Boolean, [this, flag](){
m_arguments[flag]->setValue(true);
}));
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithFlag(const QString &flag, const QString &description, std::function<void ()> action)
{
addArgument( new Argument( flag, description, ArgumentType::Boolean, action) );
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
CommandLineInterface &CommandLineInterface::WithAction(const QString &name, const QString &description, std::function<void ()> action)
{
addArgument( new Argument( name, description, ArgumentType::Action, action) );
return *this;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void CommandLineInterface::addArgument(Argument* arg)
{
m_arguments[arg->name()] = arg;
if ( arg->hasShortName() )
{
m_arguments[arg->shortName()] = arg;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::helpMessage() const
{
QString applicationExecutable = QFileInfo( QCoreApplication::applicationFilePath() ).fileName();
QString message = generateTitle();
if ( !message.isEmpty() )
{
message += QString(message.length()-1, '=') + QStringLiteral("\n");
}
if ( !m_description.isEmpty() )
{
message += m_description + QStringLiteral("\n\n");
}
message += QString("Usage: %1 [OPTION]\n\n").arg(applicationExecutable);
QStringList filterArgumentAliases;
foreach( Argument* arg, m_arguments.values() )
{
if ( filterArgumentAliases.contains( arg->name() ) ) continue;
if ( arg->hasShortName() )
{
message += QString( " -%1, --%2").arg(arg->shortName()).arg(arg->name());
}
else
{
message += QString( " -%1").arg(arg->name());
}
message += QString("\t%1\n").arg(arg->description());
filterArgumentAliases.append( arg->name());
}
return message;
}
////////////////////////////////////////////////////////////////////////////////////////////////
QString CommandLineInterface::generateTitle() const
{
QString message;
if ( !m_applicationName.isEmpty() && !m_version.isEmpty() )
{
message += QString("%1 - Version %2\n").arg(m_applicationName).arg(m_version);
}
else if ( !m_applicationName.isEmpty() )
{
message += QString("%1\n").arg(m_applicationName);
}
else if ( !m_version.isEmpty() )
{
message += QString("Version %1\n").arg(m_version);
}
return message;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void CommandLineInterface::doHelpAction() const
{
printf( "%s", helpMessage().toLatin1().data() );
QCoreApplication::exit(0);
}
////////////////////////////////////////////////////////////////////////////////////////////////
void CommandLineInterface::doVersionAction() const
{
printf( "%s", generateTitle().toLatin1().data() );
QCoreApplication::exit(0);
}
<|endoftext|> |
<commit_before>#include <gtest/gtest.h>
#include <ostream>
#include "ButtonStatus.hpp"
#include "Config.hpp"
#include "KeyCode.hpp"
using namespace org_pqrs_Karabiner;
Config config;
std::ostream& operator<<(std::ostream& os, const EventType& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const KeyboardType& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const ModifierFlag& v) { return os << v.getRawBits(); }
std::ostream& operator<<(std::ostream& os, const Flags& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const KeyCode& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const ConsumerKeyCode& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const PointingButton& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const Buttons& v) { return os << v.get(); }
TEST(ButtonStatus, all) {
ASSERT_TRUE(ButtonStatus::initialize());
EXPECT_EQ(Buttons(), ButtonStatus::makeButtons());
// ------------------------------------------------------------
// set
{
ButtonStatus::set(PointingButton(1 << 3), true);
EXPECT_EQ(Buttons((1 << 3)), ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 11), false);
EXPECT_EQ(Buttons((1 << 3)), ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 11), true);
EXPECT_EQ(Buttons((1 << 3)), ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 11), true);
EXPECT_EQ(Buttons((1 << 3) | (1 << 11)), ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 3), false);
EXPECT_EQ(Buttons((1 << 11)), ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 1), true);
EXPECT_EQ(Buttons((1 << 1) | (1 << 11)), ButtonStatus::makeButtons());
}
// ------------------------------------------------------------
// increase & decrease
ButtonStatus::increase(Buttons(1 << 9));
EXPECT_EQ(Buttons((1 << 1) | (1 << 9) | (1 << 11)), ButtonStatus::makeButtons());
ButtonStatus::decrease(Buttons((1 << 4) | (1 << 8)));
EXPECT_EQ(Buttons((1 << 1) | (1 << 9) | (1 << 11)), ButtonStatus::makeButtons());
// ------------------------------------------------------------
// reset
ButtonStatus::reset();
EXPECT_EQ(Buttons(), ButtonStatus::makeButtons());
// ------------------------------------------------------------
// lock
ButtonStatus::lock_increase(Buttons((1 << 1) | (1 << 3)));
ButtonStatus::increase(Buttons(1 << 5));
EXPECT_EQ(Buttons((1 << 1) | (1 << 3) | (1 << 5)), ButtonStatus::makeButtons());
ButtonStatus::reset();
EXPECT_EQ(Buttons((1 << 1) | (1 << 3)), ButtonStatus::makeButtons());
ButtonStatus::lock_clear();
EXPECT_EQ(Buttons(), ButtonStatus::makeButtons());
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
<commit_msg>use catch<commit_after>#define CATCH_CONFIG_MAIN
#include "../../include/catch.hpp"
#include <ostream>
#include "ButtonStatus.hpp"
#include "Config.hpp"
#include "KeyCode.hpp"
using namespace org_pqrs_Karabiner;
Config config;
std::ostream& operator<<(std::ostream& os, const EventType& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const KeyboardType& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const ModifierFlag& v) { return os << v.getRawBits(); }
std::ostream& operator<<(std::ostream& os, const Flags& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const KeyCode& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const ConsumerKeyCode& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const PointingButton& v) { return os << v.get(); }
std::ostream& operator<<(std::ostream& os, const Buttons& v) { return os << v.get(); }
TEST_CASE("all", "[Buttons]") {
REQUIRE(ButtonStatus::initialize() == true);
REQUIRE(Buttons() == ButtonStatus::makeButtons());
// ------------------------------------------------------------
// set
{
ButtonStatus::set(PointingButton(1 << 3), true);
REQUIRE(Buttons((1 << 3)) == ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 11), false);
REQUIRE(Buttons((1 << 3)) == ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 11), true);
REQUIRE(Buttons((1 << 3)) == ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 11), true);
REQUIRE(Buttons((1 << 3) | (1 << 11)) == ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 3), false);
REQUIRE(Buttons((1 << 11)) == ButtonStatus::makeButtons());
ButtonStatus::set(PointingButton(1 << 1), true);
REQUIRE(Buttons((1 << 1) | (1 << 11)) == ButtonStatus::makeButtons());
}
// ------------------------------------------------------------
// increase & decrease
ButtonStatus::increase(Buttons(1 << 9));
REQUIRE(Buttons((1 << 1) | (1 << 9) | (1 << 11)) == ButtonStatus::makeButtons());
ButtonStatus::decrease(Buttons((1 << 4) | (1 << 8)));
REQUIRE(Buttons((1 << 1) | (1 << 9) | (1 << 11)) == ButtonStatus::makeButtons());
// ------------------------------------------------------------
// reset
ButtonStatus::reset();
REQUIRE(Buttons() == ButtonStatus::makeButtons());
// ------------------------------------------------------------
// lock
ButtonStatus::lock_increase(Buttons((1 << 1) | (1 << 3)));
ButtonStatus::increase(Buttons(1 << 5));
REQUIRE(Buttons((1 << 1) | (1 << 3) | (1 << 5)) == ButtonStatus::makeButtons());
ButtonStatus::reset();
REQUIRE(Buttons((1 << 1) | (1 << 3)) == ButtonStatus::makeButtons());
ButtonStatus::lock_clear();
REQUIRE(Buttons() == ButtonStatus::makeButtons());
}
<|endoftext|> |
<commit_before>/***********************************************************************************************************************
**
** Copyright (c) 2011, 2014 ETH Zurich
** 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 ETH Zurich 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.
**
**********************************************************************************************************************/
#include "EnvisionApplication.h"
#include "EnvisionManager.h"
namespace Core {
QMap<void*, EnvisionApplication::IdleFunction>& EnvisionApplication::idleActions()
{
static QMap<void*, EnvisionApplication::IdleFunction> actions;
return actions;
}
EnvisionApplication::EnvisionApplication(int& argc, char** argv) : QApplication(argc, argv)
{
idleInputTimer_.setInterval(50);
idleInputTimer_.setSingleShot(true);
connect(&idleInputTimer_, SIGNAL(timeout()), this, SLOT(userInputIdle()));
}
bool EnvisionApplication::notify(QObject* receiver, QEvent* event)
{
if ( event->spontaneous()) idleInputTimer_.start();
EnvisionManager::processPreEventActions(receiver, event);
auto res = QApplication::notify(receiver, event);
EnvisionManager::processPostEventActions(receiver, event);
return res;
}
void EnvisionApplication::addOnUserInputIdleAction(void* actionId, IdleFunction action)
{
idleActions().insert(actionId, action);
}
void EnvisionApplication::removeOnUserInputIdleAction(void* actionId)
{
idleActions().remove(actionId);
}
void EnvisionApplication::userInputIdle()
{
for (auto& a : idleActions().values()) a();
}
} /* namespace Core */
<commit_msg>Do not constantly trigger "user input idle" events<commit_after>/***********************************************************************************************************************
**
** Copyright (c) 2011, 2014 ETH Zurich
** 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 ETH Zurich 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.
**
**********************************************************************************************************************/
#include "EnvisionApplication.h"
#include "EnvisionManager.h"
namespace Core {
QMap<void*, EnvisionApplication::IdleFunction>& EnvisionApplication::idleActions()
{
static QMap<void*, EnvisionApplication::IdleFunction> actions;
return actions;
}
EnvisionApplication::EnvisionApplication(int& argc, char** argv) : QApplication(argc, argv)
{
idleInputTimer_.setInterval(50);
idleInputTimer_.setSingleShot(true);
connect(&idleInputTimer_, SIGNAL(timeout()), this, SLOT(userInputIdle()));
}
bool EnvisionApplication::notify(QObject* receiver, QEvent* event)
{
if ( event->spontaneous() && (
// This list is meant to represent user interaction events
event->type() == QEvent::KeyPress
|| event->type() == QEvent::KeyRelease
|| event->type() == QEvent::DragEnter
|| event->type() == QEvent::DragLeave
|| event->type() == QEvent::DragMove
|| event->type() == QEvent::Drop
|| event->type() == QEvent::Enter
|| event->type() == QEvent::Gesture
|| event->type() == QEvent::HoverEnter
|| event->type() == QEvent::HoverLeave
|| event->type() == QEvent::HoverMove
|| event->type() == QEvent::Leave
|| event->type() == QEvent::MouseButtonDblClick
|| event->type() == QEvent::MouseButtonPress
|| event->type() == QEvent::MouseButtonRelease
|| event->type() == QEvent::MouseMove
|| event->type() == QEvent::NativeGesture
|| event->type() == QEvent::Wheel
)) {
idleInputTimer_.start();
}
EnvisionManager::processPreEventActions(receiver, event);
auto res = QApplication::notify(receiver, event);
EnvisionManager::processPostEventActions(receiver, event);
return res;
}
void EnvisionApplication::addOnUserInputIdleAction(void* actionId, IdleFunction action)
{
idleActions().insert(actionId, action);
}
void EnvisionApplication::removeOnUserInputIdleAction(void* actionId)
{
idleActions().remove(actionId);
}
void EnvisionApplication::userInputIdle()
{
for (auto& a : idleActions().values()) a();
}
} /* namespace Core */
<|endoftext|> |
<commit_before>/*******************************
Copyright (c) 2016-2018 Gr�goire Angerand
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 "EngineView.h"
#include <editor/EditorContext.h>
#include <yave/renderers/ToneMapper.h>
#include <yave/window/EventHandler.h>
#include <y/io/File.h>
#include <imgui/imgui.h>
namespace editor {
EngineView::EngineView(ContextPtr cptr) :
Dock("Engine view", ImGuiWindowFlags_NoScrollbar),
ContextLinked(cptr),
_ibl_data(new IBLData(device())),
_uniform_buffer(device(), 1),
_gizmo(context()) {
}
math::Vec2ui EngineView::render_size() const {
return _renderer ? _renderer->output().size() : math::Vec2ui();
}
void EngineView::create_renderer(const math::Vec2ui& size) {
auto scene = Node::Ptr<SceneRenderer>(new SceneRenderer(device(), *context()->scene_view()));
auto gbuffer = Node::Ptr<GBufferRenderer>(new GBufferRenderer(scene, size));
auto deferred = Node::Ptr<TiledDeferredRenderer>(new TiledDeferredRenderer(gbuffer, _ibl_data));
auto tonemap = Node::Ptr<SecondaryRenderer>(new ToneMapper(deferred));
_renderer = Node::Ptr<FramebufferRenderer>(new FramebufferRenderer(tonemap, size));
_ui_material = make_asset<Material>(device(), MaterialData()
.set_frag_data(SpirVData::from_file(io::File::open("copy.frag.spv").expected("Unable to load spirv file.")))
.set_vert_data(SpirVData::from_file(io::File::open("screen.vert.spv").expected("Unable to load spirv file.")))
.set_bindings({Binding(_renderer->output()), Binding(_uniform_buffer)})
.set_depth_tested(false)
);
}
void EngineView::draw_callback(RenderPassRecorder& recorder, void* user_data) {
reinterpret_cast<EngineView*>(user_data)->render_ui(recorder);
}
// called via draw_callback ONLY
void EngineView::render_ui(RenderPassRecorder& recorder) {
if(!_renderer) {
y_fatal("Internal error.");
}
auto region = recorder.region("EngineView::render_ui");
recorder.bind_material(*_ui_material);
recorder.draw(vk::DrawIndirectCommand(6, 1));
}
void EngineView::paint_ui(CmdBufferRecorder<>& recorder, const FrameToken& token) {
math::Vec2 win_size = ImGui::GetWindowSize();
math::Vec2 win_pos = ImGui::GetWindowPos();
if(!_renderer || win_size != render_size()) {
create_renderer(win_size);
}
if(_renderer) {
// process inputs
update_camera();
// render engine
{
RenderingPipeline pipeline(_renderer);
pipeline.render(recorder, token);
// so we don't have to wait when resizing
recorder.keep_alive(_renderer);
recorder.keep_alive(_ui_material);
}
// ui stuff
auto map = TypedMapping(_uniform_buffer);
map[0] = ViewData{math::Vec2i(win_size), math::Vec2i(win_pos), math::Vec2i(win_size)};
ImGui::GetWindowDrawList()->AddCallback(reinterpret_cast<ImDrawCallback>(&draw_callback), this);
}
_gizmo.paint(recorder, token);
}
void EngineView::update_camera() {
if(!ImGui::IsWindowHovered()) {
return;
}
auto size = render_size();
auto& camera = context()->scene_view()->camera();
math::Vec3 cam_pos = camera.position();
math::Vec3 cam_fwd = camera.forward();
math::Vec3 cam_lft = camera.left();
float cam_speed = 500.0f;
float dt = cam_speed / ImGui::GetIO().Framerate;
if(ImGui::IsKeyDown(int(context()->camera_settings.move_forward))) {
cam_pos += cam_fwd * dt;
}
if(ImGui::IsKeyDown(int(context()->camera_settings.move_backward))) {
cam_pos -= cam_fwd * dt;
}
if(ImGui::IsKeyDown(int(context()->camera_settings.move_left))) {
cam_pos += cam_lft * dt;
}
if(ImGui::IsKeyDown(int(context()->camera_settings.move_right))) {
cam_pos -= cam_lft * dt;
}
float fov = math::to_rad(60.0f);
if(ImGui::IsMouseDown(1)) {
auto rotation = math::Quaternion<>::from_base(cam_fwd, cam_lft, cam_fwd.cross(cam_lft));
auto euler = rotation.to_euler();
auto delta = math::Vec2(ImGui::GetIO().MouseDelta) / math::Vec2(ImGui::GetWindowSize());
delta *= context()->camera_settings.camera_sensitivity;
euler[math::Quaternion<>::YawIndex] -= delta.x();
euler[math::Quaternion<>::PitchIndex] += delta.y();
rotation = math::Quaternion<>::from_euler(euler);
cam_fwd = rotation({1.0f, 0.0f, 0.0f});
cam_lft = rotation({0.0f, 1.0f, 0.0f});
}
if(ImGui::IsMouseDown(2)) {
auto delta = ImGui::GetIO().MouseDelta;
cam_pos -= (delta.y * cam_fwd.cross(cam_lft) + delta.x * cam_lft);
}
auto proj = math::perspective(fov, float(size.x()) / float(size.y()), 1.0f);
auto view = math::look_at(cam_pos, cam_pos + cam_fwd, cam_fwd.cross(cam_lft));
camera.set_proj(proj);
camera.set_view(view);
}
}
<commit_msg>Better editor camera<commit_after>/*******************************
Copyright (c) 2016-2018 Gr�goire Angerand
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 "EngineView.h"
#include <editor/EditorContext.h>
#include <yave/renderers/ToneMapper.h>
#include <yave/window/EventHandler.h>
#include <y/io/File.h>
#include <imgui/imgui.h>
namespace editor {
EngineView::EngineView(ContextPtr cptr) :
Dock("Engine view", ImGuiWindowFlags_NoScrollbar),
ContextLinked(cptr),
_ibl_data(new IBLData(device())),
_uniform_buffer(device(), 1),
_gizmo(context()) {
}
math::Vec2ui EngineView::render_size() const {
return _renderer ? _renderer->output().size() : math::Vec2ui();
}
void EngineView::create_renderer(const math::Vec2ui& size) {
auto scene = Node::Ptr<SceneRenderer>(new SceneRenderer(device(), *context()->scene_view()));
auto gbuffer = Node::Ptr<GBufferRenderer>(new GBufferRenderer(scene, size));
auto deferred = Node::Ptr<TiledDeferredRenderer>(new TiledDeferredRenderer(gbuffer, _ibl_data));
auto tonemap = Node::Ptr<SecondaryRenderer>(new ToneMapper(deferred));
_renderer = Node::Ptr<FramebufferRenderer>(new FramebufferRenderer(tonemap, size));
_ui_material = make_asset<Material>(device(), MaterialData()
.set_frag_data(SpirVData::from_file(io::File::open("copy.frag.spv").expected("Unable to load spirv file.")))
.set_vert_data(SpirVData::from_file(io::File::open("screen.vert.spv").expected("Unable to load spirv file.")))
.set_bindings({Binding(_renderer->output()), Binding(_uniform_buffer)})
.set_depth_tested(false)
);
}
void EngineView::draw_callback(RenderPassRecorder& recorder, void* user_data) {
reinterpret_cast<EngineView*>(user_data)->render_ui(recorder);
}
// called via draw_callback ONLY
void EngineView::render_ui(RenderPassRecorder& recorder) {
if(!_renderer) {
y_fatal("Internal error.");
}
auto region = recorder.region("EngineView::render_ui");
recorder.bind_material(*_ui_material);
recorder.draw(vk::DrawIndirectCommand(6, 1));
}
void EngineView::paint_ui(CmdBufferRecorder<>& recorder, const FrameToken& token) {
math::Vec2 win_size = ImGui::GetWindowSize();
math::Vec2 win_pos = ImGui::GetWindowPos();
if(!_renderer || win_size != render_size()) {
create_renderer(win_size);
}
if(_renderer) {
// process inputs
update_camera();
// render engine
{
RenderingPipeline pipeline(_renderer);
pipeline.render(recorder, token);
// so we don't have to wait when resizing
recorder.keep_alive(_renderer);
recorder.keep_alive(_ui_material);
}
// ui stuff
auto map = TypedMapping(_uniform_buffer);
map[0] = ViewData{math::Vec2i(win_size), math::Vec2i(win_pos), math::Vec2i(win_size)};
ImGui::GetWindowDrawList()->AddCallback(reinterpret_cast<ImDrawCallback>(&draw_callback), this);
}
_gizmo.paint(recorder, token);
}
void EngineView::update_camera() {
if(!ImGui::IsWindowHovered()) {
return;
}
auto size = render_size();
auto& camera = context()->scene_view()->camera();
math::Vec3 cam_pos = camera.position();
math::Vec3 cam_fwd = camera.forward();
math::Vec3 cam_lft = camera.left();
cam_lft = math::Vec3(cam_lft.x(), cam_lft.y(), 0.0f).normalized();
float cam_speed = 500.0f;
float dt = cam_speed / ImGui::GetIO().Framerate;
if(ImGui::IsKeyDown(int(context()->camera_settings.move_forward))) {
cam_pos += cam_fwd * dt;
}
if(ImGui::IsKeyDown(int(context()->camera_settings.move_backward))) {
cam_pos -= cam_fwd * dt;
}
if(ImGui::IsKeyDown(int(context()->camera_settings.move_left))) {
cam_pos += cam_lft * dt;
}
if(ImGui::IsKeyDown(int(context()->camera_settings.move_right))) {
cam_pos -= cam_lft * dt;
}
float fov = math::to_rad(60.0f);
if(ImGui::IsMouseDown(1)) {
auto delta = math::Vec2(ImGui::GetIO().MouseDelta) / math::Vec2(ImGui::GetWindowSize());
delta *= context()->camera_settings.camera_sensitivity;
{
auto pitch = math::Quaternion<>::from_axis_angle(cam_lft, delta.y());
cam_fwd = pitch(cam_fwd);
}
{
auto yaw = math::Quaternion<>::from_axis_angle(cam_fwd.cross(cam_lft), -delta.x());
cam_fwd = yaw(cam_fwd);
cam_lft = yaw(cam_lft);
}
auto euler = math::Quaternion<>::from_base(cam_fwd, cam_lft, cam_fwd.cross(cam_lft)).to_euler();
bool upside_down = cam_fwd.cross(cam_lft).z() < 0.0f;
euler[math::Quaternion<>::RollIndex] = upside_down ? -math::pi<float> : 0.0f;
auto rotation = math::Quaternion<>::from_euler(euler);
cam_fwd = rotation({1.0f, 0.0f, 0.0f});
cam_lft = rotation({0.0f, 1.0f, 0.0f});
}
if(ImGui::IsMouseDown(2)) {
auto delta = ImGui::GetIO().MouseDelta;
cam_pos -= (delta.y * cam_fwd.cross(cam_lft) + delta.x * cam_lft);
}
auto proj = math::perspective(fov, float(size.x()) / float(size.y()), 1.0f);
auto view = math::look_at(cam_pos, cam_pos + cam_fwd, cam_fwd.cross(cam_lft));
camera.set_proj(proj);
camera.set_view(view);
}
}
<|endoftext|> |
<commit_before>// Copyright 2014 Velodyne Acoustics, Inc.
//
// 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 "vtkLASFileWriter.h"
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtk_libproj4.h>
#include <liblas/liblas.hpp>
#include <Eigen/Dense>
#ifndef PJ_VERSION // 4.8 or later
#include <cassert>
#endif
namespace
{
#ifdef PJ_VERSION // 4.8 or later
//-----------------------------------------------------------------------------
projPJ CreateProj(int epsg)
{
std::ostringstream ss;
ss << "+init=epsg:" << epsg;
return pj_init_plus(ss.str().c_str());
}
//-----------------------------------------------------------------------------
Eigen::Vector3d ConvertGcs(
Eigen::Vector3d p, projPJ inProj, projPJ outProj)
{
if (pj_is_latlong(inProj))
{
p[0] *= DEG_TO_RAD;
p[1] *= DEG_TO_RAD;
}
double* const data = p.data();
pj_transform(inProj, outProj, 1, 1, data + 0, data + 1, data + 2);
if (pj_is_latlong(outProj))
{
p[0] *= RAD_TO_DEG;
p[1] *= RAD_TO_DEG;
}
return p;
}
#else
//-----------------------------------------------------------------------------
PROJ* CreateProj(int utmZone, bool south)
{
std::ostringstream ss;
ss << "+zone=" << utmZone;
char buffer[65] = { 0 };
strncpy(buffer, ss.str().c_str(), 64);
std::vector<const char*> utmparams;
utmparams.push_back("+proj=utm");
utmparams.push_back("+ellps=WGS84");
utmparams.push_back("+units=m");
utmparams.push_back("+no_defs");
utmparams.push_back(buffer);
if (south)
{
utmparams.push_back("+south");
}
return proj_init(utmparams.size(), const_cast<char**>(&(utmparams[0])));
}
//-----------------------------------------------------------------------------
Eigen::Vector3d InvertProj(Eigen::Vector3d in, PROJ* proj)
{
// This "lovely little gem" makes an awful lot of assumptions about the input
// (some flavor of XY) and output (internal LP, which we assume / hope is
// WGS'84) GCS's and what operations are "interesting" (i.e. the assumption
// that the Z component does not need to be considered and can be passed
// through unaltered). Unfortunately, it's the best we can do with PROJ 4.7
// until VTK can be updated to use 4.8. Fortunately, given how we're being
// used, our input really ought to always be UTM.
PROJ_XY xy;
xy.x = in[0];
xy.y = in[1];
const PROJ_LP lp = proj_inv(xy, proj);
return Eigen::Vector3d(lp.lam * RAD_TO_DEG, lp.phi * RAD_TO_DEG, in[2]);
}
#endif
}
//-----------------------------------------------------------------------------
class vtkLASFileWriter::vtkInternal
{
public:
void Close();
std::ofstream Stream;
liblas::Writer* Writer;
double MinTime;
double MaxTime;
Eigen::Vector3d Origin;
#ifdef PJ_VERSION // 4.8 or later
projPJ InProj;
projPJ OutProj;
#else
PROJ* Proj;
#endif
int OutGcs;
};
//-----------------------------------------------------------------------------
void vtkLASFileWriter::vtkInternal::Close()
{
delete this->Writer;
this->Writer = 0;
this->Stream.close();
}
//-----------------------------------------------------------------------------
vtkLASFileWriter::vtkLASFileWriter(const char* filename)
: Internal(new vtkInternal)
{
this->Internal->MinTime = -std::numeric_limits<double>::infinity();
this->Internal->MaxTime = +std::numeric_limits<double>::infinity();
#ifdef PJ_VERSION // 4.8 or later
this->Internal->InProj = 0;
this->Internal->OutProj = 0;
#else
this->Internal->Proj = 0;
#endif
this->Internal->OutGcs = -1;
this->Internal->Stream.open(
filename, std::ios::out | std::ios::trunc | std::ios::binary);
liblas::Header header;
header.SetSoftwareId("VeloView");
header.SetDataFormatId(liblas::ePointFormat1);
header.SetScale(1e-3, 1e-3, 1e-3);
this->Internal->Writer = new liblas::Writer(this->Internal->Stream, header);
}
//-----------------------------------------------------------------------------
vtkLASFileWriter::~vtkLASFileWriter()
{
this->Internal->Close();
#ifdef PJ_VERSION // 4.8 or later
pj_free(this->Internal->InProj);
pj_free(this->Internal->OutProj);
#else
proj_free(this->Internal->Proj);
#endif
delete this->Internal;
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetTimeRange(double min, double max)
{
this->Internal->MinTime = min;
this->Internal->MaxTime = max;
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetOrigin(
int gcs, double easting, double northing, double height)
{
// Set internal UTM offset
Eigen::Vector3d origin(easting, northing, height);
this->Internal->Origin = origin;
// Convert offset to output GCS, if a geoconversion is set up
#ifdef PJ_VERSION // 4.8 or later
if (this->Internal->OutProj)
{
origin =
ConvertGcs(origin, this->Internal->InProj, this->Internal->OutProj);
gcs = this->Internal->OutGcs;
}
#else
if (this->Internal->Proj)
{
origin = InvertProj(origin, this->Internal->Proj);
gcs = this->Internal->OutGcs;
}
#endif
// Update header
liblas::Header header = this->Internal->Writer->GetHeader();
header.SetOffset(origin[0], origin[1], origin[2]);
try
{
liblas::SpatialReference srs;
std::ostringstream ss;
ss << "EPSG:" << gcs;
srs.SetFromUserInput(ss.str());
header.SetSRS(srs);
}
catch (std::logic_error)
{
std::cerr << "failed to set SRS (logic)" << std::endl;
}
catch (std::runtime_error)
{
std::cerr << "failed to set SRS" << std::endl;
}
this->Internal->Writer->SetHeader(header);
this->Internal->Writer->WriteHeader();
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetGeoConversion(int in, int out)
{
#ifdef PJ_VERSION // 4.8 or later
pj_free(this->Internal->InProj);
pj_free(this->Internal->OutProj);
this->Internal->InProj = CreateProj(in);
this->Internal->OutProj = CreateProj(out);
#else
// The PROJ 4.7 API makes it near impossible to do generic transforms, hence
// InvertProj (see also comments there) is full of assumptions. Assert some
// of those assumptions here.
assert((in > 32600 && in < 32661) || (in > 32700 && in < 32761));
assert(out == 4326);
proj_free(this->Internal->Proj);
this->Internal->Proj = CreateProj(in % 100, in > 32700);
#endif
this->Internal->OutGcs = out;
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetPrecision(double neTol, double hTol)
{
liblas::Header header = this->Internal->Writer->GetHeader();
header.SetScale(neTol, neTol, hTol);
this->Internal->Writer->SetHeader(header);
this->Internal->Writer->WriteHeader();
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::WriteFrame(vtkPolyData* data)
{
vtkPoints* const points = data->GetPoints();
vtkDataArray* const intensityData =
data->GetPointData()->GetArray("intensity");
vtkDataArray* const laserIdData =
data->GetPointData()->GetArray("laser_id");
vtkDataArray* const timestampData =
data->GetPointData()->GetArray("timestamp");
const vtkIdType numPoints = points->GetNumberOfPoints();
for (vtkIdType n = 0; n < numPoints; ++n)
{
const double time = timestampData->GetComponent(n, 0) * 1e-6;
if (time >= this->Internal->MinTime && time <= this->Internal->MaxTime)
{
Eigen::Vector3d pos;
points->GetPoint(n, pos.data());
pos += this->Internal->Origin;
#ifdef PJ_VERSION // 4.8 or later
if (this->Internal->OutProj)
{
pos = ConvertGcs(pos, this->Internal->InProj, this->Internal->OutProj);
}
#else
if (this->Internal->Proj)
{
pos = InvertProj(pos, this->Internal->Proj);
}
#endif
liblas::Point p(&this->Internal->Writer->GetHeader());
p.SetCoordinates(pos[0], pos[1], pos[2]);
p.SetIntensity(static_cast<uint16_t>(intensityData->GetComponent(n, 0)));
p.SetReturnNumber(0);
p.SetNumberOfReturns(1);
p.SetUserData(static_cast<uint8_t>(laserIdData->GetComponent(n, 0)));
p.SetTime(time);
this->Internal->Writer->WritePoint(p);
}
}
}
<commit_msg>fix - Add number of points by record count to header<commit_after>// Copyright 2014 Velodyne Acoustics, Inc.
//
// 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 "vtkLASFileWriter.h"
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtk_libproj4.h>
#include <liblas/liblas.hpp>
#include <Eigen/Dense>
#ifndef PJ_VERSION // 4.8 or later
#include <cassert>
#endif
namespace
{
#ifdef PJ_VERSION // 4.8 or later
//-----------------------------------------------------------------------------
projPJ CreateProj(int epsg)
{
std::ostringstream ss;
ss << "+init=epsg:" << epsg;
return pj_init_plus(ss.str().c_str());
}
//-----------------------------------------------------------------------------
Eigen::Vector3d ConvertGcs(
Eigen::Vector3d p, projPJ inProj, projPJ outProj)
{
if (pj_is_latlong(inProj))
{
p[0] *= DEG_TO_RAD;
p[1] *= DEG_TO_RAD;
}
double* const data = p.data();
pj_transform(inProj, outProj, 1, 1, data + 0, data + 1, data + 2);
if (pj_is_latlong(outProj))
{
p[0] *= RAD_TO_DEG;
p[1] *= RAD_TO_DEG;
}
return p;
}
#else
//-----------------------------------------------------------------------------
PROJ* CreateProj(int utmZone, bool south)
{
std::ostringstream ss;
ss << "+zone=" << utmZone;
char buffer[65] = { 0 };
strncpy(buffer, ss.str().c_str(), 64);
std::vector<const char*> utmparams;
utmparams.push_back("+proj=utm");
utmparams.push_back("+ellps=WGS84");
utmparams.push_back("+units=m");
utmparams.push_back("+no_defs");
utmparams.push_back(buffer);
if (south)
{
utmparams.push_back("+south");
}
return proj_init(utmparams.size(), const_cast<char**>(&(utmparams[0])));
}
//-----------------------------------------------------------------------------
Eigen::Vector3d InvertProj(Eigen::Vector3d in, PROJ* proj)
{
// This "lovely little gem" makes an awful lot of assumptions about the input
// (some flavor of XY) and output (internal LP, which we assume / hope is
// WGS'84) GCS's and what operations are "interesting" (i.e. the assumption
// that the Z component does not need to be considered and can be passed
// through unaltered). Unfortunately, it's the best we can do with PROJ 4.7
// until VTK can be updated to use 4.8. Fortunately, given how we're being
// used, our input really ought to always be UTM.
PROJ_XY xy;
xy.x = in[0];
xy.y = in[1];
const PROJ_LP lp = proj_inv(xy, proj);
return Eigen::Vector3d(lp.lam * RAD_TO_DEG, lp.phi * RAD_TO_DEG, in[2]);
}
#endif
}
//-----------------------------------------------------------------------------
class vtkLASFileWriter::vtkInternal
{
public:
void Close();
std::ofstream Stream;
liblas::Writer* Writer;
double MinTime;
double MaxTime;
Eigen::Vector3d Origin;
size_t npoints;
#ifdef PJ_VERSION // 4.8 or later
projPJ InProj;
projPJ OutProj;
#else
PROJ* Proj;
#endif
int OutGcs;
};
//-----------------------------------------------------------------------------
void vtkLASFileWriter::vtkInternal::Close()
{
delete this->Writer;
this->Writer = 0;
this->Stream.close();
}
//-----------------------------------------------------------------------------
vtkLASFileWriter::vtkLASFileWriter(const char* filename)
: Internal(new vtkInternal)
{
this->Internal->MinTime = -std::numeric_limits<double>::infinity();
this->Internal->MaxTime = +std::numeric_limits<double>::infinity();
#ifdef PJ_VERSION // 4.8 or later
this->Internal->InProj = 0;
this->Internal->OutProj = 0;
#else
this->Internal->Proj = 0;
#endif
this->Internal->OutGcs = -1;
this->Internal->npoints = 0;
this->Internal->Stream.open(
filename, std::ios::out | std::ios::trunc | std::ios::binary);
liblas::Header header;
header.SetSoftwareId("VeloView");
header.SetDataFormatId(liblas::ePointFormat1);
header.SetScale(1e-3, 1e-3, 1e-3);
this->Internal->Writer = new liblas::Writer(this->Internal->Stream, header);
}
//-----------------------------------------------------------------------------
vtkLASFileWriter::~vtkLASFileWriter()
{
liblas::Header header = this->Internal->Writer->GetHeader();
header.SetPointRecordsByReturnCount(0, this->Internal->npoints);
this->Internal->Writer->SetHeader(header);
this->Internal->Writer->WriteHeader();
this->Internal->Close();
#ifdef PJ_VERSION // 4.8 or later
pj_free(this->Internal->InProj);
pj_free(this->Internal->OutProj);
#else
proj_free(this->Internal->Proj);
#endif
delete this->Internal;
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetTimeRange(double min, double max)
{
this->Internal->MinTime = min;
this->Internal->MaxTime = max;
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetOrigin(
int gcs, double easting, double northing, double height)
{
// Set internal UTM offset
Eigen::Vector3d origin(easting, northing, height);
this->Internal->Origin = origin;
// Convert offset to output GCS, if a geoconversion is set up
#ifdef PJ_VERSION // 4.8 or later
if (this->Internal->OutProj)
{
origin =
ConvertGcs(origin, this->Internal->InProj, this->Internal->OutProj);
gcs = this->Internal->OutGcs;
}
#else
if (this->Internal->Proj)
{
origin = InvertProj(origin, this->Internal->Proj);
gcs = this->Internal->OutGcs;
}
#endif
// Update header
liblas::Header header = this->Internal->Writer->GetHeader();
header.SetOffset(origin[0], origin[1], origin[2]);
try
{
liblas::SpatialReference srs;
std::ostringstream ss;
ss << "EPSG:" << gcs;
srs.SetFromUserInput(ss.str());
header.SetSRS(srs);
}
catch (std::logic_error)
{
std::cerr << "failed to set SRS (logic)" << std::endl;
}
catch (std::runtime_error)
{
std::cerr << "failed to set SRS" << std::endl;
}
this->Internal->Writer->SetHeader(header);
this->Internal->Writer->WriteHeader();
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetGeoConversion(int in, int out)
{
#ifdef PJ_VERSION // 4.8 or later
pj_free(this->Internal->InProj);
pj_free(this->Internal->OutProj);
this->Internal->InProj = CreateProj(in);
this->Internal->OutProj = CreateProj(out);
#else
// The PROJ 4.7 API makes it near impossible to do generic transforms, hence
// InvertProj (see also comments there) is full of assumptions. Assert some
// of those assumptions here.
assert((in > 32600 && in < 32661) || (in > 32700 && in < 32761));
assert(out == 4326);
proj_free(this->Internal->Proj);
this->Internal->Proj = CreateProj(in % 100, in > 32700);
#endif
this->Internal->OutGcs = out;
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::SetPrecision(double neTol, double hTol)
{
liblas::Header header = this->Internal->Writer->GetHeader();
header.SetScale(neTol, neTol, hTol);
this->Internal->Writer->SetHeader(header);
this->Internal->Writer->WriteHeader();
}
//-----------------------------------------------------------------------------
void vtkLASFileWriter::WriteFrame(vtkPolyData* data)
{
vtkPoints* const points = data->GetPoints();
vtkDataArray* const intensityData =
data->GetPointData()->GetArray("intensity");
vtkDataArray* const laserIdData =
data->GetPointData()->GetArray("laser_id");
vtkDataArray* const timestampData =
data->GetPointData()->GetArray("timestamp");
const vtkIdType numPoints = points->GetNumberOfPoints();
for (vtkIdType n = 0; n < numPoints; ++n)
{
const double time = timestampData->GetComponent(n, 0) * 1e-6;
if (time >= this->Internal->MinTime && time <= this->Internal->MaxTime)
{
Eigen::Vector3d pos;
points->GetPoint(n, pos.data());
pos += this->Internal->Origin;
#ifdef PJ_VERSION // 4.8 or later
if (this->Internal->OutProj)
{
pos = ConvertGcs(pos, this->Internal->InProj, this->Internal->OutProj);
}
#else
if (this->Internal->Proj)
{
pos = InvertProj(pos, this->Internal->Proj);
}
#endif
liblas::Point p(&this->Internal->Writer->GetHeader());
p.SetCoordinates(pos[0], pos[1], pos[2]);
p.SetIntensity(static_cast<uint16_t>(intensityData->GetComponent(n, 0)));
p.SetReturnNumber(0);
p.SetNumberOfReturns(1);
p.SetUserData(static_cast<uint8_t>(laserIdData->GetComponent(n, 0)));
p.SetTime(time);
this->Internal->npoints++;
this->Internal->Writer->WritePoint(p);
}
}
}
<|endoftext|> |
<commit_before>#include <gtest/gtest.h>
#include <MakeReseedable.h>
#include <ModuleFactories.h>
class TestReseedable : public ::testing::Test {
protected:
Reseedable x;
Reseedable y;
Reseedable c05;
TestReseedable() :
x(makeX()),
y(makeY()),
c05(makeReseedable(std::make_shared<noise::module::Const>()))
{
((noise::module::Const&)(*c05.module)).SetConstValue(0.5);
};
~TestReseedable() {};
};
TEST_F(TestReseedable, TestReseedableGetValue)
{
EXPECT_EQ(2508., x.getValue(2508., -518., 2805.)) <<
"Incorrect value";
EXPECT_EQ(1., y.getValue(320., 1., -39.)) <<
"Incorrect value";
}
TEST_F(TestReseedable, TestReseedableSetSeed)
{
EXPECT_NO_THROW({ x.setSeed(35089); });
EXPECT_NO_THROW({ y.setSeed(293847928); });
}
TEST_F(TestReseedable, TestReseedableAbs)
{
EXPECT_EQ(5., x.abs().getValue(-5., 0, 0));
EXPECT_EQ(4., x.abs().getValue(4., 0, 0));
EXPECT_EQ(3., y.abs().getValue(-5., 3., 0));
EXPECT_EQ(2., y.abs().getValue(4., -2., 0));
}
TEST_F(TestReseedable, TestReseedableClamp)
{
EXPECT_EQ(-1., x.clamp(-1., 1.).getValue(-5., 0, 0));
EXPECT_EQ(1., y.clamp(-1., 1.).getValue(-1., 3., 0));
EXPECT_EQ(0., x.clamp(-5., 5.).getValue(0., 3., 0));
EXPECT_EQ(-10., y.clamp(-10, -10).getValue(4., -2., 0));
}
TEST_F(TestReseedable, TestReseedablePowDouble)
{
EXPECT_NEAR(-8., x.pow(3).getValue(-2., 0, 0), 0.0001);
EXPECT_EQ(0.04, x.pow(-2).getValue(5., 0, 0));
EXPECT_NEAR(3., y.pow(0.5).getValue(-5., 9., 0), 0.0001);
EXPECT_EQ(1., y.pow(0).getValue(4., -2., 5.));
}
TEST_F(TestReseedable, TestReseedablePowReseedable)
{
EXPECT_EQ(4., x.pow(x).getValue(2., 0, 0));
EXPECT_EQ(-32., x.pow(y).getValue(-2., 5, 0));
EXPECT_NEAR(-1953125., y.pow(x).getValue(9., -5., 0), 0.01);
EXPECT_EQ(1. / 256., y.pow(y).getValue(4., -4., 5.));
}
TEST_F(TestReseedable, TestReseedableExpDouble)
{
EXPECT_NEAR(1./9., x.exp(3).getValue(-2., 0, 0), 0.0001);
EXPECT_EQ(-32., x.exp(-2).getValue(5., 0, 0));
EXPECT_NEAR(0.25, y.exp(0.5).getValue(-5., 2., 0), 0.0001);
EXPECT_EQ(0., y.exp(0).getValue(4., 2., 5.));
}
TEST_F(TestReseedable, TestReseedableInv)
{
EXPECT_EQ(16., x.invert().getValue(-16., 0, 0));
EXPECT_EQ(-32., x.invert().getValue(32., 0, 0));
EXPECT_EQ(3., y.invert().getValue(-5., -3., 0));
EXPECT_EQ(-1., y.invert().getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableScaleBias)
{
EXPECT_EQ(-155, x.scaleBias(10, 5).getValue(-16., 0, 0));
EXPECT_EQ(-158, x.scaleBias(-5, 2).getValue(32., 0, 0));
EXPECT_EQ(1.5, y.scaleBias(0.5, 3).getValue(-5., -3., 0));
EXPECT_EQ(1.5, y.scaleBias(1, 0.5).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableAddReseedable)
{
EXPECT_EQ(74., (x + y).getValue(-16., 90., 0));
EXPECT_EQ(64., (x + x).getValue(32., 0, 0));
EXPECT_EQ(-8., (y + x).getValue(-5., -3., 0));
EXPECT_EQ(2., (y + y).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableAddDouble)
{
EXPECT_EQ(-11., (x + 5.).getValue(-16., 0, 0));
EXPECT_EQ(-6., (y + (-3)).getValue(-5., -3., 0));
}
TEST_F(TestReseedable, TestReseedableMaxReseedable)
{
EXPECT_EQ(-3., x.max(y).getValue(-5., -3., 0));
EXPECT_EQ(4., y.max(x).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMaxDouble)
{
EXPECT_EQ(4., x.max(4).getValue(-5., -3., 0));
EXPECT_EQ(1., y.max(0).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMinReseedable)
{
EXPECT_EQ(-5., x.min(y).getValue(-5., -3., 0));
EXPECT_EQ(1., y.min(x).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMinDouble)
{
EXPECT_EQ(-5., x.min(4).getValue(-5., -3., 0));
EXPECT_EQ(0., y.min(0).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableInvert)
{
EXPECT_EQ(-5, x.invert().getValue(5, 43, 3));
EXPECT_EQ(4, y.invert().getValue(5, -4, 34));
}
//Reseedable curve(...?)
//Reseedable terrace(...?)
TEST_F(TestReseedable, TestReseedableSubReseedable)
{
EXPECT_EQ(-106., (x - y).getValue(-16., 90., 0));
EXPECT_EQ(0., (x - x).getValue(32., 0, 0));
EXPECT_EQ(2., (y - x).getValue(-5., -3., 0));
EXPECT_EQ(0., (y - y).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableSubDouble)
{
EXPECT_EQ(-21., (x - 5.).getValue(-16., 0, 0));
EXPECT_EQ(1., (y - (-4)).getValue(-5., -3., 0));
}
TEST_F(TestReseedable, TestReseedableSubUnary)
{
EXPECT_EQ(-5, (-x).getValue(5, 43, 3));
EXPECT_EQ(4, (-y).getValue(5, -4, 34));
}
TEST_F(TestReseedable, TestReseedableMulReseedable)
{
EXPECT_EQ(-1440, (x * y).getValue(-16., 90., 0));
EXPECT_EQ(1024., (x * x).getValue(32., 0, 0));
EXPECT_EQ(15., (y * x).getValue(-5., -3., 0));
EXPECT_EQ(1., (y * y).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMulDouble)
{
EXPECT_EQ(-80., (x * 5.).getValue(-16., 0, 0));
EXPECT_EQ(12., (y * (-4)).getValue(-5., -3., 0));
}
TEST_F(TestReseedable, TestReseedableBlend)
{
EXPECT_EQ(0.75, c05.blend(x, y).getValue(0., 1., 5.));
EXPECT_EQ(-5, (c05).blend(y, x).getValue(-1, -17, 5.));
}
TEST_F(TestReseedable, TestReseedableSelect)
{
EXPECT_EQ(-17, c05.select(x, y).getValue(-1, -17, 5.));
EXPECT_EQ(0., c05.select(y, x).getValue(0., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableDisplace)
{
auto displace = (x - (y * 2)).displace(x, y, c05);
EXPECT_EQ(0., displace.getValue(0, 0, 304958.));
EXPECT_EQ(0., displace.getValue(2, 1, 30458.));
EXPECT_EQ(-10., displace.getValue(-2, 3, 30458.));
}
TEST_F(TestReseedable, TestReseedableRotatePoint)
{
EXPECT_EQ(20., x.rotatePoint(0,0,90).getValue(2, 20, 200));
EXPECT_EQ(-30, y.rotatePoint(0,0,180).getValue(2, 30, 200));
}
TEST_F(TestReseedable, TestReseedableScalePoint)
{
EXPECT_EQ(6., x.scalePoint(3, 30, 300).getValue(2, 20, 200));
EXPECT_EQ(200., y.scalePoint(-1, -10, -100).getValue(2, -20, 200));
}
TEST_F(TestReseedable, TestReseedableTranslatePoint)
{
EXPECT_EQ(3., x.translatePoint(1, 10, 100).getValue(2, 20, 200));
EXPECT_EQ(-10., y.translatePoint(1, 10, 100).getValue(2, -20, 200));
}
TEST_F(TestReseedable, TestReseedableTurbulence)
{
auto turbulence = c05.turbulence(2., 2., 3, 0);
EXPECT_EQ(0.5, turbulence.getValue(346980., 0.63, 696.346));
}
TEST_F(TestReseedable, TestReseedableConst)
{
EXPECT_EQ(3.6345, makeConst(3.6345).getValue(52935874, 57432895, 2549));
EXPECT_EQ(-3045.25, makeConst(-3045.25).getValue(259, 594, 239587));
}<commit_msg>Correct test value<commit_after>#include <gtest/gtest.h>
#include <MakeReseedable.h>
#include <ModuleFactories.h>
class TestReseedable : public ::testing::Test {
protected:
Reseedable x;
Reseedable y;
Reseedable c05;
TestReseedable() :
x(makeX()),
y(makeY()),
c05(makeReseedable(std::make_shared<noise::module::Const>()))
{
((noise::module::Const&)(*c05.module)).SetConstValue(0.5);
};
~TestReseedable() {};
};
TEST_F(TestReseedable, TestReseedableGetValue)
{
EXPECT_EQ(2508., x.getValue(2508., -518., 2805.)) <<
"Incorrect value";
EXPECT_EQ(1., y.getValue(320., 1., -39.)) <<
"Incorrect value";
}
TEST_F(TestReseedable, TestReseedableSetSeed)
{
EXPECT_NO_THROW({ x.setSeed(35089); });
EXPECT_NO_THROW({ y.setSeed(293847928); });
}
TEST_F(TestReseedable, TestReseedableAbs)
{
EXPECT_EQ(5., x.abs().getValue(-5., 0, 0));
EXPECT_EQ(4., x.abs().getValue(4., 0, 0));
EXPECT_EQ(3., y.abs().getValue(-5., 3., 0));
EXPECT_EQ(2., y.abs().getValue(4., -2., 0));
}
TEST_F(TestReseedable, TestReseedableClamp)
{
EXPECT_EQ(-1., x.clamp(-1., 1.).getValue(-5., 0, 0));
EXPECT_EQ(1., y.clamp(-1., 1.).getValue(-1., 3., 0));
EXPECT_EQ(0., x.clamp(-5., 5.).getValue(0., 3., 0));
EXPECT_EQ(-10., y.clamp(-10, -10).getValue(4., -2., 0));
}
TEST_F(TestReseedable, TestReseedablePowDouble)
{
EXPECT_NEAR(-8., x.pow(3).getValue(-2., 0, 0), 0.0001);
EXPECT_EQ(0.04, x.pow(-2).getValue(5., 0, 0));
EXPECT_NEAR(3., y.pow(0.5).getValue(-5., 9., 0), 0.0001);
EXPECT_EQ(1., y.pow(0).getValue(4., -2., 5.));
}
TEST_F(TestReseedable, TestReseedablePowReseedable)
{
EXPECT_EQ(4., x.pow(x).getValue(2., 0, 0));
EXPECT_EQ(-32., x.pow(y).getValue(-2., 5, 0));
EXPECT_NEAR(-1953125., y.pow(x).getValue(9., -5., 0), 0.01);
EXPECT_EQ(1. / 256., y.pow(y).getValue(4., -4., 5.));
}
TEST_F(TestReseedable, TestReseedableExpDouble)
{
EXPECT_NEAR(1./9., x.exp(3).getValue(-2., 0, 0), 0.0001);
EXPECT_EQ(-32., x.exp(-2).getValue(5., 0, 0));
EXPECT_NEAR(0.25, y.exp(0.5).getValue(-5., 2., 0), 0.0001);
EXPECT_EQ(0., y.exp(0).getValue(4., 2., 5.));
}
TEST_F(TestReseedable, TestReseedableInv)
{
EXPECT_EQ(16., x.invert().getValue(-16., 0, 0));
EXPECT_EQ(-32., x.invert().getValue(32., 0, 0));
EXPECT_EQ(3., y.invert().getValue(-5., -3., 0));
EXPECT_EQ(-1., y.invert().getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableScaleBias)
{
EXPECT_EQ(-155, x.scaleBias(10, 5).getValue(-16., 0, 0));
EXPECT_EQ(-158, x.scaleBias(-5, 2).getValue(32., 0, 0));
EXPECT_EQ(1.5, y.scaleBias(0.5, 3).getValue(-5., -3., 0));
EXPECT_EQ(1.5, y.scaleBias(1, 0.5).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableAddReseedable)
{
EXPECT_EQ(74., (x + y).getValue(-16., 90., 0));
EXPECT_EQ(64., (x + x).getValue(32., 0, 0));
EXPECT_EQ(-8., (y + x).getValue(-5., -3., 0));
EXPECT_EQ(2., (y + y).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableAddDouble)
{
EXPECT_EQ(-11., (x + 5.).getValue(-16., 0, 0));
EXPECT_EQ(-6., (y + (-3)).getValue(-5., -3., 0));
}
TEST_F(TestReseedable, TestReseedableMaxReseedable)
{
EXPECT_EQ(-3., x.max(y).getValue(-5., -3., 0));
EXPECT_EQ(4., y.max(x).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMaxDouble)
{
EXPECT_EQ(4., x.max(4).getValue(-5., -3., 0));
EXPECT_EQ(1., y.max(0).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMinReseedable)
{
EXPECT_EQ(-5., x.min(y).getValue(-5., -3., 0));
EXPECT_EQ(1., y.min(x).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMinDouble)
{
EXPECT_EQ(-5., x.min(4).getValue(-5., -3., 0));
EXPECT_EQ(0., y.min(0).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableInvert)
{
EXPECT_EQ(-5, x.invert().getValue(5, 43, 3));
EXPECT_EQ(4, y.invert().getValue(5, -4, 34));
}
//Reseedable curve(...?)
//Reseedable terrace(...?)
TEST_F(TestReseedable, TestReseedableSubReseedable)
{
EXPECT_EQ(-106., (x - y).getValue(-16., 90., 0));
EXPECT_EQ(0., (x - x).getValue(32., 0, 0));
EXPECT_EQ(2., (y - x).getValue(-5., -3., 0));
EXPECT_EQ(0., (y - y).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableSubDouble)
{
EXPECT_EQ(-21., (x - 5.).getValue(-16., 0, 0));
EXPECT_EQ(1., (y - (-4)).getValue(-5., -3., 0));
}
TEST_F(TestReseedable, TestReseedableSubUnary)
{
EXPECT_EQ(-5, (-x).getValue(5, 43, 3));
EXPECT_EQ(4, (-y).getValue(5, -4, 34));
}
TEST_F(TestReseedable, TestReseedableMulReseedable)
{
EXPECT_EQ(-1440, (x * y).getValue(-16., 90., 0));
EXPECT_EQ(1024., (x * x).getValue(32., 0, 0));
EXPECT_EQ(15., (y * x).getValue(-5., -3., 0));
EXPECT_EQ(1., (y * y).getValue(4., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableMulDouble)
{
EXPECT_EQ(-80., (x * 5.).getValue(-16., 0, 0));
EXPECT_EQ(12., (y * (-4)).getValue(-5., -3., 0));
}
TEST_F(TestReseedable, TestReseedableBlend)
{
EXPECT_EQ(0.75, c05.blend(x, y).getValue(0., 1., 5.));
EXPECT_EQ(-5, (c05).blend(y, x).getValue(-1, -17, 5.));
}
TEST_F(TestReseedable, TestReseedableSelect)
{
EXPECT_EQ(-17, c05.select(x, y).getValue(-1, -17, 5.));
EXPECT_EQ(0., c05.select(y, x).getValue(0., 1., 5.));
}
TEST_F(TestReseedable, TestReseedableDisplace)
{
auto displace = (x - (y * 2)).displace(x, y, c05);
EXPECT_EQ(0., displace.getValue(0, 0, 304958.));
EXPECT_EQ(0., displace.getValue(2, 1, 30458.));
EXPECT_EQ(-16., displace.getValue(-2, 3, 30458.));
}
TEST_F(TestReseedable, TestReseedableRotatePoint)
{
EXPECT_EQ(20., x.rotatePoint(0,0,90).getValue(2, 20, 200));
EXPECT_EQ(-30, y.rotatePoint(0,0,180).getValue(2, 30, 200));
}
TEST_F(TestReseedable, TestReseedableScalePoint)
{
EXPECT_EQ(6., x.scalePoint(3, 30, 300).getValue(2, 20, 200));
EXPECT_EQ(200., y.scalePoint(-1, -10, -100).getValue(2, -20, 200));
}
TEST_F(TestReseedable, TestReseedableTranslatePoint)
{
EXPECT_EQ(3., x.translatePoint(1, 10, 100).getValue(2, 20, 200));
EXPECT_EQ(-10., y.translatePoint(1, 10, 100).getValue(2, -20, 200));
}
TEST_F(TestReseedable, TestReseedableTurbulence)
{
auto turbulence = c05.turbulence(2., 2., 3, 0);
EXPECT_EQ(0.5, turbulence.getValue(346980., 0.63, 696.346));
}
TEST_F(TestReseedable, TestReseedableConst)
{
EXPECT_EQ(3.6345, makeConst(3.6345).getValue(52935874, 57432895, 2549));
EXPECT_EQ(-3045.25, makeConst(-3045.25).getValue(259, 594, 239587));
}<|endoftext|> |
<commit_before>// Declares clang::SyntaxOnlyAction.
#include "clang/Frontend/FrontendActions.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h"
// Declares llvm::cl::extrahelp.
#include "llvm/Support/CommandLine.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace llvm;
using namespace clang;
using namespace clang::ast_matchers;
using namespace clang::tooling;
// CommonOptionsParser declares HelpMessage with a description of the common
// command-line options related to the compilation database and input files.
// It's nice to have this help message in all tools.
static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
// A help message for this specific tool can be added afterwards.
static cl::extrahelp MoreHelp("\nMore help text...");
DeclarationMatcher FunctionMatcher =
functionDecl(isDefinition()).bind("functionDef");
class FunctionPrinter : public MatchFinder::MatchCallback {
public :
virtual void run(const MatchFinder::MatchResult &Result) {
if (const FunctionDecl *fun = Result.Nodes.getNodeAs<clang::FunctionDecl>("functionDef")){
FullSourceLoc startLocation = Result.Context->getFullLoc(fun->getLocStart());
FullSourceLoc endLocation = Result.Context->getFullLoc(fun->getLocEnd());
if (startLocation.isValid() && endLocation.isValid() ){
llvm::outs() << "Found declaration at ("
<< startLocation.getSpellingLineNumber() << ":"
<< startLocation.getSpellingColumnNumber() << ") - ("
<< endLocation.getSpellingLineNumber() << ":"
<< endLocation.getSpellingColumnNumber() << ")\n";
}
}
}
};
int main(int argc, const char **argv) {
CommonOptionsParser OptionsParser(argc, argv);
ClangTool Tool(OptionsParser.getCompilations(), OptionsParser.getSourcePathList());
FunctionPrinter Printer;
MatchFinder Finder;
Finder.addMatcher(FunctionMatcher, &Printer);
return Tool.run(newFrontendActionFactory(&Finder));
}
<commit_msg>Ignore system headers and include filename. NOTE: some structs are picked up even though the Matcher should only be matching function declarations.<commit_after>// Declares clang::SyntaxOnlyAction.
#include "clang/Frontend/FrontendActions.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h"
// Declares llvm::cl::extrahelp.
#include "llvm/Support/CommandLine.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace llvm;
using namespace clang;
using namespace clang::ast_matchers;
using namespace clang::tooling;
// CommonOptionsParser declares HelpMessage with a description of the common
// command-line options related to the compilation database and input files.
// It's nice to have this help message in all tools.
static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
// A help message for this specific tool can be added afterwards.
static cl::extrahelp MoreHelp("\nMore help text...");
DeclarationMatcher FunctionMatcher =
functionDecl(isDefinition()).bind("functionDef");
class FunctionPrinter : public MatchFinder::MatchCallback {
public :
virtual void run(const MatchFinder::MatchResult &Result) {
if (const FunctionDecl *fun = Result.Nodes.getNodeAs<clang::FunctionDecl>("functionDef")){
FullSourceLoc startLocation = Result.Context->getFullLoc(fun->getLocStart());
if ( startLocation.isInSystemHeader() )
return;
FullSourceLoc endLocation = Result.Context->getFullLoc(fun->getLocEnd());
if (startLocation.isValid() && endLocation.isValid() ){
llvm::outs() << "Found declaration for function "
<< Result.Context->getSourceManager().getFilename(startLocation) << ":"
<< fun->getNameInfo().getName().getAsString() << " at ("
<< startLocation.getSpellingLineNumber() << "-"
<< endLocation.getSpellingLineNumber() << ")\n";
}
}
}
};
int main(int argc, const char **argv) {
CommonOptionsParser OptionsParser(argc, argv);
ClangTool Tool(OptionsParser.getCompilations(), OptionsParser.getSourcePathList());
FunctionPrinter Printer;
MatchFinder Finder;
Finder.addMatcher(FunctionMatcher, &Printer);
return Tool.run(newFrontendActionFactory(&Finder));
}
<|endoftext|> |
<commit_before>//
// Created by Miguel Rentes on 23/01/2017.
//
#include "STL.h"
int main(void) {
int T; cin >> T;
cout << setiosflags(ios::uppercase);
cout << setw(0xf) << internal;
while(T--) {
double A;
cin >> A;
double B;
cin >> B;
double C;
cin >> C;
// pretty printing A
cout << setw(2) << "0x" << setw(13) << left << hex << (int) A << endl;
// pretty printing B
// width is 15 minus the number of digits of B
// because 1 character is for the '.', and 2 for the decimal places
// so the width is 15 - 1 - 2 = 12 minus the number of digits of B
unsigned int number_of_digits = 0;
double dx = B < 0.0 ? -0.5 : 0.5;
int number = static_cast<int>(B + dx);
if (number < 0)
number = -number;
do {
++number_of_digits;
number /= 10;
} while (number);
cout << fixed << setfill('_') << setw(12-number_of_digits);
if (B > 0)
cout << right << "+" << setprecision(2) << B << endl;
else cout << right << "-" << setprecision(2) << B << endl;
// pretty printing C
cout << scientific << setprecision(9) << C << endl;
}
return EXIT_SUCCESS;
}
<commit_msg>Starts solution for Print Pretty challenge.<commit_after>//
// Created by Miguel Rentes on 23/01/2017.
//
#include "STL.h"
int main(void) {
int T; cin >> T;
cout << setiosflags(ios::uppercase);
cout << setw(0xf) << internal;
while(T--) {
double A;
cin >> A;
double B;
cin >> B;
double C;
cin >> C;
// pretty printing A
cout << setw(2) << "0x" << setw(13) << left << hex << (int) A << endl;
// pretty printing B
// width is 15 minus the number of digits of B
// because 1 character is for the '.', and 2 for the decimal places
// so the width is 15 - 1 - 2 = 12 minus the number of digits of B
unsigned int number_of_digits = 0;
double dx = B < 0.0 ? -0.5 : 0.5;
int number = static_cast<int>(B + dx);
if (number < 0)
number = -number;
do {
++number_of_digits;
number /= 10;
} while (number);
cout << fixed << setfill('_') << setw(12-number_of_digits);
if (B > 0)
cout << right << "+" << setprecision(2) << B << endl;
else cout << right << "" << setprecision(2) << B << endl;
// pretty printing C
cout << scientific << setprecision(9) << C << endl;
}
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>//
// Created by Miguel Rentes on 23/01/2017.
//
#include "STL.h"
int main(void) {
int T; cin >> T;
cout << setiosflags(ios::uppercase);
cout << setw(0xf) << internal;
while(T--) {
double A;
cin >> A;
double B;
cin >> B;
double C;
cin >> C;
// pretty printing A
int truncA = (int) A;
cout << "0x" << hex << truncA << endl;
}
return EXIT_SUCCESS;
}
<commit_msg>Refactors solution for Print Pretty challenge.<commit_after>//
// Created by Miguel Rentes on 23/01/2017.
//
#include "STL.h"
int main(void) {
int T; cin >> T;
cout << setiosflags(ios::uppercase);
cout << setw(0xf) << internal;
while(T--) {
double A;
cin >> A;
double B;
cin >> B;
double C;
cin >> C;
// pretty printing A
cout << "0x" << hex << (int) A << endl;
}
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>#include "Thread.h"
#include <assert.h>
////////////////////////////////////////////////////////////////////////////////
//
// Base Implementation
//
////////////////////////////////////////////////////////////////////////////////
TCThreadBase::TCThreadBase(const TCThreadBaseImplFactory &factory)
: m_Impl(factory.CreateImpl())
{ }
TCThreadBase::TCThreadBase(const TCThreadBase &other)
: m_Impl(other.m_Impl)
{
assert(m_Impl->GetReferenceCount() > 0);
m_Impl->IncreaseReferenceCount();
}
TCThreadBase &TCThreadBase::operator=(const TCThreadBase &other) {
assert(m_Impl->GetReferenceCount() > 0);
m_Impl->DecreaseReferenceCount();
m_Impl = other.m_Impl;
m_Impl->IncreaseReferenceCount();
}
TCThreadBase::~TCThreadBase() {
if(m_Impl->GetReferenceCount() <= 1) {
assert(m_Impl->GetReferenceCount() >= 0);
delete m_Impl;
}
}
#ifndef NDEBUG
void TCThreadBase::CheckReferenceCount() {
assert(m_Impl->GetReferenceCount() > 0);
}
#endif
////////////////////////////////////////////////////////////////////////////////
//
// Barrier Implementation
//
////////////////////////////////////////////////////////////////////////////////
class TCBarrierImpl : public TCThreadBaseImpl {
private:
unsigned int m_ThreadLimit;
unsigned int m_ThreadCount;
unsigned int m_Times;
TCMutex m_Mutex;
TCConditionVariable m_CV;
public:
TCBarrierImpl(int threads)
: TCThreadBaseImpl()
, m_ThreadCount(threads)
, m_ThreadLimit(threads)
, m_Times(0)
{
assert(threads > 0);
}
virtual ~TCBarrierImpl() { }
bool Wait() {
TCLock lock(m_Mutex);
unsigned int times = m_Times;
if(--m_ThreadCount == 0) {
m_Times++;
m_ThreadCount = m_ThreadLimit;
m_CV.NotifyAll();
return true;
}
while(times == m_Times) {
m_CV.Wait(lock);
}
return false;
}
};
class TCBarrierImplFactory : public TCThreadBaseImplFactory {
private:
int m_NumThreads;
public:
TCBarrierImplFactory(int threads) : TCThreadBaseImplFactory(), m_NumThreads(threads) { }
virtual ~TCBarrierImplFactory() { }
virtual TCThreadBaseImpl *CreateImpl() const {
return new TCBarrierImpl(m_NumThreads);
}
};
TCBarrier::TCBarrier(int threads)
: TCThreadBase(TCBarrierImplFactory(threads))
{ }
void TCBarrier::Wait() {
((TCBarrierImpl *)m_Impl)->Wait();
}
<commit_msg>Fix some problems with our not so smart pointers.<commit_after>#include "Thread.h"
#include <assert.h>
////////////////////////////////////////////////////////////////////////////////
//
// Base Implementation
//
////////////////////////////////////////////////////////////////////////////////
TCThreadBase::TCThreadBase(const TCThreadBaseImplFactory &factory)
: m_Impl(factory.CreateImpl())
{ }
TCThreadBase::TCThreadBase(const TCThreadBase &other)
: m_Impl(other.m_Impl)
{
assert(m_Impl->GetReferenceCount() > 0);
m_Impl->IncreaseReferenceCount();
}
TCThreadBase &TCThreadBase::operator=(const TCThreadBase &other) {
assert(m_Impl->GetReferenceCount() > 0);
// We are no longer referencing this implementation...
m_Impl->DecreaseReferenceCount();
// If we're the last ones to reference it, then it should be destroyed.
if(m_Impl->GetReferenceCount() <= 0) {
delete m_Impl;
m_Impl = 0;
}
// Our implementation is now the same as the other.
m_Impl = other.m_Impl;
m_Impl->IncreaseReferenceCount();
}
TCThreadBase::~TCThreadBase() {
// We are no longer referencing this implementation...
m_Impl->DecreaseReferenceCount();
// If we're the last ones to reference it, then it should be destroyed.
if(m_Impl->GetReferenceCount() <= 0) {
assert(m_Impl->GetReferenceCount() == 0);
delete m_Impl;
}
}
#ifndef NDEBUG
void TCThreadBase::CheckReferenceCount() {
assert(m_Impl->GetReferenceCount() > 0);
}
#endif
////////////////////////////////////////////////////////////////////////////////
//
// Barrier Implementation
//
////////////////////////////////////////////////////////////////////////////////
class TCBarrierImpl : public TCThreadBaseImpl {
private:
unsigned int m_ThreadLimit;
unsigned int m_ThreadCount;
unsigned int m_Times;
TCMutex m_Mutex;
TCConditionVariable m_CV;
public:
TCBarrierImpl(int threads)
: TCThreadBaseImpl()
, m_ThreadCount(threads)
, m_ThreadLimit(threads)
, m_Times(0)
{
assert(threads > 0);
}
virtual ~TCBarrierImpl() { }
bool Wait() {
TCLock lock(m_Mutex);
unsigned int times = m_Times;
if(--m_ThreadCount == 0) {
m_Times++;
m_ThreadCount = m_ThreadLimit;
m_CV.NotifyAll();
return true;
}
while(times == m_Times) {
m_CV.Wait(lock);
}
return false;
}
};
class TCBarrierImplFactory : public TCThreadBaseImplFactory {
private:
int m_NumThreads;
public:
TCBarrierImplFactory(int threads) : TCThreadBaseImplFactory(), m_NumThreads(threads) { }
virtual ~TCBarrierImplFactory() { }
virtual TCThreadBaseImpl *CreateImpl() const {
return new TCBarrierImpl(m_NumThreads);
}
};
TCBarrier::TCBarrier(int threads)
: TCThreadBase(TCBarrierImplFactory(threads))
{ }
void TCBarrier::Wait() {
((TCBarrierImpl *)m_Impl)->Wait();
}
<|endoftext|> |
<commit_before>#ifndef BOOST_FUSION_ADAPTED_STRUCT_PRINTER_HPP
#define BOOST_FUSION_ADAPTED_STRUCT_PRINTER_HPP
#include <boost/variant.hpp>
#include <pre/boost/fusion/traits/is_boost_variant.hpp>
#include <boost/fusion/include/tag_of.hpp>
#include <boost/fusion/include/is_sequence.hpp>
#include <pre/boost/fusion/for_each_member.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/fusion/include/boost_tuple.hpp>
#include <pre/iostreams/indenting_ostream.hpp>
#include <pre/boost/fusion/detail/cstdint_to_hexa_stream_operators.hpp>
#include <pre/boost/fusion/detail/std_containers_ostream_operators.hpp>
namespace boost { namespace fusion {
namespace detail {
using pre::iostreams::indent;
using pre::iostreams::deindent;
template<class T>
using enable_if_is_not_sequence_nor_variant_t = typename std::enable_if<
! ( (boost::fusion::traits::is_sequence<T>::value )
|| traits::is_boost_variant<T>::value)
,T>::type;
template<class T>
using enable_if_is_other_sequence_and_not_variant_t = typename std::enable_if<
boost::fusion::traits::is_sequence<T>::value
&& !std::is_same<
typename boost::fusion::traits::tag_of<T>::type,
boost::fusion::struct_tag
>::value
&& !traits::is_boost_variant<T>::value
,T>::type;
template<class T>
using enable_if_is_adapted_struct_t = typename std::enable_if<
std::is_same<
typename boost::fusion::traits::tag_of<T>::type,
boost::fusion::struct_tag
>::value
,T>::type;
template<class T>
using enable_if_is_variant_t = typename std::enable_if<
traits::is_boost_variant<T>::value
,T>::type;
struct adapted_struct_printer : public boost::static_visitor<> {
adapted_struct_printer(std::ostream& os)
: boost::static_visitor<>(), m_os(os) {}
template<class T,
enable_if_is_adapted_struct_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " :";
m_os << indent;
this->operator()(value);
m_os << deindent;
}
template<class T,
enable_if_is_adapted_struct_t<T>* = nullptr>
void operator()(const T& value) const {
m_os << "\n{" << indent << "\n";
boost::fusion::for_each_member(value, *this);
m_os << deindent << "}\n";
}
template<class T,
enable_if_is_other_sequence_and_not_variant_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " :";
m_os << indent;
this->operator()(value);
m_os << deindent;
}
template<class T,
enable_if_is_other_sequence_and_not_variant_t<T>* = nullptr>
void operator()(const T& value) const {
m_os << "\n{" << indent << "\n";
boost::fusion::operator<<(m_os, value);
m_os << "\n" << deindent << "}\n";
}
template<class T,
enable_if_is_variant_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " : \n";
m_os << indent;
this->operator()(value);
m_os << deindent;
}
template<class T,
enable_if_is_variant_t<T>* = nullptr>
void operator()(const T& value) const {
m_os << "\n{" << indent << "\n";
boost::apply_visitor(*this, value);
m_os << deindent << "}\n";
}
template<class T,
enable_if_is_not_sequence_nor_variant_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " : ";
this->operator()(value);
m_os << ",\n";
}
template<class T,
enable_if_is_not_sequence_nor_variant_t<T>* = nullptr>
void operator()(const T& value) const {
using boost::fusion::operator<<;
m_os << value;
}
private:
std::ostream& m_os;
};
}
namespace adapted_struct_printer {
template<class T,
detail::enable_if_is_adapted_struct_t<T>* = nullptr>
inline std::ostream& operator<<(std::ostream& os, const T& value) {
pre::iostreams::indenting_stream indentos(os);
detail::adapted_struct_printer printer(indentos);
printer(value);
return os;
}
}
}}
#endif
<commit_msg>BUGFIX: Avoid that volatile keyword get propagated to the printer, which might generate build error.<commit_after>#ifndef BOOST_FUSION_ADAPTED_STRUCT_PRINTER_HPP
#define BOOST_FUSION_ADAPTED_STRUCT_PRINTER_HPP
#include <boost/variant.hpp>
#include <pre/boost/fusion/traits/is_boost_variant.hpp>
#include <boost/fusion/include/tag_of.hpp>
#include <boost/fusion/include/is_sequence.hpp>
#include <pre/boost/fusion/for_each_member.hpp>
#include <boost/fusion/include/io.hpp>
#include <boost/fusion/include/boost_tuple.hpp>
#include <pre/iostreams/indenting_ostream.hpp>
#include <pre/boost/fusion/detail/cstdint_to_hexa_stream_operators.hpp>
#include <pre/boost/fusion/detail/std_containers_ostream_operators.hpp>
namespace boost { namespace fusion {
namespace detail {
using pre::iostreams::indent;
using pre::iostreams::deindent;
template<class T>
using enable_if_is_not_sequence_nor_variant_t = typename std::enable_if<
! ( (boost::fusion::traits::is_sequence<T>::value )
|| traits::is_boost_variant<T>::value)
,T>::type;
template<class T>
using enable_if_is_other_sequence_and_not_variant_t = typename std::enable_if<
boost::fusion::traits::is_sequence<T>::value
&& !std::is_same<
typename boost::fusion::traits::tag_of<T>::type,
boost::fusion::struct_tag
>::value
&& !traits::is_boost_variant<T>::value
,T>::type;
template<class T>
using enable_if_is_adapted_struct_t = typename std::enable_if<
std::is_same<
typename boost::fusion::traits::tag_of<T>::type,
boost::fusion::struct_tag
>::value
,T>::type;
template<class T>
using enable_if_is_variant_t = typename std::enable_if<
traits::is_boost_variant<T>::value
,T>::type;
struct adapted_struct_printer : public boost::static_visitor<> {
adapted_struct_printer(std::ostream& os)
: boost::static_visitor<>(), m_os(os) {}
template<class T,
enable_if_is_adapted_struct_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " :";
m_os << indent;
this->operator()(value);
m_os << deindent;
}
template<class T,
enable_if_is_adapted_struct_t<T>* = nullptr>
void operator()(const T& value) const {
m_os << "\n{" << indent << "\n";
boost::fusion::for_each_member(value, *this);
m_os << deindent << "}\n";
}
template<class T,
enable_if_is_other_sequence_and_not_variant_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " :";
m_os << indent;
this->operator()(value);
m_os << deindent;
}
template<class T,
enable_if_is_other_sequence_and_not_variant_t<T>* = nullptr>
void operator()(const T& value) const {
m_os << "\n{" << indent << "\n";
boost::fusion::operator<<(m_os, value);
m_os << "\n" << deindent << "}\n";
}
template<class T,
enable_if_is_variant_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " : \n";
m_os << indent;
this->operator()(value);
m_os << deindent;
}
template<class T,
enable_if_is_variant_t<T>* = nullptr>
void operator()(const T& value) const {
m_os << "\n{" << indent << "\n";
boost::apply_visitor(*this, value);
m_os << deindent << "}\n";
}
template<class T,
enable_if_is_not_sequence_nor_variant_t<T>* = nullptr>
void operator()(const char* name, const T& value) const {
m_os << name << " : ";
this->operator()(value);
m_os << ",\n";
}
template<class T,
enable_if_is_not_sequence_nor_variant_t<T>* = nullptr>
void operator()(const T& value) const {
using boost::fusion::operator<<;
m_os << value;
}
private:
std::ostream& m_os;
};
}
namespace adapted_struct_printer {
template<class T,
detail::enable_if_is_adapted_struct_t<typename std::remove_volatile<T>::type >* = nullptr>
inline std::ostream& operator<<(std::ostream& os, const T& value) {
pre::iostreams::indenting_stream indentos(os);
detail::adapted_struct_printer printer(indentos);
printer(value);
return os;
}
}
}}
#endif
<|endoftext|> |
<commit_before>using namespace std;
class Matrix {
private:
int row, col, **mas;
public:
Matrix(int length = 4);
Matrix(int, int);
Matrix(const Matrix&);
~Matrix();
void fill(const char*);
void show() const;
Matrix operator+(const Matrix&) const;
Matrix operator*(const Matrix&) const;
};
<commit_msg>Update matrix.hpp<commit_after>using namespace std;
class Matrix {
private:
int row, col, **mas;
public:
Matrix(int length = 4);
Matrix(int, int);
Matrix(const Matrix&);
~Matrix();
void fill(const char*);
void show() const;
void rows();
void columns();
Matrix operator+(const Matrix&) const;
Matrix operator*(const Matrix&) const;
};
<|endoftext|> |
<commit_before>/*! \file serial.hpp
*/
#ifndef __SERIAL_HPP__
#define __SERIAL_HPP__
#include "ring_buffer.hpp"
#include "serial_base.hpp"
/*! \class
*/
class Serial : public SerialBase {
protected:
/*!
*/
inline void initUSART(const int baudrate) const __attribute__((always_inline)) {
uint16_t ubbr_value = (F_CPU/(baudrate*16UL))-1;
UBRRL = ubbr_value;
UBRRH = ubbr_value>>8;
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
}
/*!
*/
inline void startUSART() const __attribute__((always_inline)) {
UCSRB|=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<<TXCIE);
}
/*!
*/
inline void stopTransmission() __attribute__((always_inline)) {
UCSRB&=~(1<<UDRIE);
}
/*!
*/
void stopUSART() {
stopTransmission();
UBRRH=0x00;
UBRRL=0x00;
UCSRB=0x00;
UCSRC=0x00;
}
public:
/*!
*/
Serial(int baudrate,uint8_t rec_size,uint8_t trans_size):SerialBase(rec_size,trans_size) {
initUSART(baudrate);
startUSART();
}
/*!
*/
inline void startTransmission() const __attribute__((always_inline)) {
UCSRB|=(1<<UDRIE);
}
/*!
*/
void doUDRISR() {
if(_transmitter.getReadBuffLength()>0) {
uint8_t data=0;
_transmitter.readByte(data);
UDR = data;
} else {
stopTransmission();
}
}
/*!
*/
void doRXISR(const uint8_t& data) {
if(_reciever.getWriteBuffLength()>0) {
_reciever.writeByte(data);
}
}
/*!
*/
void doTXISR() {
}
};
/*!
*/
Serial* SERIAL_NAME;//(BAUD_RATE,RX_BUFF,TX_BUFF);
/*!
*/
Serial* getSerialPort(uint16_t baud_rate,uint16_t rx_buff,uint16_t tx_buff) {
if(SERIAL_NAME==NULL)
SERIAL_NAME = new Serial(baud_rate,rx_buff,tx_buff);
return SERIAL_NAME;
}
/*!
*/
void destroySerialPort() {
if(SERIAL_NAME!=NULL)
delete SERIAL_NAME;
SERIAL_NAME = NULL;
}
/*!
*/
ISR(USART_UDRE_vect) {
SERIAL_NAME->doUDRISR();
}
/*!
*/
ISR(USART_RXC_vect) {
const uint8_t data = UDR;
SERIAL_NAME->doRXISR(data);
}
/*!
*/
ISR(USART_TXC_vect) {
SERIAL_NAME->doTXISR();
}
#endif//__SERIAL_HPP__
<commit_msg>-- Finished serial classes<commit_after>/*! \file serial.hpp
*/
#ifndef __SERIAL_HPP__
#define __SERIAL_HPP__
#include <serial_base.hpp>
/*! \class
*/
class Serial : public SerialBase {
protected:
/*!
*/
inline void initUSART(const int baudrate) const __attribute__((always_inline)) {
uint16_t ubbr_value = (F_CPU/(baudrate*16UL))-1;
UBRRL = ubbr_value;
UBRRH = ubbr_value>>8;
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);
}
/*!
*/
inline void startUSART() const __attribute__((always_inline)) {
UCSRB|=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<<TXCIE);
}
/*!
*/
inline void stopTransmission() __attribute__((always_inline)) {
UCSRB&=~(1<<UDRIE);
}
/*!
*/
void stopUSART() {
stopTransmission();
UBRRH=0x00;
UBRRL=0x00;
UCSRB=0x00;
UCSRC=0x00;
}
public:
/*!
*/
Serial(int baudrate,uint8_t rec_size,uint8_t trans_size):SerialBase(rec_size,trans_size) {
initUSART(baudrate);
startUSART();
}
/*!
*/
inline void startTransmission() const __attribute__((always_inline)) {
UCSRB|=(1<<UDRIE);
}
/*!
*/
void doUDRISR() {
if(_transmitter.getReadBuffLength()>0) {
uint8_t data=0;
_transmitter.readByte(data);
UDR = data;
} else {
stopTransmission();
}
}
/*!
*/
void doRXISR(const uint8_t& data) {
if(_reciever.getWriteBuffLength()>0) {
_reciever.writeByte(data);
}
}
/*!
*/
void doTXISR() {
}
};
/*!
*/
Serial* SERIAL_NAME;//(BAUD_RATE,RX_BUFF,TX_BUFF);
/*!
*/
Serial* getSerialPort(uint16_t baud_rate,uint16_t rx_buff,uint16_t tx_buff) {
if(SERIAL_NAME==NULL)
SERIAL_NAME = new Serial(baud_rate,rx_buff,tx_buff);
return SERIAL_NAME;
}
/*!
*/
void destroySerialPort() {
if(SERIAL_NAME!=NULL)
delete SERIAL_NAME;
SERIAL_NAME = NULL;
}
/*!
*/
ISR(USART_UDRE_vect) {
SERIAL_NAME->doUDRISR();
}
/*!
*/
ISR(USART_RXC_vect) {
const uint8_t data = UDR;
SERIAL_NAME->doRXISR(data);
}
/*!
*/
ISR(USART_TXC_vect) {
SERIAL_NAME->doTXISR();
}
#endif//__SERIAL_HPP__
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: WW8ResourceModelImpl.hxx,v $
*
* $Revision: 1.2 $
*
* last change: $Author: hbrinkm $ $Date: 2006-11-01 09:14:32 $
*
* 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 INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX
#define INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX
#ifndef INCLUDED_WW8_DOCUMENT_HXX
#include <doctok/WW8Document.hxx>
#endif
#ifndef INCLUDED_WW8_RESOURCE_MODEL_HXX
#include <doctok/WW8ResourceModel.hxx>
#endif
#ifndef INCLUDED_WW8_STRUCT_BASE_HXX
#include <WW8StructBase.hxx>
#endif
#ifndef INCLUDED_OUTPUT_WITH_DEPTH_HXX
#include <doctok/OutputWithDepth.hxx>
#endif
#include <odiapi/qname/QName.hxx>
#include <map>
namespace doctok
{
using namespace ::std;
class WW8PropertiesReference : public doctok::Reference<Properties>
{
WW8PropertySet::Pointer_t mpPropSet;
public:
WW8PropertiesReference(WW8PropertySet::Pointer_t pPropSet)
: mpPropSet(pPropSet)
{
}
~WW8PropertiesReference()
{
}
virtual void resolve(Properties & rHandler);
virtual string getType() const;
};
class WW8TableReference : public doctok::Reference<Table>
{
public:
WW8TableReference()
{
}
~WW8TableReference()
{
}
virtual void resolve(Table & rHandler);
virtual string getType() const;
};
class WW8BinaryObjReference : public doctok::Reference<BinaryObj>,
public WW8StructBase
{
public:
typedef boost::shared_ptr<WW8BinaryObjReference> Pointer_t;
WW8BinaryObjReference(WW8StructBase & rParent, sal_uInt32 nOffset,
sal_uInt32 nCount);
WW8BinaryObjReference(WW8StructBase * rParent, sal_uInt32 nOffset,
sal_uInt32 nCount);
WW8BinaryObjReference()
: WW8StructBase(WW8StructBase::Sequence())
{
}
~WW8BinaryObjReference()
{
}
virtual doctok::Reference<BinaryObj>::Pointer_t getBinary();
virtual void resolve(BinaryObj & rHandler);
virtual string getType() const;
virtual WW8BinaryObjReference * clone() { return new WW8BinaryObjReference(*this); }
};
class WW8Sprm : public Sprm
{
WW8Property::Pointer_t mpProperty;
WW8BinaryObjReference::Pointer_t mpBinary;
public:
WW8Sprm(WW8Property::Pointer_t pProperty)
: mpProperty(pProperty)
{
}
WW8Sprm(WW8BinaryObjReference::Pointer_t pBinary)
: mpBinary(pBinary)
{
}
WW8Sprm()
{
}
WW8Sprm(const WW8Sprm & rSprm)
: Sprm(rSprm), mpProperty(rSprm.mpProperty), mpBinary(rSprm.mpBinary)
{
}
virtual ~WW8Sprm()
{
}
virtual Value::Pointer_t getValue();
virtual doctok::Reference<BinaryObj>::Pointer_t getBinary();
virtual doctok::Reference<Stream>::Pointer_t getStream();
virtual doctok::Reference<Properties>::Pointer_t getProps();
virtual sal_uInt32 getId() const;
virtual string toString() const;
virtual string getName() const;
virtual WW8Sprm * clone() const { return new WW8Sprm(*this); }
};
class WW8Value : public Value
{
public:
WW8Value() {}
virtual ~WW8Value() {}
virtual string toString() const;
virtual int getInt() const;
virtual ::rtl::OUString getString() const;
virtual uno::Any getAny() const;
virtual doctok::Reference<Properties>::Pointer_t getProperties();
virtual WW8Value * clone() const = 0;
};
class WW8IntValue : public WW8Value
{
int mValue;
public:
WW8IntValue(int value) : mValue(value) {}
virtual ~WW8IntValue() {}
virtual int getInt() const;
virtual ::rtl::OUString getString() const;
virtual uno::Any getAny() const;
virtual string toString() const;
virtual WW8Value * clone() const { return new WW8IntValue(*this); }
};
/**
Creates value from an integer.
@param value integer to create value from.
*/
WW8Value::Pointer_t createValue(int value);
ostream & operator << (ostream & o, const WW8Value & rValue);
class WW8StringValue : public WW8Value
{
::rtl::OUString mString;
public:
WW8StringValue(::rtl::OUString string_) : mString(string_) {}
virtual ~WW8StringValue() {}
virtual int getInt() const;
virtual ::rtl::OUString getString() const;
virtual uno::Any getAny() const;
virtual string toString() const;
virtual WW8Value * clone() const { return new WW8StringValue(*this); }
};
/**
Creates value from a string.
@param rStr string to create value from.
*/
WW8Value::Pointer_t createValue(const rtl::OUString & rStr);
class WW8PropertiesValue : public WW8Value
{
mutable doctok::Reference<Properties>::Pointer_t mRef;
public:
WW8PropertiesValue(doctok::Reference<Properties>::Pointer_t rRef)
: mRef(rRef)
{
}
virtual ~WW8PropertiesValue()
{
}
virtual doctok::Reference<Properties>::Pointer_t getProperties();
virtual string toString() const;
virtual WW8Value * clone() const { return new WW8PropertiesValue(mRef); }
};
/**
Creates value from a properties reference.
@param rRef reference to create value from.
*/
WW8Value::Pointer_t createValue(doctok::Reference<Properties>::Pointer_t rRef);
WW8Value::Pointer_t createValue(WW8Value::Pointer_t value);
class WW8StreamHandler : public Stream
{
public:
WW8StreamHandler();
virtual ~WW8StreamHandler();
virtual void startSectionGroup();
virtual void endSectionGroup();
virtual void startParagraphGroup();
virtual void endParagraphGroup();
virtual void startCharacterGroup();
virtual void endCharacterGroup();
virtual void text(const sal_uInt8 * data, size_t len);
virtual void utext(const sal_uInt8 * data, size_t len);
virtual void props(doctok::Reference<Properties>::Pointer_t ref);
virtual void table(Id name,
doctok::Reference<Table>::Pointer_t ref);
virtual void substream(Id name, doctok::Reference<Stream>::Pointer_t ref);
virtual void info(const string & info);
};
class WW8PropertiesHandler : public Properties
{
public:
WW8PropertiesHandler()
{
}
virtual ~WW8PropertiesHandler()
{
}
virtual void attribute(Id name, Value & val);
virtual void sprm(Sprm & sprm);
};
class WW8BinaryObjHandler : public BinaryObj
{
public:
WW8BinaryObjHandler()
{
}
virtual ~WW8BinaryObjHandler()
{
}
virtual void data(const sal_uInt8* buf, size_t len,
doctok::Reference<Properties>::Pointer_t ref);
};
class WW8TableHandler : public Table
{
public:
WW8TableHandler()
{
}
virtual ~WW8TableHandler()
{
}
void entry(int pos, doctok::Reference<Properties>::Pointer_t ref);
};
class QNameToString
{
typedef boost::shared_ptr<QNameToString> Pointer_t;
static Pointer_t pInstance;
map < writerfilter::QName_t, string > mMap;
protected:
/**
Generated.
*/
QNameToString();
public:
static Pointer_t Instance();
string operator()(writerfilter::QName_t qName);
};
void dump(OutputWithDepth<string> & o, const char * name, doctok::Reference<Properties>::Pointer_t props);
void dump(OutputWithDepth<string> & o, const char * name, sal_uInt32 n);
}
#endif // INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX
<commit_msg>new: blip<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: WW8ResourceModelImpl.hxx,v $
*
* $Revision: 1.3 $
*
* last change: $Author: hbrinkm $ $Date: 2006-11-09 15:59:09 $
*
* 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 INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX
#define INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX
#ifndef INCLUDED_WW8_DOCUMENT_HXX
#include <doctok/WW8Document.hxx>
#endif
#ifndef INCLUDED_WW8_RESOURCE_MODEL_HXX
#include <doctok/WW8ResourceModel.hxx>
#endif
#ifndef INCLUDED_WW8_STRUCT_BASE_HXX
#include <WW8StructBase.hxx>
#endif
#ifndef INCLUDED_OUTPUT_WITH_DEPTH_HXX
#include <doctok/OutputWithDepth.hxx>
#endif
#include <odiapi/qname/QName.hxx>
#include <map>
namespace doctok
{
using namespace ::std;
class WW8PropertiesReference : public doctok::Reference<Properties>
{
WW8PropertySet::Pointer_t mpPropSet;
public:
WW8PropertiesReference(WW8PropertySet::Pointer_t pPropSet)
: mpPropSet(pPropSet)
{
}
~WW8PropertiesReference()
{
}
virtual void resolve(Properties & rHandler);
virtual string getType() const;
};
class WW8TableReference : public doctok::Reference<Table>
{
public:
WW8TableReference()
{
}
~WW8TableReference()
{
}
virtual void resolve(Table & rHandler);
virtual string getType() const;
};
class WW8BinaryObjReference : public doctok::Reference<BinaryObj>,
public WW8StructBase
{
public:
typedef boost::shared_ptr<WW8BinaryObjReference> Pointer_t;
WW8BinaryObjReference(WW8Stream & rStream, sal_uInt32 nOffset,
sal_uInt32 nCount);
WW8BinaryObjReference(WW8StructBase & rParent, sal_uInt32 nOffset,
sal_uInt32 nCount);
WW8BinaryObjReference(WW8StructBase * rParent, sal_uInt32 nOffset,
sal_uInt32 nCount);
WW8BinaryObjReference()
: WW8StructBase(WW8StructBase::Sequence())
{
}
~WW8BinaryObjReference()
{
}
virtual doctok::Reference<BinaryObj>::Pointer_t getBinary();
virtual void resolve(BinaryObj & rHandler);
virtual string getType() const;
virtual WW8BinaryObjReference * clone() { return new WW8BinaryObjReference(*this); }
};
class WW8Sprm : public Sprm
{
WW8Property::Pointer_t mpProperty;
WW8BinaryObjReference::Pointer_t mpBinary;
public:
WW8Sprm(WW8Property::Pointer_t pProperty)
: mpProperty(pProperty)
{
}
WW8Sprm(WW8BinaryObjReference::Pointer_t pBinary)
: mpBinary(pBinary)
{
}
WW8Sprm()
{
}
WW8Sprm(const WW8Sprm & rSprm)
: Sprm(rSprm), mpProperty(rSprm.mpProperty), mpBinary(rSprm.mpBinary)
{
}
virtual ~WW8Sprm()
{
}
virtual Value::Pointer_t getValue();
virtual doctok::Reference<BinaryObj>::Pointer_t getBinary();
virtual doctok::Reference<Stream>::Pointer_t getStream();
virtual doctok::Reference<Properties>::Pointer_t getProps();
virtual sal_uInt32 getId() const;
virtual string toString() const;
virtual string getName() const;
virtual WW8Sprm * clone() const { return new WW8Sprm(*this); }
};
class WW8Value : public Value
{
public:
WW8Value() {}
virtual ~WW8Value() {}
virtual string toString() const;
virtual int getInt() const;
virtual ::rtl::OUString getString() const;
virtual uno::Any getAny() const;
virtual doctok::Reference<Properties>::Pointer_t getProperties();
virtual WW8Value * clone() const = 0;
};
class WW8IntValue : public WW8Value
{
int mValue;
public:
WW8IntValue(int value) : mValue(value) {}
virtual ~WW8IntValue() {}
virtual int getInt() const;
virtual ::rtl::OUString getString() const;
virtual uno::Any getAny() const;
virtual string toString() const;
virtual WW8Value * clone() const { return new WW8IntValue(*this); }
};
/**
Creates value from an integer.
@param value integer to create value from.
*/
WW8Value::Pointer_t createValue(int value);
ostream & operator << (ostream & o, const WW8Value & rValue);
class WW8StringValue : public WW8Value
{
::rtl::OUString mString;
public:
WW8StringValue(::rtl::OUString string_) : mString(string_) {}
virtual ~WW8StringValue() {}
virtual int getInt() const;
virtual ::rtl::OUString getString() const;
virtual uno::Any getAny() const;
virtual string toString() const;
virtual WW8Value * clone() const { return new WW8StringValue(*this); }
};
/**
Creates value from a string.
@param rStr string to create value from.
*/
WW8Value::Pointer_t createValue(const rtl::OUString & rStr);
class WW8PropertiesValue : public WW8Value
{
mutable doctok::Reference<Properties>::Pointer_t mRef;
public:
WW8PropertiesValue(doctok::Reference<Properties>::Pointer_t rRef)
: mRef(rRef)
{
}
virtual ~WW8PropertiesValue()
{
}
virtual doctok::Reference<Properties>::Pointer_t getProperties();
virtual string toString() const;
virtual WW8Value * clone() const { return new WW8PropertiesValue(mRef); }
};
/**
Creates value from a properties reference.
@param rRef reference to create value from.
*/
WW8Value::Pointer_t createValue(doctok::Reference<Properties>::Pointer_t rRef);
WW8Value::Pointer_t createValue(WW8Value::Pointer_t value);
class WW8StreamHandler : public Stream
{
public:
WW8StreamHandler();
virtual ~WW8StreamHandler();
virtual void startSectionGroup();
virtual void endSectionGroup();
virtual void startParagraphGroup();
virtual void endParagraphGroup();
virtual void startCharacterGroup();
virtual void endCharacterGroup();
virtual void text(const sal_uInt8 * data, size_t len);
virtual void utext(const sal_uInt8 * data, size_t len);
virtual void props(doctok::Reference<Properties>::Pointer_t ref);
virtual void table(Id name,
doctok::Reference<Table>::Pointer_t ref);
virtual void substream(Id name, doctok::Reference<Stream>::Pointer_t ref);
virtual void info(const string & info);
};
class WW8PropertiesHandler : public Properties
{
public:
WW8PropertiesHandler()
{
}
virtual ~WW8PropertiesHandler()
{
}
virtual void attribute(Id name, Value & val);
virtual void sprm(Sprm & sprm);
};
class WW8BinaryObjHandler : public BinaryObj
{
public:
WW8BinaryObjHandler()
{
}
virtual ~WW8BinaryObjHandler()
{
}
virtual void data(const sal_uInt8* buf, size_t len,
doctok::Reference<Properties>::Pointer_t ref);
};
class WW8TableHandler : public Table
{
public:
WW8TableHandler()
{
}
virtual ~WW8TableHandler()
{
}
void entry(int pos, doctok::Reference<Properties>::Pointer_t ref);
};
class QNameToString
{
typedef boost::shared_ptr<QNameToString> Pointer_t;
static Pointer_t pInstance;
map < writerfilter::QName_t, string > mMap;
protected:
/**
Generated.
*/
QNameToString();
public:
static Pointer_t Instance();
string operator()(writerfilter::QName_t qName);
};
void dump(OutputWithDepth<string> & o, const char * name, doctok::Reference<Properties>::Pointer_t props);
void dump(OutputWithDepth<string> & o, const char * name, sal_uInt32 n);
}
#endif // INCLUDED_WW8_RESOURCE_MODEL_IMPL_HXX
<|endoftext|> |
<commit_before>/*************************************************************************
*
* 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: resourcemodel.cxx,v $
* $Revision: 1.4 $
*
* 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.
*
************************************************************************/
#include <resourcemodel/WW8ResourceModel.hxx>
#include <resourcemodel/TableManager.hxx>
#include <resourcemodel/QNameToString.hxx>
#include <resourcemodel/exceptions.hxx>
#include <resourcemodel/SubSequence.hxx>
#include <resourcemodel.hxx>
namespace writerfilter {
class ResourceModelOutputWithDepth : public OutputWithDepth<string>
{
public:
ResourceModelOutputWithDepth()
: OutputWithDepth<string>("<tablegroup>", "</tablegroup>") {}
~ResourceModelOutputWithDepth() {outputGroup();}
void output(const string & str) const { cout << str << endl; }
};
ResourceModelOutputWithDepth output;
Stream::Pointer_t createStreamHandler()
{
return Stream::Pointer_t(new WW8StreamHandler());
}
void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
writerfilter::Reference<Properties>::Pointer_t /*props*/)
{
}
void dump(OutputWithDepth<string> & o, const char * name, sal_uInt32 n)
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIuUINT32, n);
string tmpStr = name;
tmpStr += "=";
tmpStr += sBuffer;
o.addItem(tmpStr);
}
void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
const rtl::OUString & /*str*/)
{
}
void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
writerfilter::Reference<BinaryObj>::Pointer_t /*binary*/)
{
}
string gInfo = "";
// ------- WW8TableDataHandler ---------
class TablePropsRef : public writerfilter::Reference<Properties>
{
public:
typedef boost::shared_ptr<TablePropsRef> Pointer_t;
TablePropsRef() {}
virtual ~TablePropsRef() {}
virtual void resolve(Properties & /*rHandler*/) {}
virtual string getType() const { return "TableProps"; }
void reset() {}
void insert(Pointer_t /* pTablePropsRef */) {}
};
typedef TablePropsRef::Pointer_t TablePropsRef_t;
class WW8TableDataHandler : public TableDataHandler<string,
TablePropsRef_t>
{
public:
typedef boost::shared_ptr<WW8TableDataHandler> Pointer_t;
virtual void startTable(unsigned int nRows, unsigned int nDepth,
TablePropsRef_t pProps);
virtual void endTable();
virtual void startRow(unsigned int nCols,
TablePropsRef_t pProps);
virtual void endRow();
virtual void startCell(const string & start, TablePropsRef_t pProps);
virtual void endCell(const string & end);
};
void WW8TableDataHandler::startTable(unsigned int nRows, unsigned int nDepth,
TablePropsRef_t /*pProps*/)
{
char sBuffer[256];
string tmpStr = "<tabledata.table rows=\"";
snprintf(sBuffer, sizeof(sBuffer), "%d", nRows);
tmpStr += sBuffer;
tmpStr += "\" depth=\"";
snprintf(sBuffer, sizeof(sBuffer), "%d", nDepth);
tmpStr += sBuffer;
tmpStr += "\">";
output.addItem(tmpStr);
}
void WW8TableDataHandler::endTable()
{
output.addItem("</tabledata.table>");
}
void WW8TableDataHandler::startRow
(unsigned int nCols, TablePropsRef_t /*pProps*/)
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "%d", nCols);
string tmpStr = "<tabledata.row cells=\"";
tmpStr += sBuffer;
tmpStr += "\">";
output.addItem(tmpStr);
}
void WW8TableDataHandler::endRow()
{
output.addItem("</tabledata.row>");
}
void WW8TableDataHandler::startCell(const string & start,
TablePropsRef_t /*pProps*/)
{
output.addItem("<tabledata.cell>");
output.addItem(start);
output.addItem(", ");
}
void WW8TableDataHandler::endCell(const string & end)
{
output.addItem(end);
output.addItem("</tabledata.cell>");
}
// ----- WW8TableDataManager -------------------------------
class WW8TableManager :
public TableManager<string, TablePropsRef_t>
{
typedef TableDataHandler<string, TablePropsRef_t>
TableDataHandlerPointer_t;
public:
WW8TableManager();
virtual ~WW8TableManager() {}
virtual void endParagraphGroup();
virtual bool sprm(Sprm & rSprm);
};
WW8TableManager::WW8TableManager()
{
TableDataHandler<string, TablePropsRef_t>::Pointer_t pHandler(new WW8TableDataHandler());
setHandler(pHandler);
}
bool WW8TableManager::sprm(Sprm & rSprm)
{
TableManager<string, TablePropsRef_t>::sprm(rSprm);
output.setDepth(getTableDepthNew());
return true;
}
void WW8TableManager::endParagraphGroup()
{
string tmpStr = "<tabledepth depth=\"";
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIuUINT32, getTableDepthNew());
tmpStr += sBuffer;
tmpStr += "\"/>";
output.addItem(tmpStr);
TableManager<string, TablePropsRef_t>::endParagraphGroup();
}
WW8TableManager gTableManager;
/* WW8StreamHandler */
WW8StreamHandler::WW8StreamHandler()
{
output.closeGroup();
output.addItem("<stream>");
gTableManager.startLevel();
}
WW8StreamHandler::~WW8StreamHandler()
{
gTableManager.endLevel();
output.closeGroup();
output.addItem("</stream>");
}
void WW8StreamHandler::startSectionGroup()
{
output.addItem("<section-group>");
}
void WW8StreamHandler::endSectionGroup()
{
output.addItem("</section-group>");
}
void WW8StreamHandler::startParagraphGroup()
{
output.openGroup();
output.addItem("<paragraph-group>");
gTableManager.startParagraphGroup();
gTableManager.handle(gInfo);
}
void WW8StreamHandler::endParagraphGroup()
{
gTableManager.endParagraphGroup();
output.addItem("</paragraph-group>");
output.closeGroup();
}
void WW8StreamHandler::startCharacterGroup()
{
output.addItem("<character-group>");
}
void WW8StreamHandler::endCharacterGroup()
{
output.addItem("</character-group>");
}
void WW8StreamHandler::text(const sal_uInt8 * data, size_t len)
{
string tmpStr = "<text>";
for (unsigned int n = 0; n < len; ++n)
{
switch (static_cast<unsigned char>(data[n]))
{
case '<':
tmpStr += "<";
break;
case '>':
tmpStr += ">";
break;
case '&':
tmpStr += "&";
break;
default:
if (isprint(data[n]))
tmpStr += static_cast<char>(data[n]);
else
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "\\0x%02x", data[n]);
tmpStr += sBuffer;
}
}
}
tmpStr += "</text>";
output.addItem(tmpStr);
gTableManager.text(data, len);
}
void WW8StreamHandler::utext(const sal_uInt8 * data, size_t len)
{
string tmpStr = "<utext>";
for (unsigned int n = 0; n < len; ++n)
{
sal_Unicode nChar = data[n * 2] + (data[n * 2 + 1] << 8);
if (nChar < 0xff && isprint(nChar))
{
switch (nChar)
{
case '&':
tmpStr += "&";
break;
case '<':
tmpStr += "<";
break;
case '>':
tmpStr += ">";
break;
default:
tmpStr += static_cast<char>(nChar);
}
}
else
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "\\0x%04x", nChar);
tmpStr += sBuffer;
}
}
tmpStr += "</utext>";
output.addItem(tmpStr);
gTableManager.utext(data, len);
}
void WW8StreamHandler::props(writerfilter::Reference<Properties>::Pointer_t ref)
{
WW8PropertiesHandler aHandler;
output.addItem("<properties type=\"" + ref->getType() + "\">");
ref->resolve(aHandler);
//gTableManager.props(ref);
output.addItem("</properties>");
}
void WW8StreamHandler::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
{
WW8TableHandler aHandler;
output.addItem("<table id=\"" + (*QNameToString::Instance())(name)
+ "\">");
try
{
ref->resolve(aHandler);
}
catch (Exception e)
{
output.addItem("<exception>" + e.getText() + "</exception>");
}
output.addItem("</table>");
}
void WW8StreamHandler::substream(Id name,
writerfilter::Reference<Stream>::Pointer_t ref)
{
output.addItem("<substream name=\"" + (*QNameToString::Instance())(name)
+ "\">");
gTableManager.startLevel();
ref->resolve(*this);
gTableManager.endLevel();
output.addItem("</substream>");
}
void WW8StreamHandler::info(const string & info_)
{
gInfo = info_;
output.addItem("<info>" + info_ + "</info>");
}
void WW8PropertiesHandler::attribute(Id name, Value & val)
{
boost::shared_ptr<rtl::OString> pStr(new ::rtl::OString());
::rtl::OUString aStr = val.getString();
aStr.convertToString(pStr.get(), RTL_TEXTENCODING_ASCII_US,
OUSTRING_TO_OSTRING_CVTFLAGS);
string sXMLValue = xmlify(pStr->getStr());
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "0x%x", val.getInt());
output.addItem("<attribute name=\"" +
(*QNameToString::Instance())(name) +
"\" value=\"" +
sXMLValue +
+ "\" hexvalue=\""
+ sBuffer + "\">");
writerfilter::Reference<Properties>::Pointer_t pProps = val.getProperties();
if (pProps.get() != NULL)
{
output.addItem("<properties name=\"" +
(*QNameToString::Instance())(name)
+ "\" type=\"" + pProps->getType() + "\">");
try
{
pProps->resolve(*this);
}
catch (ExceptionOutOfBounds e)
{
}
output.addItem("</properties>");
}
writerfilter::Reference<Stream>::Pointer_t pStream = val.getStream();
if (pStream.get() != NULL)
{
try
{
WW8StreamHandler aHandler;
pStream->resolve(aHandler);
}
catch (ExceptionOutOfBounds e)
{
}
}
writerfilter::Reference<BinaryObj>::Pointer_t pBinObj = val.getBinary();
if (pBinObj.get() != NULL)
{
try
{
WW8BinaryObjHandler aHandler;
pBinObj->resolve(aHandler);
}
catch (ExceptionOutOfBounds e)
{
}
}
output.addItem("</attribute>");
}
bool WW8PropertiesHandler::compare(SprmSharedPointer_t sprm1,
SprmSharedPointer_t sprm2)
{
return sprm1->getId() < sprm2->getId();
}
void WW8PropertiesHandler::sprm(Sprm & sprm_)
{
string tmpStr = "<sprm id=\"";
char buffer[256];
snprintf(buffer, sizeof(buffer), "0x%" SAL_PRIxUINT32, sprm_.getId());
tmpStr += buffer;
tmpStr += "\" name=\"";
tmpStr += sprm_.getName();
tmpStr += "\">";
output.addItem(tmpStr);
output.addItem(sprm_.toString());
writerfilter::Reference<Properties>::Pointer_t pProps = sprm_.getProps();
if (pProps.get() != NULL)
{
output.addItem("<properties type=\"" + pProps->getType() + "\">");
pProps->resolve(*this);
output.addItem("</properties>");
}
writerfilter::Reference<BinaryObj>::Pointer_t pBinObj = sprm_.getBinary();
if (pBinObj.get() != NULL)
{
output.addItem("<binary>");
WW8BinaryObjHandler aHandler;
pBinObj->resolve(aHandler);
output.addItem("</binary>");
}
writerfilter::Reference<Stream>::Pointer_t pStream = sprm_.getStream();
if (pStream.get() != NULL)
{
output.addItem("<stream>");
WW8StreamHandler aHandler;
pStream->resolve(aHandler);
output.addItem("</stream>");
}
gTableManager.sprm(sprm_);
output.addItem("</sprm>");
}
void WW8TableHandler::entry(int /*pos*/,
writerfilter::Reference<Properties>::Pointer_t ref)
{
output.addItem("<tableentry>");
WW8PropertiesHandler aHandler;
try
{
ref->resolve(aHandler);
}
catch (Exception e)
{
output.addItem("<exception>" + e.getText() + "</exception>");
output.addItem("</tableentry>");
throw e;
}
output.addItem("</tableentry>");
}
void WW8BinaryObjHandler::data
(const sal_uInt8 * buf, size_t length,
writerfilter::Reference<Properties>::Pointer_t /*pRef*/)
{
#if 1
SubSequence<sal_uInt8> aSeq(buf, length);
aSeq.dump(output);
#endif
}
}
<commit_msg>INTEGRATION: CWS hr51 (1.4.10); FILE MERGED 2008/06/06 14:12:15 hr 1.4.10.1: #i88947#: includes<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: resourcemodel.cxx,v $
* $Revision: 1.5 $
*
* 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.
*
************************************************************************/
#include <stdio.h>
#include <resourcemodel/WW8ResourceModel.hxx>
#include <resourcemodel/TableManager.hxx>
#include <resourcemodel/QNameToString.hxx>
#include <resourcemodel/exceptions.hxx>
#include <resourcemodel/SubSequence.hxx>
#include <resourcemodel.hxx>
namespace writerfilter {
class ResourceModelOutputWithDepth : public OutputWithDepth<string>
{
public:
ResourceModelOutputWithDepth()
: OutputWithDepth<string>("<tablegroup>", "</tablegroup>") {}
~ResourceModelOutputWithDepth() {outputGroup();}
void output(const string & str) const { cout << str << endl; }
};
ResourceModelOutputWithDepth output;
Stream::Pointer_t createStreamHandler()
{
return Stream::Pointer_t(new WW8StreamHandler());
}
void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
writerfilter::Reference<Properties>::Pointer_t /*props*/)
{
}
void dump(OutputWithDepth<string> & o, const char * name, sal_uInt32 n)
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIuUINT32, n);
string tmpStr = name;
tmpStr += "=";
tmpStr += sBuffer;
o.addItem(tmpStr);
}
void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
const rtl::OUString & /*str*/)
{
}
void dump(OutputWithDepth<string> & /*o*/, const char * /*name*/,
writerfilter::Reference<BinaryObj>::Pointer_t /*binary*/)
{
}
string gInfo = "";
// ------- WW8TableDataHandler ---------
class TablePropsRef : public writerfilter::Reference<Properties>
{
public:
typedef boost::shared_ptr<TablePropsRef> Pointer_t;
TablePropsRef() {}
virtual ~TablePropsRef() {}
virtual void resolve(Properties & /*rHandler*/) {}
virtual string getType() const { return "TableProps"; }
void reset() {}
void insert(Pointer_t /* pTablePropsRef */) {}
};
typedef TablePropsRef::Pointer_t TablePropsRef_t;
class WW8TableDataHandler : public TableDataHandler<string,
TablePropsRef_t>
{
public:
typedef boost::shared_ptr<WW8TableDataHandler> Pointer_t;
virtual void startTable(unsigned int nRows, unsigned int nDepth,
TablePropsRef_t pProps);
virtual void endTable();
virtual void startRow(unsigned int nCols,
TablePropsRef_t pProps);
virtual void endRow();
virtual void startCell(const string & start, TablePropsRef_t pProps);
virtual void endCell(const string & end);
};
void WW8TableDataHandler::startTable(unsigned int nRows, unsigned int nDepth,
TablePropsRef_t /*pProps*/)
{
char sBuffer[256];
string tmpStr = "<tabledata.table rows=\"";
snprintf(sBuffer, sizeof(sBuffer), "%d", nRows);
tmpStr += sBuffer;
tmpStr += "\" depth=\"";
snprintf(sBuffer, sizeof(sBuffer), "%d", nDepth);
tmpStr += sBuffer;
tmpStr += "\">";
output.addItem(tmpStr);
}
void WW8TableDataHandler::endTable()
{
output.addItem("</tabledata.table>");
}
void WW8TableDataHandler::startRow
(unsigned int nCols, TablePropsRef_t /*pProps*/)
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "%d", nCols);
string tmpStr = "<tabledata.row cells=\"";
tmpStr += sBuffer;
tmpStr += "\">";
output.addItem(tmpStr);
}
void WW8TableDataHandler::endRow()
{
output.addItem("</tabledata.row>");
}
void WW8TableDataHandler::startCell(const string & start,
TablePropsRef_t /*pProps*/)
{
output.addItem("<tabledata.cell>");
output.addItem(start);
output.addItem(", ");
}
void WW8TableDataHandler::endCell(const string & end)
{
output.addItem(end);
output.addItem("</tabledata.cell>");
}
// ----- WW8TableDataManager -------------------------------
class WW8TableManager :
public TableManager<string, TablePropsRef_t>
{
typedef TableDataHandler<string, TablePropsRef_t>
TableDataHandlerPointer_t;
public:
WW8TableManager();
virtual ~WW8TableManager() {}
virtual void endParagraphGroup();
virtual bool sprm(Sprm & rSprm);
};
WW8TableManager::WW8TableManager()
{
TableDataHandler<string, TablePropsRef_t>::Pointer_t pHandler(new WW8TableDataHandler());
setHandler(pHandler);
}
bool WW8TableManager::sprm(Sprm & rSprm)
{
TableManager<string, TablePropsRef_t>::sprm(rSprm);
output.setDepth(getTableDepthNew());
return true;
}
void WW8TableManager::endParagraphGroup()
{
string tmpStr = "<tabledepth depth=\"";
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIuUINT32, getTableDepthNew());
tmpStr += sBuffer;
tmpStr += "\"/>";
output.addItem(tmpStr);
TableManager<string, TablePropsRef_t>::endParagraphGroup();
}
WW8TableManager gTableManager;
/* WW8StreamHandler */
WW8StreamHandler::WW8StreamHandler()
{
output.closeGroup();
output.addItem("<stream>");
gTableManager.startLevel();
}
WW8StreamHandler::~WW8StreamHandler()
{
gTableManager.endLevel();
output.closeGroup();
output.addItem("</stream>");
}
void WW8StreamHandler::startSectionGroup()
{
output.addItem("<section-group>");
}
void WW8StreamHandler::endSectionGroup()
{
output.addItem("</section-group>");
}
void WW8StreamHandler::startParagraphGroup()
{
output.openGroup();
output.addItem("<paragraph-group>");
gTableManager.startParagraphGroup();
gTableManager.handle(gInfo);
}
void WW8StreamHandler::endParagraphGroup()
{
gTableManager.endParagraphGroup();
output.addItem("</paragraph-group>");
output.closeGroup();
}
void WW8StreamHandler::startCharacterGroup()
{
output.addItem("<character-group>");
}
void WW8StreamHandler::endCharacterGroup()
{
output.addItem("</character-group>");
}
void WW8StreamHandler::text(const sal_uInt8 * data, size_t len)
{
string tmpStr = "<text>";
for (unsigned int n = 0; n < len; ++n)
{
switch (static_cast<unsigned char>(data[n]))
{
case '<':
tmpStr += "<";
break;
case '>':
tmpStr += ">";
break;
case '&':
tmpStr += "&";
break;
default:
if (isprint(data[n]))
tmpStr += static_cast<char>(data[n]);
else
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "\\0x%02x", data[n]);
tmpStr += sBuffer;
}
}
}
tmpStr += "</text>";
output.addItem(tmpStr);
gTableManager.text(data, len);
}
void WW8StreamHandler::utext(const sal_uInt8 * data, size_t len)
{
string tmpStr = "<utext>";
for (unsigned int n = 0; n < len; ++n)
{
sal_Unicode nChar = data[n * 2] + (data[n * 2 + 1] << 8);
if (nChar < 0xff && isprint(nChar))
{
switch (nChar)
{
case '&':
tmpStr += "&";
break;
case '<':
tmpStr += "<";
break;
case '>':
tmpStr += ">";
break;
default:
tmpStr += static_cast<char>(nChar);
}
}
else
{
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "\\0x%04x", nChar);
tmpStr += sBuffer;
}
}
tmpStr += "</utext>";
output.addItem(tmpStr);
gTableManager.utext(data, len);
}
void WW8StreamHandler::props(writerfilter::Reference<Properties>::Pointer_t ref)
{
WW8PropertiesHandler aHandler;
output.addItem("<properties type=\"" + ref->getType() + "\">");
ref->resolve(aHandler);
//gTableManager.props(ref);
output.addItem("</properties>");
}
void WW8StreamHandler::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
{
WW8TableHandler aHandler;
output.addItem("<table id=\"" + (*QNameToString::Instance())(name)
+ "\">");
try
{
ref->resolve(aHandler);
}
catch (Exception e)
{
output.addItem("<exception>" + e.getText() + "</exception>");
}
output.addItem("</table>");
}
void WW8StreamHandler::substream(Id name,
writerfilter::Reference<Stream>::Pointer_t ref)
{
output.addItem("<substream name=\"" + (*QNameToString::Instance())(name)
+ "\">");
gTableManager.startLevel();
ref->resolve(*this);
gTableManager.endLevel();
output.addItem("</substream>");
}
void WW8StreamHandler::info(const string & info_)
{
gInfo = info_;
output.addItem("<info>" + info_ + "</info>");
}
void WW8PropertiesHandler::attribute(Id name, Value & val)
{
boost::shared_ptr<rtl::OString> pStr(new ::rtl::OString());
::rtl::OUString aStr = val.getString();
aStr.convertToString(pStr.get(), RTL_TEXTENCODING_ASCII_US,
OUSTRING_TO_OSTRING_CVTFLAGS);
string sXMLValue = xmlify(pStr->getStr());
char sBuffer[256];
snprintf(sBuffer, sizeof(sBuffer), "0x%x", val.getInt());
output.addItem("<attribute name=\"" +
(*QNameToString::Instance())(name) +
"\" value=\"" +
sXMLValue +
+ "\" hexvalue=\""
+ sBuffer + "\">");
writerfilter::Reference<Properties>::Pointer_t pProps = val.getProperties();
if (pProps.get() != NULL)
{
output.addItem("<properties name=\"" +
(*QNameToString::Instance())(name)
+ "\" type=\"" + pProps->getType() + "\">");
try
{
pProps->resolve(*this);
}
catch (ExceptionOutOfBounds e)
{
}
output.addItem("</properties>");
}
writerfilter::Reference<Stream>::Pointer_t pStream = val.getStream();
if (pStream.get() != NULL)
{
try
{
WW8StreamHandler aHandler;
pStream->resolve(aHandler);
}
catch (ExceptionOutOfBounds e)
{
}
}
writerfilter::Reference<BinaryObj>::Pointer_t pBinObj = val.getBinary();
if (pBinObj.get() != NULL)
{
try
{
WW8BinaryObjHandler aHandler;
pBinObj->resolve(aHandler);
}
catch (ExceptionOutOfBounds e)
{
}
}
output.addItem("</attribute>");
}
bool WW8PropertiesHandler::compare(SprmSharedPointer_t sprm1,
SprmSharedPointer_t sprm2)
{
return sprm1->getId() < sprm2->getId();
}
void WW8PropertiesHandler::sprm(Sprm & sprm_)
{
string tmpStr = "<sprm id=\"";
char buffer[256];
snprintf(buffer, sizeof(buffer), "0x%" SAL_PRIxUINT32, sprm_.getId());
tmpStr += buffer;
tmpStr += "\" name=\"";
tmpStr += sprm_.getName();
tmpStr += "\">";
output.addItem(tmpStr);
output.addItem(sprm_.toString());
writerfilter::Reference<Properties>::Pointer_t pProps = sprm_.getProps();
if (pProps.get() != NULL)
{
output.addItem("<properties type=\"" + pProps->getType() + "\">");
pProps->resolve(*this);
output.addItem("</properties>");
}
writerfilter::Reference<BinaryObj>::Pointer_t pBinObj = sprm_.getBinary();
if (pBinObj.get() != NULL)
{
output.addItem("<binary>");
WW8BinaryObjHandler aHandler;
pBinObj->resolve(aHandler);
output.addItem("</binary>");
}
writerfilter::Reference<Stream>::Pointer_t pStream = sprm_.getStream();
if (pStream.get() != NULL)
{
output.addItem("<stream>");
WW8StreamHandler aHandler;
pStream->resolve(aHandler);
output.addItem("</stream>");
}
gTableManager.sprm(sprm_);
output.addItem("</sprm>");
}
void WW8TableHandler::entry(int /*pos*/,
writerfilter::Reference<Properties>::Pointer_t ref)
{
output.addItem("<tableentry>");
WW8PropertiesHandler aHandler;
try
{
ref->resolve(aHandler);
}
catch (Exception e)
{
output.addItem("<exception>" + e.getText() + "</exception>");
output.addItem("</tableentry>");
throw e;
}
output.addItem("</tableentry>");
}
void WW8BinaryObjHandler::data
(const sal_uInt8 * buf, size_t length,
writerfilter::Reference<Properties>::Pointer_t /*pRef*/)
{
#if 1
SubSequence<sal_uInt8> aSeq(buf, length);
aSeq.dump(output);
#endif
}
}
<|endoftext|> |
<commit_before>/*****************************************************************************
*
* YEXTEND: Help for YARA users.
* This file is part of yextend.
*
* Copyright (c) 2104-2016, Bayshore Networks, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that
* the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
*
* 2. 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.
*
* 3. Neither the name of the copyright holder 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.
*****************************************************************************/
#include <iostream>
#include <algorithm>
using namespace std;
#include <filedissect.h>
#include <wrapper.h>
#include <sys/stat.h>
/*
* The following functions implement the high-level API to our content-inspection facilities.
* High-level applications will want to call these entry points rather than the underlying
* C++ objects.
*
*/
/****************
* get_content_type
* ****************/
int get_content_type (const uint8_t *data, size_t sz)
{
FileDissect fd;
return fd.GetBufferType (data, std::min(sz,(size_t)100000));
}
/***********************
* get_content_type_string
* ***********************/
const char *get_content_type_string (int ft)
{
FileDissect fd;
string s = fd.GetFileTypeStr (ft);
/*
* WARNING, this is not thread-safe.
* This needs refactoring because the underlying
* function in FileDissect returns a std::string
* instead of a static const char* as it probably
* should
*/
static char buf [2048];
snprintf (buf, sizeof(buf), s.c_str());
return buf;
}
/***************
is_type_archive
***************/
bool is_type_archive (int ix)
{
FileDissect fd;
return fd.is_archive (ix);
}
/***************
is_type_officex
***************/
bool is_type_officex (int ix)
{
FileDissect fd;
return fd.is_officex (ix);
}
/************
is_type_pcap
************/
bool is_type_pcap (int ix)
{
FileDissect fd;
return fd.is_pcap (ix);
}
/********************
is_type_unclassified
********************/
bool is_type_unclassified (int ix)
{
FileDissect fd;
return fd.is_unclassified (ix);
}
/***********
is_type_tar
***********/
bool is_type_tar (int ix)
{
FileDissect fd;
return fd.is_tar (ix);
}
/***********
is_type_xml
***********/
bool is_type_xml (int ix)
{
FileDissect fd;
return fd.is_xml (ix);
}
/****************************
is_type_open_document_format
****************************/
bool is_type_open_document_format (int ix)
{
FileDissect fd;
return fd.is_open_document_format (ix);
}
/***********
is_type_php
***********/
bool is_type_php (int ix)
{
FileDissect fd;
return fd.is_php (ix);
}
/***********
is_type_rar
***********/
bool is_type_rar (int ix)
{
FileDissect fd;
return fd.is_rar (ix);
}
/***************
is_type_win_exe
***************/
bool is_type_win_exe (int ix)
{
FileDissect fd;
return fd.is_win_exe (ix);
}
/************
is_type_html
************/
bool is_type_html (int ix)
{
FileDissect fd;
return fd.is_html (ix);
}
/************
is_type_gzip
************/
bool is_type_gzip (int ix)
{
FileDissect fd;
return fd.is_gzip (ix);
}
/***********
is_type_pdf
***********/
bool is_type_pdf (int ix)
{
FileDissect fd;
return fd.is_pdf (ix);
}
/**************
is_type_office
**************/
bool is_type_office (int ix)
{
FileDissect fd;
return fd.is_office (ix);
}
/*************
is_type_image
*************/
bool is_type_image (int ix)
{
FileDissect fd;
return fd.is_image (ix);
}
<commit_msg>Fix compiler warning<commit_after>/*****************************************************************************
*
* YEXTEND: Help for YARA users.
* This file is part of yextend.
*
* Copyright (c) 2104-2016, Bayshore Networks, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that
* the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
* following disclaimer.
*
* 2. 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.
*
* 3. Neither the name of the copyright holder 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.
*****************************************************************************/
#include <iostream>
#include <algorithm>
using namespace std;
#include <filedissect.h>
#include <wrapper.h>
#include <sys/stat.h>
/*
* The following functions implement the high-level API to our content-inspection facilities.
* High-level applications will want to call these entry points rather than the underlying
* C++ objects.
*
*/
/****************
* get_content_type
* ****************/
int get_content_type (const uint8_t *data, size_t sz)
{
FileDissect fd;
return fd.GetBufferType (data, std::min(sz,(size_t)100000));
}
/***********************
* get_content_type_string
* ***********************/
const char *get_content_type_string (int ft)
{
FileDissect fd;
string s = fd.GetFileTypeStr (ft);
/*
* WARNING, this is not thread-safe.
* This needs refactoring because the underlying
* function in FileDissect returns a std::string
* instead of a static const char* as it probably
* should
*/
static char buf [2048];
snprintf (buf, sizeof(buf), "%s", s.c_str());
return buf;
}
/***************
is_type_archive
***************/
bool is_type_archive (int ix)
{
FileDissect fd;
return fd.is_archive (ix);
}
/***************
is_type_officex
***************/
bool is_type_officex (int ix)
{
FileDissect fd;
return fd.is_officex (ix);
}
/************
is_type_pcap
************/
bool is_type_pcap (int ix)
{
FileDissect fd;
return fd.is_pcap (ix);
}
/********************
is_type_unclassified
********************/
bool is_type_unclassified (int ix)
{
FileDissect fd;
return fd.is_unclassified (ix);
}
/***********
is_type_tar
***********/
bool is_type_tar (int ix)
{
FileDissect fd;
return fd.is_tar (ix);
}
/***********
is_type_xml
***********/
bool is_type_xml (int ix)
{
FileDissect fd;
return fd.is_xml (ix);
}
/****************************
is_type_open_document_format
****************************/
bool is_type_open_document_format (int ix)
{
FileDissect fd;
return fd.is_open_document_format (ix);
}
/***********
is_type_php
***********/
bool is_type_php (int ix)
{
FileDissect fd;
return fd.is_php (ix);
}
/***********
is_type_rar
***********/
bool is_type_rar (int ix)
{
FileDissect fd;
return fd.is_rar (ix);
}
/***************
is_type_win_exe
***************/
bool is_type_win_exe (int ix)
{
FileDissect fd;
return fd.is_win_exe (ix);
}
/************
is_type_html
************/
bool is_type_html (int ix)
{
FileDissect fd;
return fd.is_html (ix);
}
/************
is_type_gzip
************/
bool is_type_gzip (int ix)
{
FileDissect fd;
return fd.is_gzip (ix);
}
/***********
is_type_pdf
***********/
bool is_type_pdf (int ix)
{
FileDissect fd;
return fd.is_pdf (ix);
}
/**************
is_type_office
**************/
bool is_type_office (int ix)
{
FileDissect fd;
return fd.is_office (ix);
}
/*************
is_type_image
*************/
bool is_type_image (int ix)
{
FileDissect fd;
return fd.is_image (ix);
}
<|endoftext|> |
<commit_before>/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/* $Id: AliCorrQADataMakerRec.cxx 27570 2008-07-24 21:49:27Z cvetan $ */
/*
Produces the data needed to calculate the quality assurance.
All data must be mergeable objects.
Y. Schutz CERN July 2007
*/
// --- ROOT system ---
#include <TClonesArray.h>
#include <TFile.h>
#include <TH1F.h>
#include <TH1I.h>
#include <TH2F.h>
#include <TNtupleD.h>
#include <TParameter.h>
#include <TMath.h>
// --- Standard library ---
// --- AliRoot header files ---
#include "AliLog.h"
#include "AliCorrQADataMakerRec.h"
#include "AliQAChecker.h"
ClassImp(AliCorrQADataMakerRec)
//____________________________________________________________________________
AliCorrQADataMakerRec::AliCorrQADataMakerRec(AliQADataMaker ** qadm ) :
AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kCORR), "Corr Quality Assurance Data Maker"),
fMaxRawVar(0),
fqadm(qadm),
fVarvalue(NULL)
{
// ctor
fCorrNt = new TNtupleD *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
fCorrNt[specie] = NULL ;
}
//____________________________________________________________________________
AliCorrQADataMakerRec::AliCorrQADataMakerRec(const AliCorrQADataMakerRec& qadm) :
AliQADataMakerRec(),
fMaxRawVar(qadm.fMaxRawVar),
fqadm(qadm.fqadm),
fVarvalue(NULL)
{
//copy ctor
SetName((const char*)qadm.GetName()) ;
SetTitle((const char*)qadm.GetTitle());
if ( fMaxRawVar > 0 )
fVarvalue = new Double_t[fMaxRawVar] ;
}
//__________________________________________________________________
AliCorrQADataMakerRec& AliCorrQADataMakerRec::operator = (const AliCorrQADataMakerRec& qadm )
{
// assign operator.
this->~AliCorrQADataMakerRec();
new(this) AliCorrQADataMakerRec(qadm);
return *this;
}
//____________________________________________________________________________
AliCorrQADataMakerRec::~AliCorrQADataMakerRec()
{
// dtor only destroy the ntuple
if ( fCorrNt ) {
// for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
// if ( fCorrNt[specie] != NULL )
// delete fCorrNt[specie] ;
// }
delete[] fCorrNt ;
fCorrNt = 0x0;
}
if ( fMaxRawVar > 0 )
delete [] fVarvalue ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** /*list*/)
{
//Detector specific actions at end of cycle
// do the QA checking
if (task == AliQAv1::kRAWS) {
AliQAChecker::Instance()->Run(AliQAv1::kCORR, task, fCorrNt) ;
}
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::InitESDs()
{
//Create histograms to controll ESD
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::InitRecPoints()
{
// create Reconstructed Points histograms in RecPoints subdir
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::InitRaws()
{
// createa ntuple taking all the parameters declared by detectors
if (fCorrNt[AliRecoParam::AConvert(fEventSpecie)])
return ;
if ( fRawsQAList )
{
delete[] fRawsQAList ; // not needed for the time being
fRawsQAList = NULL ;
}
TString varlist("") ;
for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
AliQADataMaker * qadm = fqadm[detIndex] ;
if ( ! qadm )
continue ;
TList * list = qadm->GetParameterList() ;
if (list) {
TIter next(list) ;
TParameter<double> * p ;
while ( (p = static_cast<TParameter<double>*>(next()) ) ) {
varlist.Append(p->GetName()) ;
varlist.Append(":") ;
fMaxRawVar++ ;
}
}
}
varlist = varlist.Strip(TString::kTrailing, ':') ;
if (fMaxRawVar == 0) {
AliWarning("NTUPLE not created") ;
} else {
char * name = Form("%s_%s", AliQAv1::GetQACorrName(), AliRecoParam::GetEventSpecieName(fEventSpecie)) ;
fCorrNt[AliRecoParam::AConvert(fEventSpecie)] = new TNtupleD(name, "Raws data correlation among detectors", varlist.Data()) ;
fVarvalue = new Double_t[fMaxRawVar] ;
}
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeESDs(AliESDEvent * /*esd*/)
{
// make QA data from ESDs
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeRaws(AliRawReader *)
{
//Fill prepared histograms with Raw digit properties
if ( ! fCorrNt[AliRecoParam::AConvert(fEventSpecie)])
InitRaws() ;
if ( fMaxRawVar > 0 ) {
Int_t index = 0 ;
for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
AliQADataMaker * qadm = fqadm[detIndex] ;
if ( ! qadm )
continue ;
TList * list = qadm->GetParameterList() ;
TIter next(list) ;
TParameter<double> * p ;
while ( (p = static_cast<TParameter<double>*>(next()) ) ) {
fVarvalue[index] = p->GetVal() ;
index++ ;
}
}
static_cast<TNtupleD*>(fCorrNt[AliRecoParam::AConvert(fEventSpecie)])->Fill(fVarvalue);
}
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeRecPoints(TTree * /*clustersTree*/)
{
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
}
<commit_msg>Additional protection<commit_after>/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/* $Id: AliCorrQADataMakerRec.cxx 27570 2008-07-24 21:49:27Z cvetan $ */
/*
Produces the data needed to calculate the quality assurance.
All data must be mergeable objects.
Y. Schutz CERN July 2007
*/
// --- ROOT system ---
#include <TClonesArray.h>
#include <TFile.h>
#include <TH1F.h>
#include <TH1I.h>
#include <TH2F.h>
#include <TNtupleD.h>
#include <TParameter.h>
#include <TMath.h>
// --- Standard library ---
// --- AliRoot header files ---
#include "AliLog.h"
#include "AliCorrQADataMakerRec.h"
#include "AliQAChecker.h"
ClassImp(AliCorrQADataMakerRec)
//____________________________________________________________________________
AliCorrQADataMakerRec::AliCorrQADataMakerRec(AliQADataMaker ** qadm ) :
AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kCORR), "Corr Quality Assurance Data Maker"),
fMaxRawVar(0),
fqadm(qadm),
fVarvalue(NULL)
{
// ctor
fCorrNt = new TNtupleD *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
fCorrNt[specie] = NULL ;
}
//____________________________________________________________________________
AliCorrQADataMakerRec::AliCorrQADataMakerRec(const AliCorrQADataMakerRec& qadm) :
AliQADataMakerRec(),
fMaxRawVar(qadm.fMaxRawVar),
fqadm(qadm.fqadm),
fVarvalue(NULL)
{
//copy ctor
SetName((const char*)qadm.GetName()) ;
SetTitle((const char*)qadm.GetTitle());
if ( fMaxRawVar > 0 )
fVarvalue = new Double_t[fMaxRawVar] ;
fCorrNt = new TNtupleD *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
fCorrNt[specie] = qadm.fCorrNt[specie] ;
}
//__________________________________________________________________
AliCorrQADataMakerRec& AliCorrQADataMakerRec::operator = (const AliCorrQADataMakerRec& qadm )
{
// assign operator.
this->~AliCorrQADataMakerRec();
new(this) AliCorrQADataMakerRec(qadm);
return *this;
}
//____________________________________________________________________________
AliCorrQADataMakerRec::~AliCorrQADataMakerRec()
{
// dtor only destroy the ntuple
if ( fCorrNt ) {
// for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
// if ( fCorrNt[specie] != NULL )
// delete fCorrNt[specie] ;
// }
delete[] fCorrNt ;
fCorrNt = 0x0;
}
if ( fMaxRawVar > 0 )
delete [] fVarvalue ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** /*list*/)
{
//Detector specific actions at end of cycle
// do the QA checking
if (task == AliQAv1::kRAWS) {
AliQAChecker::Instance()->Run(AliQAv1::kCORR, task, fCorrNt) ;
}
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::InitESDs()
{
//Create histograms to controll ESD
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::InitRecPoints()
{
// create Reconstructed Points histograms in RecPoints subdir
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::InitRaws()
{
// createa ntuple taking all the parameters declared by detectors
if (fCorrNt && fCorrNt[AliRecoParam::AConvert(fEventSpecie)])
return ;
if (!fCorrNt) {
fCorrNt = new TNtupleD *[AliRecoParam::kNSpecies] ; ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
fCorrNt[specie] = NULL ;
}
if ( fRawsQAList )
{
delete[] fRawsQAList ; // not needed for the time being
fRawsQAList = NULL ;
}
TString varlist("") ;
for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
AliQADataMaker * qadm = fqadm[detIndex] ;
if ( ! qadm )
continue ;
TList * list = qadm->GetParameterList() ;
if (list) {
TIter next(list) ;
TParameter<double> * p ;
while ( (p = static_cast<TParameter<double>*>(next()) ) ) {
varlist.Append(p->GetName()) ;
varlist.Append(":") ;
fMaxRawVar++ ;
}
}
}
varlist = varlist.Strip(TString::kTrailing, ':') ;
if (fMaxRawVar == 0) {
AliWarning("NTUPLE not created") ;
} else {
char * name = Form("%s_%s", AliQAv1::GetQACorrName(), AliRecoParam::GetEventSpecieName(fEventSpecie)) ;
fCorrNt[AliRecoParam::AConvert(fEventSpecie)] = new TNtupleD(name, "Raws data correlation among detectors", varlist.Data()) ;
fVarvalue = new Double_t[fMaxRawVar] ;
}
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeESDs(AliESDEvent * /*esd*/)
{
// make QA data from ESDs
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeRaws(AliRawReader *)
{
//Fill prepared histograms with Raw digit properties
if ( !fCorrNt || ! fCorrNt[AliRecoParam::AConvert(fEventSpecie)])
InitRaws() ;
if ( fMaxRawVar > 0 ) {
Int_t index = 0 ;
for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++ ) {
AliQADataMaker * qadm = fqadm[detIndex] ;
if ( ! qadm )
continue ;
TList * list = qadm->GetParameterList() ;
if (list) {
TIter next(list) ;
TParameter<double> * p ;
while ( (p = static_cast<TParameter<double>*>(next()) ) ) {
if (index >= fMaxRawVar) {
AliError(Form("Variables list size exceeded (%d) !",index));
break;
}
fVarvalue[index] = p->GetVal() ;
index++ ;
}
}
}
static_cast<TNtupleD*>(fCorrNt[AliRecoParam::AConvert(fEventSpecie)])->Fill(fVarvalue);
}
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeRecPoints(TTree * /*clustersTree*/)
{
AliInfo("TO BE IMPLEMENTED") ;
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
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 cereal 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 RANDOLPH VOORHIES AND SHANE GRANT 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.
*/
#ifndef CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
#define CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
#include "common.hpp"
#include <cmath>
namespace mynamespace { struct MyCustomClass {}; }
template <class T>
inline void swapBytes( T & t )
{
cereal::portable_binary_detail::swap_bytes<sizeof(T)>( reinterpret_cast<std::uint8_t*>(&t) );
}
// swaps all output data
#define CEREAL_TEST_SWAP_OUTPUT \
swapBytes(o_bool); \
swapBytes(o_uint8); \
swapBytes(o_int8); \
swapBytes(o_uint16); \
swapBytes(o_int16); \
swapBytes(o_uint32); \
swapBytes(o_int32); \
swapBytes(o_uint64); \
swapBytes(o_int64); \
swapBytes(o_float); \
swapBytes(o_double);
#define CEREAL_TEST_CHECK_EQUAL \
CHECK_EQ(i_bool , o_bool); \
CHECK_EQ(i_uint8 , o_uint8); \
CHECK_EQ(i_int8 , o_int8); \
CHECK_EQ(i_uint16 , o_uint16); \
CHECK_EQ(i_int16 , o_int16); \
CHECK_EQ(i_uint32 , o_uint32); \
CHECK_EQ(i_int32 , o_int32); \
CHECK_EQ(i_uint64 , o_uint64); \
CHECK_EQ(i_int64 , o_int64); \
if( !std::isnan(i_float) && !std::isnan(o_float) ) CHECK_EQ(i_float , doctest::Approx(o_float).epsilon(1e-5F)); \
if( !std::isnan(i_float) && !std::isnan(o_float) ) CHECK_EQ(i_double, doctest::Approx(o_double).epsilon(1e-5));
// Last parameter exists to keep everything hidden in options
template <class IArchive, class OArchive> inline
void test_endian_serialization( typename IArchive::Options const & iOptions, typename OArchive::Options const & oOptions, const std::uint8_t inputLittleEndian )
{
std::random_device rd;
std::mt19937 gen(rd());
for(size_t i=0; i<100; ++i)
{
bool o_bool = random_value<uint8_t>(gen) % 2 ? true : false;
uint8_t o_uint8 = random_value<uint8_t>(gen);
int8_t o_int8 = random_value<int8_t>(gen);
uint16_t o_uint16 = random_value<uint16_t>(gen);
int16_t o_int16 = random_value<int16_t>(gen);
uint32_t o_uint32 = random_value<uint32_t>(gen);
int32_t o_int32 = random_value<int32_t>(gen);
uint64_t o_uint64 = random_value<uint64_t>(gen);
int64_t o_int64 = random_value<int64_t>(gen);
float o_float = random_value<float>(gen);
double o_double = random_value<double>(gen);
std::vector<int32_t> o_vector(100);
for(auto & elem : o_vector)
elem = random_value<uint32_t>(gen);
std::ostringstream os;
{
OArchive oar(os, oOptions);
oar(o_bool);
oar(o_uint8);
oar(o_int8);
oar(o_uint16);
oar(o_int16);
oar(o_uint32);
oar(o_int32);
oar(o_uint64);
oar(o_int64);
oar(o_float);
oar(o_double);
// We can't test vector directly here since we are artificially interfering with the endianness,
// which can result in the size being incorrect
oar(cereal::binary_data( o_vector.data(), static_cast<std::size_t>( o_vector.size() * sizeof(int32_t) ) ));
}
bool i_bool = false;
uint8_t i_uint8 = 0;
int8_t i_int8 = 0;
uint16_t i_uint16 = 0;
int16_t i_int16 = 0;
uint32_t i_uint32 = 0;
int32_t i_int32 = 0;
uint64_t i_uint64 = 0;
int64_t i_int64 = 0;
float i_float = 0;
double i_double = 0;
std::vector<int32_t> i_vector(100);
std::istringstream is(os.str());
{
IArchive iar(is, iOptions);
iar(i_bool);
iar(i_uint8);
iar(i_int8);
iar(i_uint16);
iar(i_int16);
iar(i_uint32);
iar(i_int32);
iar(i_uint64);
iar(i_int64);
iar(i_float);
iar(i_double);
iar(cereal::binary_data( i_vector.data(), static_cast<std::size_t>( i_vector.size() * sizeof(int32_t) ) ));
}
// Convert to big endian if we expect to read big and didn't start big
if( cereal::portable_binary_detail::is_little_endian() ^ inputLittleEndian ) // Convert to little endian if
{
CEREAL_TEST_SWAP_OUTPUT
for( auto & val : o_vector )
swapBytes(val);
}
CEREAL_TEST_CHECK_EQUAL
check_collection(i_vector, o_vector);
}
}
#endif // CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
<commit_msg>Fix macro for double comparison in unit test relates #338<commit_after>/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
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 cereal 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 RANDOLPH VOORHIES AND SHANE GRANT 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.
*/
#ifndef CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
#define CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
#include "common.hpp"
#include <cmath>
namespace mynamespace { struct MyCustomClass {}; }
template <class T>
inline void swapBytes( T & t )
{
cereal::portable_binary_detail::swap_bytes<sizeof(T)>( reinterpret_cast<std::uint8_t*>(&t) );
}
// swaps all output data
#define CEREAL_TEST_SWAP_OUTPUT \
swapBytes(o_bool); \
swapBytes(o_uint8); \
swapBytes(o_int8); \
swapBytes(o_uint16); \
swapBytes(o_int16); \
swapBytes(o_uint32); \
swapBytes(o_int32); \
swapBytes(o_uint64); \
swapBytes(o_int64); \
swapBytes(o_float); \
swapBytes(o_double);
#define CEREAL_TEST_CHECK_EQUAL \
CHECK_EQ(i_bool , o_bool); \
CHECK_EQ(i_uint8 , o_uint8); \
CHECK_EQ(i_int8 , o_int8); \
CHECK_EQ(i_uint16 , o_uint16); \
CHECK_EQ(i_int16 , o_int16); \
CHECK_EQ(i_uint32 , o_uint32); \
CHECK_EQ(i_int32 , o_int32); \
CHECK_EQ(i_uint64 , o_uint64); \
CHECK_EQ(i_int64 , o_int64); \
if( !std::isnan(i_float) && !std::isnan(o_float) ) CHECK_EQ(i_float , doctest::Approx(o_float).epsilon(1e-5F)); \
if( !std::isnan(i_double) && !std::isnan(o_double) ) CHECK_EQ(i_double, doctest::Approx(o_double).epsilon(1e-5));
// Last parameter exists to keep everything hidden in options
template <class IArchive, class OArchive> inline
void test_endian_serialization( typename IArchive::Options const & iOptions, typename OArchive::Options const & oOptions, const std::uint8_t inputLittleEndian )
{
std::random_device rd;
std::mt19937 gen(rd());
for(size_t i=0; i<100; ++i)
{
bool o_bool = random_value<uint8_t>(gen) % 2 ? true : false;
uint8_t o_uint8 = random_value<uint8_t>(gen);
int8_t o_int8 = random_value<int8_t>(gen);
uint16_t o_uint16 = random_value<uint16_t>(gen);
int16_t o_int16 = random_value<int16_t>(gen);
uint32_t o_uint32 = random_value<uint32_t>(gen);
int32_t o_int32 = random_value<int32_t>(gen);
uint64_t o_uint64 = random_value<uint64_t>(gen);
int64_t o_int64 = random_value<int64_t>(gen);
float o_float = random_value<float>(gen);
double o_double = random_value<double>(gen);
std::vector<int32_t> o_vector(100);
for(auto & elem : o_vector)
elem = random_value<uint32_t>(gen);
std::ostringstream os;
{
OArchive oar(os, oOptions);
oar(o_bool);
oar(o_uint8);
oar(o_int8);
oar(o_uint16);
oar(o_int16);
oar(o_uint32);
oar(o_int32);
oar(o_uint64);
oar(o_int64);
oar(o_float);
oar(o_double);
// We can't test vector directly here since we are artificially interfering with the endianness,
// which can result in the size being incorrect
oar(cereal::binary_data( o_vector.data(), static_cast<std::size_t>( o_vector.size() * sizeof(int32_t) ) ));
}
bool i_bool = false;
uint8_t i_uint8 = 0;
int8_t i_int8 = 0;
uint16_t i_uint16 = 0;
int16_t i_int16 = 0;
uint32_t i_uint32 = 0;
int32_t i_int32 = 0;
uint64_t i_uint64 = 0;
int64_t i_int64 = 0;
float i_float = 0;
double i_double = 0;
std::vector<int32_t> i_vector(100);
std::istringstream is(os.str());
{
IArchive iar(is, iOptions);
iar(i_bool);
iar(i_uint8);
iar(i_int8);
iar(i_uint16);
iar(i_int16);
iar(i_uint32);
iar(i_int32);
iar(i_uint64);
iar(i_int64);
iar(i_float);
iar(i_double);
iar(cereal::binary_data( i_vector.data(), static_cast<std::size_t>( i_vector.size() * sizeof(int32_t) ) ));
}
// Convert to big endian if we expect to read big and didn't start big
if( cereal::portable_binary_detail::is_little_endian() ^ inputLittleEndian ) // Convert to little endian if
{
CEREAL_TEST_SWAP_OUTPUT
for( auto & val : o_vector )
swapBytes(val);
}
CEREAL_TEST_CHECK_EQUAL
check_collection(i_vector, o_vector);
}
}
#endif // CEREAL_TEST_PORTABLE_BINARY_ARCHIVE_H_
<|endoftext|> |
<commit_before>/*
* Copyright(c) Sophist Solutions, Inc. 1990-2021. All rights reserved
*/
#include "Stroika/Frameworks/StroikaPreComp.h"
#include <cstdlib>
#include "Stroika/Foundation/Characters/String.h"
#include "Stroika/Foundation/Containers/Set.h"
#if qHasFeature_sqlite
#include "Stroika/Foundation/Database/SQLite.h"
#endif
using namespace std;
using namespace Stroika::Foundation;
using namespace Stroika::Foundation::Characters;
using namespace Stroika::Foundation::Containers;
using namespace Stroika::Foundation::Database;
namespace {
void Test1_ ()
{
#if qHasFeature_sqlite
using namespace SQLite;
/*
***** SETUP SCHEMA ****
*/
// Example roughly from https://www.tutorialspoint.com/sqlite/sqlite_insert_query.htm
auto initializeDB = [] (const Connection::Ptr& c) {
c.Exec (
L"CREATE TABLE COMPANY("
L"ID INT PRIMARY KEY NOT NULL,"
L"NAME TEXT NOT NULL,"
L"AGE INT NOT NULL,"
L"ADDRESS CHAR(50),"
L"SALARY REAL"
L");");
c.Exec (
L"CREATE TABLE DEPARTMENT(ID INT PRIMARY KEY NOT NULL,"
L"DEPT CHAR (50) NOT NULL,"
L" EMP_ID INT NOT NULL"
L");");
};
auto dbPath = filesystem::current_path () / "testdb.db";
(void)std::filesystem::remove (dbPath);
/*
***** CONNECT TO DATABASE ****
*/
#if __cpp_designated_initializers
Connection::Ptr conn = Connection::New (Options{.fDBPath = dbPath}, initializeDB);
#else
Connection::Ptr conn = Connection::New (Options{dbPath}, initializeDB);
#endif
/*
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
*/
/*
***** INSERT ROWS ****
*/
Statement addCompanyStatement{conn, L"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) values (:ID, :NAME, :AGE, :ADDRESS, :SALARY);"};
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 1},
{L":NAME", L"Paul"},
{L":AGE", 32},
{L":ADDRESS", L"California"},
{L":SALARY", 20000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 2},
{L":NAME", L"Allen"},
{L":AGE", 25},
{L":ADDRESS", L"Texas"},
{L":SALARY", 15000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 3},
{L":NAME", L"Teddy"},
{L":AGE", 23},
{L":ADDRESS", L"Norway"},
{L":SALARY", 20000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 4},
{L":NAME", L"Mark"},
{L":AGE", 25},
{L":ADDRESS", L"Rich-Mond"},
{L":SALARY", 65000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 5},
{L":NAME", L"David"},
{L":AGE", 27},
{L":ADDRESS", L"Texas"},
{L":SALARY", 85000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 6},
{L":NAME", L"Kim"},
{L":AGE", 22},
{L":ADDRESS", L"South-Hall"},
{L":SALARY", 45000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 7},
{L":NAME", L"James"},
{L":AGE", 24},
{L":ADDRESS", L"Houston"},
{L":SALARY", 10000.00},
});
/*
***** INSERT ROWS (ERROR CHECKING) ****
*/
#if 0
// This call will generate a REQUIRE assertion error - terminating your program. Don't violate assertions!
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":BAD-ARGUMENT", 7},
{L":NAME", L"James"},
{L":AGE", 24},
{L":ADDRESS", L"Houston"},
{L":SALARY", 10000.00},
});
AssertNotReached ();
#endif
try {
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 7},
{L":NAME", L"James"},
{L":AGE", 24},
{L":ADDRESS", L"Houston"},
{L":SALARY", 10000.00},
});
AssertNotReached (); // RE-USED ID!!! - only detectable at runtime - so exception thrown
}
catch (...) {
DbgTrace (L"Note good error message: %s", Characters::ToString (current_exception ()).c_str ()); // silently ignore this here...
}
/*
***** SIMPLE QUERIES ****
*/
Statement getAllNames{conn, L"Select NAME from COMPANY;"};
Set<String> allNames = getAllNames.GetAllRows (0).Select<String> ([] (VariantValue v) { return v.As<String> (); }).As<Set<String>> ();
Assert ((allNames == Set<String>{L"Paul", L"Allen", L"Kim", L"David", L"Mark", L"James", L"Teddy"}));
Statement sumAllSalarys{conn, L"select SUM(SALARY) from COMPANY;"};
[[maybe_unused]]double sumSalaryUsingSQL = sumAllSalarys.GetAllRows (0)[0].As<double> ();
Statement getAllSalarys{conn, L"select SALARY from COMPANY;"};
[[maybe_unused]] double sumSalaryUsingIterableApply = getAllSalarys.GetAllRows (0).Select<double> ([] (VariantValue v) { return v.As<double> (); }).SumValue ();
Assert (Math::NearlyEquals (sumSalaryUsingSQL, sumSalaryUsingIterableApply));
#endif
}
}
int main ([[maybe_unused]] int argc, [[maybe_unused]] const char* argv[])
{
Test1_ ();
return EXIT_SUCCESS;
}
<commit_msg>cosmetic<commit_after>/*
* Copyright(c) Sophist Solutions, Inc. 1990-2021. All rights reserved
*/
#include "Stroika/Frameworks/StroikaPreComp.h"
#include <cstdlib>
#include "Stroika/Foundation/Characters/String.h"
#include "Stroika/Foundation/Containers/Set.h"
#if qHasFeature_sqlite
#include "Stroika/Foundation/Database/SQLite.h"
#endif
using namespace std;
using namespace Stroika::Foundation;
using namespace Stroika::Foundation::Characters;
using namespace Stroika::Foundation::Containers;
using namespace Stroika::Foundation::Database;
namespace {
void Test1_ ()
{
#if qHasFeature_sqlite
using namespace SQLite;
/*
***** SETUP SCHEMA ****
*/
// Example roughly from https://www.tutorialspoint.com/sqlite/sqlite_insert_query.htm
auto initializeDB = [] (const Connection::Ptr& c) {
c.Exec (
L"CREATE TABLE COMPANY("
L"ID INT PRIMARY KEY NOT NULL,"
L"NAME TEXT NOT NULL,"
L"AGE INT NOT NULL,"
L"ADDRESS CHAR(50),"
L"SALARY REAL"
L");");
c.Exec (
L"CREATE TABLE DEPARTMENT(ID INT PRIMARY KEY NOT NULL,"
L"DEPT CHAR (50) NOT NULL,"
L" EMP_ID INT NOT NULL"
L");");
};
auto dbPath = filesystem::current_path () / "testdb.db";
(void)std::filesystem::remove (dbPath);
/*
***** CONNECT TO DATABASE ****
*/
#if __cpp_designated_initializers
Connection::Ptr conn = Connection::New (Options{.fDBPath = dbPath}, initializeDB);
#else
Connection::Ptr conn = Connection::New (Options{dbPath}, initializeDB);
#endif
/*
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
*/
/*
***** INSERT ROWS ****
*/
Statement addCompanyStatement{conn, L"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) values (:ID, :NAME, :AGE, :ADDRESS, :SALARY);"};
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 1},
{L":NAME", L"Paul"},
{L":AGE", 32},
{L":ADDRESS", L"California"},
{L":SALARY", 20000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 2},
{L":NAME", L"Allen"},
{L":AGE", 25},
{L":ADDRESS", L"Texas"},
{L":SALARY", 15000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 3},
{L":NAME", L"Teddy"},
{L":AGE", 23},
{L":ADDRESS", L"Norway"},
{L":SALARY", 20000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 4},
{L":NAME", L"Mark"},
{L":AGE", 25},
{L":ADDRESS", L"Rich-Mond"},
{L":SALARY", 65000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 5},
{L":NAME", L"David"},
{L":AGE", 27},
{L":ADDRESS", L"Texas"},
{L":SALARY", 85000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 6},
{L":NAME", L"Kim"},
{L":AGE", 22},
{L":ADDRESS", L"South-Hall"},
{L":SALARY", 45000.00},
});
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 7},
{L":NAME", L"James"},
{L":AGE", 24},
{L":ADDRESS", L"Houston"},
{L":SALARY", 10000.00},
});
/*
***** INSERT ROWS (ERROR CHECKING) ****
*/
#if 0
// This call will generate a REQUIRE assertion error - terminating your program. Don't violate assertions!
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":BAD-ARGUMENT", 7},
{L":NAME", L"James"},
{L":AGE", 24},
{L":ADDRESS", L"Houston"},
{L":SALARY", 10000.00},
});
AssertNotReached ();
#endif
try {
addCompanyStatement.Execute (initializer_list<Statement::ParameterDescription>{
{L":ID", 7},
{L":NAME", L"James"},
{L":AGE", 24},
{L":ADDRESS", L"Houston"},
{L":SALARY", 10000.00},
});
AssertNotReached (); // RE-USED ID!!! - only detectable at runtime - so exception thrown
}
catch (...) {
DbgTrace (L"Note good error message: %s", Characters::ToString (current_exception ()).c_str ()); // silently ignore this here...
}
/*
***** SIMPLE QUERIES ****
*/
Statement getAllNames{conn, L"Select NAME from COMPANY;"};
Set<String> allNames = getAllNames.GetAllRows (0).Select<String> ([] (VariantValue v) { return v.As<String> (); }).As<Set<String>> ();
Assert ((allNames == Set<String>{L"Paul", L"Allen", L"Kim", L"David", L"Mark", L"James", L"Teddy"}));
Statement sumAllSalarys{conn, L"select SUM(SALARY) from COMPANY;"};
[[maybe_unused]] double sumSalaryUsingSQL = sumAllSalarys.GetAllRows (0)[0].As<double> ();
Statement getAllSalarys{conn, L"select SALARY from COMPANY;"};
[[maybe_unused]] double sumSalaryUsingIterableApply = getAllSalarys.GetAllRows (0).Select<double> ([] (VariantValue v) { return v.As<double> (); }).SumValue ();
Assert (Math::NearlyEquals (sumSalaryUsingSQL, sumSalaryUsingIterableApply));
#endif
}
}
int main ([[maybe_unused]] int argc, [[maybe_unused]] const char* argv[])
{
Test1_ ();
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>#include <cstdio>
#include <cstdlib>
#include <MultiRegions/ExpList.h>
#include <MultiRegions/ExpList1D.h>
#include <MultiRegions/ExpList2D.h>
#include <MultiRegions/ExpList3D.h>
#include <MultiRegions/ExpList2DHomogeneous1D.h>
#include <MultiRegions/ExpList3DHomogeneous1D.h>
using namespace Nektar;
#include <sys/stat.h>
int fexist( const char *filename ) {
struct stat buffer ;
if ( stat( filename, &buffer ) ) return 0 ;
return 1 ;
}
int main(int argc, char *argv[])
{
int i,j;
if(argc < 3)
{
fprintf(stderr,"Usage: FldToVtk meshfile fieldfile(s)\n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
string meshfile(argv[1]);
SpatialDomains::MeshGraph graph;
SpatialDomains::MeshGraphSharedPtr graphShPt = graph.Read(meshfile);
//----------------------------------------------
for (int n = 2; n < argc; ++n)
{
string fname = std::string(argv[n]);
fname = fname.substr(0,fname.find_last_of('.')) + ".vtu";
if (argc > 3)
{
if (fexist(fname.c_str()))
{
cout << "Skipping converted file: " << argv[n] << endl;
continue;
}
cout << "Processing " << argv[n] << endl;
}
//----------------------------------------------
// Import field file.
string fieldfile(argv[n]);
vector<SpatialDomains::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
graphShPt->Import(fieldfile,fielddef,fielddata);
//----------------------------------------------
//----------------------------------------------
// Set up Expansion information
vector< vector<LibUtilities::PointsType> > pointstype;
for(i = 0; i < fielddef.size(); ++i)
{
vector<LibUtilities::PointsType> ptype;
for(j = 0; j < 3; ++j)
{
ptype.push_back(LibUtilities::ePolyEvenlySpaced);
}
pointstype.push_back(ptype);
}
graphShPt->SetExpansions(fielddef,pointstype);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
int nfields = fielddef[0]->m_fields.size();
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(nfields);
switch(expdim)
{
case 1:
{
SpatialDomains::MeshGraph1DSharedPtr mesh;
if(!(mesh = boost::dynamic_pointer_cast<
SpatialDomains::MeshGraph1D>(graphShPt)))
{
ASSERTL0(false,"Dynamic cast failed");
}
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 1,"NumHomogeneousDir is only set up for 1");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
// Define Homogeneous expansion
int nplanes = fielddef[0]->m_numModes[1];
// choose points to be at evenly spaced points at
const LibUtilities::PointsKey Pkey(nplanes+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[1],nplanes,Pkey);
NekDouble ly = fielddef[0]->m_homogeneousLengths[0];
Exp2DH1 = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(Bkey,ly,*mesh);
Exp[0] = Exp2DH1;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(*Exp2DH1);
}
}
else
{
MultiRegions::ExpList1DSharedPtr Exp1D;
Exp1D = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(*mesh);
Exp[0] = Exp1D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(*Exp1D);
}
}
}
break;
case 2:
{
SpatialDomains::MeshGraph2DSharedPtr mesh;
if(!(mesh = boost::dynamic_pointer_cast<
SpatialDomains::MeshGraph2D>(graphShPt)))
{
ASSERTL0(false,"Dynamic cast failed");
}
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 1,"NumHomogeneousDir is only set up for 1");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
// Define Homogeneous expansion
int nplanes = fielddef[0]->m_numModes[2];
// choose points to be at evenly spaced points at
// nplanes + 1 points
const LibUtilities::PointsKey Pkey(nplanes+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[2],nplanes,Pkey);
NekDouble lz = fielddef[0]->m_homogeneousLengths[0];
Exp3DH1 = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(Bkey,lz,*mesh);
Exp[0] = Exp3DH1;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(*Exp3DH1);
}
}
else
{
MultiRegions::ExpList2DSharedPtr Exp2D;
Exp2D = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*mesh);
Exp[0] = Exp2D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*Exp2D);
}
}
}
break;
case 3:
{
SpatialDomains::MeshGraph3DSharedPtr mesh;
if(!(mesh = boost::dynamic_pointer_cast<
SpatialDomains::MeshGraph3D>(graphShPt)))
{
ASSERTL0(false,"Dynamic cast failed");
}
MultiRegions::ExpList3DSharedPtr Exp3D;
Exp3D = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*mesh);
Exp[0] = Exp3D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*Exp3D);
}
}
break;
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
for(j = 0; j < nfields; ++j)
{
for(int i = 0; i < fielddata.size(); ++i)
{
Exp[j]->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
fielddef [i]->m_fields[j]);
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(),Exp[j]->UpdatePhys());
}
//----------------------------------------------
//----------------------------------------------
// Write solution
//string outname(strtok(argv[n],"."));
//outname += ".vtu";
ofstream outfile(fname.c_str());
cout << "Writing file: " << fname;
Exp[0]->WriteVtkHeader(outfile);
cout << ".";
// For each field write out field data for each expansion.
for(i = 0; i < Exp[0]->GetNumElmts(); ++i)
{
Exp[0]->WriteVtkPieceHeader(outfile,i);
// For this expansion, write out each field.
for(j = 0; j < Exp.num_elements(); ++j)
{
Exp[j]->WriteVtkPieceData(outfile,i, fielddef[0]->m_fields[j]);
}
Exp[0]->WriteVtkPieceFooter(outfile,i);
cout << ".";
}
Exp[0]->WriteVtkFooter(outfile);
cout << "Done " << endl;
//----------------------------------------------
}
return 0;
}
<commit_msg>modifications for homogeneous approach<commit_after>#include <cstdio>
#include <cstdlib>
#include <MultiRegions/ExpList.h>
#include <MultiRegions/ExpList1D.h>
#include <MultiRegions/ExpList2D.h>
#include <MultiRegions/ExpList3D.h>
#include <MultiRegions/ExpList2DHomogeneous1D.h>
#include <MultiRegions/ExpList3DHomogeneous1D.h>
using namespace Nektar;
#include <sys/stat.h>
int fexist( const char *filename ) {
struct stat buffer ;
if ( stat( filename, &buffer ) ) return 0 ;
return 1 ;
}
int main(int argc, char *argv[])
{
int i,j;
if(argc < 3)
{
fprintf(stderr,"Usage: FldToVtk meshfile fieldfile(s)\n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
string meshfile(argv[1]);
SpatialDomains::MeshGraph graph;
SpatialDomains::MeshGraphSharedPtr graphShPt = graph.Read(meshfile);
//----------------------------------------------
for (int n = 2; n < argc; ++n)
{
string fname = std::string(argv[n]);
fname = fname.substr(0,fname.find_last_of('.')) + ".vtu";
if (argc > 3)
{
if (fexist(fname.c_str()))
{
cout << "Skipping converted file: " << argv[n] << endl;
continue;
}
cout << "Processing " << argv[n] << endl;
}
//----------------------------------------------
// Import field file.
string fieldfile(argv[n]);
vector<SpatialDomains::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
graphShPt->Import(fieldfile,fielddef,fielddata);
bool useFFT = false;
//----------------------------------------------
//----------------------------------------------
// Set up Expansion information
vector< vector<LibUtilities::PointsType> > pointstype;
for(i = 0; i < fielddef.size(); ++i)
{
vector<LibUtilities::PointsType> ptype;
for(j = 0; j < 3; ++j)
{
ptype.push_back(LibUtilities::ePolyEvenlySpaced);
}
pointstype.push_back(ptype);
}
graphShPt->SetExpansions(fielddef,pointstype);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
int nfields = fielddef[0]->m_fields.size();
Array<OneD, MultiRegions::ExpListSharedPtr> Exp(nfields);
switch(expdim)
{
case 1:
{
SpatialDomains::MeshGraph1DSharedPtr mesh;
if(!(mesh = boost::dynamic_pointer_cast<
SpatialDomains::MeshGraph1D>(graphShPt)))
{
ASSERTL0(false,"Dynamic cast failed");
}
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 1,"NumHomogeneousDir is only set up for 1");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList2DHomogeneous1DSharedPtr Exp2DH1;
// Define Homogeneous expansion
int nplanes = fielddef[0]->m_numModes[1];
// choose points to be at evenly spaced points at
const LibUtilities::PointsKey Pkey(nplanes+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[1],nplanes,Pkey);
NekDouble ly = fielddef[0]->m_homogeneousLengths[0];
Exp2DH1 = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(Bkey,ly,useFFT,*mesh);
Exp[0] = Exp2DH1;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::AllocateSharedPtr(*Exp2DH1);
}
}
else
{
MultiRegions::ExpList1DSharedPtr Exp1D;
Exp1D = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(*mesh);
Exp[0] = Exp1D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList1D>
::AllocateSharedPtr(*Exp1D);
}
}
}
break;
case 2:
{
SpatialDomains::MeshGraph2DSharedPtr mesh;
if(!(mesh = boost::dynamic_pointer_cast<
SpatialDomains::MeshGraph2D>(graphShPt)))
{
ASSERTL0(false,"Dynamic cast failed");
}
ASSERTL0(fielddef[0]->m_numHomogeneousDir <= 1,"NumHomogeneousDir is only set up for 1");
if(fielddef[0]->m_numHomogeneousDir == 1)
{
MultiRegions::ExpList3DHomogeneous1DSharedPtr Exp3DH1;
// Define Homogeneous expansion
int nplanes = fielddef[0]->m_numModes[2];
// choose points to be at evenly spaced points at
// nplanes + 1 points
const LibUtilities::PointsKey Pkey(nplanes+1,LibUtilities::ePolyEvenlySpaced);
const LibUtilities::BasisKey Bkey(fielddef[0]->m_basis[2],nplanes,Pkey);
NekDouble lz = fielddef[0]->m_homogeneousLengths[0];
Exp3DH1 = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(Bkey,lz,useFFT,*mesh);
Exp[0] = Exp3DH1;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3DHomogeneous1D>::AllocateSharedPtr(*Exp3DH1);
}
}
else
{
MultiRegions::ExpList2DSharedPtr Exp2D;
Exp2D = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*mesh);
Exp[0] = Exp2D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList2D>
::AllocateSharedPtr(*Exp2D);
}
}
}
break;
case 3:
{
SpatialDomains::MeshGraph3DSharedPtr mesh;
if(!(mesh = boost::dynamic_pointer_cast<
SpatialDomains::MeshGraph3D>(graphShPt)))
{
ASSERTL0(false,"Dynamic cast failed");
}
MultiRegions::ExpList3DSharedPtr Exp3D;
Exp3D = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*mesh);
Exp[0] = Exp3D;
for(i = 1; i < nfields; ++i)
{
Exp[i] = MemoryManager<MultiRegions::ExpList3D>
::AllocateSharedPtr(*Exp3D);
}
}
break;
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
for(j = 0; j < nfields; ++j)
{
for(int i = 0; i < fielddata.size(); ++i)
{
Exp[j]->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
fielddef [i]->m_fields[j]);
}
Exp[j]->BwdTrans(Exp[j]->GetCoeffs(),Exp[j]->UpdatePhys());
}
//----------------------------------------------
//----------------------------------------------
// Write solution
//string outname(strtok(argv[n],"."));
//outname += ".vtu";
ofstream outfile(fname.c_str());
cout << "Writing file: " << fname;
Exp[0]->WriteVtkHeader(outfile);
cout << ".";
// For each field write out field data for each expansion.
for(i = 0; i < Exp[0]->GetNumElmts(); ++i)
{
Exp[0]->WriteVtkPieceHeader(outfile,i);
// For this expansion, write out each field.
for(j = 0; j < Exp.num_elements(); ++j)
{
Exp[j]->WriteVtkPieceData(outfile,i, fielddef[0]->m_fields[j]);
}
Exp[0]->WriteVtkPieceFooter(outfile,i);
cout << ".";
}
Exp[0]->WriteVtkFooter(outfile);
cout << "Done " << endl;
//----------------------------------------------
}
return 0;
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2012 Vladimir Jimenez
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*** Flag Reset Timer Details ***
Author:
Vladimir Jimenez (allejo)
Description:
Plugin will reset all unused flags except for team flags on a CTF map after a
certain amount of seconds. Plugin will also reset all unused flags except on a
FFA map after a certain amount of seconds. Plugin has one parameter when being
loaded.
-loadplugin /path/to/flagResetTimer.so,<time in minutes>
Slash Commands:
/flagresetunused
/frsettime <time in minutes>
/frcurrenttime
License:
BSD
Version:
2.0
*/
#include "bzfsAPI.h"
#include "plugin_utils.h"
#define TOTAL_CTF_TEAMS 4
int timeLimitMinutes = 5;
std::string gameStyle = "ffa";
double nextReset = 0;
class flagResetTimerHandler : public bz_Plugin , public bz_CustomSlashCommandHandler
{
public:
virtual const char* Name (){return "Flag Reset Timer";}
virtual void Init (const char* config);
virtual void Event(bz_EventData *eventData);
virtual void Cleanup ();
virtual bool SlashCommand (int playerID, bz_ApiString, bz_ApiString, bz_APIStringList*);
};
BZ_PLUGIN(flagResetTimerHandler);
unsigned int getNumTeams()
{
return TOTAL_CTF_TEAMS - (!bz_getTeamPlayerLimit(eRedTeam) +
!bz_getTeamPlayerLimit(eGreenTeam) +
!bz_getTeamPlayerLimit(eBlueTeam) +
!bz_getTeamPlayerLimit(ePurpleTeam));
}
double ConvertToInteger(std::string msg){
int msglength = (int)msg.length();
if (msglength > 0 && msglength < 4){
double msgvalue = 0;
double tens = 1;
for ( int i = (msglength - 1); i >= 0; i-- ){
if (msg[i] < '0' || msg[i] > '9')
return 0;
tens *= 10;
msgvalue += (((double)msg[i] - '0') / 10) * tens;
}
if (msgvalue >= 1 && msgvalue <= 120)
return msgvalue;
}
return 0;
}
void flagResetTimerHandler::Event(bz_EventData *eventData)
{
switch (eventData->eventType)
{
case bz_eTickEvent:
{
double timeLimitSeconds = timeLimitMinutes*60;
std::string flagname = bz_getName(0).c_str();
if(flagname=="R*" || flagname=="G*" || flagname=="B*" || flagname=="P*"){
gameStyle = "ctf";
}
if(nextReset<bz_getCurrentTime()){
if(gameStyle=="ctf"){
for(unsigned int i = getNumTeams(); i < bz_getNumFlags(); i++){
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
else{
for(unsigned int i = 0; i < bz_getNumFlags(); i++){
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
nextReset = bz_getCurrentTime()+timeLimitSeconds;
}
}
break;
default:break;
}
}
bool flagResetTimerHandler::SlashCommand (int playerID, bz_ApiString _command, bz_ApiString _message, bz_APIStringList *params)
{
std::string command = _command.c_str();
std::string message = _message.c_str();
bz_BasePlayerRecord *playerdata;
playerdata = bz_getPlayerByIndex(playerID);
if(command == "flagresetunused" && (bz_hasPerm(playerID, "flagMaster")||bz_hasPerm(playerID, "FLAGMASTER"))){
if(gameStyle=="ctf"){
for(unsigned int i = getNumTeams(); i < bz_getNumFlags(); i++){
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
else{
for(unsigned int i = 0; i < bz_getNumFlags(); i++){
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
nextReset = bz_getCurrentTime()+(timeLimitMinutes*60);
return 1;
}
else if(command == "frsettime" && (bz_hasPerm(playerID, "flagMaster")||bz_hasPerm(playerID, "FLAGMASTER"))){
double invalue = ConvertToInteger(message);
if (invalue > 0){
timeLimitMinutes=invalue;
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "Flag reset time has been set to %i minutes by %s.", timeLimitMinutes,playerdata->callsign.c_str());
nextReset = bz_getCurrentTime()+(timeLimitMinutes*60);
}
else{
bz_sendTextMessagef (BZ_SERVER, playerID, "Flag reset time invalid: must be between 1 and 120 minutes.");
}
return 1;
}
else if(command == "frcurrenttime"){
bz_sendTextMessagef (BZ_SERVER, playerID, "Current flag reset time is set to: %i minute(s).",timeLimitMinutes);
}
else{
bz_sendTextMessage(BZ_SERVER,playerID,"You do not have the permission to run the flag reset commands.");
}
bz_freePlayerRecord(playerdata);
return 1;
}
void flagResetTimerHandler::Init(const char* commandLine)
{
bz_debugMessage(4,"flagResetTimer plugin loaded");
Register(bz_eTickEvent);
bz_registerCustomSlashCommand("flagresetunused", this);
bz_registerCustomSlashCommand("frsettime", this);
bz_registerCustomSlashCommand("frcurrenttime", this);
if(&commandLine[0] != "" ){
timeLimitMinutes=atoi(&commandLine[0]);
}
else{
timeLimitMinutes=5;
}
}
void flagResetTimerHandler::Cleanup(void)
{
Flush();
bz_removeCustomSlashCommand("flagresetunused");
bz_removeCustomSlashCommand("frsetttime");
bz_removeCustomSlashCommand("frcurrenttime");
bz_debugMessage(4,"flagResetTimer plugin unloaded");
}
<commit_msg>Fixed annoying alignments<commit_after>/*
Copyright (c) 2012 Vladimir Jimenez
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. 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.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*** Flag Reset Timer Details ***
Author:
Vladimir Jimenez (allejo)
Description:
Plugin will reset all unused flags except for team flags on a CTF map after a
certain amount of seconds. Plugin will also reset all unused flags except on a
FFA map after a certain amount of seconds. Plugin has one parameter when being
loaded.
-loadplugin /path/to/flagResetTimer.so,<time in minutes>
Slash Commands:
/flagresetunused
/frsettime <time in minutes>
/frcurrenttime
License:
BSD
Version:
2.0
*/
#include "bzfsAPI.h"
#include "plugin_utils.h"
#define TOTAL_CTF_TEAMS 4
int timeLimitMinutes = 5;
std::string gameStyle = "ffa";
double nextReset = 0;
class flagResetTimerHandler : public bz_Plugin , public bz_CustomSlashCommandHandler
{
public:
virtual const char* Name (){return "Flag Reset Timer";}
virtual void Init (const char* config);
virtual void Event(bz_EventData *eventData);
virtual void Cleanup ();
virtual bool SlashCommand (int playerID, bz_ApiString, bz_ApiString, bz_APIStringList*);
};
BZ_PLUGIN(flagResetTimerHandler);
unsigned int getNumTeams()
{
return TOTAL_CTF_TEAMS - (!bz_getTeamPlayerLimit(eRedTeam) +
!bz_getTeamPlayerLimit(eGreenTeam) +
!bz_getTeamPlayerLimit(eBlueTeam) +
!bz_getTeamPlayerLimit(ePurpleTeam));
}
double ConvertToInteger(std::string msg)
{
int msglength = (int)msg.length();
if (msglength > 0 && msglength < 4)
{
double msgvalue = 0;
double tens = 1;
for ( int i = (msglength - 1); i >= 0; i-- )
{
if (msg[i] < '0' || msg[i] > '9')
return 0;
tens *= 10;
msgvalue += (((double)msg[i] - '0') / 10) * tens;
}
if (msgvalue >= 1 && msgvalue <= 120)
return msgvalue;
}
return 0;
}
void flagResetTimerHandler::Event(bz_EventData *eventData)
{
switch (eventData->eventType)
{
case bz_eTickEvent:
{
double timeLimitSeconds = timeLimitMinutes*60;
std::string flagname = bz_getName(0).c_str();
if(flagname=="R*" || flagname=="G*" || flagname=="B*" || flagname=="P*")
{
gameStyle = "ctf";
}
if(nextReset<bz_getCurrentTime())
{
if(gameStyle=="ctf")
{
for(unsigned int i = getNumTeams(); i < bz_getNumFlags(); i++)
{
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
else
{
for(unsigned int i = 0; i < bz_getNumFlags(); i++)
{
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
nextReset = bz_getCurrentTime()+timeLimitSeconds;
}
}
break;
default:break;
}
}
bool flagResetTimerHandler::SlashCommand (int playerID, bz_ApiString _command, bz_ApiString _message, bz_APIStringList *params)
{
std::string command = _command.c_str();
std::string message = _message.c_str();
bz_BasePlayerRecord *playerdata;
playerdata = bz_getPlayerByIndex(playerID);
if(command == "flagresetunused" && (bz_hasPerm(playerID, "flagMaster")||bz_hasPerm(playerID, "FLAGMASTER")))
{
if(gameStyle=="ctf")
{
for(unsigned int i = getNumTeams(); i < bz_getNumFlags(); i++)
{
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
else
{
for(unsigned int i = 0; i < bz_getNumFlags(); i++)
{
if(bz_flagPlayer(i)==-1)
bz_resetFlag(i);
}
}
nextReset = bz_getCurrentTime()+(timeLimitMinutes*60);
return 1;
}
else if(command == "frsettime" && (bz_hasPerm(playerID, "flagMaster")||bz_hasPerm(playerID, "FLAGMASTER")))
{
double invalue = ConvertToInteger(message);
if (invalue > 0)
{
timeLimitMinutes=invalue;
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "Flag reset time has been set to %i minutes by %s.", timeLimitMinutes,playerdata->callsign.c_str());
nextReset = bz_getCurrentTime()+(timeLimitMinutes*60);
}
else
{
bz_sendTextMessagef (BZ_SERVER, playerID, "Flag reset time invalid: must be between 1 and 120 minutes.");
}
return 1;
}
else if(command == "frcurrenttime")
{
bz_sendTextMessagef (BZ_SERVER, playerID, "Current flag reset time is set to: %i minute(s).",timeLimitMinutes);
}
else
{
bz_sendTextMessage(BZ_SERVER,playerID,"You do not have the permission to run the flag reset commands.");
}
bz_freePlayerRecord(playerdata);
return 1;
}
void flagResetTimerHandler::Init(const char* commandLine)
{
bz_debugMessage(4,"flagResetTimer plugin loaded");
Register(bz_eTickEvent);
bz_registerCustomSlashCommand("flagresetunused", this);
bz_registerCustomSlashCommand("frsettime", this);
bz_registerCustomSlashCommand("frcurrenttime", this);
if(&commandLine[0] != "" )
{
timeLimitMinutes=atoi(&commandLine[0]);
}
else
{
timeLimitMinutes=5;
}
}
void flagResetTimerHandler::Cleanup(void)
{
Flush();
bz_removeCustomSlashCommand("flagresetunused");
bz_removeCustomSlashCommand("frsetttime");
bz_removeCustomSlashCommand("frcurrenttime");
bz_debugMessage(4,"flagResetTimer plugin unloaded");
}
<|endoftext|> |
<commit_before>// $Header$
#include "BoxSet.h"
#include <TRandom.h>
#include <TBuffer3D.h>
#include <TBuffer3DTypes.h>
#include <TVirtualPad.h>
#include <TVirtualViewer3D.h>
using namespace Reve;
/**************************************************************************/
// Box
/**************************************************************************/
Box::Box(Color_t col)
{
Reve::ColorFromIdx(col, color);
}
Box::Box(Color_t col, Float_t* p)
{
Reve::ColorFromIdx(col, color);
memcpy(vertices, p, 24*sizeof(Float_t));
}
Box::Box(Color_t col, Float_t x, Float_t y, Float_t z,
Float_t dx, Float_t dy, Float_t dz)
{
Reve::ColorFromIdx(col, color);
MakeAxisAlignedBox(x, y, z, dx, dy, dz);
}
Box::Box(TRandom& rnd, Float_t origin, Float_t size)
{
Reve::ColorFromIdx(Int_t(30*rnd.Rndm()), color);
Float_t x = 2*origin*(rnd.Rndm() - 0.5);
Float_t y = 2*origin*(rnd.Rndm() - 0.5);
Float_t z = 2*origin*(rnd.Rndm() - 0.5);
Float_t dx = 2*size*(rnd.Rndm() - 0.5);
Float_t dy = 2*size*(rnd.Rndm() - 0.5);
Float_t dz = 2*size*(rnd.Rndm() - 0.5);
MakeAxisAlignedBox(x, y, z, dx, dy, dz);
}
void Box::MakeAxisAlignedBox(Float_t x, Float_t y, Float_t z,
Float_t dx, Float_t dy, Float_t dz)
{
Float_t* p = vertices;
//bottom
p[0] = x - dx; p[1] = y + dy, p[2] = z - dz; p += 3;
p[0] = x + dx; p[1] = y + dy, p[2] = z - dz; p += 3;
p[0] = x + dx; p[1] = y - dy, p[2] = z - dz; p += 3;
p[0] = x - dx; p[1] = y - dy, p[2] = z - dz; p += 3;
//top
p[0] = x - dx; p[1] = y + dy, p[2] = z + dz; p += 3;
p[0] = x + dx; p[1] = y + dy, p[2] = z + dz; p += 3;
p[0] = x + dx; p[1] = y - dy, p[2] = z + dz; p += 3;
p[0] = x - dx; p[1] = y - dy, p[2] = z + dz;
}
//______________________________________________________________________
// BoxSet
//
ClassImp(BoxSet)
BoxSet::BoxSet(const Text_t* n, const Text_t* t) :
RenderElement(fDefaultColor),
TNamed(n, t),
fRenderMode (RM_AsIs)
{}
/**************************************************************************/
void BoxSet::ComputeBBox()
{
if(fBoxes.empty()) {
#if ROOT_VERSION_CODE <= ROOT_VERSION(5,11,2)
bbox_zero();
#else
BBoxZero();
#endif
return;
}
#if ROOT_VERSION_CODE <= ROOT_VERSION(5,11,2)
bbox_init();
#else
BBoxInit();
#endif
for(std::vector<Box>::iterator q=fBoxes.begin(); q!=fBoxes.end(); ++q) {
Float_t* p = q->vertices;
for(int i=0; i<8; ++i, p+=3)
#if ROOT_VERSION_CODE <= ROOT_VERSION(5,11,2)
bbox_check_point(p);
#else
BBoxCheckPoint(p);
#endif
}
// printf("%s BBox is x(%f,%f), y(%f,%f), z(%f,%f)\n", GetName(),
// fBBox[0], fBBox[1], fBBox[2], fBBox[3], fBBox[4], fBBox[5]);
}
void BoxSet::Paint(Option_t* /*option*/)
{
TBuffer3D buff(TBuffer3DTypes::kGeneric);
// Section kCore
buff.fID = this;
buff.fColor = 1;
buff.fTransparency = 0;
fHMTrans.SetBuffer3D(buff);
buff.SetSectionsValid(TBuffer3D::kCore);
Int_t reqSections = gPad->GetViewer3D()->AddObject(buff);
if (reqSections == TBuffer3D::kNone) {
// printf("BoxSet::Paint viewer was happy with Core buff3d.\n");
return;
}
if (reqSections & TBuffer3D::kRawSizes) {
Int_t nbPnts = fBoxes.size()*8;
Int_t nbSegs = fBoxes.size()*12;
Int_t nbPoly = fBoxes.size()*6;
if (!buff.SetRawSizes(nbPnts, 3*nbPnts, nbSegs, 3*nbSegs, nbPoly, nbPoly*6)) {
return;
}
buff.SetSectionsValid(TBuffer3D::kRawSizes);
}
if ((reqSections & TBuffer3D::kRaw) && buff.SectionsValid(TBuffer3D::kRawSizes)) {
// Points
Int_t pidx = 0;
for (std::vector<Box>::iterator i=fBoxes.begin(); i!=fBoxes.end(); ++i) {
for (Int_t k=0; k<24; ++k) {
buff.fPnts[pidx] = (*i).vertices[k];
pidx++;
}
}
Int_t c = 2; // color; !!! wrong
Int_t eoff; // polygon or segment offset in fPols and fSegs array
Int_t voff; // vertex offset
Int_t soff; // offset in counting segments
Int_t nspp = 4; // number of segments per polygon
// Segments & Polygons
for (Int_t q = 0; q < (Int_t)fBoxes.size(); ++q) {
eoff = q*36;
soff = q*12;
voff = q*8;
//bottom
buff.fSegs[ 0 + eoff] = c; buff.fSegs[ 1 + eoff] = 0 + voff; buff.fSegs[ 2 + eoff] = 1 + voff;
buff.fSegs[ 3 + eoff] = c; buff.fSegs[ 4 + eoff] = 1 + voff; buff.fSegs[ 5 + eoff] = 2 + voff;
buff.fSegs[ 6 + eoff] = c; buff.fSegs[ 7 + eoff] = 2 + voff; buff.fSegs[ 8 + eoff] = 3 + voff;
buff.fSegs[ 9 + eoff] = c; buff.fSegs[10 + eoff] = 3 + voff; buff.fSegs[11 + eoff] = 0 + voff;
// top
buff.fSegs[12 + eoff] = c; buff.fSegs[13 + eoff] = 4 + voff; buff.fSegs[14 + eoff] = 5 + voff;
buff.fSegs[15 + eoff] = c; buff.fSegs[16 + eoff] = 5 + voff; buff.fSegs[17 + eoff] = 6 + voff;
buff.fSegs[18 + eoff] = c; buff.fSegs[19 + eoff] = 6 + voff; buff.fSegs[20 + eoff] = 7 + voff;
buff.fSegs[21 + eoff] = c; buff.fSegs[22 + eoff] = 7 + voff; buff.fSegs[23 + eoff] = 4 + voff;
//sides
buff.fSegs[24 + eoff] = c; buff.fSegs[25 + eoff] = 0 + voff; buff.fSegs[26 + eoff] = 4 + voff;
buff.fSegs[27 + eoff] = c; buff.fSegs[28 + eoff] = 1 + voff; buff.fSegs[29 + eoff] = 5 + voff;
buff.fSegs[30 + eoff] = c; buff.fSegs[31 + eoff] = 2 + voff; buff.fSegs[32 + eoff] = 6 + voff;
buff.fSegs[33 + eoff] = c; buff.fSegs[34 + eoff] = 3 + voff; buff.fSegs[35 + eoff] = 7 + voff;
buff.fPols[ 0 + eoff] = c; buff.fPols[ 1 + eoff] = nspp;
buff.fPols[ 2 + eoff] = 0 + soff; buff.fPols[ 3 + eoff] = 9 + soff;
buff.fPols[ 4 + eoff] = 4 + soff; buff.fPols[ 5 + eoff] = 8 + soff;
buff.fPols[ 6 + eoff] = c; buff.fPols[ 7 + eoff] = nspp;
buff.fPols[ 8 + eoff] = 1 + soff; buff.fPols[ 9 + eoff] = 10 + soff;
buff.fPols[10 + eoff] = 5 + soff; buff.fPols[11 + eoff] = 9 + soff;
buff.fPols[12 + eoff] = c; buff.fPols[13 + eoff] = nspp;
buff.fPols[14 + eoff] = 2 + soff; buff.fPols[15 + eoff] = 11 + soff;
buff.fPols[16 + eoff] = 6 + soff; buff.fPols[17 + eoff] = 10 + soff;
buff.fPols[18 + eoff] = c; buff.fPols[19 + eoff] = nspp;
buff.fPols[20 + eoff] = 3 + soff; buff.fPols[21 + eoff] = 8 + soff;
buff.fPols[22 + eoff] = 7 + soff; buff.fPols[23 + eoff] = 11 + soff;
buff.fPols[24 + eoff] = c; buff.fPols[25 + eoff] = nspp;
buff.fPols[26 + eoff] = 0 + soff; buff.fPols[27 + eoff] = 3 + soff;
buff.fPols[28 + eoff] = 2 + soff; buff.fPols[29 + eoff] = 1 + soff;
buff.fPols[30 + eoff] = c; buff.fPols[31 + eoff] = nspp;
buff.fPols[32 + eoff] = 4 + soff; buff.fPols[33 + eoff] = 5 + soff;
buff.fPols[34 + eoff] = 6 + soff; buff.fPols[35 + eoff] = 7 + soff;
}
buff.fColor = 2; // colors on polygons are ignored
buff.SetSectionsValid(TBuffer3D::kRaw);
}
gPad->GetViewer3D()->AddObject(buff);
}
/**************************************************************************/
void BoxSet::Test(Int_t nboxes)
{
TRandom rnd(0);
fBoxes.resize(nboxes);
for(Int_t i=0; i<nboxes; ++i) {
new (&fBoxes[i]) Box(rnd, 10, 2);
}
}
<commit_msg>Removed support for old ROOT versions.<commit_after>// $Header$
#include "BoxSet.h"
#include <TRandom.h>
#include <TBuffer3D.h>
#include <TBuffer3DTypes.h>
#include <TVirtualPad.h>
#include <TVirtualViewer3D.h>
using namespace Reve;
/**************************************************************************/
// Box
/**************************************************************************/
Box::Box(Color_t col)
{
Reve::ColorFromIdx(col, color);
}
Box::Box(Color_t col, Float_t* p)
{
Reve::ColorFromIdx(col, color);
memcpy(vertices, p, 24*sizeof(Float_t));
}
Box::Box(Color_t col, Float_t x, Float_t y, Float_t z,
Float_t dx, Float_t dy, Float_t dz)
{
Reve::ColorFromIdx(col, color);
MakeAxisAlignedBox(x, y, z, dx, dy, dz);
}
Box::Box(TRandom& rnd, Float_t origin, Float_t size)
{
Reve::ColorFromIdx(Int_t(30*rnd.Rndm()), color);
Float_t x = 2*origin*(rnd.Rndm() - 0.5);
Float_t y = 2*origin*(rnd.Rndm() - 0.5);
Float_t z = 2*origin*(rnd.Rndm() - 0.5);
Float_t dx = 2*size*(rnd.Rndm() - 0.5);
Float_t dy = 2*size*(rnd.Rndm() - 0.5);
Float_t dz = 2*size*(rnd.Rndm() - 0.5);
MakeAxisAlignedBox(x, y, z, dx, dy, dz);
}
void Box::MakeAxisAlignedBox(Float_t x, Float_t y, Float_t z,
Float_t dx, Float_t dy, Float_t dz)
{
Float_t* p = vertices;
//bottom
p[0] = x - dx; p[1] = y + dy; p[2] = z - dz; p += 3;
p[0] = x + dx; p[1] = y + dy; p[2] = z - dz; p += 3;
p[0] = x + dx; p[1] = y - dy; p[2] = z - dz; p += 3;
p[0] = x - dx; p[1] = y - dy; p[2] = z - dz; p += 3;
//top
p[0] = x - dx; p[1] = y + dy; p[2] = z + dz; p += 3;
p[0] = x + dx; p[1] = y + dy; p[2] = z + dz; p += 3;
p[0] = x + dx; p[1] = y - dy; p[2] = z + dz; p += 3;
p[0] = x - dx; p[1] = y - dy; p[2] = z + dz;
}
//______________________________________________________________________
// BoxSet
//
ClassImp(BoxSet)
BoxSet::BoxSet(const Text_t* n, const Text_t* t) :
RenderElement(fDefaultColor),
TNamed(n, t),
fRenderMode (RM_AsIs)
{}
/**************************************************************************/
void BoxSet::ComputeBBox()
{
if(fBoxes.empty()) {
BBoxZero();
return;
}
BBoxInit();
for(std::vector<Box>::iterator q=fBoxes.begin(); q!=fBoxes.end(); ++q) {
Float_t* p = q->vertices;
for(int i=0; i<8; ++i, p+=3)
BBoxCheckPoint(p);
}
// printf("%s BBox is x(%f,%f), y(%f,%f), z(%f,%f)\n", GetName(),
// fBBox[0], fBBox[1], fBBox[2], fBBox[3], fBBox[4], fBBox[5]);
}
void BoxSet::Paint(Option_t* /*option*/)
{
TBuffer3D buff(TBuffer3DTypes::kGeneric);
// Section kCore
buff.fID = this;
buff.fColor = 1;
buff.fTransparency = 0;
fHMTrans.SetBuffer3D(buff);
buff.SetSectionsValid(TBuffer3D::kCore);
Int_t reqSections = gPad->GetViewer3D()->AddObject(buff);
if (reqSections == TBuffer3D::kNone) {
// printf("BoxSet::Paint viewer was happy with Core buff3d.\n");
return;
}
if (reqSections & TBuffer3D::kRawSizes) {
Int_t nbPnts = fBoxes.size()*8;
Int_t nbSegs = fBoxes.size()*12;
Int_t nbPoly = fBoxes.size()*6;
if (!buff.SetRawSizes(nbPnts, 3*nbPnts, nbSegs, 3*nbSegs, nbPoly, nbPoly*6)) {
return;
}
buff.SetSectionsValid(TBuffer3D::kRawSizes);
}
if ((reqSections & TBuffer3D::kRaw) && buff.SectionsValid(TBuffer3D::kRawSizes)) {
// Points
Int_t pidx = 0;
for (std::vector<Box>::iterator i=fBoxes.begin(); i!=fBoxes.end(); ++i) {
for (Int_t k=0; k<24; ++k) {
buff.fPnts[pidx] = (*i).vertices[k];
pidx++;
}
}
Int_t c = 2; // color; !!! wrong
Int_t eoff; // polygon or segment offset in fPols and fSegs array
Int_t voff; // vertex offset
Int_t soff; // offset in counting segments
Int_t nspp = 4; // number of segments per polygon
// Segments & Polygons
for (Int_t q = 0; q < (Int_t)fBoxes.size(); ++q) {
eoff = q*36;
soff = q*12;
voff = q*8;
//bottom
buff.fSegs[ 0 + eoff] = c; buff.fSegs[ 1 + eoff] = 0 + voff; buff.fSegs[ 2 + eoff] = 1 + voff;
buff.fSegs[ 3 + eoff] = c; buff.fSegs[ 4 + eoff] = 1 + voff; buff.fSegs[ 5 + eoff] = 2 + voff;
buff.fSegs[ 6 + eoff] = c; buff.fSegs[ 7 + eoff] = 2 + voff; buff.fSegs[ 8 + eoff] = 3 + voff;
buff.fSegs[ 9 + eoff] = c; buff.fSegs[10 + eoff] = 3 + voff; buff.fSegs[11 + eoff] = 0 + voff;
// top
buff.fSegs[12 + eoff] = c; buff.fSegs[13 + eoff] = 4 + voff; buff.fSegs[14 + eoff] = 5 + voff;
buff.fSegs[15 + eoff] = c; buff.fSegs[16 + eoff] = 5 + voff; buff.fSegs[17 + eoff] = 6 + voff;
buff.fSegs[18 + eoff] = c; buff.fSegs[19 + eoff] = 6 + voff; buff.fSegs[20 + eoff] = 7 + voff;
buff.fSegs[21 + eoff] = c; buff.fSegs[22 + eoff] = 7 + voff; buff.fSegs[23 + eoff] = 4 + voff;
//sides
buff.fSegs[24 + eoff] = c; buff.fSegs[25 + eoff] = 0 + voff; buff.fSegs[26 + eoff] = 4 + voff;
buff.fSegs[27 + eoff] = c; buff.fSegs[28 + eoff] = 1 + voff; buff.fSegs[29 + eoff] = 5 + voff;
buff.fSegs[30 + eoff] = c; buff.fSegs[31 + eoff] = 2 + voff; buff.fSegs[32 + eoff] = 6 + voff;
buff.fSegs[33 + eoff] = c; buff.fSegs[34 + eoff] = 3 + voff; buff.fSegs[35 + eoff] = 7 + voff;
buff.fPols[ 0 + eoff] = c; buff.fPols[ 1 + eoff] = nspp;
buff.fPols[ 2 + eoff] = 0 + soff; buff.fPols[ 3 + eoff] = 9 + soff;
buff.fPols[ 4 + eoff] = 4 + soff; buff.fPols[ 5 + eoff] = 8 + soff;
buff.fPols[ 6 + eoff] = c; buff.fPols[ 7 + eoff] = nspp;
buff.fPols[ 8 + eoff] = 1 + soff; buff.fPols[ 9 + eoff] = 10 + soff;
buff.fPols[10 + eoff] = 5 + soff; buff.fPols[11 + eoff] = 9 + soff;
buff.fPols[12 + eoff] = c; buff.fPols[13 + eoff] = nspp;
buff.fPols[14 + eoff] = 2 + soff; buff.fPols[15 + eoff] = 11 + soff;
buff.fPols[16 + eoff] = 6 + soff; buff.fPols[17 + eoff] = 10 + soff;
buff.fPols[18 + eoff] = c; buff.fPols[19 + eoff] = nspp;
buff.fPols[20 + eoff] = 3 + soff; buff.fPols[21 + eoff] = 8 + soff;
buff.fPols[22 + eoff] = 7 + soff; buff.fPols[23 + eoff] = 11 + soff;
buff.fPols[24 + eoff] = c; buff.fPols[25 + eoff] = nspp;
buff.fPols[26 + eoff] = 0 + soff; buff.fPols[27 + eoff] = 3 + soff;
buff.fPols[28 + eoff] = 2 + soff; buff.fPols[29 + eoff] = 1 + soff;
buff.fPols[30 + eoff] = c; buff.fPols[31 + eoff] = nspp;
buff.fPols[32 + eoff] = 4 + soff; buff.fPols[33 + eoff] = 5 + soff;
buff.fPols[34 + eoff] = 6 + soff; buff.fPols[35 + eoff] = 7 + soff;
}
buff.fColor = 2; // colors on polygons are ignored
buff.SetSectionsValid(TBuffer3D::kRaw);
}
gPad->GetViewer3D()->AddObject(buff);
}
/**************************************************************************/
void BoxSet::Test(Int_t nboxes)
{
TRandom rnd(0);
fBoxes.resize(nboxes);
for(Int_t i=0; i<nboxes; ++i) {
new (&fBoxes[i]) Box(rnd, 10, 2);
}
}
<|endoftext|> |
<commit_before>//===- AsmWriterEmitter.cpp - Generate an assembly writer -----------------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This tablegen backend is emits an assembly printer for the current target.
// Note that this is currently fairly skeletal, but will grow over time.
//
//===----------------------------------------------------------------------===//
#include "AsmWriterEmitter.h"
#include "CodeGenTarget.h"
#include "Record.h"
#include <ostream>
using namespace llvm;
static bool isIdentChar(char C) {
return (C >= 'a' && C <= 'z') ||
(C >= 'A' && C <= 'Z') ||
(C >= '0' && C <= '9') ||
C == '_';
}
void AsmWriterEmitter::run(std::ostream &O) {
EmitSourceFileHeader("Assembly Writer Source Fragment", O);
O << "namespace llvm {\n\n";
CodeGenTarget Target;
Record *AsmWriter = Target.getAsmWriter();
std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
unsigned Variant = AsmWriter->getValueAsInt("Variant");
O <<
"/// printInstruction - This method is automatically generated by tablegen\n"
"/// from the instruction set description. This method returns true if the\n"
"/// machine instruction was sufficiently described to print it, otherwise\n"
"/// it returns false.\n"
"bool " << Target.getName() << ClassName
<< "::printInstruction(const MachineInstr *MI) {\n";
O << " switch (MI->getOpcode()) {\n"
" default: return false;\n";
std::string Namespace = Target.inst_begin()->second.Namespace;
bool inVariant = false; // True if we are inside a {.|.|.} region.
for (CodeGenTarget::inst_iterator I = Target.inst_begin(),
E = Target.inst_end(); I != E; ++I)
if (!I->second.AsmString.empty()) {
const std::string &AsmString = I->second.AsmString;
O << " case " << Namespace << "::" << I->first << ": O ";
std::string::size_type LastEmitted = 0;
while (LastEmitted != AsmString.size()) {
std::string::size_type DollarPos =
AsmString.find_first_of("${|}", LastEmitted);
if (DollarPos == std::string::npos) DollarPos = AsmString.size();
// Emit a constant string fragment.
if (DollarPos != LastEmitted) {
// TODO: this should eventually handle escaping.
O << " << \"" << std::string(AsmString.begin()+LastEmitted,
AsmString.begin()+DollarPos) << "\"";
LastEmitted = DollarPos;
} else if (AsmString[DollarPos] == '{') {
if (inVariant)
throw "Nested variants found for instruction '" + I->first + "'!";
LastEmitted = DollarPos+1;
inVariant = true; // We are now inside of the variant!
for (unsigned i = 0; i != Variant; ++i) {
// Skip over all of the text for an irrelevant variant here. The
// next variant starts at |, or there may not be text for this
// variant if we see a }.
std::string::size_type NP =
AsmString.find_first_of("|}", LastEmitted);
if (NP == std::string::npos)
throw "Incomplete variant for instruction '" + I->first + "'!";
LastEmitted = NP+1;
if (AsmString[NP] == '}') {
inVariant = false; // No text for this variant.
break;
}
}
} else if (AsmString[DollarPos] == '|') {
if (!inVariant)
throw "'|' character found outside of a variant in instruction '"
+ I->first + "'!";
// Move to the end of variant list.
std::string::size_type NP = AsmString.find('}', LastEmitted);
if (NP == std::string::npos)
throw "Incomplete variant for instruction '" + I->first + "'!";
LastEmitted = NP+1;
inVariant = false;
} else if (AsmString[DollarPos] == '}') {
if (!inVariant)
throw "'}' character found outside of a variant in instruction '"
+ I->first + "'!";
LastEmitted = DollarPos+1;
inVariant = false;
} else if (DollarPos+1 != AsmString.size() &&
AsmString[DollarPos+1] == '$') {
O << " << '$'"; // "$$" -> $
} else {
// Get the name of the variable.
// TODO: should eventually handle ${foo}bar as $foo
std::string::size_type VarEnd = DollarPos+1;
while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd]))
++VarEnd;
std::string VarName(AsmString.begin()+DollarPos+1,
AsmString.begin()+VarEnd);
if (VarName.empty())
throw "Stray '$' in '" + I->first +
"' asm string, maybe you want $$?";
unsigned OpNo = I->second.getOperandNamed(VarName);
// If this is a two-address instruction and we are not accessing the
// 0th operand, remove an operand.
unsigned MIOp = I->second.OperandList[OpNo].MIOperandNo;
if (I->second.isTwoAddress && MIOp != 0) {
if (MIOp == 1)
throw "Should refer to operand #0 instead of #1 for two-address"
" instruction '" + I->first + "'!";
--MIOp;
}
O << "; " << I->second.OperandList[OpNo].PrinterMethodName
<< "(MI, " << MIOp << ", MVT::"
<< getName(I->second.OperandList[OpNo].Ty) << "); O ";
LastEmitted = VarEnd;
}
}
O << " << '\\n'; break;\n";
}
O << " }\n"
" return true;\n"
"}\n";
O << "} // End llvm namespace \n";
}
<commit_msg>Don't emit the method into the llvm namespace, let the #includer decide where it goes<commit_after>//===- AsmWriterEmitter.cpp - Generate an assembly writer -----------------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This tablegen backend is emits an assembly printer for the current target.
// Note that this is currently fairly skeletal, but will grow over time.
//
//===----------------------------------------------------------------------===//
#include "AsmWriterEmitter.h"
#include "CodeGenTarget.h"
#include "Record.h"
#include <ostream>
using namespace llvm;
static bool isIdentChar(char C) {
return (C >= 'a' && C <= 'z') ||
(C >= 'A' && C <= 'Z') ||
(C >= '0' && C <= '9') ||
C == '_';
}
void AsmWriterEmitter::run(std::ostream &O) {
EmitSourceFileHeader("Assembly Writer Source Fragment", O);
CodeGenTarget Target;
Record *AsmWriter = Target.getAsmWriter();
std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
unsigned Variant = AsmWriter->getValueAsInt("Variant");
O <<
"/// printInstruction - This method is automatically generated by tablegen\n"
"/// from the instruction set description. This method returns true if the\n"
"/// machine instruction was sufficiently described to print it, otherwise\n"
"/// it returns false.\n"
"bool " << Target.getName() << ClassName
<< "::printInstruction(const MachineInstr *MI) {\n";
O << " switch (MI->getOpcode()) {\n"
" default: return false;\n";
std::string Namespace = Target.inst_begin()->second.Namespace;
bool inVariant = false; // True if we are inside a {.|.|.} region.
for (CodeGenTarget::inst_iterator I = Target.inst_begin(),
E = Target.inst_end(); I != E; ++I)
if (!I->second.AsmString.empty()) {
const std::string &AsmString = I->second.AsmString;
O << " case " << Namespace << "::" << I->first << ": O ";
std::string::size_type LastEmitted = 0;
while (LastEmitted != AsmString.size()) {
std::string::size_type DollarPos =
AsmString.find_first_of("${|}", LastEmitted);
if (DollarPos == std::string::npos) DollarPos = AsmString.size();
// Emit a constant string fragment.
if (DollarPos != LastEmitted) {
// TODO: this should eventually handle escaping.
O << " << \"" << std::string(AsmString.begin()+LastEmitted,
AsmString.begin()+DollarPos) << "\"";
LastEmitted = DollarPos;
} else if (AsmString[DollarPos] == '{') {
if (inVariant)
throw "Nested variants found for instruction '" + I->first + "'!";
LastEmitted = DollarPos+1;
inVariant = true; // We are now inside of the variant!
for (unsigned i = 0; i != Variant; ++i) {
// Skip over all of the text for an irrelevant variant here. The
// next variant starts at |, or there may not be text for this
// variant if we see a }.
std::string::size_type NP =
AsmString.find_first_of("|}", LastEmitted);
if (NP == std::string::npos)
throw "Incomplete variant for instruction '" + I->first + "'!";
LastEmitted = NP+1;
if (AsmString[NP] == '}') {
inVariant = false; // No text for this variant.
break;
}
}
} else if (AsmString[DollarPos] == '|') {
if (!inVariant)
throw "'|' character found outside of a variant in instruction '"
+ I->first + "'!";
// Move to the end of variant list.
std::string::size_type NP = AsmString.find('}', LastEmitted);
if (NP == std::string::npos)
throw "Incomplete variant for instruction '" + I->first + "'!";
LastEmitted = NP+1;
inVariant = false;
} else if (AsmString[DollarPos] == '}') {
if (!inVariant)
throw "'}' character found outside of a variant in instruction '"
+ I->first + "'!";
LastEmitted = DollarPos+1;
inVariant = false;
} else if (DollarPos+1 != AsmString.size() &&
AsmString[DollarPos+1] == '$') {
O << " << '$'"; // "$$" -> $
} else {
// Get the name of the variable.
// TODO: should eventually handle ${foo}bar as $foo
std::string::size_type VarEnd = DollarPos+1;
while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd]))
++VarEnd;
std::string VarName(AsmString.begin()+DollarPos+1,
AsmString.begin()+VarEnd);
if (VarName.empty())
throw "Stray '$' in '" + I->first +
"' asm string, maybe you want $$?";
unsigned OpNo = I->second.getOperandNamed(VarName);
// If this is a two-address instruction and we are not accessing the
// 0th operand, remove an operand.
unsigned MIOp = I->second.OperandList[OpNo].MIOperandNo;
if (I->second.isTwoAddress && MIOp != 0) {
if (MIOp == 1)
throw "Should refer to operand #0 instead of #1 for two-address"
" instruction '" + I->first + "'!";
--MIOp;
}
O << "; " << I->second.OperandList[OpNo].PrinterMethodName
<< "(MI, " << MIOp << ", MVT::"
<< getName(I->second.OperandList[OpNo].Ty) << "); O ";
LastEmitted = VarEnd;
}
}
O << " << '\\n'; break;\n";
}
O << " }\n"
" return true;\n"
"}\n";
}
<|endoftext|> |
<commit_before>#include <TinyExtender.h>
#include "TinyWindow.h"
using namespace TinyWindow;
using namespace TinyExtender;
/**< loads a text file into a string buffer */
GLchar* FileToBuffer(const GLchar* path)
{
FILE* file = fopen(path, "rt"); // open a read only filestream
if (file == nullptr)
{
printf( "Error: cannot open file %s for reading \n", path );
return nullptr;
}
//get total byte in given file
fseek(file, 0, SEEK_END); //set the position indicator to the end of the file
GLuint FileLength = ftell(file);//get the current value of the position indicator in bytes
fseek(file, 0, SEEK_SET); //set the position indicator back to the beginning of the file
//allocate a file buffer and read the contents of the file
GLchar* buffer = new GLchar[FileLength + 1];
memset(buffer, 0, FileLength + 1);
fread(buffer, sizeof(GLchar), FileLength, file); //read from beginning to end of the file and load the data into the buffer
fclose(file);
return buffer;
}
/**< returns a handle to a shader program. returns 0 if failed */
GLuint LoadShader(const char* vertexSource, const char* fragmentSource)
{
GLuint vertexShaderHandle = 0;
GLuint fragmentShaderHandle = 0;
GLuint programHandle = 0;
GLint successful = false;
GLchar errorLog[512];
const char* vertexShaderSource = FileToBuffer(vertexSource);
const char* fragmentShaderSource = FileToBuffer(fragmentSource);
vertexShaderHandle = glCreateShader(gl_vertex_shader);//create a handle to the vertex shader
glShaderSource(vertexShaderHandle, 1, (const GLchar**)&vertexShaderSource, NULL);//give openGL the vertex shader source code
glCompileShader(vertexShaderHandle);//compile the vertex shader
glGetShaderiv(vertexShaderHandle, gl_compile_status, &successful);//check if the vertex shader compiled correctly
if (!successful)
{
//if not successful, get and print the error message
glGetShaderInfoLog(programHandle, sizeof(errorLog), 0, errorLog);
printf("%s \n", errorLog);
}
fragmentShaderHandle = glCreateShader(gl_fragment_shader);// create a handle to the pixel shader
glShaderSource(fragmentShaderHandle, 1, (const GLchar**)&fragmentShaderSource, NULL);// give OpenGL the fragment shader source code
glCompileShader(fragmentShaderHandle);//compile the fragment shader
glGetShaderiv(fragmentShaderHandle, gl_compile_status, &successful);//check if the fragment shader compiled correctly
if (!successful)
{
//if not successful, get and print the error message
glGetShaderInfoLog(programHandle, sizeof(errorLog), 0, errorLog);
printf("%s \n", errorLog);
}
programHandle = glCreateProgram();//create a handle to the shader program
glAttachShader(programHandle, vertexShaderHandle);//attach the vertex shader to the shader program
glAttachShader(programHandle, fragmentShaderHandle);//attach the fragment shader to the shader program
glLinkProgram(programHandle);//link the attached shaders together
glGetProgramiv(programHandle, openGL2_0::gl_link_status, &successful);//check if the shaders linked successfully
if (!successful)
{
//if not successful, get and print the error message
glGetProgramInfoLog(programHandle, sizeof(errorLog), 0, errorLog);
printf("%s \n", errorLog);
}
return programHandle;
}
int main()
{
windowManager* manager = new windowManager();
tWindow* window = manager->AddWindow("TinyExtender example");
InitializeExtentions();
GLuint programHandle = LoadShader("Example.vert", "Example.frag");
glPointSize(20.0f);
glClearColor(0.25f, 0.25f, 0.25f, 1.0f);
glUseProgram(programHandle);
while(!window->shouldClose)
{
manager->PollForEvents();
glDrawArrays(GL_POINTS, 0, 1);//I just need one point for this
window->SwapDrawBuffers();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glDeleteProgram(programHandle);
return 0;
}
<commit_msg>trying to fix issues with Example,<commit_after>#include <TinyExtender.h>
#include "TinyWindow.h"
#define NO_STDIO_REDIRECT
using namespace TinyWindow;
using namespace TinyExtender;
/**< loads a text file into a string buffer */
GLchar* FileToBuffer(const GLchar* path)
{
FILE* file = fopen(path, "rt"); // open a read only filestream
if (file == nullptr)
{
printf( "Error: cannot open file %s for reading \n", path );
return nullptr;
}
//get total byte in given file
fseek(file, 0, SEEK_END); //set the position indicator to the end of the file
GLuint FileLength = ftell(file);//get the current value of the position indicator in bytes
fseek(file, 0, SEEK_SET); //set the position indicator back to the beginning of the file
//allocate a file buffer and read the contents of the file
GLchar* buffer = new GLchar[FileLength + 1];
memset(buffer, 0, FileLength + 1);
fread(buffer, sizeof(GLchar), FileLength, file); //read from beginning to end of the file and load the data into the buffer
fclose(file);
return buffer;
}
/**< returns a handle to a shader program. returns 0 if failed */
GLuint LoadShader(const char* vertexSource, const char* fragmentSource)
{
GLuint vertexShaderHandle = 0;
GLuint fragmentShaderHandle = 0;
GLuint programHandle = 0;
GLint successful = false;
GLchar errorLog[512];
const char* vertexShaderSource = FileToBuffer(vertexSource);
const char* fragmentShaderSource = FileToBuffer(fragmentSource);
vertexShaderHandle = glCreateShader(gl_vertex_shader);//create a handle to the vertex shader
glShaderSource(vertexShaderHandle, 1, (const GLchar**)&vertexShaderSource, NULL);//give openGL the vertex shader source code
glCompileShader(vertexShaderHandle);//compile the vertex shader
glGetShaderiv(vertexShaderHandle, gl_compile_status, &successful);//check if the vertex shader compiled correctly
if (!successful)
{
//if not successful, get and print the error message
glGetShaderInfoLog(vertexShaderHandle, sizeof(errorLog), 0, errorLog);
printf("%s \n", errorLog);
}
fragmentShaderHandle = glCreateShader(gl_fragment_shader);// create a handle to the pixel shader
glShaderSource(fragmentShaderHandle, 1, (const GLchar**)&fragmentShaderSource, NULL);// give OpenGL the fragment shader source code
glCompileShader(fragmentShaderHandle);//compile the fragment shader
if (glGetShaderiv)
{
glGetShaderiv(fragmentShaderHandle, gl_compile_status, &successful);//check if the fragment shader compiled correctly
}
if (!successful)
{
//if not successful, get and print the error message
glGetShaderInfoLog(vertexShaderHandle, sizeof(errorLog), 0, errorLog);
printf("%s \n", errorLog);
}
programHandle = glCreateProgram();//create a handle to the shader program
glAttachShader(programHandle, vertexShaderHandle);//attach the vertex shader to the shader program
glAttachShader(programHandle, fragmentShaderHandle);//attach the fragment shader to the shader program
glLinkProgram(programHandle);//link the attached shaders together
glGetProgramiv(programHandle, gl_link_status, &successful);//check if the shaders linked successfully
if (!successful)
{
//if not successful, get and print the error message
glGetProgramInfoLog(programHandle, sizeof(errorLog), 0, errorLog);
printf("%s \n", errorLog);
}
return programHandle;
}
int main()
{
windowManager* manager = new windowManager();
tWindow* window = manager->AddWindow("TinyExtender example");
printf("poop \n");
InitializeExtentions();
GLuint programHandle = LoadShader("Example.vert", "Example.frag");
glPointSize(20.0f);
glClearColor(0.25f, 0.25f, 0.25f, 1.0f);
glUseProgram(programHandle);
while(!window->shouldClose)
{
manager->PollForEvents();
glDrawArrays(GL_POINTS, 0, 1);//I just need one point for this
window->SwapDrawBuffers();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
glDeleteProgram(programHandle);
return 0;
}
<|endoftext|> |
<commit_before> // Size of space
#define KSIZE 10
// Number of EOF used in final compression
#define MSIZE 5
#define MAX_ITER 100
#define TOL 1.0e-7
#define RANDOM_SEED 123456
#include <random>
#include <algorithm>
#include <mpi.h>
#include <iostream>
#include "usi_compression.h"
#include "read_timeseries_matrix.h"
#include "gamma_zero.h"
#include "find.h"
#include "theta_s.h"
#include "L_value.h"
#include "lanczos_correlation.h"
#include "gamma_s.h"
#include "reduction.h"
#include "reconstruction.h"
/**
Write description of function here.
The function should follow these comments.
Use of "brief" tag is optional. (no point to it)
The function arguments listed with "param" will be compared
to the declaration and verified.
@param[in] filename Filename (string)
@param[in] fields List of the fields to be extracted (vector of strings0
@return vector of concatenated field values
*/
int main(int argc, char *argv[])
//****************************************************************************80
//
// Purpose:
//
// Example of parallel NetCDF functionality
//
// Discussion:
//
// This program demonstrates parallel NetCDF functionality. It reads from
// a NetCDF file a specified, specified as the first and second arguments of
// the function.
//
// This is the first step toward implementing a compression backend which
// reads a NetCDF stream, and compresses the time series data in parallel
// using the approaches of Horenko, et al.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// Starting October 2013
//
// Author:
//
// William Sawyer (CSCS)
// Ben Cumming (CSCS)
//
// Reference:
//
// Horenko, Klein, Dolaptchiev, Schuette
// Automated Generation of Reduced Stochastic Weather Models I:
// simultaneous dimension and model reduction for time series analysis
// XXX
//
// Example execution:
//
// aprun -n 2 ./netcdf_get_data /project/csstaff/outputs/echam/echam6/echam_output/t31_196001.01_echam.nc seaice
//
{
//
// Input Argument Handling
//
if (argc <= 2) {
std::cout << "Usage: " << argv[0] << " <Filename>" << " <field name>" << std::endl;
exit(1);
}
std::string filename = argv[1];
std::vector<std::string> fields(argv+2, argv+argc); // only the first field is currently used
//
// Initialize MPI
//
MPI_Init ( &argc, &argv );
double time_at_start = MPI_Wtime(); // used for calculating running time of each part of the algorithm
int my_rank, mpi_processes;
MPI_Comm_rank( MPI_COMM_WORLD, &my_rank );
MPI_Comm_size( MPI_COMM_WORLD, &mpi_processes );
int processes_in_x;
int processes_in_y = 1;
for ( processes_in_x = mpi_processes; processes_in_x > processes_in_y; processes_in_x /= 2 ) { processes_in_y *= 2; }
const int iam_in_x = my_rank % processes_in_x;
const int iam_in_y = my_rank / processes_in_x;
std::cout << "Decomposition: processes_in_x " << processes_in_x << " processes_in_y " << processes_in_y << " iam x " << iam_in_x << " iam_in_y " << iam_in_y << std::endl;
if ( processes_in_x * processes_in_y != mpi_processes ) { std::cout << "mpi_processes " << mpi_processes << " not power of two; aborting " << std::endl; abort(); }
//
// Read NetCDF Data
//
int Xrows, Xcols, ncid_out, varid_out;
size_t *start, *count;
ScalarType* data = read_timeseries_matrix<ScalarType>( filename, fields, iam_in_x, iam_in_y, processes_in_x, processes_in_y, Xrows, Xcols, &start, &count, &ncid_out, &varid_out );
#if defined( USE_EIGEN )
Eigen::Map<MatrixXXrow> X(data,Xrows,Xcols); // Needs to be row-major to mirror NetCDF output
#elif defined( USE_MINLIN )
HostMatrix<ScalarType> X(Xrows,Xcols);
for(int i=0; i<Xrows; i++)
for(int j=0; j<Xcols; j++, data++)
X(i,j) = *data;
#endif
double time_after_reading_data = MPI_Wtime();
const int Ntl = Xrows; // number of values along direction that is
// compressed (observations in PCA)
const int nl = Xcols; // number of values along direction that is
// distributed on cores (parameters in PCA)
// we need the global nl to know the length needed for gamma_ind
int *nl_global = new int[sizeof(int)*mpi_processes];
int total_nl = 0;
MPI_Allgather( &nl, 1, MPI_INT, nl_global, 1, MPI_INT, MPI_COMM_WORLD);
for ( int rank=0; rank < mpi_processes; rank++ ) { total_nl += nl_global[rank]; }
std::vector<int> gamma_ind = gamma_zero(nl_global, my_rank, KSIZE ); // Needs to be generated in a consistent way for any PE configuration
// print out nl sizes of all processes (for debugging)
// std::cout << "nl sizes "; for ( int rank=0; rank < mpi_processes; rank++ ) { std::cout << nl_global[rank] << " "; }
// std::cout << std::endl;
delete[] nl_global;
GenericColMatrix theta(Ntl,KSIZE); // Time series means (one for each k), allocate outside loop
std::vector<GenericColMatrix> TT(KSIZE,GenericColMatrix(Ntl,1) ); // Eigenvectors: 1-each for each k
std::vector<GenericColMatrix> EOFs(KSIZE,GenericColMatrix(Ntl,MSIZE) ); // Eigenvectors: MSIZE eigenvectors for each k
std::vector<GenericColMatrix> Xreduced(KSIZE,GenericColMatrix(MSIZE, nl) ); // Reduced representation of X
GenericRowMatrix Xreconstructed(Ntl,nl); // Reconstructed time series
GenericRowMatrix Diff(Ntl,nl); // Reconstructed time series
ScalarType L_value_old = 1.0e19; // Very big value
ScalarType L_value_new;
#if defined( USE_EIGEN )
// initialize random seed used in lanczos algorithm
srand(RANDOM_SEED);
#endif
for ( int iter = 0; iter < MAX_ITER; iter++ ) {
theta_s<ScalarType>(gamma_ind, X, theta); // Determine X column means for each active state denoted by gamma_ind
L_value_new = L_value( gamma_ind, TT, X, theta );
if (!my_rank) std::cout << "L value after Theta calc " << L_value_new << std::endl;
// Not clear if there should be monotonic decrease here: new theta_s needs new TT, right?
// if ( iter > 0 ) { std::cout << "L value after theta determination " << L_value( gamma_ind, TT, X, theta ) << std::endl; }
for(int k = 0; k < KSIZE; k++) { // Principle Component Analysis
std::vector<int> Nonzeros = find( gamma_ind, k );
GenericColMatrix Xtranslated( Ntl, Nonzeros.size() ) ;
// if (!my_rank) std::cout << " For k = " << k << " nbr nonzeros " << Nonzeros.size() << std::endl;
for (int m = 0; m < Nonzeros.size() ; m++ ) // Translate X columns with mean value at new origin
{
GET_COLUMN(Xtranslated,m) = GET_COLUMN(X,Nonzeros[m]) - GET_COLUMN(theta,k) ;
}
// lanczos_correlation(Xtranslated.block(0,0,Ntl,Nonzeros.size()), 1, 1.0e-13, 50, TT[k], true);
bool success = lanczos_correlation(Xtranslated, 1, 1.0e-11, 50, TT[k], true);
}
L_value_new = L_value( gamma_ind, TT, X, theta );
if (!my_rank) std::cout << "L value after PCA " << L_value_new << std::endl;
gamma_s( X, theta, TT, gamma_ind );
L_value_new = L_value( gamma_ind, TT, X, theta );
if (!my_rank) std::cout << "L value after gamma minimization " << L_value_new << std::endl;
if ( L_value_new > L_value_old ) {
if (!my_rank) std::cout << "New L_value " << L_value_new << " larger than old: " << L_value_old << " aborting " << std::endl;
break;
}
else if ( (L_value_old - L_value_new) < L_value_new*TOL ) {
if (!my_rank) std::cout << " Converged: to tolerance " << TOL << " after " << iter << " iterations " << std::endl;
break;
}
else if ( iter+1 == MAX_ITER ) {
if (!my_rank) std::cout << " Reached maximum number of iterations " << MAX_ITER << " without convergence " << std::endl;
}
L_value_old = L_value_new;
}
//
// Do Compression With Best Clustering
//
theta_s<ScalarType>(gamma_ind, X, theta); // Determine X column means for each active state denoted by gamma_ind
for(int k = 0; k < KSIZE; k++) { // Principle Component Analysis
std::vector<int> Nonzeros = find( gamma_ind, k );
GenericColMatrix Xtranslated( Ntl, Nonzeros.size() ) ;
for (int m = 0; m < Nonzeros.size() ; m++ ) // Translate X columns with mean value at new origin
{
GET_COLUMN(Xtranslated,m) = GET_COLUMN(X,Nonzeros[m]) - GET_COLUMN(theta,k); // bsxfun(@minus,X(:,Nonzeros),Theta(:,k))
}
// lanczos_correlation(Xtranslated.block(0,0,Ntl,Nonzeros.size()), MSIZE, 1.0e-8, Ntl, EOFs[k], true);
lanczos_correlation(Xtranslated, MSIZE, 1.0e-8, Ntl, EOFs[k], true);
}
L_value_new = L_value( gamma_ind, EOFs, X, theta );
if (!my_rank) std::cout << "L value final " << L_value_new << std::endl;
// Calculated the reduced representation of X
reduction<ScalarType>( gamma_ind, EOFs, X, theta, Xreduced );
double time_after_compression = MPI_Wtime();
// Calculate the reconstructed X
reconstruction<ScalarType>( gamma_ind, EOFs, theta, Xreduced, Xreconstructed );
ScalarType value = 0.0;
ScalarType output;
for (int l = 0; l < nl; l++ ) {
#if defined( USE_EIGEN )
Diff.col(l) = Xreconstructed.col(l)-X.col(l);
ScalarType colnorm = (Xreconstructed.col(l)-X.col(l)).norm(); value += colnorm*colnorm;
#elif defined( USE_MINLIN )
// TODO: MINLIN implementation
#else
ERROR: must USE_EIGEN or USE_MINLIN
#endif
}
MPI_Allreduce( &value, &output, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD );
double time_for_solve = time_after_compression - time_after_reading_data;
double time_for_input = time_after_reading_data - time_at_start;
double max_time_for_solve, max_time_for_input;
MPI_Allreduce( &time_for_solve, &max_time_for_solve, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );
MPI_Allreduce( &time_for_input, &max_time_for_input, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );
double size_uncompressed = (double) (Ntl * total_nl);
double size_compressed = (double) (KSIZE * ( MSIZE + 1) *( Ntl + total_nl ) );
if (!my_rank) std::cout << "Max time for input " << max_time_for_input << std::endl;
if (!my_rank) std::cout << "Max time for solve " << max_time_for_solve << std::endl;
if (!my_rank) std::cout << "Compression ratio " << size_uncompressed / size_compressed << std::endl;
if (!my_rank) std::cout << "Root mean square error " << sqrt( output ) << std::endl;
int retval;
// OUTPUT
if ((retval = nc_put_vara_double(ncid_out, varid_out, start, count, Xreconstructed.data() ))) ERR(retval);
// OUTPUT FILE will be closed in main program
if ((retval = nc_close(ncid_out))) ERR(retval);
retval = 0;
if (!my_rank) std::cout << "retval " << retval << std::endl;
//
// Terminate MPI.
//
MPI_Finalize();
return 0;
}
<commit_msg>more code cleanup, no functionality changes<commit_after> // Size of space
#define KSIZE 10
// Number of EOF used in final compression
#define MSIZE 5
#define MAX_ITER 100
#define TOL 1.0e-7
#define RANDOM_SEED 123456
#include <random>
#include <algorithm>
#include <mpi.h>
#include <iostream>
#include "usi_compression.h"
#include "read_timeseries_matrix.h"
#include "gamma_zero.h"
#include "find.h"
#include "theta_s.h"
#include "L_value.h"
#include "lanczos_correlation.h"
#include "gamma_s.h"
#include "reduction.h"
#include "reconstruction.h"
/**
Write description of function here.
The function should follow these comments.
Use of "brief" tag is optional. (no point to it)
The function arguments listed with "param" will be compared
to the declaration and verified.
@param[in] filename Filename (string)
@param[in] fields List of the fields to be extracted (vector of strings0
@return vector of concatenated field values
*/
int main(int argc, char *argv[])
//****************************************************************************80
//
// Purpose:
//
// Example of parallel NetCDF functionality
//
// Discussion:
//
// This program demonstrates parallel NetCDF functionality. It reads from
// a NetCDF file a specified, specified as the first and second arguments of
// the function.
//
// This is the first step toward implementing a compression backend which
// reads a NetCDF stream, and compresses the time series data in parallel
// using the approaches of Horenko, et al.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// Starting October 2013
//
// Author:
//
// William Sawyer (CSCS)
// Ben Cumming (CSCS)
//
// Reference:
//
// Horenko, Klein, Dolaptchiev, Schuette
// Automated Generation of Reduced Stochastic Weather Models I:
// simultaneous dimension and model reduction for time series analysis
// XXX
//
// Example execution:
//
// aprun -n 2 ./netcdf_get_data /project/csstaff/outputs/echam/echam6/echam_output/t31_196001.01_echam.nc seaice
//
{
//
// Input Argument Handling
//
if (argc <= 2) {
std::cout << "Usage: " << argv[0] << " <Filename>" << " <field name>" << std::endl;
exit(1);
}
std::string filename = argv[1];
std::vector<std::string> fields(argv+2, argv+argc); // only the first field is currently used
//
// Initialize MPI
//
MPI_Init ( &argc, &argv );
double time_at_start = MPI_Wtime(); // used for calculating running time of each part of the algorithm
int my_rank, mpi_processes;
MPI_Comm_rank( MPI_COMM_WORLD, &my_rank );
MPI_Comm_size( MPI_COMM_WORLD, &mpi_processes );
int processes_in_x;
int processes_in_y = 1;
for ( processes_in_x = mpi_processes; processes_in_x > processes_in_y; processes_in_x /= 2 ) { processes_in_y *= 2; }
const int iam_in_x = my_rank % processes_in_x;
const int iam_in_y = my_rank / processes_in_x;
std::cout << "Decomposition: processes_in_x " << processes_in_x << " processes_in_y " << processes_in_y << " iam x " << iam_in_x << " iam_in_y " << iam_in_y << std::endl;
if ( processes_in_x * processes_in_y != mpi_processes ) { std::cout << "mpi_processes " << mpi_processes << " not power of two; aborting " << std::endl; abort(); }
//
// Read NetCDF Data
//
int Xrows, Xcols, ncid_out, varid_out;
size_t *start, *count;
ScalarType* data = read_timeseries_matrix<ScalarType>( filename, fields, iam_in_x, iam_in_y, processes_in_x, processes_in_y, Xrows, Xcols, &start, &count, &ncid_out, &varid_out );
#if defined( USE_EIGEN )
Eigen::Map<MatrixXXrow> X(data,Xrows,Xcols); // Needs to be row-major to mirror NetCDF output
#elif defined( USE_MINLIN )
HostMatrix<ScalarType> X(Xrows,Xcols);
for(int i=0; i<Xrows; i++)
for(int j=0; j<Xcols; j++, data++)
X(i,j) = *data;
#endif
double time_after_reading_data = MPI_Wtime();
//
// Set Up Data Used In Algorithm
//
// dimensions of data are saved as Ntl and nl for convenience & clarity
const int Ntl = Xrows; // number of values along direction that is
// compressed (variables/parameters in PCA)
const int nl = Xcols; // number of values along direction that is
// distributed on cores (observations in PCA)
// we need the global nl to generate the initial cluster configuration
// in a consistent way for any PE configuration
int *nl_global = new int[sizeof(int)*mpi_processes];
int total_nl = 0;
MPI_Allgather( &nl, 1, MPI_INT, nl_global, 1, MPI_INT, MPI_COMM_WORLD);
for ( int rank=0; rank < mpi_processes; rank++ ) { total_nl += nl_global[rank]; }
std::vector<int> gamma_ind = gamma_zero(nl_global, my_rank, KSIZE);
// print out nl sizes of all processes (for debugging)
// std::cout << "nl sizes "; for ( int rank=0; rank < mpi_processes; rank++ ) { std::cout << nl_global[rank] << " "; }
// std::cout << std::endl;
delete[] nl_global;
// we allocate the matrices used for the algorithm outside of the loop
GenericColMatrix theta(Ntl,KSIZE); // Time series means (one for each k), allocate outside loop
std::vector<GenericColMatrix> TT(KSIZE,GenericColMatrix(Ntl,1) ); // Eigenvectors: 1-each for each k
std::vector<GenericColMatrix> EOFs(KSIZE,GenericColMatrix(Ntl,MSIZE) ); // Eigenvectors: MSIZE eigenvectors for each k
std::vector<GenericColMatrix> Xreduced(KSIZE,GenericColMatrix(MSIZE, nl) ); // Reduced representation of X
GenericRowMatrix Xreconstructed(Ntl,nl); // Reconstructed time series
GenericRowMatrix Diff(Ntl,nl); // Reconstructed time series
ScalarType L_value_old = 1.0e19; // Very big value
ScalarType L_value_new;
#if defined( USE_EIGEN )
// initialize random seed used in lanczos algorithm
srand(RANDOM_SEED);
#endif
//
// Iterate To Find Optimal Clustering
//
for ( int iter = 0; iter < MAX_ITER; iter++ ) {
// determine X column means for each active state denoted by gamma_ind
theta_s<ScalarType>(gamma_ind, X, theta);
// we calculate the L value here for output only (TODO: remove this for optimization later)
L_value_new = L_value( gamma_ind, TT, X, theta );
if (!my_rank) std::cout << "L value after Theta calc " << L_value_new << std::endl;
// Not clear if there should be monotonic decrease here: new theta_s needs new TT, right?
// Principle Component Analysis for every cluster
for(int k = 0; k < KSIZE; k++) {
std::vector<int> Nonzeros = find( gamma_ind, k );
GenericColMatrix Xtranslated( Ntl, Nonzeros.size() ) ;
// if (!my_rank) std::cout << " For k = " << k << " nbr nonzeros " << Nonzeros.size() << std::endl;
for (int m = 0; m < Nonzeros.size() ; m++ ) // Translate X columns with mean value at new origin
{
GET_COLUMN(Xtranslated,m) = GET_COLUMN(X,Nonzeros[m]) - GET_COLUMN(theta,k) ;
}
bool success = lanczos_correlation(Xtranslated, 1, 1.0e-11, 50, TT[k], true);
}
// we calculate the L value here for output only (TODO: remove this for optimization later)
L_value_new = L_value( gamma_ind, TT, X, theta );
if (!my_rank) std::cout << "L value after PCA " << L_value_new << std::endl;
// find new optimal clustering
gamma_s( X, theta, TT, gamma_ind );
// calculate new L value and decide whether to continue
L_value_new = L_value( gamma_ind, TT, X, theta );
if (!my_rank) std::cout << "L value after gamma minimization " << L_value_new << std::endl;
if ( L_value_new > L_value_old ) {
if (!my_rank) std::cout << "New L_value " << L_value_new << " larger than old: " << L_value_old << " aborting " << std::endl;
break;
}
else if ( (L_value_old - L_value_new) < L_value_new*TOL ) {
if (!my_rank) std::cout << " Converged: to tolerance " << TOL << " after " << iter << " iterations " << std::endl;
break;
}
else if ( iter+1 == MAX_ITER ) {
if (!my_rank) std::cout << " Reached maximum number of iterations " << MAX_ITER << " without convergence " << std::endl;
}
L_value_old = L_value_new;
}
//
// Do Compression With Optimal Clustering
//
// Determine X column means for each active state denoted by gamma_ind
theta_s<ScalarType>(gamma_ind, X, theta);
// Principal Component Analysis for every cluster
for(int k = 0; k < KSIZE; k++) {
std::vector<int> Nonzeros = find( gamma_ind, k );
GenericColMatrix Xtranslated( Ntl, Nonzeros.size() ) ;
for (int m = 0; m < Nonzeros.size() ; m++ ) // Translate X columns with mean value at new origin
{
GET_COLUMN(Xtranslated,m) = GET_COLUMN(X,Nonzeros[m]) - GET_COLUMN(theta,k); // bsxfun(@minus,X(:,Nonzeros),Theta(:,k))
}
lanczos_correlation(Xtranslated, MSIZE, 1.0e-8, Ntl, EOFs[k], true);
}
L_value_new = L_value( gamma_ind, EOFs, X, theta );
if (!my_rank) std::cout << "L value final " << L_value_new << std::endl;
// Calculated the reduced representation of X
reduction<ScalarType>( gamma_ind, EOFs, X, theta, Xreduced );
// we save the time to check the runtime for each part of the algorithm
double time_after_compression = MPI_Wtime();
//
// Reconstruct Data for Comparison with Original
//
reconstruction<ScalarType>(gamma_ind, EOFs, theta, Xreduced, Xreconstructed);
ScalarType value = 0.0;
ScalarType output;
for (int l = 0; l < nl; l++ ) {
#if defined( USE_EIGEN )
Diff.col(l) = Xreconstructed.col(l)-X.col(l);
ScalarType colnorm = (Xreconstructed.col(l)-X.col(l)).norm(); value += colnorm*colnorm;
#elif defined( USE_MINLIN )
// TODO: MINLIN implementation
#else
ERROR: must USE_EIGEN or USE_MINLIN
#endif
}
MPI_Allreduce( &value, &output, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD );
//
// Statistics Output
//
double time_for_solve = time_after_compression - time_after_reading_data;
double time_for_input = time_after_reading_data - time_at_start;
double max_time_for_solve, max_time_for_input;
MPI_Allreduce( &time_for_solve, &max_time_for_solve, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );
MPI_Allreduce( &time_for_input, &max_time_for_input, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD );
double size_uncompressed = (double) (Ntl * total_nl);
double size_compressed = (double) (KSIZE * ( MSIZE + 1) *( Ntl + total_nl ) );
if (!my_rank) std::cout << "Max time for input " << max_time_for_input << std::endl;
if (!my_rank) std::cout << "Max time for solve " << max_time_for_solve << std::endl;
if (!my_rank) std::cout << "Compression ratio " << size_uncompressed / size_compressed << std::endl;
if (!my_rank) std::cout << "Root mean square error " << sqrt( output ) << std::endl;
//
// Write Reconstructed Data to File
//
int retval;
// TODO: this line doesn't return, fix this
if ((retval = nc_put_vara_double(ncid_out, varid_out, start, count, Xreconstructed.data() ))) ERR(retval);
if ((retval = nc_close(ncid_out))) ERR(retval);
//
// Terminate MPI and Quit Program.
//
retval = 0;
if (!my_rank) std::cout << "retval " << retval << std::endl;
MPI_Finalize();
return 0;
}
<|endoftext|> |
<commit_before>//
// Created by Dmitry Mozgin on 28/04/2017.
//
#include "CameraImpl.h"
#include "../../VoidApp.h"
using namespace vd;
CameraImpl::CameraImpl(VoidApp &app)
: VoidAppObject(app),
_nearClipPlane(0.1f),
_backgroundColor(Color::White),
_transform(std::make_shared<CameraTransform>(*this)) {
Setup();
}
const ITransformRef vd::CameraImpl::GetTransform() const {
return _transform;
}
void CameraImpl::SetNearClipPlane(float nearClipPlane) {
_nearClipPlane = nearClipPlane;
Setup();
}
float CameraImpl::GetNearClipPlane() const {
return _nearClipPlane;
}
void CameraImpl::SetBackgroundColor(const Color &color) {
_backgroundColor = color;
}
Color CameraImpl::GetBackgroundColor() const {
return _backgroundColor;
}
void CameraImpl::Setup() {
auto windowSize = app.getWindow()->getSize();
auto aspectRatio = (float) windowSize.x / (float) windowSize.y;
auto p = GetTransform()->GetPosition();
// The game uses left-handed coordinates, but OpenGL is right-handed
_camera.lookAt(ci::vec3(-p.x, p.y, p.z), ci::vec3(-p.x, p.y, p.z + 1));
_camera.setPerspective(35, aspectRatio, _nearClipPlane, 1000.0f);
}
void CameraImpl::LoadMatrices() {
ci::gl::setMatrices(_camera);
app.GetShader()->SetMatrices(_camera);
}
CameraTransform::CameraTransform(CameraImpl &camera)
: _camera(camera) {
}
void CameraTransform::SetPosition(const Vector3 &position) {
Transform::SetPosition(position);
_camera.Setup();
}
<commit_msg>Fix camera aspect ratio<commit_after>//
// Created by Dmitry Mozgin on 28/04/2017.
//
#include "CameraImpl.h"
#include "../../VoidApp.h"
using namespace vd;
CameraImpl::CameraImpl(VoidApp &app)
: VoidAppObject(app),
_nearClipPlane(0.1f),
_backgroundColor(Color::White),
_transform(std::make_shared<CameraTransform>(*this)) {
Setup();
}
const ITransformRef vd::CameraImpl::GetTransform() const {
return _transform;
}
void CameraImpl::SetNearClipPlane(float nearClipPlane) {
_nearClipPlane = nearClipPlane;
Setup();
}
float CameraImpl::GetNearClipPlane() const {
return _nearClipPlane;
}
void CameraImpl::SetBackgroundColor(const Color &color) {
_backgroundColor = color;
}
Color CameraImpl::GetBackgroundColor() const {
return _backgroundColor;
}
void CameraImpl::Setup() {
auto windowSize = app.getWindow()->getSize();
auto aspectRatio = (float) windowSize.x / (float) windowSize.y;
auto p = GetTransform()->GetPosition();
// The game uses left-handed coordinates, but OpenGL is right-handed
_camera.lookAt(ci::vec3(-p.x, p.y, p.z), ci::vec3(-p.x, p.y, p.z + 1));
_camera.setPerspective(60, aspectRatio, _nearClipPlane, 1000.0f);
}
void CameraImpl::LoadMatrices() {
ci::gl::setMatrices(_camera);
app.GetShader()->SetMatrices(_camera);
}
CameraTransform::CameraTransform(CameraImpl &camera)
: _camera(camera) {
}
void CameraTransform::SetPosition(const Vector3 &position) {
Transform::SetPosition(position);
_camera.Setup();
}
<|endoftext|> |
<commit_before>
#include <boost/asio.hpp>
#include "vtrc-common/vtrc-mutex-typedefs.h"
#include "vtrc-bind.h"
#include "vtrc-function.h"
#include "vtrc-protocol-layer-s.h"
#include "vtrc-monotonic-timer.h"
#include "vtrc-data-queue.h"
#include "vtrc-hash-iface.h"
#include "vtrc-transformer-iface.h"
#include "vtrc-transport-iface.h"
#include "vtrc-common/vtrc-rpc-service-wrapper.h"
#include "vtrc-common/vtrc-exception.h"
#include "vtrc-common/vtrc-rpc-controller.h"
#include "vtrc-common/vtrc-call-context.h"
#include "vtrc-application.h"
#include "protocol/vtrc-errors.pb.h"
#include "protocol/vtrc-auth.pb.h"
#include "protocol/vtrc-rpc-lowlevel.pb.h"
namespace vtrc { namespace server {
namespace gpb = google::protobuf;
namespace {
enum init_stage_enum {
stage_begin = 1
,stage_client_select = 2
,stage_client_ready = 3
};
typedef std::map <
std::string,
common::rpc_service_wrapper_sptr
> service_map;
}
namespace data_queue = common::data_queue;
struct protocol_layer_s::impl {
typedef impl this_type;
application &app_;
common::transport_iface *connection_;
protocol_layer_s *parent_;
bool ready_;
service_map services_;
shared_mutex services_lock_;
typedef vtrc::function<void (void)> stage_function_type;
stage_function_type stage_function_;
impl( application &a, common::transport_iface *c )
:app_(a)
,connection_(c)
,ready_(false)
{
stage_function_ =
vtrc::bind( &this_type::on_client_selection, this );
}
common::rpc_service_wrapper_sptr get_service( const std::string &name )
{
upgradable_lock l( services_lock_ );
common::rpc_service_wrapper_sptr result;
service_map::iterator f( services_.find( name ) );
if( f != services_.end( ) ) {
result = f->second;
} else {
result = app_.get_service_by_name( connection_, name );
if( result ) {
upgrade_to_unique ul( l );
services_.insert( std::make_pair( name, result ) );
}
}
return result;
}
void pop_message( )
{
parent_->pop_message( );
}
void on_timer( boost::system::error_code const &error )
{
}
bool check_message_hash( const std::string &mess )
{
return parent_->check_message( mess );
}
void write( const char *data, size_t length )
{
connection_->write( data, length );
}
void write( const char *data, size_t length ) const
{
connection_->write( data, length );
}
void send_proto_message( const gpb::Message &mess ) const
{
std::string s(mess.SerializeAsString( ));
write( s.c_str( ), s.size( ) );
}
void on_client_selection( )
{
std::string &mess(parent_->message_queue( ).front( ));
bool check = check_message_hash(mess);
if( !check ) {
connection_->close( );
return;
}
vtrc_auth::client_selection cs;
parse_message( mess, cs );
pop_message( );
parent_->change_hash_checker(
common::hash::create_by_index( cs.hash( ) ));
parent_->change_hash_maker(
common::hash::create_by_index( cs.hash( ) ));
vtrc_auth::transformer_setup ts;
ts.set_ready( true );
stage_function_ =
vtrc::bind( &this_type::on_rcp_call_ready, this );
send_proto_message( ts );
}
void get_pop_message( gpb::Message &capsule )
{
std::string &mess(parent_->message_queue( ).front( ));
bool check = check_message_hash(mess);
if( !check ) {
connection_->close( );
return;
}
parse_message( mess, capsule );
pop_message( );
}
void closure( common::rpc_controller_sptr controller,
vtrc::shared_ptr <
vtrc_rpc_lowlevel::lowlevel_unit
> llu)
{
;;;
}
bool make_call_impl( vtrc::shared_ptr <
vtrc_rpc_lowlevel::lowlevel_unit> llu )
{
protocol_layer_s::context_holder ch( parent_, llu.get( ) );
common::rpc_service_wrapper_sptr
service(get_service(llu->call( ).service()));
if( !service ) {
throw vtrc::common::exception( vtrc_errors::ERR_BAD_FILE,
"Service not found");
}
gpb::MethodDescriptor const *meth
(service->get_method(llu->call( ).method( )));
if( !meth ) {
throw vtrc::common::exception( vtrc_errors::ERR_NO_FUNC );
}
const vtrc_rpc_lowlevel::options &call_opts
( parent_->get_method_options( meth ) );
ch.ctx_->set_call_options( call_opts );
vtrc::shared_ptr<gpb::Message> req
(service->service( )->GetRequestPrototype( meth ).New( ));
req->ParseFromString( llu->request( ) );
vtrc::shared_ptr<gpb::Message> res
(service->service( )->GetResponsePrototype( meth ).New( ));
res->ParseFromString( llu->response( ) );
common::rpc_controller_sptr controller
(vtrc::make_shared<common::rpc_controller>( ));
vtrc::shared_ptr<gpb::Closure> clos
(gpb::NewPermanentCallback( this, &this_type::closure,
controller, llu ));
service->service( )
->CallMethod( meth, controller.get( ),
req.get( ), res.get( ), clos.get( ) );
if( controller->Failed( ) ) {
throw vtrc::common::exception( vtrc_errors::ERR_INTERNAL,
controller->ErrorText( ));
}
llu->set_response( res->SerializeAsString( ) );
return call_opts.wait( );
}
void make_call( vtrc::shared_ptr <vtrc_rpc_lowlevel::lowlevel_unit> llu)
{
bool failed = true;
bool opt_wait = true;
bool request_wait = llu->info( ).wait_for_response( );
unsigned errorcode = 0;
try {
opt_wait = make_call_impl( llu );
failed = false;
} catch ( const vtrc::common::exception &ex ) {
errorcode = ex.code( );
llu->mutable_error( )
->set_additional( ex.additional( ) );
} catch ( const std::exception &ex ) {
errorcode = vtrc_errors::ERR_INTERNAL;
llu->mutable_error( )
->set_additional( ex.what( ) );
} catch ( ... ) {
errorcode = vtrc_errors::ERR_UNKNOWN;
llu->mutable_error( )
->set_additional( "..." );
}
if( opt_wait && request_wait ) {
llu->clear_request( );
llu->clear_call( );
if( failed ) {
llu->mutable_error( )->set_code( errorcode );
llu->clear_response( );
}
send_proto_message( *llu );
}
}
void on_rcp_call_ready( )
{
while( !parent_->message_queue( ).empty( ) ) {
vtrc::shared_ptr < vtrc_rpc_lowlevel::lowlevel_unit >
llu(new vtrc_rpc_lowlevel::lowlevel_unit);
get_pop_message( *llu );
switch (llu->info( ).message_type( )) {
case vtrc_rpc_lowlevel::message_info::MESSAGE_CALL:
make_call( llu );
break;
default:
break;
}
}
//connection_->close( );
}
void parse_message( const std::string &block, gpb::Message &mess )
{
parent_->parse_message( block, mess );
}
std::string first_message( )
{
vtrc_auth::init_protocol hello_mess;
hello_mess.set_hello_message( "Tervetuloa!" );
hello_mess.add_hash_supported( vtrc_auth::HASH_NONE );
hello_mess.add_hash_supported( vtrc_auth::HASH_CRC_16 );
hello_mess.add_hash_supported( vtrc_auth::HASH_CRC_32 );
hello_mess.add_hash_supported( vtrc_auth::HASH_CRC_64 );
hello_mess.add_hash_supported( vtrc_auth::HASH_SHA2_256 );
hello_mess.add_transform_supported( vtrc_auth::TRANSFORM_NONE );
hello_mess.add_transform_supported( vtrc_auth::TRANSFORM_ERSEEFOR );
return hello_mess.SerializeAsString( );
}
void init( )
{
static const std::string data(first_message( ));
write(data.c_str( ), data.size( ));
}
void data_ready( )
{
stage_function_( );
}
bool ready( ) const
{
return true;
}
};
protocol_layer_s::protocol_layer_s( application &a,
common::transport_iface *connection )
:common::protocol_layer(connection)
,impl_(new impl(a, connection))
{
impl_->parent_ = this;
}
protocol_layer_s::~protocol_layer_s( )
{
delete impl_;
}
void protocol_layer_s::init( )
{
impl_->init( );
}
void protocol_layer_s::on_data_ready( )
{
impl_->data_ready( );
}
bool protocol_layer_s::ready( ) const
{
return impl_->ready( );
}
}}
<commit_msg>protocol<commit_after>
#include <boost/asio.hpp>
#include "vtrc-common/vtrc-mutex-typedefs.h"
#include "vtrc-bind.h"
#include "vtrc-function.h"
#include "vtrc-protocol-layer-s.h"
#include "vtrc-monotonic-timer.h"
#include "vtrc-data-queue.h"
#include "vtrc-hash-iface.h"
#include "vtrc-transformer-iface.h"
#include "vtrc-transport-iface.h"
#include "vtrc-common/vtrc-rpc-service-wrapper.h"
#include "vtrc-common/vtrc-exception.h"
#include "vtrc-common/vtrc-rpc-controller.h"
#include "vtrc-common/vtrc-call-context.h"
#include "vtrc-application.h"
#include "protocol/vtrc-errors.pb.h"
#include "protocol/vtrc-auth.pb.h"
#include "protocol/vtrc-rpc-lowlevel.pb.h"
namespace vtrc { namespace server {
namespace gpb = google::protobuf;
namespace {
enum init_stage_enum {
stage_begin = 1
,stage_client_select = 2
,stage_client_ready = 3
};
typedef std::map <
std::string,
common::rpc_service_wrapper_sptr
> service_map;
}
namespace data_queue = common::data_queue;
struct protocol_layer_s::impl {
typedef impl this_type;
application &app_;
common::transport_iface *connection_;
protocol_layer_s *parent_;
bool ready_;
service_map services_;
shared_mutex services_lock_;
typedef vtrc::function<void (void)> stage_function_type;
stage_function_type stage_function_;
impl( application &a, common::transport_iface *c )
:app_(a)
,connection_(c)
,ready_(false)
{
stage_function_ =
vtrc::bind( &this_type::on_client_selection, this );
}
common::rpc_service_wrapper_sptr get_service( const std::string &name )
{
upgradable_lock l( services_lock_ );
common::rpc_service_wrapper_sptr result;
service_map::iterator f( services_.find( name ) );
if( f != services_.end( ) ) {
result = f->second;
} else {
result = app_.get_service_by_name( connection_, name );
if( result ) {
upgrade_to_unique ul( l );
services_.insert( std::make_pair( name, result ) );
}
}
return result;
}
void pop_message( )
{
parent_->pop_message( );
}
void on_timer( boost::system::error_code const &error )
{
}
bool check_message_hash( const std::string &mess )
{
return parent_->check_message( mess );
}
void write( const char *data, size_t length )
{
connection_->write( data, length );
}
void write( const char *data, size_t length ) const
{
connection_->write( data, length );
}
void send_proto_message( const gpb::Message &mess ) const
{
std::string s(mess.SerializeAsString( ));
write( s.c_str( ), s.size( ) );
}
void on_client_selection( )
{
std::string &mess(parent_->message_queue( ).front( ));
bool check = check_message_hash(mess);
if( !check ) {
connection_->close( );
return;
}
vtrc_auth::client_selection cs;
parse_message( mess, cs );
pop_message( );
parent_->change_hash_checker(
common::hash::create_by_index( cs.hash( ) ));
parent_->change_hash_maker(
common::hash::create_by_index( cs.hash( ) ));
vtrc_auth::transformer_setup ts;
ts.set_ready( true );
stage_function_ =
vtrc::bind( &this_type::on_rcp_call_ready, this );
send_proto_message( ts );
}
void get_pop_message( gpb::Message &capsule )
{
std::string &mess(parent_->message_queue( ).front( ));
bool check = check_message_hash(mess);
if( !check ) {
connection_->close( );
return;
}
parse_message( mess, capsule );
pop_message( );
}
void closure( common::rpc_controller_sptr controller,
vtrc::shared_ptr <
vtrc_rpc_lowlevel::lowlevel_unit
> llu)
{
;;;
}
bool make_call_impl( vtrc::shared_ptr <
vtrc_rpc_lowlevel::lowlevel_unit> llu )
{
protocol_layer_s::context_holder ch( parent_, llu.get( ) );
common::rpc_service_wrapper_sptr
service(get_service(llu->call( ).service()));
if( !service ) {
throw vtrc::common::exception( vtrc_errors::ERR_BAD_FILE,
"Service not found");
}
gpb::MethodDescriptor const *meth
(service->get_method(llu->call( ).method( )));
if( !meth ) {
throw vtrc::common::exception( vtrc_errors::ERR_NO_FUNC );
}
const vtrc_rpc_lowlevel::options &call_opts
( parent_->get_method_options( meth ) );
ch.ctx_->set_call_options( call_opts );
vtrc::shared_ptr<gpb::Message> req
(service->service( )->GetRequestPrototype( meth ).New( ));
req->ParseFromString( llu->request( ) );
vtrc::shared_ptr<gpb::Message> res
(service->service( )->GetResponsePrototype( meth ).New( ));
res->ParseFromString(llu->response( ));
common::rpc_controller_sptr controller
(vtrc::make_shared<common::rpc_controller>( ));
vtrc::shared_ptr<gpb::Closure> clos
(gpb::NewPermanentCallback( this, &this_type::closure,
controller, llu ));
service->service( )
->CallMethod( meth, controller.get( ),
req.get( ), res.get( ), clos.get( ) );
if( controller->Failed( ) ) {
throw vtrc::common::exception( vtrc_errors::ERR_INTERNAL,
controller->ErrorText( ));
}
llu->set_response( res->SerializeAsString( ) );
return call_opts.wait( );
}
void make_call( vtrc::shared_ptr <vtrc_rpc_lowlevel::lowlevel_unit> llu)
{
bool failed = true;
bool opt_wait = true;
bool request_wait = llu->info( ).wait_for_response( );
unsigned errorcode = 0;
try {
opt_wait = make_call_impl( llu );
failed = false;
} catch ( const vtrc::common::exception &ex ) {
errorcode = ex.code( );
llu->mutable_error( )
->set_additional( ex.additional( ) );
} catch ( const std::exception &ex ) {
errorcode = vtrc_errors::ERR_INTERNAL;
llu->mutable_error( )
->set_additional( ex.what( ) );
} catch ( ... ) {
errorcode = vtrc_errors::ERR_UNKNOWN;
llu->mutable_error( )
->set_additional( "..." );
}
if( opt_wait && request_wait ) {
llu->clear_request( );
llu->clear_call( );
if( failed ) {
llu->mutable_error( )->set_code( errorcode );
llu->clear_response( );
}
send_proto_message( *llu );
}
}
void on_rcp_call_ready( )
{
while( !parent_->message_queue( ).empty( ) ) {
vtrc::shared_ptr < vtrc_rpc_lowlevel::lowlevel_unit >
llu(new vtrc_rpc_lowlevel::lowlevel_unit);
get_pop_message( *llu );
switch (llu->info( ).message_type( )) {
case vtrc_rpc_lowlevel::message_info::MESSAGE_CALL:
make_call( llu );
break;
default:
break;
}
}
//connection_->close( );
}
void parse_message( const std::string &block, gpb::Message &mess )
{
parent_->parse_message( block, mess );
}
std::string first_message( )
{
vtrc_auth::init_protocol hello_mess;
hello_mess.set_hello_message( "Tervetuloa!" );
hello_mess.add_hash_supported( vtrc_auth::HASH_NONE );
hello_mess.add_hash_supported( vtrc_auth::HASH_CRC_16 );
hello_mess.add_hash_supported( vtrc_auth::HASH_CRC_32 );
hello_mess.add_hash_supported( vtrc_auth::HASH_CRC_64 );
hello_mess.add_hash_supported( vtrc_auth::HASH_SHA2_256 );
hello_mess.add_transform_supported( vtrc_auth::TRANSFORM_NONE );
hello_mess.add_transform_supported( vtrc_auth::TRANSFORM_ERSEEFOR );
return hello_mess.SerializeAsString( );
}
void init( )
{
static const std::string data(first_message( ));
write(data.c_str( ), data.size( ));
}
void data_ready( )
{
stage_function_( );
}
bool ready( ) const
{
return true;
}
};
protocol_layer_s::protocol_layer_s( application &a,
common::transport_iface *connection )
:common::protocol_layer(connection)
,impl_(new impl(a, connection))
{
impl_->parent_ = this;
}
protocol_layer_s::~protocol_layer_s( )
{
delete impl_;
}
void protocol_layer_s::init( )
{
impl_->init( );
}
void protocol_layer_s::on_data_ready( )
{
impl_->data_ready( );
}
bool protocol_layer_s::ready( ) const
{
return impl_->ready( );
}
}}
<|endoftext|> |
<commit_before>// Copyright 2011 the V8 project authors. 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 Google Inc. 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 <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "../include/v8stdint.h"
#include "../include/v8-preparser.h"
#include "../src/preparse-data-format.h"
namespace i = v8::internal;
// This file is only used for testing the stand-alone preparser
// library.
// The first argument must be the path of a JavaScript source file, or
// the flags "-e" and the next argument is then the source of a JavaScript
// program.
// Optionally this can be followed by the word "throws" (case sensitive),
// which signals that the parsing is expected to throw - the default is
// to expect the parsing to not throw.
// The command line can further be followed by a message text (the
// *type* of the exception to throw), and even more optionally, the
// start and end position reported with the exception.
//
// This source file is preparsed and tested against the expectations, and if
// successful, the resulting preparser data is written to stdout.
// Diagnostic output is output on stderr.
// The source file must contain only ASCII characters (UTF-8 isn't supported).
// The file is read into memory, so it should have a reasonable size.
// Adapts an ASCII string to the UnicodeInputStream interface.
class AsciiInputStream : public v8::UnicodeInputStream {
public:
AsciiInputStream(const uint8_t* buffer, size_t length)
: buffer_(buffer),
end_offset_(static_cast<int>(length)),
offset_(0) { }
virtual ~AsciiInputStream() { }
virtual void PushBack(int32_t ch) {
offset_--;
#ifdef DEBUG
if (offset_ < 0 ||
(ch != ((offset_ >= end_offset_) ? -1 : buffer_[offset_]))) {
fprintf(stderr, "Invalid pushback: '%c' at offset %d.", ch, offset_);
exit(1);
}
#endif
}
virtual int32_t Next() {
if (offset_ >= end_offset_) {
offset_++; // Increment anyway to allow symmetric pushbacks.
return -1;
}
uint8_t next_char = buffer_[offset_];
#ifdef DEBUG
if (next_char > 0x7fu) {
fprintf(stderr, "Non-ASCII character in input: '%c'.", next_char);
exit(1);
}
#endif
offset_++;
return static_cast<int32_t>(next_char);
}
private:
const uint8_t* buffer_;
const int end_offset_;
int offset_;
};
bool ReadBuffer(FILE* source, void* buffer, size_t length) {
size_t actually_read = fread(buffer, 1, length, source);
return (actually_read == length);
}
bool WriteBuffer(FILE* dest, const void* buffer, size_t length) {
size_t actually_written = fwrite(buffer, 1, length, dest);
return (actually_written == length);
}
class PreparseDataInterpreter {
public:
PreparseDataInterpreter(const uint8_t* data, int length)
: data_(data), length_(length), message_(NULL) { }
~PreparseDataInterpreter() {
if (message_ != NULL) delete[] message_;
}
bool valid() {
int header_length =
i::PreparseDataConstants::kHeaderSize * sizeof(int); // NOLINT
return length_ >= header_length;
}
bool throws() {
return valid() &&
word(i::PreparseDataConstants::kHasErrorOffset) != 0;
}
const char* message() {
if (message_ != NULL) return message_;
if (!throws()) return NULL;
int text_pos = i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageTextPos;
int length = word(text_pos);
char* buffer = new char[length + 1];
for (int i = 1; i <= length; i++) {
int character = word(text_pos + i);
buffer[i - 1] = character;
}
buffer[length] = '\0';
message_ = buffer;
return buffer;
}
int beg_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageStartPos);
}
int end_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageEndPos);
}
private:
int word(int offset) {
const int* word_data = reinterpret_cast<const int*>(data_);
if (word_data + offset < reinterpret_cast<const int*>(data_ + length_)) {
return word_data[offset];
}
return -1;
}
const uint8_t* const data_;
const int length_;
const char* message_;
};
template <typename T>
class ScopedPointer {
public:
explicit ScopedPointer() : pointer_(NULL) {}
explicit ScopedPointer(T* pointer) : pointer_(pointer) {}
~ScopedPointer() { if (pointer_ != NULL) delete[] pointer_; }
T& operator[](int index) { return pointer_[index]; }
T* operator*() { return pointer_ ;}
T*& operator=(T* new_value) {
if (pointer_ != NULL) delete[] pointer_;
pointer_ = new_value;
}
private:
T* pointer_;
};
void fail(v8::PreParserData* data, const char* message, ...) {
va_list args;
va_start(args, message);
vfprintf(stderr, message, args);
va_end(args);
fflush(stderr);
// Print preparser data to stdout.
uint32_t size = data->size();
fprintf(stderr, "LOG: data size: %u\n", size);
if (!WriteBuffer(stdout, data->data(), size)) {
perror("ERROR: Writing data");
fflush(stderr);
}
exit(EXIT_FAILURE);
};
bool IsFlag(const char* arg) {
// Anything starting with '-' is considered a flag.
// It's summarily ignored for now.
return arg[0] == '-';
}
struct ExceptionExpectation {
ExceptionExpectation()
: throws(false), type(NULL), beg_pos(-1), end_pos(-1) { }
bool throws;
const char* type;
int beg_pos;
int end_pos;
};
void CheckException(v8::PreParserData* data,
ExceptionExpectation* expects) {
PreparseDataInterpreter reader(data->data(), data->size());
if (expects->throws) {
if (!reader.throws()) {
if (expects->type == NULL) {
fail(data, "Didn't throw as expected\n");
} else {
fail(data, "Didn't throw \"%s\" as expected\n", expects->type);
}
}
if (expects->type != NULL) {
const char* actual_message = reader.message();
if (strcmp(expects->type, actual_message)) {
fail(data, "Wrong error message. Expected <%s>, found <%s>\n",
expects->type, actual_message);
}
}
if (expects->beg_pos >= 0) {
if (expects->beg_pos != reader.beg_pos()) {
fail(data, "Wrong error start position: Expected %i, found %i\n",
expects->beg_pos, reader.beg_pos());
}
}
if (expects->end_pos >= 0) {
if (expects->end_pos != reader.end_pos()) {
fail(data, "Wrong error end position: Expected %i, found %i\n",
expects->end_pos, reader.end_pos());
}
}
} else if (reader.throws()) {
const char* message = reader.message();
fail(data, "Throws unexpectedly with message: %s at location %d-%d\n",
message, reader.beg_pos(), reader.end_pos());
}
}
ExceptionExpectation ParseExpectation(int argc, const char* argv[]) {
ExceptionExpectation expects;
// Parse exception expectations from (the remainder of) the command line.
int arg_index = 0;
// Skip any flags.
while (argc > arg_index && IsFlag(argv[arg_index])) arg_index++;
if (argc > arg_index) {
if (strncmp("throws", argv[arg_index], 7)) {
// First argument after filename, if present, must be the verbatim
// "throws", marking that the preparsing should fail with an exception.
fail(NULL, "ERROR: Extra arguments not prefixed by \"throws\".\n");
}
expects.throws = true;
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
// Next argument is the exception type identifier.
expects.type = argv[arg_index];
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.beg_pos = atoi(argv[arg_index]);
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.end_pos = atoi(argv[arg_index]);
}
}
}
}
return expects;
}
int main(int argc, const char* argv[]) {
// Parse command line.
// Format: preparser (<scriptfile> | -e "<source>")
// ["throws" [<exn-type> [<start> [<end>]]]]
// Any flags (except an initial -s) are ignored.
// Check for mandatory filename argument.
int arg_index = 1;
if (argc <= arg_index) {
fail(NULL, "ERROR: No filename on command line.\n");
}
const uint8_t* source = NULL;
const char* filename = argv[arg_index];
if (!strcmp(filename, "-e")) {
arg_index++;
if (argc <= arg_index) {
fail(NULL, "ERROR: No source after -e on command line.\n");
}
source = reinterpret_cast<const uint8_t*>(argv[arg_index]);
}
// Check remainder of command line for exception expectations.
arg_index++;
ExceptionExpectation expects =
ParseExpectation(argc - arg_index, argv + arg_index);
ScopedPointer<uint8_t> buffer;
size_t length;
if (source == NULL) {
// Open JS file.
FILE* input = fopen(filename, "rb");
if (input == NULL) {
perror("ERROR: Error opening file");
fflush(stderr);
return EXIT_FAILURE;
}
// Find length of JS file.
if (fseek(input, 0, SEEK_END) != 0) {
perror("ERROR: Error during seek");
fflush(stderr);
return EXIT_FAILURE;
}
length = static_cast<size_t>(ftell(input));
rewind(input);
// Read JS file into memory buffer.
buffer = new uint8_t[length];
if (!ReadBuffer(input, *buffer, length)) {
perror("ERROR: Reading file");
fflush(stderr);
return EXIT_FAILURE;
}
fclose(input);
source = *buffer;
} else {
length = strlen(reinterpret_cast<const char*>(source));
}
// Preparse input file.
AsciiInputStream input_buffer(source, length);
size_t kMaxStackSize = 64 * 1024 * sizeof(void*); // NOLINT
v8::PreParserData data = v8::Preparse(&input_buffer, kMaxStackSize);
// Fail if stack overflow.
if (data.stack_overflow()) {
fail(&data, "ERROR: Stack overflow\n");
}
// Check that the expected exception is thrown, if an exception is
// expected.
CheckException(&data, &expects);
return EXIT_SUCCESS;
}
<commit_msg>Fix missing retun value.<commit_after>// Copyright 2011 the V8 project authors. 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 Google Inc. 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 <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "../include/v8stdint.h"
#include "../include/v8-preparser.h"
#include "../src/preparse-data-format.h"
namespace i = v8::internal;
// This file is only used for testing the stand-alone preparser
// library.
// The first argument must be the path of a JavaScript source file, or
// the flags "-e" and the next argument is then the source of a JavaScript
// program.
// Optionally this can be followed by the word "throws" (case sensitive),
// which signals that the parsing is expected to throw - the default is
// to expect the parsing to not throw.
// The command line can further be followed by a message text (the
// *type* of the exception to throw), and even more optionally, the
// start and end position reported with the exception.
//
// This source file is preparsed and tested against the expectations, and if
// successful, the resulting preparser data is written to stdout.
// Diagnostic output is output on stderr.
// The source file must contain only ASCII characters (UTF-8 isn't supported).
// The file is read into memory, so it should have a reasonable size.
// Adapts an ASCII string to the UnicodeInputStream interface.
class AsciiInputStream : public v8::UnicodeInputStream {
public:
AsciiInputStream(const uint8_t* buffer, size_t length)
: buffer_(buffer),
end_offset_(static_cast<int>(length)),
offset_(0) { }
virtual ~AsciiInputStream() { }
virtual void PushBack(int32_t ch) {
offset_--;
#ifdef DEBUG
if (offset_ < 0 ||
(ch != ((offset_ >= end_offset_) ? -1 : buffer_[offset_]))) {
fprintf(stderr, "Invalid pushback: '%c' at offset %d.", ch, offset_);
exit(1);
}
#endif
}
virtual int32_t Next() {
if (offset_ >= end_offset_) {
offset_++; // Increment anyway to allow symmetric pushbacks.
return -1;
}
uint8_t next_char = buffer_[offset_];
#ifdef DEBUG
if (next_char > 0x7fu) {
fprintf(stderr, "Non-ASCII character in input: '%c'.", next_char);
exit(1);
}
#endif
offset_++;
return static_cast<int32_t>(next_char);
}
private:
const uint8_t* buffer_;
const int end_offset_;
int offset_;
};
bool ReadBuffer(FILE* source, void* buffer, size_t length) {
size_t actually_read = fread(buffer, 1, length, source);
return (actually_read == length);
}
bool WriteBuffer(FILE* dest, const void* buffer, size_t length) {
size_t actually_written = fwrite(buffer, 1, length, dest);
return (actually_written == length);
}
class PreparseDataInterpreter {
public:
PreparseDataInterpreter(const uint8_t* data, int length)
: data_(data), length_(length), message_(NULL) { }
~PreparseDataInterpreter() {
if (message_ != NULL) delete[] message_;
}
bool valid() {
int header_length =
i::PreparseDataConstants::kHeaderSize * sizeof(int); // NOLINT
return length_ >= header_length;
}
bool throws() {
return valid() &&
word(i::PreparseDataConstants::kHasErrorOffset) != 0;
}
const char* message() {
if (message_ != NULL) return message_;
if (!throws()) return NULL;
int text_pos = i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageTextPos;
int length = word(text_pos);
char* buffer = new char[length + 1];
for (int i = 1; i <= length; i++) {
int character = word(text_pos + i);
buffer[i - 1] = character;
}
buffer[length] = '\0';
message_ = buffer;
return buffer;
}
int beg_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageStartPos);
}
int end_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageEndPos);
}
private:
int word(int offset) {
const int* word_data = reinterpret_cast<const int*>(data_);
if (word_data + offset < reinterpret_cast<const int*>(data_ + length_)) {
return word_data[offset];
}
return -1;
}
const uint8_t* const data_;
const int length_;
const char* message_;
};
template <typename T>
class ScopedPointer {
public:
explicit ScopedPointer() : pointer_(NULL) {}
explicit ScopedPointer(T* pointer) : pointer_(pointer) {}
~ScopedPointer() { if (pointer_ != NULL) delete[] pointer_; }
T& operator[](int index) { return pointer_[index]; }
T* operator*() { return pointer_ ;}
T* operator=(T* new_value) {
if (pointer_ != NULL) delete[] pointer_;
pointer_ = new_value;
return new_value;
}
private:
T* pointer_;
};
void fail(v8::PreParserData* data, const char* message, ...) {
va_list args;
va_start(args, message);
vfprintf(stderr, message, args);
va_end(args);
fflush(stderr);
// Print preparser data to stdout.
uint32_t size = data->size();
fprintf(stderr, "LOG: data size: %u\n", size);
if (!WriteBuffer(stdout, data->data(), size)) {
perror("ERROR: Writing data");
fflush(stderr);
}
exit(EXIT_FAILURE);
};
bool IsFlag(const char* arg) {
// Anything starting with '-' is considered a flag.
// It's summarily ignored for now.
return arg[0] == '-';
}
struct ExceptionExpectation {
ExceptionExpectation()
: throws(false), type(NULL), beg_pos(-1), end_pos(-1) { }
bool throws;
const char* type;
int beg_pos;
int end_pos;
};
void CheckException(v8::PreParserData* data,
ExceptionExpectation* expects) {
PreparseDataInterpreter reader(data->data(), data->size());
if (expects->throws) {
if (!reader.throws()) {
if (expects->type == NULL) {
fail(data, "Didn't throw as expected\n");
} else {
fail(data, "Didn't throw \"%s\" as expected\n", expects->type);
}
}
if (expects->type != NULL) {
const char* actual_message = reader.message();
if (strcmp(expects->type, actual_message)) {
fail(data, "Wrong error message. Expected <%s>, found <%s>\n",
expects->type, actual_message);
}
}
if (expects->beg_pos >= 0) {
if (expects->beg_pos != reader.beg_pos()) {
fail(data, "Wrong error start position: Expected %i, found %i\n",
expects->beg_pos, reader.beg_pos());
}
}
if (expects->end_pos >= 0) {
if (expects->end_pos != reader.end_pos()) {
fail(data, "Wrong error end position: Expected %i, found %i\n",
expects->end_pos, reader.end_pos());
}
}
} else if (reader.throws()) {
const char* message = reader.message();
fail(data, "Throws unexpectedly with message: %s at location %d-%d\n",
message, reader.beg_pos(), reader.end_pos());
}
}
ExceptionExpectation ParseExpectation(int argc, const char* argv[]) {
ExceptionExpectation expects;
// Parse exception expectations from (the remainder of) the command line.
int arg_index = 0;
// Skip any flags.
while (argc > arg_index && IsFlag(argv[arg_index])) arg_index++;
if (argc > arg_index) {
if (strncmp("throws", argv[arg_index], 7)) {
// First argument after filename, if present, must be the verbatim
// "throws", marking that the preparsing should fail with an exception.
fail(NULL, "ERROR: Extra arguments not prefixed by \"throws\".\n");
}
expects.throws = true;
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
// Next argument is the exception type identifier.
expects.type = argv[arg_index];
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.beg_pos = atoi(argv[arg_index]);
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.end_pos = atoi(argv[arg_index]);
}
}
}
}
return expects;
}
int main(int argc, const char* argv[]) {
// Parse command line.
// Format: preparser (<scriptfile> | -e "<source>")
// ["throws" [<exn-type> [<start> [<end>]]]]
// Any flags (except an initial -s) are ignored.
// Check for mandatory filename argument.
int arg_index = 1;
if (argc <= arg_index) {
fail(NULL, "ERROR: No filename on command line.\n");
}
const uint8_t* source = NULL;
const char* filename = argv[arg_index];
if (!strcmp(filename, "-e")) {
arg_index++;
if (argc <= arg_index) {
fail(NULL, "ERROR: No source after -e on command line.\n");
}
source = reinterpret_cast<const uint8_t*>(argv[arg_index]);
}
// Check remainder of command line for exception expectations.
arg_index++;
ExceptionExpectation expects =
ParseExpectation(argc - arg_index, argv + arg_index);
ScopedPointer<uint8_t> buffer;
size_t length;
if (source == NULL) {
// Open JS file.
FILE* input = fopen(filename, "rb");
if (input == NULL) {
perror("ERROR: Error opening file");
fflush(stderr);
return EXIT_FAILURE;
}
// Find length of JS file.
if (fseek(input, 0, SEEK_END) != 0) {
perror("ERROR: Error during seek");
fflush(stderr);
return EXIT_FAILURE;
}
length = static_cast<size_t>(ftell(input));
rewind(input);
// Read JS file into memory buffer.
buffer = new uint8_t[length];
if (!ReadBuffer(input, *buffer, length)) {
perror("ERROR: Reading file");
fflush(stderr);
return EXIT_FAILURE;
}
fclose(input);
source = *buffer;
} else {
length = strlen(reinterpret_cast<const char*>(source));
}
// Preparse input file.
AsciiInputStream input_buffer(source, length);
size_t kMaxStackSize = 64 * 1024 * sizeof(void*); // NOLINT
v8::PreParserData data = v8::Preparse(&input_buffer, kMaxStackSize);
// Fail if stack overflow.
if (data.stack_overflow()) {
fail(&data, "ERROR: Stack overflow\n");
}
// Check that the expected exception is thrown, if an exception is
// expected.
CheckException(&data, &expects);
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>// Copyright 2011 the V8 project authors. 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 Google Inc. 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 <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "../include/v8stdint.h"
#include "../include/v8-preparser.h"
#include "../src/preparse-data-format.h"
namespace i = v8::internal;
// This file is only used for testing the stand-alone preparser
// library.
// The first argument must be the path of a JavaScript source file, or
// the flags "-e" and the next argument is then the source of a JavaScript
// program.
// Optionally this can be followed by the word "throws" (case sensitive),
// which signals that the parsing is expected to throw - the default is
// to expect the parsing to not throw.
// The command line can further be followed by a message text (the
// *type* of the exception to throw), and even more optionally, the
// start and end position reported with the exception.
//
// This source file is preparsed and tested against the expectations, and if
// successful, the resulting preparser data is written to stdout.
// Diagnostic output is output on stderr.
// The source file must contain only ASCII characters (UTF-8 isn't supported).
// The file is read into memory, so it should have a reasonable size.
// Adapts an ASCII string to the UnicodeInputStream interface.
class AsciiInputStream : public v8::UnicodeInputStream {
public:
AsciiInputStream(const uint8_t* buffer, size_t length)
: buffer_(buffer),
end_offset_(static_cast<int>(length)),
offset_(0) { }
virtual ~AsciiInputStream() { }
virtual void PushBack(int32_t ch) {
offset_--;
#ifdef DEBUG
if (offset_ < 0 ||
(ch != ((offset_ >= end_offset_) ? -1 : buffer_[offset_]))) {
fprintf(stderr, "Invalid pushback: '%c' at offset %d.", ch, offset_);
exit(1);
}
#endif
}
virtual int32_t Next() {
if (offset_ >= end_offset_) {
offset_++; // Increment anyway to allow symmetric pushbacks.
return -1;
}
uint8_t next_char = buffer_[offset_];
#ifdef DEBUG
if (next_char > 0x7fu) {
fprintf(stderr, "Non-ASCII character in input: '%c'.", next_char);
exit(1);
}
#endif
offset_++;
return static_cast<int32_t>(next_char);
}
private:
const uint8_t* buffer_;
const int end_offset_;
int offset_;
};
bool ReadBuffer(FILE* source, void* buffer, size_t length) {
size_t actually_read = fread(buffer, 1, length, source);
return (actually_read == length);
}
bool WriteBuffer(FILE* dest, const void* buffer, size_t length) {
size_t actually_written = fwrite(buffer, 1, length, dest);
return (actually_written == length);
}
class PreparseDataInterpreter {
public:
PreparseDataInterpreter(const uint8_t* data, int length)
: data_(data), length_(length), message_(NULL) { }
~PreparseDataInterpreter() {
if (message_ != NULL) delete[] message_;
}
bool valid() {
int header_length =
i::PreparseDataConstants::kHeaderSize * sizeof(int); // NOLINT
return length_ >= header_length;
}
bool throws() {
return valid() &&
word(i::PreparseDataConstants::kHasErrorOffset) != 0;
}
const char* message() {
if (message_ != NULL) return message_;
if (!throws()) return NULL;
int text_pos = i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageTextPos;
int length = word(text_pos);
char* buffer = new char[length + 1];
for (int i = 1; i <= length; i++) {
int character = word(text_pos + i);
buffer[i - 1] = character;
}
buffer[length] = '\0';
message_ = buffer;
return buffer;
}
int beg_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageStartPos);
}
int end_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageEndPos);
}
private:
int word(int offset) {
const int* word_data = reinterpret_cast<const int*>(data_);
if (word_data + offset < reinterpret_cast<const int*>(data_ + length_)) {
return word_data[offset];
}
return -1;
}
const uint8_t* const data_;
const int length_;
const char* message_;
};
template <typename T>
class ScopedPointer {
public:
explicit ScopedPointer() : pointer_(NULL) {}
explicit ScopedPointer(T* pointer) : pointer_(pointer) {}
~ScopedPointer() { if (pointer_ != NULL) delete[] pointer_; }
T& operator[](int index) { return pointer_[index]; }
T* operator*() { return pointer_ ;}
T* operator=(T* new_value) {
if (pointer_ != NULL) delete[] pointer_;
pointer_ = new_value;
return new_value;
}
private:
T* pointer_;
};
void fail(v8::PreParserData* data, const char* message, ...) {
va_list args;
va_start(args, message);
vfprintf(stderr, message, args);
va_end(args);
fflush(stderr);
// Print preparser data to stdout.
uint32_t size = data->size();
fprintf(stderr, "LOG: data size: %u\n", size);
if (!WriteBuffer(stdout, data->data(), size)) {
perror("ERROR: Writing data");
fflush(stderr);
}
exit(EXIT_FAILURE);
};
bool IsFlag(const char* arg) {
// Anything starting with '-' is considered a flag.
// It's summarily ignored for now.
return arg[0] == '-';
}
struct ExceptionExpectation {
ExceptionExpectation()
: throws(false), type(NULL), beg_pos(-1), end_pos(-1) { }
bool throws;
const char* type;
int beg_pos;
int end_pos;
};
void CheckException(v8::PreParserData* data,
ExceptionExpectation* expects) {
PreparseDataInterpreter reader(data->data(), data->size());
if (expects->throws) {
if (!reader.throws()) {
if (expects->type == NULL) {
fail(data, "Didn't throw as expected\n");
} else {
fail(data, "Didn't throw \"%s\" as expected\n", expects->type);
}
}
if (expects->type != NULL) {
const char* actual_message = reader.message();
if (strcmp(expects->type, actual_message)) {
fail(data, "Wrong error message. Expected <%s>, found <%s> at %d..%d\n",
expects->type, actual_message, reader.beg_pos(), reader.end_pos());
}
}
if (expects->beg_pos >= 0) {
if (expects->beg_pos != reader.beg_pos()) {
fail(data, "Wrong error start position: Expected %i, found %i\n",
expects->beg_pos, reader.beg_pos());
}
}
if (expects->end_pos >= 0) {
if (expects->end_pos != reader.end_pos()) {
fail(data, "Wrong error end position: Expected %i, found %i\n",
expects->end_pos, reader.end_pos());
}
}
} else if (reader.throws()) {
const char* message = reader.message();
fail(data, "Throws unexpectedly with message: %s at location %d-%d\n",
message, reader.beg_pos(), reader.end_pos());
}
}
ExceptionExpectation ParseExpectation(int argc, const char* argv[]) {
ExceptionExpectation expects;
// Parse exception expectations from (the remainder of) the command line.
int arg_index = 0;
// Skip any flags.
while (argc > arg_index && IsFlag(argv[arg_index])) arg_index++;
if (argc > arg_index) {
if (strncmp("throws", argv[arg_index], 7)) {
// First argument after filename, if present, must be the verbatim
// "throws", marking that the preparsing should fail with an exception.
fail(NULL, "ERROR: Extra arguments not prefixed by \"throws\".\n");
}
expects.throws = true;
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
// Next argument is the exception type identifier.
expects.type = argv[arg_index];
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.beg_pos = atoi(argv[arg_index]); // NOLINT
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.end_pos = atoi(argv[arg_index]); // NOLINT
}
}
}
}
return expects;
}
int main(int argc, const char* argv[]) {
// Parse command line.
// Format: preparser (<scriptfile> | -e "<source>")
// ["throws" [<exn-type> [<start> [<end>]]]]
// Any flags (except an initial -s) are ignored.
// Check for mandatory filename argument.
int arg_index = 1;
if (argc <= arg_index) {
fail(NULL, "ERROR: No filename on command line.\n");
}
const uint8_t* source = NULL;
const char* filename = argv[arg_index];
if (!strcmp(filename, "-e")) {
arg_index++;
if (argc <= arg_index) {
fail(NULL, "ERROR: No source after -e on command line.\n");
}
source = reinterpret_cast<const uint8_t*>(argv[arg_index]);
}
// Check remainder of command line for exception expectations.
arg_index++;
ExceptionExpectation expects =
ParseExpectation(argc - arg_index, argv + arg_index);
ScopedPointer<uint8_t> buffer;
size_t length;
if (source == NULL) {
// Open JS file.
FILE* input = fopen(filename, "rb");
if (input == NULL) {
perror("ERROR: Error opening file");
fflush(stderr);
return EXIT_FAILURE;
}
// Find length of JS file.
if (fseek(input, 0, SEEK_END) != 0) {
perror("ERROR: Error during seek");
fflush(stderr);
return EXIT_FAILURE;
}
length = static_cast<size_t>(ftell(input));
rewind(input);
// Read JS file into memory buffer.
buffer = new uint8_t[length];
if (!ReadBuffer(input, *buffer, length)) {
perror("ERROR: Reading file");
fflush(stderr);
return EXIT_FAILURE;
}
fclose(input);
source = *buffer;
} else {
length = strlen(reinterpret_cast<const char*>(source));
}
// Preparse input file.
AsciiInputStream input_buffer(source, length);
size_t kMaxStackSize = 64 * 1024 * sizeof(void*); // NOLINT
v8::PreParserData data = v8::Preparse(&input_buffer, kMaxStackSize);
// Fail if stack overflow.
if (data.stack_overflow()) {
fail(&data, "ERROR: Stack overflow\n");
}
// Check that the expected exception is thrown, if an exception is
// expected.
CheckException(&data, &expects);
return EXIT_SUCCESS;
}
<commit_msg>Removed unnecessary semicolon.<commit_after>// Copyright 2011 the V8 project authors. 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 Google Inc. 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 <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "../include/v8stdint.h"
#include "../include/v8-preparser.h"
#include "../src/preparse-data-format.h"
namespace i = v8::internal;
// This file is only used for testing the stand-alone preparser
// library.
// The first argument must be the path of a JavaScript source file, or
// the flags "-e" and the next argument is then the source of a JavaScript
// program.
// Optionally this can be followed by the word "throws" (case sensitive),
// which signals that the parsing is expected to throw - the default is
// to expect the parsing to not throw.
// The command line can further be followed by a message text (the
// *type* of the exception to throw), and even more optionally, the
// start and end position reported with the exception.
//
// This source file is preparsed and tested against the expectations, and if
// successful, the resulting preparser data is written to stdout.
// Diagnostic output is output on stderr.
// The source file must contain only ASCII characters (UTF-8 isn't supported).
// The file is read into memory, so it should have a reasonable size.
// Adapts an ASCII string to the UnicodeInputStream interface.
class AsciiInputStream : public v8::UnicodeInputStream {
public:
AsciiInputStream(const uint8_t* buffer, size_t length)
: buffer_(buffer),
end_offset_(static_cast<int>(length)),
offset_(0) { }
virtual ~AsciiInputStream() { }
virtual void PushBack(int32_t ch) {
offset_--;
#ifdef DEBUG
if (offset_ < 0 ||
(ch != ((offset_ >= end_offset_) ? -1 : buffer_[offset_]))) {
fprintf(stderr, "Invalid pushback: '%c' at offset %d.", ch, offset_);
exit(1);
}
#endif
}
virtual int32_t Next() {
if (offset_ >= end_offset_) {
offset_++; // Increment anyway to allow symmetric pushbacks.
return -1;
}
uint8_t next_char = buffer_[offset_];
#ifdef DEBUG
if (next_char > 0x7fu) {
fprintf(stderr, "Non-ASCII character in input: '%c'.", next_char);
exit(1);
}
#endif
offset_++;
return static_cast<int32_t>(next_char);
}
private:
const uint8_t* buffer_;
const int end_offset_;
int offset_;
};
bool ReadBuffer(FILE* source, void* buffer, size_t length) {
size_t actually_read = fread(buffer, 1, length, source);
return (actually_read == length);
}
bool WriteBuffer(FILE* dest, const void* buffer, size_t length) {
size_t actually_written = fwrite(buffer, 1, length, dest);
return (actually_written == length);
}
class PreparseDataInterpreter {
public:
PreparseDataInterpreter(const uint8_t* data, int length)
: data_(data), length_(length), message_(NULL) { }
~PreparseDataInterpreter() {
if (message_ != NULL) delete[] message_;
}
bool valid() {
int header_length =
i::PreparseDataConstants::kHeaderSize * sizeof(int); // NOLINT
return length_ >= header_length;
}
bool throws() {
return valid() &&
word(i::PreparseDataConstants::kHasErrorOffset) != 0;
}
const char* message() {
if (message_ != NULL) return message_;
if (!throws()) return NULL;
int text_pos = i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageTextPos;
int length = word(text_pos);
char* buffer = new char[length + 1];
for (int i = 1; i <= length; i++) {
int character = word(text_pos + i);
buffer[i - 1] = character;
}
buffer[length] = '\0';
message_ = buffer;
return buffer;
}
int beg_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageStartPos);
}
int end_pos() {
if (!throws()) return -1;
return word(i::PreparseDataConstants::kHeaderSize +
i::PreparseDataConstants::kMessageEndPos);
}
private:
int word(int offset) {
const int* word_data = reinterpret_cast<const int*>(data_);
if (word_data + offset < reinterpret_cast<const int*>(data_ + length_)) {
return word_data[offset];
}
return -1;
}
const uint8_t* const data_;
const int length_;
const char* message_;
};
template <typename T>
class ScopedPointer {
public:
explicit ScopedPointer() : pointer_(NULL) {}
explicit ScopedPointer(T* pointer) : pointer_(pointer) {}
~ScopedPointer() { if (pointer_ != NULL) delete[] pointer_; }
T& operator[](int index) { return pointer_[index]; }
T* operator*() { return pointer_ ;}
T* operator=(T* new_value) {
if (pointer_ != NULL) delete[] pointer_;
pointer_ = new_value;
return new_value;
}
private:
T* pointer_;
};
void fail(v8::PreParserData* data, const char* message, ...) {
va_list args;
va_start(args, message);
vfprintf(stderr, message, args);
va_end(args);
fflush(stderr);
// Print preparser data to stdout.
uint32_t size = data->size();
fprintf(stderr, "LOG: data size: %u\n", size);
if (!WriteBuffer(stdout, data->data(), size)) {
perror("ERROR: Writing data");
fflush(stderr);
}
exit(EXIT_FAILURE);
}
bool IsFlag(const char* arg) {
// Anything starting with '-' is considered a flag.
// It's summarily ignored for now.
return arg[0] == '-';
}
struct ExceptionExpectation {
ExceptionExpectation()
: throws(false), type(NULL), beg_pos(-1), end_pos(-1) { }
bool throws;
const char* type;
int beg_pos;
int end_pos;
};
void CheckException(v8::PreParserData* data,
ExceptionExpectation* expects) {
PreparseDataInterpreter reader(data->data(), data->size());
if (expects->throws) {
if (!reader.throws()) {
if (expects->type == NULL) {
fail(data, "Didn't throw as expected\n");
} else {
fail(data, "Didn't throw \"%s\" as expected\n", expects->type);
}
}
if (expects->type != NULL) {
const char* actual_message = reader.message();
if (strcmp(expects->type, actual_message)) {
fail(data, "Wrong error message. Expected <%s>, found <%s> at %d..%d\n",
expects->type, actual_message, reader.beg_pos(), reader.end_pos());
}
}
if (expects->beg_pos >= 0) {
if (expects->beg_pos != reader.beg_pos()) {
fail(data, "Wrong error start position: Expected %i, found %i\n",
expects->beg_pos, reader.beg_pos());
}
}
if (expects->end_pos >= 0) {
if (expects->end_pos != reader.end_pos()) {
fail(data, "Wrong error end position: Expected %i, found %i\n",
expects->end_pos, reader.end_pos());
}
}
} else if (reader.throws()) {
const char* message = reader.message();
fail(data, "Throws unexpectedly with message: %s at location %d-%d\n",
message, reader.beg_pos(), reader.end_pos());
}
}
ExceptionExpectation ParseExpectation(int argc, const char* argv[]) {
ExceptionExpectation expects;
// Parse exception expectations from (the remainder of) the command line.
int arg_index = 0;
// Skip any flags.
while (argc > arg_index && IsFlag(argv[arg_index])) arg_index++;
if (argc > arg_index) {
if (strncmp("throws", argv[arg_index], 7)) {
// First argument after filename, if present, must be the verbatim
// "throws", marking that the preparsing should fail with an exception.
fail(NULL, "ERROR: Extra arguments not prefixed by \"throws\".\n");
}
expects.throws = true;
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
// Next argument is the exception type identifier.
expects.type = argv[arg_index];
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.beg_pos = atoi(argv[arg_index]); // NOLINT
do {
arg_index++;
} while (argc > arg_index && IsFlag(argv[arg_index]));
if (argc > arg_index) {
expects.end_pos = atoi(argv[arg_index]); // NOLINT
}
}
}
}
return expects;
}
int main(int argc, const char* argv[]) {
// Parse command line.
// Format: preparser (<scriptfile> | -e "<source>")
// ["throws" [<exn-type> [<start> [<end>]]]]
// Any flags (except an initial -s) are ignored.
// Check for mandatory filename argument.
int arg_index = 1;
if (argc <= arg_index) {
fail(NULL, "ERROR: No filename on command line.\n");
}
const uint8_t* source = NULL;
const char* filename = argv[arg_index];
if (!strcmp(filename, "-e")) {
arg_index++;
if (argc <= arg_index) {
fail(NULL, "ERROR: No source after -e on command line.\n");
}
source = reinterpret_cast<const uint8_t*>(argv[arg_index]);
}
// Check remainder of command line for exception expectations.
arg_index++;
ExceptionExpectation expects =
ParseExpectation(argc - arg_index, argv + arg_index);
ScopedPointer<uint8_t> buffer;
size_t length;
if (source == NULL) {
// Open JS file.
FILE* input = fopen(filename, "rb");
if (input == NULL) {
perror("ERROR: Error opening file");
fflush(stderr);
return EXIT_FAILURE;
}
// Find length of JS file.
if (fseek(input, 0, SEEK_END) != 0) {
perror("ERROR: Error during seek");
fflush(stderr);
return EXIT_FAILURE;
}
length = static_cast<size_t>(ftell(input));
rewind(input);
// Read JS file into memory buffer.
buffer = new uint8_t[length];
if (!ReadBuffer(input, *buffer, length)) {
perror("ERROR: Reading file");
fflush(stderr);
return EXIT_FAILURE;
}
fclose(input);
source = *buffer;
} else {
length = strlen(reinterpret_cast<const char*>(source));
}
// Preparse input file.
AsciiInputStream input_buffer(source, length);
size_t kMaxStackSize = 64 * 1024 * sizeof(void*); // NOLINT
v8::PreParserData data = v8::Preparse(&input_buffer, kMaxStackSize);
// Fail if stack overflow.
if (data.stack_overflow()) {
fail(&data, "ERROR: Stack overflow\n");
}
// Check that the expected exception is thrown, if an exception is
// expected.
CheckException(&data, &expects);
return EXIT_SUCCESS;
}
<|endoftext|> |
<commit_before>/******************************************************************************
* Controls.cpp
*
* Contains the yaw_controller() and depth_controller functions
******************************************************************************/
#include "Mapper.h"
/******************************************************************************
* float yaw_controller()
*
* Takes in readings from the IMU and returns a value between -1 and 1 (-100% -
* +100%) that the port and starboard thrusters should run at
******************************************************************************/
float yaw_controller(bno055_t bno055 pid_data_t yaw_pid)
{
// control output //
if( bno055.yaw < 180 ) // AUV is pointed right
{
// u[2] is negative
motor_percent = yaw_pid.kp*(yaw_pid.err)
+ yaw_pid.kd*(bno055.r)+ yaw_pid.ki*yaw_pid.i_err; // yaw controller
}
else // AUV is pointed left
{
// u[2] is positive
motor_percent = yaw_pid.kp*(yaw_pid.err) + yaw_pid.kd*(bno055.r)
+ yaw_pid.ki*yaw_pid.i_err; // yaw controller
}
// saturate yaw controller //
if( u[2] > YAW_SAT )
{
motor_percent=YAW_SAT;
}
else if( motor_percent < -YAW_SAT )
{
motor_percent = -YAW_SAT;
}
yaw_pid.i_err += yaw_pid.err*DT;
// set current yaw to be the old yaw //
yaw_pid.oldyaw = bno055.yaw;
return motor_percent;
}
/******************************************************************************
* float depth_controller(float range)
*
* Takes a range-from-bottom reading from the laser range-finder code and
* returns a value between -1 and 1 (-100% - +100%) that the vertical thruster
* should run at
******************************************************************************/
/*
float depth_controller(float range)
{
float vert_percent; // vertical thruster output in a percentage
float depth_sum_error = 0; // accumulated range error for integral control
float range_current;
float range_old;
float
// accumulated range error for integral control //
depth_sum_error += range - depth_pid.setpoint;
if( range > depth_pid.setpoint )
{
vert_percent = depth_pid.kp*(range-depth_pid.setpoint)
+ depth_pid.ki*(depth_sum_error)
+ depth_pid.kd*((range_current-range_old)/DT);
}
else
{
// shut off vertical thruster //
vert_percent = 0;
}
// saturate depth controller //
if( vert_percent > DEPTH_SAT )
{
vert_percent = DEPTH_SAT;
}
else if( vert_percent < -DEPTH_SAT )
{
vert_percent = -DEPTH_SAT;
}
// set current depth to be the old depth //
depth_pid.old = depth_pid.current;
return vert_percent;
}
*/
<commit_msg>More controls edits<commit_after>/******************************************************************************
* Controls.cpp
*
* Contains the yaw_controller() and depth_controller functions
******************************************************************************/
#include "Mapper.h"
/******************************************************************************
* float yaw_controller()
*
* Takes in readings from the IMU and returns a value between -1 and 1 (-100% -
* +100%) that the port and starboard thrusters should run at
******************************************************************************/
float yaw_controller(bno055_t bno055, pid_data_t yaw_pid)
{
// control output //
if( bno055.yaw < 180 ) // AUV is pointed right
{
// u[2] is negative
motor_percent = yaw_pid.kp*(yaw_pid.err)
+ yaw_pid.kd*(bno055.r)+ yaw_pid.ki*yaw_pid.i_err; // yaw controller
}
else // AUV is pointed left
{
// u[2] is positive
motor_percent = yaw_pid.kp*(yaw_pid.err) + yaw_pid.kd*(bno055.r)
+ yaw_pid.ki*yaw_pid.i_err; // yaw controller
}
// saturate yaw controller //
if( motor_percent > YAW_SAT )
{
motor_percent=YAW_SAT;
}
else if( motor_percent < -YAW_SAT )
{
motor_percent = -YAW_SAT;
}
yaw_pid.i_err += yaw_pid.err*DT;
// set current yaw to be the old yaw //
yaw_pid.oldyaw = bno055.yaw;
return motor_percent;
}
/******************************************************************************
* float depth_controller(float range)
*
* Takes a range-from-bottom reading from the laser range-finder code and
* returns a value between -1 and 1 (-100% - +100%) that the vertical thruster
* should run at
******************************************************************************/
/*
float depth_controller(float range)
{
float vert_percent; // vertical thruster output in a percentage
float depth_sum_error = 0; // accumulated range error for integral control
float range_current;
float range_old;
float
// accumulated range error for integral control //
depth_sum_error += range - depth_pid.setpoint;
if( range > depth_pid.setpoint )
{
vert_percent = depth_pid.kp*(range-depth_pid.setpoint)
+ depth_pid.ki*(depth_sum_error)
+ depth_pid.kd*((range_current-range_old)/DT);
}
else
{
// shut off vertical thruster //
vert_percent = 0;
}
// saturate depth controller //
if( vert_percent > DEPTH_SAT )
{
vert_percent = DEPTH_SAT;
}
else if( vert_percent < -DEPTH_SAT )
{
vert_percent = -DEPTH_SAT;
}
// set current depth to be the old depth //
depth_pid.old = depth_pid.current;
return vert_percent;
}
*/
<|endoftext|> |
<commit_before>/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. 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.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR
* ITS 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.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
* FileUtility.hpp
*/
#if !defined(FILEUTILITY_HEADER_GUARD_1357924680)
#define FILEUTILITY_HEADER_GUARD_1357924680
#include<string>
#include<stdio.h>
#include <time.h>
#if defined(XALAN_OLD_STREAM_HEADERS)
#include <iostream.h>
#else
#include <iostream>
#endif
// XERCES HEADERS ...
// Are included in HarnessInit.hpp
// XALAN HEADERS...
#include <PlatformSupport/XalanOutputStreamPrintWriter.hpp>
#include <PlatformSupport/XalanFileOutputStream.hpp>
#include <PlatformSupport/DirectoryEnumerator.hpp>
#include <PlatformSupport/DOMStringHelper.hpp>
#include <XPath/XObjectFactoryDefault.hpp>
#include <XPath/XPathFactoryDefault.hpp>
#include <XMLSupport/FormatterToXML.hpp>
#include <XMLSupport/FormatterTreeWalker.hpp>
#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
#include <XalanSourceTree/XalanSourceTreeDocument.hpp>
#include <XalanTransformer/XalanCompiledStylesheetDefault.hpp>
#include <XalanTransformer/XalanTransformer.hpp>
#include "XMLFileReporter.hpp"
using namespace std;
/**
* Utility call that extracts test file names from testsuite.
* @author Paul Dick@lotus.com
* @version $Id$
*/
#if defined HARNESS_EXPORTS
#define HARNESS_API __declspec(dllexport)
#else
#define HARNESS_API __declspec(dllimport)
#endif
// Misc typedefs and Global variables.
// These structures hold vectors of directory names and file names.
#if defined(XALAN_NO_NAMESPACES)
typedef vector<XalanDOMString> FileNameVectorType;
#else
typedef std::vector<XalanDOMString> FileNameVectorType;
#endif
// Basic Global variables used by many tests.
const XalanDOMString processorType(XALAN_STATIC_UCODE_STRING("XalanC"));
const XalanDOMString XSLSuffix(XALAN_STATIC_UCODE_STRING(".xsl"));
const XalanDOMString XMLSuffix(XALAN_STATIC_UCODE_STRING(".xml"));
const XalanDOMString pathSep(XALAN_STATIC_UCODE_STRING("\\"));
// This class is exported from the Harness.dll
class HARNESS_API FileUtility
{
public:
struct reportStruct
{
XalanDOMString testOrFile;
char* msg;
XalanDOMString currentNode;
XalanDOMString actual;
XalanDOMString expected;
int pass;
int fail;
void reset()
{
clear(testOrFile);
msg = "";
clear(currentNode);
clear(actual);
clear(expected);
}
} data ;
/** Simple constructor, does not perform initialization. */
FileUtility()
{
cout << endl << "Using Xerces Version " << gXercesFullVersionStr << endl;
}
/**
* Utility method used to get test files from a specific directory.
* @returns a vector containing test files.
*/
FileNameVectorType FileUtility::getTestFileNames(XalanDOMString baseDir, XalanDOMString relDir, bool useDirPrefix);
//FileNameVectorType getTestFileNames (char* theDirectory);
/**
* Utility method used to get subdirectories from a specific directory.
* @returns a vector containing directory files.
*/
FileNameVectorType FileUtility::getDirectoryNames(XalanDOMString rootDirectory);
/**
* Utility method used to create default directories when neccessary
*/
void FileUtility::checkAndCreateDir(XalanDOMString directory );
/**
* Utility method determines if directory exists.
*/
bool FileUtility::checkDir(XalanDOMString directory );
/**
* Utility method used to get XSL file based on XML file.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::GetXSLFileName(const XalanDOMString& theXMLFileName);
/**
* Utility method used to get OUT file based on XML file.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::GenerateFileName(const XalanDOMString& theXMLFileName, char* suffix);
/**
* Utility method used to generate UniqRunid.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::GenerateUniqRunid();
/**
* Utility methods used to get Xerces Version number.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::getXercesVersion();
void
FileUtility::checkResults(const XalanDOMString& outputFile,
const XalanDOMString& goldFile,
XMLFileReporter& logfile);
/**
* Utility method used to compare the results. It inturn
* call domCompare.
* @returns Void.
*/
bool
FileUtility::compareDOMResults(const XalanDOMString& theOutputFile,
const XalanCompiledStylesheet* compiledSS,
XalanSourceTreeDocument* dom,
const XSLTInputSource& goldInputSource);
/**
* Simplified version of above.
*/
// void
// FileUtility::compareSerializedResults(const XSLTInputSource& transformResult,
// const XSLTInputSource& goldInputSource,
// XalanDOMString fileName, const char* testCase);
bool
FileUtility::compareSerializedResults(const XalanDOMString& transformResult,
const XalanDOMString& goldInputSource);
/**
* Utility method used to create a FormatterToXML FormatterListener.
* This is required to DOM comparisions.
* @returns a pointer to a FormatterListener.
*/
FormatterListener*
FileUtility::getXMLFormatter(bool shouldWriteXMLHeader,
bool stripCData,
bool escapeCData,
PrintWriter& resultWriter,
int indentAmount,
const XalanDOMString& mimeEncoding,
const StylesheetRoot* stylesheet);
bool
FileUtility::fileCompare(const char* goldFile,
const char* outputFile);
/**
* Utility methods used to perform a DOM Compare
* @returns boolean
*/
bool
FileUtility::domCompare(const XalanNode& gold, const XalanNode& doc);
/**
* Utility methods used to diff two Element nodes.
* @returns boolean.
*/
bool
FileUtility::diffElement(const XalanNode& gold, const XalanNode& doc);
/**
* Utility methods used to diff two attribute nodes.
* @returns boolean.
*/
bool
FileUtility::diffAttr(const XalanNode* gAttr, const XalanNode* dAttr);
/**
* Utility methods used to report Pass/Fail numbers.
* @returns void.
*/
void
FileUtility::reportPassFail(XMLFileReporter& logfile);
private:
/**
* Utility methods used to collect information about compare failures.
* @returns void.
*/
void
FileUtility::collectData(char* errmsg,
XalanDOMString currentnode,
XalanDOMString actdata,
XalanDOMString expdata);
/**
* Utility methods used to report DOM compare errors.
* @returns void.
*/
void
FileUtility::reportDOMError();
}; // end of class FileUtility
#endif
<commit_msg>Added variable to track missing gold files.<commit_after>/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. 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.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR
* ITS 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.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*
* FileUtility.hpp
*/
#if !defined(FILEUTILITY_HEADER_GUARD_1357924680)
#define FILEUTILITY_HEADER_GUARD_1357924680
#include<string>
#include<stdio.h>
#include <time.h>
#if defined(XALAN_OLD_STREAM_HEADERS)
#include <iostream.h>
#else
#include <iostream>
#endif
// XERCES HEADERS ...
// Are included in HarnessInit.hpp
// XALAN HEADERS...
#include <PlatformSupport/XalanOutputStreamPrintWriter.hpp>
#include <PlatformSupport/XalanFileOutputStream.hpp>
#include <PlatformSupport/DirectoryEnumerator.hpp>
#include <PlatformSupport/DOMStringHelper.hpp>
#include <XPath/XObjectFactoryDefault.hpp>
#include <XPath/XPathFactoryDefault.hpp>
#include <XMLSupport/FormatterToXML.hpp>
#include <XMLSupport/FormatterTreeWalker.hpp>
#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
#include <XalanSourceTree/XalanSourceTreeDocument.hpp>
#include <XalanTransformer/XalanCompiledStylesheetDefault.hpp>
#include <XalanTransformer/XalanTransformer.hpp>
#include "XMLFileReporter.hpp"
using namespace std;
/**
* Utility call that extracts test file names from testsuite.
* @author Paul Dick@lotus.com
* @version $Id$
*/
#if defined HARNESS_EXPORTS
#define HARNESS_API __declspec(dllexport)
#else
#define HARNESS_API __declspec(dllimport)
#endif
// Misc typedefs and Global variables.
// These structures hold vectors of directory names and file names.
#if defined(XALAN_NO_NAMESPACES)
typedef vector<XalanDOMString> FileNameVectorType;
#else
typedef std::vector<XalanDOMString> FileNameVectorType;
#endif
// Basic Global variables used by many tests.
const XalanDOMString processorType(XALAN_STATIC_UCODE_STRING("XalanC"));
const XalanDOMString XSLSuffix(XALAN_STATIC_UCODE_STRING(".xsl"));
const XalanDOMString XMLSuffix(XALAN_STATIC_UCODE_STRING(".xml"));
const XalanDOMString pathSep(XALAN_STATIC_UCODE_STRING("\\"));
// This class is exported from the Harness.dll
class HARNESS_API FileUtility
{
public:
struct reportStruct
{
XalanDOMString testOrFile;
char* msg;
XalanDOMString currentNode;
XalanDOMString actual;
XalanDOMString expected;
int pass;
int fail;
int nogold;
void reset()
{
clear(testOrFile);
msg = "";
clear(currentNode);
clear(actual);
clear(expected);
}
} data ;
/** Simple constructor, does not perform initialization. */
FileUtility()
{
cout << endl << "Using Xerces Version " << gXercesFullVersionStr << endl;
}
/**
* Utility method used to get test files from a specific directory.
* @returns a vector containing test files.
*/
FileNameVectorType FileUtility::getTestFileNames(XalanDOMString baseDir, XalanDOMString relDir, bool useDirPrefix);
//FileNameVectorType getTestFileNames (char* theDirectory);
/**
* Utility method used to get subdirectories from a specific directory.
* @returns a vector containing directory files.
*/
FileNameVectorType FileUtility::getDirectoryNames(XalanDOMString rootDirectory);
/**
* Utility method used to create default directories when neccessary
*/
void FileUtility::checkAndCreateDir(XalanDOMString directory );
/**
* Utility method determines if directory exists.
*/
bool FileUtility::checkDir(XalanDOMString directory );
/**
* Utility method used to get XSL file based on XML file.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::GetXSLFileName(const XalanDOMString& theXMLFileName);
/**
* Utility method used to get OUT file based on XML file.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::GenerateFileName(const XalanDOMString& theXMLFileName, char* suffix);
/**
* Utility method used to generate UniqRunid.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::GenerateUniqRunid();
/**
* Utility methods used to get Xerces Version number.
* @returns a XalanDOMString.
*/
XalanDOMString FileUtility::getXercesVersion();
void
FileUtility::checkResults(const XalanDOMString& outputFile,
const XalanDOMString& goldFile,
XMLFileReporter& logfile);
/**
* Utility method used to compare the results. It inturn
* call domCompare.
* @returns Void.
*/
bool
FileUtility::compareDOMResults(const XalanDOMString& theOutputFile,
const XalanCompiledStylesheet* compiledSS,
XalanSourceTreeDocument* dom,
const XSLTInputSource& goldInputSource);
/**
* Simplified version of above.
*/
// void
// FileUtility::compareSerializedResults(const XSLTInputSource& transformResult,
// const XSLTInputSource& goldInputSource,
// XalanDOMString fileName, const char* testCase);
bool
FileUtility::compareSerializedResults(const XalanDOMString& transformResult,
const XalanDOMString& goldInputSource);
/**
* Utility method used to create a FormatterToXML FormatterListener.
* This is required to DOM comparisions.
* @returns a pointer to a FormatterListener.
*/
FormatterListener*
FileUtility::getXMLFormatter(bool shouldWriteXMLHeader,
bool stripCData,
bool escapeCData,
PrintWriter& resultWriter,
int indentAmount,
const XalanDOMString& mimeEncoding,
const StylesheetRoot* stylesheet);
bool
FileUtility::fileCompare(const char* goldFile,
const char* outputFile);
/**
* Utility methods used to perform a DOM Compare
* @returns boolean
*/
bool
FileUtility::domCompare(const XalanNode& gold, const XalanNode& doc);
/**
* Utility methods used to diff two Element nodes.
* @returns boolean.
*/
bool
FileUtility::diffElement(const XalanNode& gold, const XalanNode& doc);
/**
* Utility methods used to diff two attribute nodes.
* @returns boolean.
*/
bool
FileUtility::diffAttr(const XalanNode* gAttr, const XalanNode* dAttr);
/**
* Utility methods used to report Pass/Fail numbers.
* @returns void.
*/
void
FileUtility::reportPassFail(XMLFileReporter& logfile);
private:
/**
* Utility methods used to collect information about compare failures.
* @returns void.
*/
void
FileUtility::collectData(char* errmsg,
XalanDOMString currentnode,
XalanDOMString actdata,
XalanDOMString expdata);
/**
* Utility methods used to report DOM compare errors.
* @returns void.
*/
void
FileUtility::reportDOMError();
}; // end of class FileUtility
#endif
<|endoftext|> |
<commit_before><commit_msg>fix multi-console problem for bat on win32<commit_after><|endoftext|> |
<commit_before>// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/vespalib/testkit/test_kit.h>
#include <vespa/eval/eval/fast_value.h>
#include <vespa/eval/eval/simple_value.h>
#include <vespa/eval/eval/tensor_function.h>
#include <vespa/eval/instruction/mixed_simple_join_function.h>
#include <vespa/eval/eval/test/eval_fixture.h>
#include <vespa/eval/eval/test/gen_spec.h>
#include <vespa/vespalib/util/stringfmt.h>
using namespace vespalib;
using namespace vespalib::eval;
using namespace vespalib::eval::test;
using namespace vespalib::eval::tensor_function;
using vespalib::make_string_short::fmt;
const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
const ValueBuilderFactory &test_factory = SimpleValueBuilderFactory::get();
using Primary = MixedSimpleJoinFunction::Primary;
using Overlap = MixedSimpleJoinFunction::Overlap;
namespace vespalib::eval {
std::ostream &operator<<(std::ostream &os, Primary primary)
{
switch(primary) {
case Primary::LHS: return os << "LHS";
case Primary::RHS: return os << "RHS";
}
abort();
}
std::ostream &operator<<(std::ostream &os, Overlap overlap)
{
switch(overlap) {
case Overlap::FULL: return os << "FULL";
case Overlap::INNER: return os << "INNER";
case Overlap::OUTER: return os << "OUTER";
}
abort();
}
}
struct FunInfo {
using LookFor = MixedSimpleJoinFunction;
Overlap overlap;
size_t factor;
Primary primary;
bool l_mut;
bool r_mut;
bool inplace;
void verify(const EvalFixture &fixture, const LookFor &fun) const {
EXPECT_TRUE(fun.result_is_mutable());
EXPECT_EQUAL(fun.overlap(), overlap);
EXPECT_EQUAL(fun.factor(), factor);
EXPECT_EQUAL(fun.primary(), primary);
if (fun.primary_is_mutable()) {
if (fun.primary() == Primary::LHS) {
EXPECT_TRUE(l_mut);
}
if (fun.primary() == Primary::RHS) {
EXPECT_TRUE(r_mut);
}
}
EXPECT_EQUAL(fun.inplace(), inplace);
if (fun.inplace()) {
EXPECT_TRUE(fun.primary_is_mutable());
size_t idx = (fun.primary() == Primary::LHS) ? 0 : 1;
EXPECT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(idx).cells().data);
EXPECT_NOT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(1-idx).cells().data);
} else {
EXPECT_NOT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(0).cells().data);
EXPECT_NOT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(1).cells().data);
}
}
};
void verify_simple(const vespalib::string &expr, Primary primary, Overlap overlap, size_t factor,
bool l_mut, bool r_mut, bool inplace)
{
TEST_STATE(expr.c_str());
CellTypeSpace just_double({CellType::DOUBLE}, 2);
FunInfo details{overlap, factor, primary, l_mut, r_mut, inplace};
EvalFixture::verify<FunInfo>(expr, {details}, just_double);
CellTypeSpace just_float({CellType::FLOAT}, 2);
EvalFixture::verify<FunInfo>(expr, {details}, just_float);
}
void verify_optimized(const vespalib::string &expr, Primary primary, Overlap overlap, size_t factor,
bool l_mut = false, bool r_mut = false, bool inplace = false)
{
TEST_STATE(expr.c_str());
CellTypeSpace all_types(CellTypeUtils::list_types(), 2);
FunInfo details{overlap, factor, primary, l_mut, r_mut, inplace};
EvalFixture::verify<FunInfo>(expr, {details}, all_types);
}
void verify_not_optimized(const vespalib::string &expr) {
TEST_STATE(expr.c_str());
CellTypeSpace just_double({CellType::DOUBLE}, 2);
EvalFixture::verify<FunInfo>(expr, {}, just_double);
}
TEST("require that basic join is optimized") {
TEST_DO(verify_optimized("y5+y5$2", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that inplace is preferred") {
TEST_DO(verify_simple("y5+y5$2", Primary::RHS, Overlap::FULL, 1, false, false, false));
TEST_DO(verify_simple("y5+@y5$2", Primary::RHS, Overlap::FULL, 1, false, true, true));
TEST_DO(verify_simple("@y5+@y5$2", Primary::RHS, Overlap::FULL, 1, true, true, true));
TEST_DO(verify_simple("@y5+y5$2", Primary::LHS, Overlap::FULL, 1, true, false, true));
}
TEST("require that unit join is optimized") {
TEST_DO(verify_optimized("a1b1c1+x1y1z1", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that trivial dimensions do not affect overlap calculation") {
TEST_DO(verify_optimized("c5d1+b1c5", Primary::RHS, Overlap::FULL, 1));
TEST_DO(verify_simple("@c5d1+@b1c5", Primary::RHS, Overlap::FULL, 1, true, true, true));
}
TEST("require that outer nesting is preferred to inner nesting") {
TEST_DO(verify_optimized("a1b1c1+y5", Primary::RHS, Overlap::OUTER, 5));
}
TEST("require that non-subset join is not optimized") {
TEST_DO(verify_not_optimized("y5+z3"));
}
TEST("require that subset join with complex overlap is not optimized") {
TEST_DO(verify_not_optimized("x3y5z3+y5"));
}
struct LhsRhs {
vespalib::string lhs;
vespalib::string rhs;
size_t lhs_size;
size_t rhs_size;
Overlap overlap;
size_t factor;
LhsRhs(const vespalib::string &lhs_in, const vespalib::string &rhs_in,
size_t lhs_size_in, size_t rhs_size_in, Overlap overlap_in) noexcept
: lhs(lhs_in), rhs(rhs_in), lhs_size(lhs_size_in), rhs_size(rhs_size_in), overlap(overlap_in), factor(1)
{
if (lhs_size > rhs_size) {
ASSERT_EQUAL(lhs_size % rhs_size, 0u);
factor = (lhs_size / rhs_size);
} else {
ASSERT_EQUAL(rhs_size % lhs_size, 0u);
factor = (rhs_size / lhs_size);
}
}
};
TEST("require that various parameter combinations work") {
for (CellType lct : CellTypeUtils::list_types()) {
for (CellType rct : CellTypeUtils::list_types()) {
for (bool left_mut: {false, true}) {
for (bool right_mut: {false, true}) {
for (const char * expr: {"a+b", "a-b", "a*b"}) {
for (const LhsRhs ¶ms:
{ LhsRhs("y5", "y5", 5, 5, Overlap::FULL),
LhsRhs("y5", "x3y5", 5, 15, Overlap::INNER),
LhsRhs("y5", "y5z3", 5, 15, Overlap::OUTER),
LhsRhs("x3y5", "y5", 15, 5, Overlap::INNER),
LhsRhs("y5z3", "y5", 15, 5, Overlap::OUTER)})
{
EvalFixture::ParamRepo param_repo;
auto a_spec = GenSpec::from_desc(params.lhs).cells(lct).seq(AX_B(0.25, 1.125));
auto b_spec = GenSpec::from_desc(params.rhs).cells(rct).seq(AX_B(-0.25, 25.0));
if (left_mut) {
param_repo.add_mutable("a", a_spec);
} else {
param_repo.add("a", a_spec);
}
if (right_mut) {
param_repo.add_mutable("b", b_spec);
} else {
param_repo.add("b", b_spec);
}
TEST_STATE(expr);
CellType result_ct = CellMeta::join(CellMeta{lct, false}, CellMeta{rct, false}).cell_type;
Primary primary = Primary::RHS;
if (params.overlap == Overlap::FULL) {
bool w_lhs = (lct == result_ct) && left_mut;
bool w_rhs = (rct == result_ct) && right_mut;
if (w_lhs && !w_rhs) {
primary = Primary::LHS;
}
} else if (params.lhs_size > params.rhs_size) {
primary = Primary::LHS;
}
bool pri_mut = (primary == Primary::LHS) ? left_mut : right_mut;
bool pri_same_ct = (primary == Primary::LHS) ? (lct == result_ct) : (rct == result_ct);
bool inplace = (pri_mut && pri_same_ct);
auto expect = EvalFixture::ref(expr, param_repo);
EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
EvalFixture test_fixture(test_factory, expr, param_repo, true, true);
EvalFixture fixture(prod_factory, expr, param_repo, true, true);
EXPECT_EQUAL(fixture.result(), expect);
EXPECT_EQUAL(slow_fixture.result(), expect);
EXPECT_EQUAL(test_fixture.result(), expect);
auto info = fixture.find_all<FunInfo::LookFor>();
ASSERT_EQUAL(info.size(), 1u);
FunInfo details{params.overlap, params.factor, primary, left_mut, right_mut, inplace};
details.verify(fixture, *info[0]);
}
}
}
}
}
}
}
TEST("require that scalar values are not optimized") {
TEST_DO(verify_not_optimized("reduce(v3,sum)+reduce(v4,sum)"));
TEST_DO(verify_not_optimized("reduce(v3,sum)+y5"));
TEST_DO(verify_not_optimized("y5+reduce(v3,sum)"));
TEST_DO(verify_not_optimized("reduce(v3,sum)+x3_1"));
TEST_DO(verify_not_optimized("x3_1+reduce(v3,sum)"));
TEST_DO(verify_not_optimized("reduce(v3,sum)+x3_1y5z3"));
TEST_DO(verify_not_optimized("x3_1y5z3+reduce(v3,sum)"));
}
TEST("require that sparse tensors are mostly not optimized") {
TEST_DO(verify_not_optimized("x3_1+x3_1$2"));
TEST_DO(verify_not_optimized("x3_1+y5"));
TEST_DO(verify_not_optimized("y5+x3_1"));
TEST_DO(verify_not_optimized("x3_1+x3_1y5z3"));
TEST_DO(verify_not_optimized("x3_1y5z3+x3_1"));
}
TEST("require that sparse tensor joined with trivial dense tensor is optimized") {
TEST_DO(verify_optimized("x3_1+a1b1c1", Primary::LHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("a1b1c1+x3_1", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that primary tensor can be empty") {
TEST_DO(verify_optimized("x0_1y5z3+y5z3", Primary::LHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("y5z3+x0_1y5z3", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that mixed tensors can be optimized") {
TEST_DO(verify_not_optimized("x3_1y5z3+x3_1y5z3$2"));
TEST_DO(verify_optimized("x3_1y5z3+y5z3", Primary::LHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("x3_1y5z3+y5", Primary::LHS, Overlap::OUTER, 3));
TEST_DO(verify_optimized("x3_1y5z3+z3", Primary::LHS, Overlap::INNER, 5));
TEST_DO(verify_optimized("y5z3+x3_1y5z3", Primary::RHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("y5+x3_1y5z3", Primary::RHS, Overlap::OUTER, 3));
TEST_DO(verify_optimized("z3+x3_1y5z3", Primary::RHS, Overlap::INNER, 5));
}
TEST("require that mixed tensors can be inplace") {
TEST_DO(verify_simple("@x3_1y5z3+y5z3", Primary::LHS, Overlap::FULL, 1, true, false, true));
TEST_DO(verify_simple("@x3_1y5z3+y5", Primary::LHS, Overlap::OUTER, 3, true, false, true));
TEST_DO(verify_simple("@x3_1y5z3+z3", Primary::LHS, Overlap::INNER, 5, true, false, true));
TEST_DO(verify_simple("@x3_1y5z3+@y5z3", Primary::LHS, Overlap::FULL, 1, true, true, true));
TEST_DO(verify_simple("@x3_1y5z3+@y5", Primary::LHS, Overlap::OUTER, 3, true, true, true));
TEST_DO(verify_simple("@x3_1y5z3+@z3", Primary::LHS, Overlap::INNER, 5, true, true, true));
TEST_DO(verify_simple("y5z3+@x3_1y5z3", Primary::RHS, Overlap::FULL, 1, false, true, true));
TEST_DO(verify_simple("y5+@x3_1y5z3", Primary::RHS, Overlap::OUTER, 3, false, true, true));
TEST_DO(verify_simple("z3+@x3_1y5z3", Primary::RHS, Overlap::INNER, 5, false, true, true));
TEST_DO(verify_simple("@y5z3+@x3_1y5z3", Primary::RHS, Overlap::FULL, 1, true, true, true));
TEST_DO(verify_simple("@y5+@x3_1y5z3", Primary::RHS, Overlap::OUTER, 3, true, true, true));
TEST_DO(verify_simple("@z3+@x3_1y5z3", Primary::RHS, Overlap::INNER, 5, true, true, true));
}
TEST_MAIN() { TEST_RUN_ALL(); }
<commit_msg>Deinline LhsRhs destructor.<commit_after>// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/vespalib/testkit/test_kit.h>
#include <vespa/eval/eval/fast_value.h>
#include <vespa/eval/eval/simple_value.h>
#include <vespa/eval/eval/tensor_function.h>
#include <vespa/eval/instruction/mixed_simple_join_function.h>
#include <vespa/eval/eval/test/eval_fixture.h>
#include <vespa/eval/eval/test/gen_spec.h>
#include <vespa/vespalib/util/stringfmt.h>
using namespace vespalib;
using namespace vespalib::eval;
using namespace vespalib::eval::test;
using namespace vespalib::eval::tensor_function;
using vespalib::make_string_short::fmt;
const ValueBuilderFactory &prod_factory = FastValueBuilderFactory::get();
const ValueBuilderFactory &test_factory = SimpleValueBuilderFactory::get();
using Primary = MixedSimpleJoinFunction::Primary;
using Overlap = MixedSimpleJoinFunction::Overlap;
namespace vespalib::eval {
std::ostream &operator<<(std::ostream &os, Primary primary)
{
switch(primary) {
case Primary::LHS: return os << "LHS";
case Primary::RHS: return os << "RHS";
}
abort();
}
std::ostream &operator<<(std::ostream &os, Overlap overlap)
{
switch(overlap) {
case Overlap::FULL: return os << "FULL";
case Overlap::INNER: return os << "INNER";
case Overlap::OUTER: return os << "OUTER";
}
abort();
}
}
struct FunInfo {
using LookFor = MixedSimpleJoinFunction;
Overlap overlap;
size_t factor;
Primary primary;
bool l_mut;
bool r_mut;
bool inplace;
void verify(const EvalFixture &fixture, const LookFor &fun) const {
EXPECT_TRUE(fun.result_is_mutable());
EXPECT_EQUAL(fun.overlap(), overlap);
EXPECT_EQUAL(fun.factor(), factor);
EXPECT_EQUAL(fun.primary(), primary);
if (fun.primary_is_mutable()) {
if (fun.primary() == Primary::LHS) {
EXPECT_TRUE(l_mut);
}
if (fun.primary() == Primary::RHS) {
EXPECT_TRUE(r_mut);
}
}
EXPECT_EQUAL(fun.inplace(), inplace);
if (fun.inplace()) {
EXPECT_TRUE(fun.primary_is_mutable());
size_t idx = (fun.primary() == Primary::LHS) ? 0 : 1;
EXPECT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(idx).cells().data);
EXPECT_NOT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(1-idx).cells().data);
} else {
EXPECT_NOT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(0).cells().data);
EXPECT_NOT_EQUAL(fixture.result_value().cells().data,
fixture.param_value(1).cells().data);
}
}
};
void verify_simple(const vespalib::string &expr, Primary primary, Overlap overlap, size_t factor,
bool l_mut, bool r_mut, bool inplace)
{
TEST_STATE(expr.c_str());
CellTypeSpace just_double({CellType::DOUBLE}, 2);
FunInfo details{overlap, factor, primary, l_mut, r_mut, inplace};
EvalFixture::verify<FunInfo>(expr, {details}, just_double);
CellTypeSpace just_float({CellType::FLOAT}, 2);
EvalFixture::verify<FunInfo>(expr, {details}, just_float);
}
void verify_optimized(const vespalib::string &expr, Primary primary, Overlap overlap, size_t factor,
bool l_mut = false, bool r_mut = false, bool inplace = false)
{
TEST_STATE(expr.c_str());
CellTypeSpace all_types(CellTypeUtils::list_types(), 2);
FunInfo details{overlap, factor, primary, l_mut, r_mut, inplace};
EvalFixture::verify<FunInfo>(expr, {details}, all_types);
}
void verify_not_optimized(const vespalib::string &expr) {
TEST_STATE(expr.c_str());
CellTypeSpace just_double({CellType::DOUBLE}, 2);
EvalFixture::verify<FunInfo>(expr, {}, just_double);
}
TEST("require that basic join is optimized") {
TEST_DO(verify_optimized("y5+y5$2", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that inplace is preferred") {
TEST_DO(verify_simple("y5+y5$2", Primary::RHS, Overlap::FULL, 1, false, false, false));
TEST_DO(verify_simple("y5+@y5$2", Primary::RHS, Overlap::FULL, 1, false, true, true));
TEST_DO(verify_simple("@y5+@y5$2", Primary::RHS, Overlap::FULL, 1, true, true, true));
TEST_DO(verify_simple("@y5+y5$2", Primary::LHS, Overlap::FULL, 1, true, false, true));
}
TEST("require that unit join is optimized") {
TEST_DO(verify_optimized("a1b1c1+x1y1z1", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that trivial dimensions do not affect overlap calculation") {
TEST_DO(verify_optimized("c5d1+b1c5", Primary::RHS, Overlap::FULL, 1));
TEST_DO(verify_simple("@c5d1+@b1c5", Primary::RHS, Overlap::FULL, 1, true, true, true));
}
TEST("require that outer nesting is preferred to inner nesting") {
TEST_DO(verify_optimized("a1b1c1+y5", Primary::RHS, Overlap::OUTER, 5));
}
TEST("require that non-subset join is not optimized") {
TEST_DO(verify_not_optimized("y5+z3"));
}
TEST("require that subset join with complex overlap is not optimized") {
TEST_DO(verify_not_optimized("x3y5z3+y5"));
}
struct LhsRhs {
vespalib::string lhs;
vespalib::string rhs;
size_t lhs_size;
size_t rhs_size;
Overlap overlap;
size_t factor;
LhsRhs(const vespalib::string &lhs_in, const vespalib::string &rhs_in,
size_t lhs_size_in, size_t rhs_size_in, Overlap overlap_in) noexcept
: lhs(lhs_in), rhs(rhs_in), lhs_size(lhs_size_in), rhs_size(rhs_size_in), overlap(overlap_in), factor(1)
{
if (lhs_size > rhs_size) {
ASSERT_EQUAL(lhs_size % rhs_size, 0u);
factor = (lhs_size / rhs_size);
} else {
ASSERT_EQUAL(rhs_size % lhs_size, 0u);
factor = (rhs_size / lhs_size);
}
}
~LhsRhs();
};
LhsRhs::~LhsRhs() = default;
TEST("require that various parameter combinations work") {
for (CellType lct : CellTypeUtils::list_types()) {
for (CellType rct : CellTypeUtils::list_types()) {
for (bool left_mut: {false, true}) {
for (bool right_mut: {false, true}) {
for (const char * expr: {"a+b", "a-b", "a*b"}) {
for (const LhsRhs ¶ms:
{ LhsRhs("y5", "y5", 5, 5, Overlap::FULL),
LhsRhs("y5", "x3y5", 5, 15, Overlap::INNER),
LhsRhs("y5", "y5z3", 5, 15, Overlap::OUTER),
LhsRhs("x3y5", "y5", 15, 5, Overlap::INNER),
LhsRhs("y5z3", "y5", 15, 5, Overlap::OUTER)})
{
EvalFixture::ParamRepo param_repo;
auto a_spec = GenSpec::from_desc(params.lhs).cells(lct).seq(AX_B(0.25, 1.125));
auto b_spec = GenSpec::from_desc(params.rhs).cells(rct).seq(AX_B(-0.25, 25.0));
if (left_mut) {
param_repo.add_mutable("a", a_spec);
} else {
param_repo.add("a", a_spec);
}
if (right_mut) {
param_repo.add_mutable("b", b_spec);
} else {
param_repo.add("b", b_spec);
}
TEST_STATE(expr);
CellType result_ct = CellMeta::join(CellMeta{lct, false}, CellMeta{rct, false}).cell_type;
Primary primary = Primary::RHS;
if (params.overlap == Overlap::FULL) {
bool w_lhs = (lct == result_ct) && left_mut;
bool w_rhs = (rct == result_ct) && right_mut;
if (w_lhs && !w_rhs) {
primary = Primary::LHS;
}
} else if (params.lhs_size > params.rhs_size) {
primary = Primary::LHS;
}
bool pri_mut = (primary == Primary::LHS) ? left_mut : right_mut;
bool pri_same_ct = (primary == Primary::LHS) ? (lct == result_ct) : (rct == result_ct);
bool inplace = (pri_mut && pri_same_ct);
auto expect = EvalFixture::ref(expr, param_repo);
EvalFixture slow_fixture(prod_factory, expr, param_repo, false);
EvalFixture test_fixture(test_factory, expr, param_repo, true, true);
EvalFixture fixture(prod_factory, expr, param_repo, true, true);
EXPECT_EQUAL(fixture.result(), expect);
EXPECT_EQUAL(slow_fixture.result(), expect);
EXPECT_EQUAL(test_fixture.result(), expect);
auto info = fixture.find_all<FunInfo::LookFor>();
ASSERT_EQUAL(info.size(), 1u);
FunInfo details{params.overlap, params.factor, primary, left_mut, right_mut, inplace};
details.verify(fixture, *info[0]);
}
}
}
}
}
}
}
TEST("require that scalar values are not optimized") {
TEST_DO(verify_not_optimized("reduce(v3,sum)+reduce(v4,sum)"));
TEST_DO(verify_not_optimized("reduce(v3,sum)+y5"));
TEST_DO(verify_not_optimized("y5+reduce(v3,sum)"));
TEST_DO(verify_not_optimized("reduce(v3,sum)+x3_1"));
TEST_DO(verify_not_optimized("x3_1+reduce(v3,sum)"));
TEST_DO(verify_not_optimized("reduce(v3,sum)+x3_1y5z3"));
TEST_DO(verify_not_optimized("x3_1y5z3+reduce(v3,sum)"));
}
TEST("require that sparse tensors are mostly not optimized") {
TEST_DO(verify_not_optimized("x3_1+x3_1$2"));
TEST_DO(verify_not_optimized("x3_1+y5"));
TEST_DO(verify_not_optimized("y5+x3_1"));
TEST_DO(verify_not_optimized("x3_1+x3_1y5z3"));
TEST_DO(verify_not_optimized("x3_1y5z3+x3_1"));
}
TEST("require that sparse tensor joined with trivial dense tensor is optimized") {
TEST_DO(verify_optimized("x3_1+a1b1c1", Primary::LHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("a1b1c1+x3_1", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that primary tensor can be empty") {
TEST_DO(verify_optimized("x0_1y5z3+y5z3", Primary::LHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("y5z3+x0_1y5z3", Primary::RHS, Overlap::FULL, 1));
}
TEST("require that mixed tensors can be optimized") {
TEST_DO(verify_not_optimized("x3_1y5z3+x3_1y5z3$2"));
TEST_DO(verify_optimized("x3_1y5z3+y5z3", Primary::LHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("x3_1y5z3+y5", Primary::LHS, Overlap::OUTER, 3));
TEST_DO(verify_optimized("x3_1y5z3+z3", Primary::LHS, Overlap::INNER, 5));
TEST_DO(verify_optimized("y5z3+x3_1y5z3", Primary::RHS, Overlap::FULL, 1));
TEST_DO(verify_optimized("y5+x3_1y5z3", Primary::RHS, Overlap::OUTER, 3));
TEST_DO(verify_optimized("z3+x3_1y5z3", Primary::RHS, Overlap::INNER, 5));
}
TEST("require that mixed tensors can be inplace") {
TEST_DO(verify_simple("@x3_1y5z3+y5z3", Primary::LHS, Overlap::FULL, 1, true, false, true));
TEST_DO(verify_simple("@x3_1y5z3+y5", Primary::LHS, Overlap::OUTER, 3, true, false, true));
TEST_DO(verify_simple("@x3_1y5z3+z3", Primary::LHS, Overlap::INNER, 5, true, false, true));
TEST_DO(verify_simple("@x3_1y5z3+@y5z3", Primary::LHS, Overlap::FULL, 1, true, true, true));
TEST_DO(verify_simple("@x3_1y5z3+@y5", Primary::LHS, Overlap::OUTER, 3, true, true, true));
TEST_DO(verify_simple("@x3_1y5z3+@z3", Primary::LHS, Overlap::INNER, 5, true, true, true));
TEST_DO(verify_simple("y5z3+@x3_1y5z3", Primary::RHS, Overlap::FULL, 1, false, true, true));
TEST_DO(verify_simple("y5+@x3_1y5z3", Primary::RHS, Overlap::OUTER, 3, false, true, true));
TEST_DO(verify_simple("z3+@x3_1y5z3", Primary::RHS, Overlap::INNER, 5, false, true, true));
TEST_DO(verify_simple("@y5z3+@x3_1y5z3", Primary::RHS, Overlap::FULL, 1, true, true, true));
TEST_DO(verify_simple("@y5+@x3_1y5z3", Primary::RHS, Overlap::OUTER, 3, true, true, true));
TEST_DO(verify_simple("@z3+@x3_1y5z3", Primary::RHS, Overlap::INNER, 5, true, true, true));
}
TEST_MAIN() { TEST_RUN_ALL(); }
<|endoftext|> |
<commit_before>#include "base64.h"
#include <cstdint>
#include <iostream>
#include "../leanify.h"
namespace
{
int Base64Decode(const uint8_t *in, size_t in_len, uint8_t *out, size_t *out_len)
{
static const uint8_t d[] =
{
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 64, 66, 66, 64, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 64, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 62, 66, 66, 66, 63, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 66, 66, 66, 65, 66, 66, 66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 66, 66, 66, 66, 66, 66, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66
};
uint32_t buf = 1;
size_t len = 0;
for (size_t i = 0; i < in_len; i++)
{
uint8_t c = d[in[i]];
switch (c)
{
case 66:
return 2; /* invalid input, return error */
case 65:
i = in_len; /* pad character, end of data */
case 64:
continue; /* skip whitespace */
default:
buf = buf << 6 | c;
/* If the buffer is full, split it into bytes */
if (buf & 0x1000000)
{
if ((len += 3) > *out_len) return 1; /* buffer overflow */
*out++ = buf >> 16;
*out++ = buf >> 8;
*out++ = buf;
buf = 1;
}
}
}
if (buf & 0x40000)
{
if ((len += 2) > *out_len) return 1; /* buffer overflow */
*out++ = buf >> 10;
*out++ = buf >> 2;
}
else if (buf & 0x1000)
{
if (++len > *out_len) return 1; /* buffer overflow */
*out++ = buf >> 4;
}
*out_len = len; /* modify to reflect the actual output size */
return 0;
}
size_t Base64Encode(const uint8_t *in, size_t in_len, uint8_t *out)
{
static const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
size_t resultIndex = 0;
/* increment over the length of the string, three characters at a time */
for (size_t x = 0; x < in_len; x += 3)
{
/* these three 8-bit (ASCII) characters become one 24-bit number */
uint32_t n = in[x] << 16;
if ((x + 2) < in_len)
{
n += (in[x + 1] << 8) + in[x + 2];
}
else if ((x + 1) < in_len)
{
n += in[x + 1] << 8;
}
/*
* if we have one byte available, then its encoding is spread
* out over two characters
*/
out[resultIndex++] = base64chars[(uint8_t)(n >> 18) & 63];
out[resultIndex++] = base64chars[(uint8_t)(n >> 12) & 63];
if ((x + 2) < in_len)
{
out[resultIndex++] = base64chars[(uint8_t)(n >> 6) & 63];
out[resultIndex++] = base64chars[(uint8_t)n & 63];
}
else
{
if ((x + 1) < in_len)
{
out[resultIndex++] = base64chars[(uint8_t)(n >> 6) & 63];
}
else
{
out[resultIndex++] = '=';
}
out[resultIndex++] = '=';
}
}
return resultIndex;
}
} // namespace
size_t Base64::Leanify(size_t size_leanified /*= 0*/)
{
// 4 base64 character contains information of 3 bytes
size_t binary_len = size * 3 / 4;
uint8_t *binary_data = new uint8_t[binary_len];
if (Base64Decode(fp, size, binary_data, &binary_len))
{
std::cerr << "Base64 decode error." << std::endl;
delete[] binary_data;
return Format::Leanify(size_leanified);
}
// Leanify embedded file
binary_len = LeanifyFile(binary_data, binary_len);
fp -= size_leanified;
// encode back
size = Base64Encode(binary_data, binary_len, fp);
delete[] binary_data;
return size;
}
<commit_msg>Base64: style fix<commit_after>#include "base64.h"
#include <cstdint>
#include <iostream>
#include "../leanify.h"
namespace
{
int Base64Decode(const uint8_t *in, size_t in_len, uint8_t *out, size_t *out_len)
{
static const uint8_t d[] =
{
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 64, 66, 66, 64, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 64, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 62, 66, 66, 66, 63, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 66, 66, 66, 65, 66, 66, 66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 66, 66, 66, 66, 66, 66, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
66, 66, 66, 66, 66, 66
};
uint32_t buf = 1;
size_t len = 0;
for (size_t i = 0; i < in_len; i++)
{
uint8_t c = d[in[i]];
switch (c)
{
case 66:
return 2; // invalid input, return error
case 65:
i = in_len; // pad character, end of data
case 64:
continue; // skip whitespace
default:
buf = buf << 6 | c;
// If the buffer is full, split it into bytes
if (buf & 0x1000000)
{
if ((len += 3) > *out_len) return 1;
*out++ = buf >> 16;
*out++ = buf >> 8;
*out++ = buf;
buf = 1;
}
}
}
if (buf & 0x40000)
{
if ((len += 2) > *out_len) return 1;
*out++ = buf >> 10;
*out = buf >> 2;
}
else if (buf & 0x1000)
{
if (++len > *out_len) return 1;
*out = buf >> 4;
}
*out_len = len;
return 0;
}
size_t Base64Encode(const uint8_t *in, size_t in_len, uint8_t *out)
{
static const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
size_t resultIndex = 0;
// increment over the length of the string, three characters at a time
for (size_t x = 0; x < in_len; x += 3)
{
// these three 8-bit (ASCII) characters become one 24-bit number
uint32_t n = in[x] << 16;
if ((x + 2) < in_len)
{
n += (in[x + 1] << 8) + in[x + 2];
}
else if ((x + 1) < in_len)
{
n += in[x + 1] << 8;
}
// if we have one byte available, then its encoding is spread out over two characters
out[resultIndex++] = base64chars[(n >> 18) & 63];
out[resultIndex++] = base64chars[(n >> 12) & 63];
if ((x + 2) < in_len)
{
out[resultIndex++] = base64chars[(n >> 6) & 63];
out[resultIndex++] = base64chars[n & 63];
}
else
{
if ((x + 1) < in_len)
{
out[resultIndex++] = base64chars[(n >> 6) & 63];
}
else
{
out[resultIndex++] = '=';
}
out[resultIndex++] = '=';
}
}
return resultIndex;
}
} // namespace
size_t Base64::Leanify(size_t size_leanified /*= 0*/)
{
// 4 base64 character contains information of 3 bytes
size_t binary_len = size * 3 / 4;
uint8_t *binary_data = new uint8_t[binary_len];
if (Base64Decode(fp, size, binary_data, &binary_len))
{
std::cerr << "Base64 decode error." << std::endl;
delete[] binary_data;
return Format::Leanify(size_leanified);
}
// Leanify embedded file
binary_len = LeanifyFile(binary_data, binary_len);
fp -= size_leanified;
// encode back
size = Base64Encode(binary_data, binary_len, fp);
delete[] binary_data;
return size;
}
<|endoftext|> |
<commit_before><commit_msg>Use WINDOW instead of BUBBLE for the throbber widget.<commit_after><|endoftext|> |
<commit_before><commit_msg>GTK: add NULL check in StatusBubbleGtk to fix crasher.<commit_after><|endoftext|> |
<commit_before>/* BEGIN_COMMON_COPYRIGHT_HEADER
* (c)LGPL2+
*
* Razor - a lightweight, Qt based, desktop toolset
* http://razor-qt.org
*
* Copyright: 2010-2011 Razor team
* Authors:
* Alexander Sokoloff <sokoloff.a@gmail.com>
*
* This program or 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) any later version.
*
* 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., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*
* END_COMMON_COPYRIGHT_HEADER */
#include "xdgdirs.h"
#include <stdlib.h>
#include <QDir>
#include <QStringBuilder> // for the % operator
#include <QDebug>
static const QString userDirectoryString[8] =
{
"Desktop",
"Download",
"Templates",
"Publicshare",
"Documents",
"Music",
"Pictures",
"Videos"
};
// Helper functions prototypes
void fixBashShortcuts(QString &s);
void removeEndigSlash(QString &s);
QString xdgSingleDir(const QString &envVar, const QString &def, bool createDir);
QStringList xdgDirList(const QString &envVar, const QString &postfix);
/************************************************
Helper func.
************************************************/
void fixBashShortcuts(QString &s)
{
if (s.startsWith('~'))
s = QString(getenv("HOME")) + (s).mid(1);
}
void removeEndingSlash(QString &s)
{
// We don't check for empty strings. Caller must check it.
// Remove the ending slash, except for root dirs.
if (s.length() > 1 && s.endsWith(QLatin1Char('/')))
s.chop(1);
}
/************************************************
Helper func.
************************************************/
QString xdgSingleDir(const QString &envVar, const QString &def, bool createDir)
{
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
QString s(getenv(envVar.toAscii()));
#else
QString s(getenv(envVar.toLatin1()));
#endif
if (!s.isEmpty())
fixBashShortcuts(s);
else
s = QString("%1/%2").arg(getenv("HOME"), def);
QDir d(s);
if (createDir && !d.exists())
{
if (!d.mkpath("."))
qWarning() << QString("Can't create %1 directory.").arg(d.absolutePath());
}
QString r = d.absolutePath();
removeEndingSlash(r);
return r;
}
/************************************************
Helper func.
************************************************/
QStringList xdgDirList(const QString &envVar, const QString &postfix)
{
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
QStringList dirs = QString(getenv(envVar.toAscii())).split(':', QString::SkipEmptyParts);
#else
QStringList dirs = QString(getenv(envVar.toLatin1())).split(':', QString::SkipEmptyParts);
#endif
QMutableStringListIterator i(dirs);
while(i.hasNext()) {
i.next();
QString s = i.value();
if (s.isEmpty()) {
i.remove();
} else {
fixBashShortcuts(s);
removeEndingSlash(s);
i.setValue(s % postfix);
}
}
return dirs;
}
/************************************************
************************************************/
QString XdgDirs::userDir(XdgDirs::UserDirectory dir)
{
// possible values for UserDirectory
if (dir < 0 || dir > 7)
return QString();
QString folderName = userDirectoryString[dir];
QString fallback;
if (getenv("HOME") == NULL)
return QString("/tmp");
else if (dir == XdgDirs::Desktop)
fallback = QString("%1/%2").arg(getenv("HOME")).arg("Desktop");
else
fallback = QString(getenv("HOME"));
QString configDir(configHome());
QFile configFile(configDir + "/user-dirs.dirs");
if (!configFile.exists())
return fallback;
if (!configFile.open(QIODevice::ReadOnly | QIODevice::Text))
return fallback;
QString userDirVar("XDG_" + folderName.toUpper() + "_DIR");
QTextStream in(&configFile);
QString line;
while (!in.atEnd())
{
line = in.readLine();
if (line.contains(userDirVar))
{
configFile.close();
// get path between quotes
line = line.section(QLatin1Char('"'), 1, 1);
line.replace(QLatin1String("$HOME"), QLatin1String("~"));
fixBashShortcuts(line);
return line;
}
}
configFile.close();
return fallback;
}
/************************************************
************************************************/
bool XdgDirs::setUserDir(XdgDirs::UserDirectory dir, const QString& value, bool createDir)
{
// possible values for UserDirectory
if (dir < 0 || dir > 7)
return false;
if (!(value.startsWith(QLatin1String("$HOME"))
|| value.startsWith(QLatin1String("~/"))
|| value.startsWith(QString(getenv("HOME")))))
return false;
QString folderName = userDirectoryString[dir];
QString configDir(configHome());
QFile configFile(configDir % QLatin1String("/user-dirs.dirs"));
// create the file if doesn't exist and opens it
if (!configFile.open(QIODevice::ReadWrite | QIODevice::Text))
return false;
QTextStream stream(&configFile);
QVector<QString> lines;
QString line;
bool foundVar = false;
while (!stream.atEnd())
{
line = stream.readLine();
if (line.indexOf(QLatin1String("XDG_") + folderName.toUpper() + QLatin1String("_DIR")) == 0)
{
foundVar = true;
QString path = line.section(QLatin1Char('"'), 1, 1);
line.replace(path, value);
lines.append(line);
}
else if (line.indexOf(QLatin1String("XDG_")) == 0)
{
lines.append(line);
}
}
stream.reset();
configFile.resize(0);
if (!foundVar)
stream << QString("XDG_%1_DIR=\"%2\"\n").arg(folderName.toUpper()).arg(value);
for (QVector<QString>::iterator i = lines.begin(); i != lines.end(); ++i)
stream << *i << "\n";
configFile.close();
if (createDir) {
QString path = QString(value).replace(QLatin1String("$HOME"), QLatin1String("~"));
fixBashShortcuts(path);
QDir().mkpath(path);
}
return true;
}
/************************************************
************************************************/
QString XdgDirs::dataHome(bool createDir)
{
return xdgSingleDir("XDG_DATA_HOME", QLatin1String(".local/share"), createDir);
}
/************************************************
************************************************/
QString XdgDirs::configHome(bool createDir)
{
return xdgSingleDir("XDG_CONFIG_HOME", QLatin1String(".config"), createDir);
}
/************************************************
************************************************/
QStringList XdgDirs::dataDirs(const QString &postfix)
{
QStringList dirs = xdgDirList("XDG_DATA_DIRS", postfix);
if (dirs.isEmpty())
{
dirs << QLatin1String("/usr/local/share") % postfix;
dirs << QLatin1String("/usr/share") % postfix;
}
return dirs;
}
/************************************************
************************************************/
QStringList XdgDirs::configDirs(const QString &postfix)
{
QStringList dirs = xdgDirList("XDG_CONFIG_DIRS", postfix);
if (dirs.isEmpty())
{
dirs << QLatin1String("/etc/xdg") % postfix;
}
return dirs;
}
/************************************************
************************************************/
QString XdgDirs::cacheHome(bool createDir)
{
return xdgSingleDir("XDG_CACHE_HOME", QLatin1String(".cache"), createDir);
}
/************************************************
************************************************/
QString XdgDirs::runtimeDir()
{
QString result(getenv("XDG_RUNTIME_DIR"));
fixBashShortcuts(result);
return result;
}
/************************************************
************************************************/
QString XdgDirs::autostartHome(bool createDir)
{
QDir dir(QString("%1/autostart").arg(configHome(createDir)));
if (createDir && !dir.exists())
{
if (!dir.mkpath(QLatin1String(".")))
qWarning() << QString("Can't create %1 directory.").arg(dir.absolutePath());
}
return dir.absolutePath();
}
/************************************************
************************************************/
QStringList XdgDirs::autostartDirs(const QString &postfix)
{
QStringList dirs;
foreach(QString dir, configDirs())
dirs << QString("%1/autostart").arg(dir) + postfix;
return dirs;
}
<commit_msg>Qt5: Use QStandardPaths() where possible<commit_after>/* BEGIN_COMMON_COPYRIGHT_HEADER
* (c)LGPL2+
*
* Razor - a lightweight, Qt based, desktop toolset
* http://razor-qt.org
*
* Copyright: 2010-2011 Razor team
* Authors:
* Alexander Sokoloff <sokoloff.a@gmail.com>
*
* This program or 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) any later version.
*
* 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., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*
* END_COMMON_COPYRIGHT_HEADER */
#include "xdgdirs.h"
#include <stdlib.h>
#include <QDir>
#include <QStringBuilder> // for the % operator
#include <QDebug>
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
#include <QStandardPaths>
#endif
static const QString userDirectoryString[8] =
{
"Desktop",
"Download",
"Templates",
"Publicshare",
"Documents",
"Music",
"Pictures",
"Videos"
};
// Helper functions prototypes
void fixBashShortcuts(QString &s);
void removeEndingSlash(QString &s);
QString createDirectory(const QString &dir);
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
void cleanAndAddPostfix(QStringList &dirs, const QString& postfix);
#endif
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
QString xdgSingleDir(const QString &envVar, const QString &def, bool createDir);
QStringList xdgDirList(const QString &envVar, const QString &postfix);
#endif
/************************************************
Helper func.
************************************************/
void fixBashShortcuts(QString &s)
{
if (s.startsWith(QLatin1Char('~')))
s = QString(getenv("HOME")) + (s).mid(1);
}
void removeEndingSlash(QString &s)
{
// We don't check for empty strings. Caller must check it.
// Remove the ending slash, except for root dirs.
if (s.length() > 1 && s.endsWith(QLatin1Char('/')))
s.chop(1);
}
QString createDirectory(const QString &dir)
{
QDir d(dir);
if (!d.exists())
{
if (!d.mkpath("."))
{
qWarning() << QString("Can't create %1 directory.").arg(d.absolutePath());
}
}
QString r = d.absolutePath();
removeEndingSlash(r);
return r;
}
void cleanAndAddPostfix(QStringList &dirs, const QString& postfix)
{
const int N = dirs.count();
for(int i = 0; i < N; ++i)
{
fixBashShortcuts(dirs[i]);
removeEndingSlash(dirs[i]);
dirs[i].append(postfix);
}
}
/************************************************
Helper func.
************************************************/
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
QString xdgSingleDir(const QString &envVar, const QString &def, bool createDir)
{
QString s(getenv(envVar.toAscii()));
if (!s.isEmpty())
fixBashShortcuts(s);
else
s = QString("%1/%2").arg(getenv("HOME"), def);
if (createDir)
return createDirectory(s);
removeEndingSlash(s);
return s;
}
#endif
/************************************************
Helper func.
************************************************/
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
QStringList xdgDirList(const QString &envVar, const QString &postfix)
{
QStringList dirs = QString(getenv(envVar.toAscii())).split(':', QString::SkipEmptyParts);
QMutableStringListIterator i(dirs);
while(i.hasNext()) {
i.next();
QString s = i.value();
if (s.isEmpty()) {
i.remove();
} else {
fixBashShortcuts(s);
removeEndingSlash(s);
i.setValue(s % postfix);
}
}
return dirs;
}
#endif
/************************************************
************************************************/
QString XdgDirs::userDir(XdgDirs::UserDirectory dir)
{
// possible values for UserDirectory
if (dir < 0 || dir > 7)
return QString();
QString folderName = userDirectoryString[dir];
QString fallback;
if (getenv("HOME") == NULL)
return QString("/tmp");
else if (dir == XdgDirs::Desktop)
fallback = QString("%1/%2").arg(getenv("HOME")).arg("Desktop");
else
fallback = QString(getenv("HOME"));
QString configDir(configHome());
QFile configFile(configDir + "/user-dirs.dirs");
if (!configFile.exists())
return fallback;
if (!configFile.open(QIODevice::ReadOnly | QIODevice::Text))
return fallback;
QString userDirVar("XDG_" + folderName.toUpper() + "_DIR");
QTextStream in(&configFile);
QString line;
while (!in.atEnd())
{
line = in.readLine();
if (line.contains(userDirVar))
{
configFile.close();
// get path between quotes
line = line.section(QLatin1Char('"'), 1, 1);
line.replace(QLatin1String("$HOME"), QLatin1String("~"));
fixBashShortcuts(line);
return line;
}
}
configFile.close();
return fallback;
}
/************************************************
************************************************/
bool XdgDirs::setUserDir(XdgDirs::UserDirectory dir, const QString& value, bool createDir)
{
// possible values for UserDirectory
if (dir < 0 || dir > 7)
return false;
if (!(value.startsWith(QLatin1String("$HOME"))
|| value.startsWith(QLatin1String("~/"))
|| value.startsWith(QString(getenv("HOME")))))
return false;
QString folderName = userDirectoryString[dir];
QString configDir(configHome());
QFile configFile(configDir % QLatin1String("/user-dirs.dirs"));
// create the file if doesn't exist and opens it
if (!configFile.open(QIODevice::ReadWrite | QIODevice::Text))
return false;
QTextStream stream(&configFile);
QVector<QString> lines;
QString line;
bool foundVar = false;
while (!stream.atEnd())
{
line = stream.readLine();
if (line.indexOf(QLatin1String("XDG_") + folderName.toUpper() + QLatin1String("_DIR")) == 0)
{
foundVar = true;
QString path = line.section(QLatin1Char('"'), 1, 1);
line.replace(path, value);
lines.append(line);
}
else if (line.indexOf(QLatin1String("XDG_")) == 0)
{
lines.append(line);
}
}
stream.reset();
configFile.resize(0);
if (!foundVar)
stream << QString("XDG_%1_DIR=\"%2\"\n").arg(folderName.toUpper()).arg(value);
for (QVector<QString>::iterator i = lines.begin(); i != lines.end(); ++i)
stream << *i << "\n";
configFile.close();
if (createDir) {
QString path = QString(value).replace(QLatin1String("$HOME"), QLatin1String("~"));
fixBashShortcuts(path);
QDir().mkpath(path);
}
return true;
}
/************************************************
************************************************/
QString XdgDirs::dataHome(bool createDir)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
QString s = QStandardPaths::writableLocation(QStandardPaths::DataLocation);
fixBashShortcuts(s);
if (createDir)
return createDirectory(s);
removeEndingSlash(s);
return s;
#else
return xdgSingleDir("XDG_DATA_HOME", QLatin1String(".local/share"), createDir);
#endif
}
/************************************************
************************************************/
QString XdgDirs::configHome(bool createDir)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
QString s = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
fixBashShortcuts(s);
if (createDir)
return createDirectory(s);
removeEndingSlash(s);
return s;
#else
return xdgSingleDir("XDG_CONFIG_HOME", QLatin1String(".config"), createDir);
#endif
}
/************************************************
************************************************/
QStringList XdgDirs::dataDirs(const QString &postfix)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
QString d = QFile::decodeName(qgetenv("XDG_DATA_DIRS"));
QStringList dirs = d.split(QLatin1Char(':'), QString::SkipEmptyParts);
QMutableListIterator<QString> it(dirs);
while (it.hasNext()) {
const QString dir = it.next();
if (!dir.startsWith(QLatin1Char('/')))
it.remove();
}
dirs.removeDuplicates();
cleanAndAddPostfix(dirs, postfix);
return dirs;
#else
QStringList dirs = xdgDirList("XDG_DATA_DIRS", postfix);
if (dirs.isEmpty())
{
dirs << QLatin1String("/usr/local/share") % postfix;
dirs << QLatin1String("/usr/share") % postfix;
}
return dirs;
#endif
}
/************************************************
************************************************/
QStringList XdgDirs::configDirs(const QString &postfix)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
QStringList dirs;
const QString env = QFile::decodeName(qgetenv("XDG_CONFIG_DIRS"));
if (env.isEmpty())
dirs.append(QString::fromLatin1("/etc/xdg"));
else
dirs = env.split(QLatin1Char(':'), QString::SkipEmptyParts);
cleanAndAddPostfix(dirs, postfix);
return dirs;
#else
QStringList dirs = xdgDirList("XDG_CONFIG_DIRS", postfix);
if (dirs.isEmpty())
{
dirs << QLatin1String("/etc/xdg") % postfix;
}
return dirs;
#endif
}
/************************************************
************************************************/
QString XdgDirs::cacheHome(bool createDir)
{
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
QString s = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);
fixBashShortcuts(s);
if (createDir)
return createDirectory(s);
removeEndingSlash(s);
return s;
#else
return xdgSingleDir("XDG_CACHE_HOME", QLatin1String(".cache"), createDir);
#endif
}
/************************************************
************************************************/
QString XdgDirs::runtimeDir()
{
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
QString result = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
fixBashShortcuts(result);
removeEndingSlash(result);
return result;
#else
QString result(getenv("XDG_RUNTIME_DIR"));
fixBashShortcuts(result);
return result;
#endif
}
/************************************************
************************************************/
QString XdgDirs::autostartHome(bool createDir)
{
QString s = QString("%1/autostart").arg(configHome(createDir));
fixBashShortcuts(s);
if (createDir)
return createDirectory(s);
QDir d(s);
QString r = d.absolutePath();
removeEndingSlash(r);
return r;
}
/************************************************
************************************************/
QStringList XdgDirs::autostartDirs(const QString &postfix)
{
QStringList dirs;
QStringList s = configDirs();
foreach(QString dir, s)
dirs << QString("%1/autostart").arg(dir) + postfix;
return dirs;
}
<|endoftext|> |
<commit_before>#include "nodeinstanceserverproxy.h"
#include <QLocalServer>
#include <QLocalSocket>
#include <QProcess>
#include <QCoreApplication>
#include <QUuid>
#include "propertyabstractcontainer.h"
#include "propertyvaluecontainer.h"
#include "propertybindingcontainer.h"
#include "instancecontainer.h"
#include "createinstancescommand.h"
#include "createscenecommand.h"
#include "changevaluescommand.h"
#include "changebindingscommand.h"
#include "changefileurlcommand.h"
#include "removeinstancescommand.h"
#include "clearscenecommand.h"
#include "removepropertiescommand.h"
#include "reparentinstancescommand.h"
#include "changeidscommand.h"
#include "changestatecommand.h"
#include "addimportcommand.h"
#include "completecomponentcommand.h"
#include "informationchangedcommand.h"
#include "pixmapchangedcommand.h"
#include "valueschangedcommand.h"
#include "childrenchangedcommand.h"
#include "imagecontainer.h"
#include "statepreviewimagechangedcommand.h"
#include "componentcompletedcommand.h"
#include "nodeinstanceview.h"
#include "nodeinstanceclientproxy.h"
namespace QmlDesigner {
NodeInstanceServerProxy::NodeInstanceServerProxy(NodeInstanceView *nodeInstanceView)
: NodeInstanceServerInterface(nodeInstanceView),
m_localServer(new QLocalServer(this)),
m_nodeInstanceView(nodeInstanceView),
m_blockSize(0)
{
QString socketToken(QUuid::createUuid().toString());
m_localServer->listen(socketToken);
m_localServer->setMaxPendingConnections(2);
m_qmlPuppetProcess = new QProcess(QCoreApplication::instance());
connect(m_qmlPuppetProcess.data(), SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)));
m_qmlPuppetProcess->setProcessChannelMode(QProcess::ForwardedChannels);
m_qmlPuppetProcess->start(QString("%1/%2").arg(QCoreApplication::applicationDirPath()).arg("qmlpuppet"), QStringList() << socketToken);
connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
m_qmlPuppetProcess->waitForStarted();
Q_ASSERT(m_qmlPuppetProcess->state() == QProcess::Running);
if (!m_localServer->hasPendingConnections())
m_localServer->waitForNewConnection(-1);
m_socket = m_localServer->nextPendingConnection();
Q_ASSERT(m_socket);
connect(m_socket.data(), SIGNAL(readyRead()), this, SLOT(readDataStream()));
m_localServer->close();
}
NodeInstanceServerProxy::~NodeInstanceServerProxy()
{
if (m_qmlPuppetProcess) {
m_qmlPuppetProcess->blockSignals(true);
m_qmlPuppetProcess->terminate();
}
}
void NodeInstanceServerProxy::dispatchCommand(const QVariant &command)
{
static const int informationChangedCommandType = QMetaType::type("InformationChangedCommand");
static const int valuesChangedCommandType = QMetaType::type("ValuesChangedCommand");
static const int pixmapChangedCommandType = QMetaType::type("PixmapChangedCommand");
static const int childrenChangedCommandType = QMetaType::type("ChildrenChangedCommand");
static const int statePreviewImageChangedCommandType = QMetaType::type("StatePreviewImageChangedCommand");
static const int componentCompletedCommandType = QMetaType::type("ComponentCompletedCommand");
if (command.userType() == informationChangedCommandType)
nodeInstanceClient()->informationChanged(command.value<InformationChangedCommand>());
else if (command.userType() == valuesChangedCommandType)
nodeInstanceClient()->valuesChanged(command.value<ValuesChangedCommand>());
else if (command.userType() == pixmapChangedCommandType)
nodeInstanceClient()->pixmapChanged(command.value<PixmapChangedCommand>());
else if (command.userType() == childrenChangedCommandType)
nodeInstanceClient()->childrenChanged(command.value<ChildrenChangedCommand>());
else if (command.userType() == statePreviewImageChangedCommandType)
nodeInstanceClient()->statePreviewImagesChanged(command.value<StatePreviewImageChangedCommand>());
else if (command.userType() == componentCompletedCommandType)
nodeInstanceClient()->componentCompleted(command.value<ComponentCompletedCommand>());
else
Q_ASSERT(false);
}
NodeInstanceClientInterface *NodeInstanceServerProxy::nodeInstanceClient() const
{
return m_nodeInstanceView.data();
}
void NodeInstanceServerProxy::writeCommand(const QVariant &command)
{
Q_ASSERT(m_socket.data());
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out << quint32(0);
out << command;
out.device()->seek(0);
out << quint32(block.size() - sizeof(quint32));
m_socket->write(block);
}
void NodeInstanceServerProxy::processFinished(int /*exitCode*/, QProcess::ExitStatus /* exitStatus */)
{
m_socket->close();
emit processCrashed();
}
void NodeInstanceServerProxy::readDataStream()
{
QList<QVariant> commandList;
while (!m_socket->atEnd()) {
if (m_socket->bytesAvailable() < int(sizeof(quint32)))
break;
QDataStream in(m_socket.data());
if (m_blockSize == 0) {
in >> m_blockSize;
}
if (m_socket->bytesAvailable() < m_blockSize)
break;
QVariant command;
in >> command;
m_blockSize = 0;
Q_ASSERT(in.status() == QDataStream::Ok);
commandList.append(command);
}
foreach (const QVariant &command, commandList) {
dispatchCommand(command);
}
}
void NodeInstanceServerProxy::createInstances(const CreateInstancesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changeFileUrl(const ChangeFileUrlCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::createScene(const CreateSceneCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::clearScene(const ClearSceneCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::removeInstances(const RemoveInstancesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::removeProperties(const RemovePropertiesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changePropertyBindings(const ChangeBindingsCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changePropertyValues(const ChangeValuesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::reparentInstances(const ReparentInstancesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changeIds(const ChangeIdsCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changeState(const ChangeStateCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::addImport(const AddImportCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::completeComponent(const CompleteComponentCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
} // namespace QmlDesigner
<commit_msg>QmlDesigner.NodeInstance: Only 1 connection is used<commit_after>#include "nodeinstanceserverproxy.h"
#include <QLocalServer>
#include <QLocalSocket>
#include <QProcess>
#include <QCoreApplication>
#include <QUuid>
#include "propertyabstractcontainer.h"
#include "propertyvaluecontainer.h"
#include "propertybindingcontainer.h"
#include "instancecontainer.h"
#include "createinstancescommand.h"
#include "createscenecommand.h"
#include "changevaluescommand.h"
#include "changebindingscommand.h"
#include "changefileurlcommand.h"
#include "removeinstancescommand.h"
#include "clearscenecommand.h"
#include "removepropertiescommand.h"
#include "reparentinstancescommand.h"
#include "changeidscommand.h"
#include "changestatecommand.h"
#include "addimportcommand.h"
#include "completecomponentcommand.h"
#include "informationchangedcommand.h"
#include "pixmapchangedcommand.h"
#include "valueschangedcommand.h"
#include "childrenchangedcommand.h"
#include "imagecontainer.h"
#include "statepreviewimagechangedcommand.h"
#include "componentcompletedcommand.h"
#include "nodeinstanceview.h"
#include "nodeinstanceclientproxy.h"
namespace QmlDesigner {
NodeInstanceServerProxy::NodeInstanceServerProxy(NodeInstanceView *nodeInstanceView)
: NodeInstanceServerInterface(nodeInstanceView),
m_localServer(new QLocalServer(this)),
m_nodeInstanceView(nodeInstanceView),
m_blockSize(0)
{
QString socketToken(QUuid::createUuid().toString());
m_localServer->listen(socketToken);
m_localServer->setMaxPendingConnections(1);
m_qmlPuppetProcess = new QProcess(QCoreApplication::instance());
connect(m_qmlPuppetProcess.data(), SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(processFinished(int,QProcess::ExitStatus)));
m_qmlPuppetProcess->setProcessChannelMode(QProcess::ForwardedChannels);
m_qmlPuppetProcess->start(QString("%1/%2").arg(QCoreApplication::applicationDirPath()).arg("qmlpuppet"), QStringList() << socketToken);
connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(deleteLater()));
m_qmlPuppetProcess->waitForStarted();
Q_ASSERT(m_qmlPuppetProcess->state() == QProcess::Running);
if (!m_localServer->hasPendingConnections())
m_localServer->waitForNewConnection(-1);
m_socket = m_localServer->nextPendingConnection();
Q_ASSERT(m_socket);
connect(m_socket.data(), SIGNAL(readyRead()), this, SLOT(readDataStream()));
m_localServer->close();
}
NodeInstanceServerProxy::~NodeInstanceServerProxy()
{
if (m_qmlPuppetProcess) {
m_qmlPuppetProcess->blockSignals(true);
m_qmlPuppetProcess->terminate();
}
}
void NodeInstanceServerProxy::dispatchCommand(const QVariant &command)
{
static const int informationChangedCommandType = QMetaType::type("InformationChangedCommand");
static const int valuesChangedCommandType = QMetaType::type("ValuesChangedCommand");
static const int pixmapChangedCommandType = QMetaType::type("PixmapChangedCommand");
static const int childrenChangedCommandType = QMetaType::type("ChildrenChangedCommand");
static const int statePreviewImageChangedCommandType = QMetaType::type("StatePreviewImageChangedCommand");
static const int componentCompletedCommandType = QMetaType::type("ComponentCompletedCommand");
if (command.userType() == informationChangedCommandType)
nodeInstanceClient()->informationChanged(command.value<InformationChangedCommand>());
else if (command.userType() == valuesChangedCommandType)
nodeInstanceClient()->valuesChanged(command.value<ValuesChangedCommand>());
else if (command.userType() == pixmapChangedCommandType)
nodeInstanceClient()->pixmapChanged(command.value<PixmapChangedCommand>());
else if (command.userType() == childrenChangedCommandType)
nodeInstanceClient()->childrenChanged(command.value<ChildrenChangedCommand>());
else if (command.userType() == statePreviewImageChangedCommandType)
nodeInstanceClient()->statePreviewImagesChanged(command.value<StatePreviewImageChangedCommand>());
else if (command.userType() == componentCompletedCommandType)
nodeInstanceClient()->componentCompleted(command.value<ComponentCompletedCommand>());
else
Q_ASSERT(false);
}
NodeInstanceClientInterface *NodeInstanceServerProxy::nodeInstanceClient() const
{
return m_nodeInstanceView.data();
}
void NodeInstanceServerProxy::writeCommand(const QVariant &command)
{
Q_ASSERT(m_socket.data());
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out << quint32(0);
out << command;
out.device()->seek(0);
out << quint32(block.size() - sizeof(quint32));
m_socket->write(block);
}
void NodeInstanceServerProxy::processFinished(int /*exitCode*/, QProcess::ExitStatus /* exitStatus */)
{
m_socket->close();
emit processCrashed();
}
void NodeInstanceServerProxy::readDataStream()
{
QList<QVariant> commandList;
while (!m_socket->atEnd()) {
if (m_socket->bytesAvailable() < int(sizeof(quint32)))
break;
QDataStream in(m_socket.data());
if (m_blockSize == 0) {
in >> m_blockSize;
}
if (m_socket->bytesAvailable() < m_blockSize)
break;
QVariant command;
in >> command;
m_blockSize = 0;
Q_ASSERT(in.status() == QDataStream::Ok);
commandList.append(command);
}
foreach (const QVariant &command, commandList) {
dispatchCommand(command);
}
}
void NodeInstanceServerProxy::createInstances(const CreateInstancesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changeFileUrl(const ChangeFileUrlCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::createScene(const CreateSceneCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::clearScene(const ClearSceneCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::removeInstances(const RemoveInstancesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::removeProperties(const RemovePropertiesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changePropertyBindings(const ChangeBindingsCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changePropertyValues(const ChangeValuesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::reparentInstances(const ReparentInstancesCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changeIds(const ChangeIdsCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::changeState(const ChangeStateCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::addImport(const AddImportCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
void NodeInstanceServerProxy::completeComponent(const CompleteComponentCommand &command)
{
writeCommand(QVariant::fromValue(command));
}
} // namespace QmlDesigner
<|endoftext|> |
<commit_before>#ifndef Exc_Ruby___cpp__st__hpp_
#define Exc_Ruby___cpp__st__hpp_
/*! \file
* \brief Hacks to allow functions in st.h to be called from C++
* programs.
*/
#include "ruby.hpp"
// Ruby doesn't put extern "C" around st.h
extern "C"
{
#include "st.h"
}
// Older versions of Ruby don't have proper signatures for the st_
// functions
#if RUBY_VERSION_CODE < 180
typedef char * st_data_t;
namespace Exc_Ruby
{
namespace detail
{
extern "C" typedef int (*St_Insert_Signature)(
st_table *table,
st_data_t key,
st_data_t * value);
extern "C" typedef int (*St_Lookup_Signature)(
st_table * table,
st_data_t key,
st_data_t * value);
extern "C" typedef st_table* (*St_Init_Table_Signature)(
struct st_hash_type * type);
#define st_insert(table, key, value) \
((::Exc_Ruby::detail::St_Insert_Signature)(st_insert))(table, key, value)
#define st_lookup(table, key, value) \
((::Exc_Ruby::detail::St_Lookup_Signature)(st_lookup))(table, key, value)
#define st_init_table(type) \
((::Exc_Ruby::detail::St_Init_Table_Signature)(st_init_table))(type)
} // namespace detail
} // namespace Exc_Ruby
#endif // RUBY_VERSION_CODE < 180
#endif // Exc_Ruby___cpp__st__hpp_
<commit_msg>Whitespace fix.<commit_after>#ifndef Exc_Ruby___cpp__st__hpp_
#define Exc_Ruby___cpp__st__hpp_
/*! \file
* \brief Hacks to allow functions in st.h to be called from C++
* programs.
*/
#include "ruby.hpp"
// Ruby doesn't put extern "C" around st.h
extern "C"
{
#include "st.h"
}
// Older versions of Ruby don't have proper signatures for the st_
// functions
#if RUBY_VERSION_CODE < 180
typedef char * st_data_t;
namespace Exc_Ruby
{
namespace detail
{
extern "C" typedef int (*St_Insert_Signature)(
st_table * table,
st_data_t key,
st_data_t * value);
extern "C" typedef int (*St_Lookup_Signature)(
st_table * table,
st_data_t key,
st_data_t * value);
extern "C" typedef st_table* (*St_Init_Table_Signature)(
struct st_hash_type * type);
#define st_insert(table, key, value) \
((::Exc_Ruby::detail::St_Insert_Signature)(st_insert))(table, key, value)
#define st_lookup(table, key, value) \
((::Exc_Ruby::detail::St_Lookup_Signature)(st_lookup))(table, key, value)
#define st_init_table(type) \
((::Exc_Ruby::detail::St_Init_Table_Signature)(st_init_table))(type)
} // namespace detail
} // namespace Exc_Ruby
#endif // RUBY_VERSION_CODE < 180
#endif // Exc_Ruby___cpp__st__hpp_
<|endoftext|> |
<commit_before>// Copyright (c) 2014 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/node_debugger.h"
#include "base/command_line.h"
#include "libplatform/libplatform.h"
namespace atom {
NodeDebugger::NodeDebugger(node::Environment* env) : env_(env) {
}
NodeDebugger::~NodeDebugger() {
}
void NodeDebugger::Start() {
auto inspector = env_->inspector_agent();
if (inspector == nullptr)
return;
node::DebugOptions options;
for (auto& arg : base::CommandLine::ForCurrentProcess()->argv())
options.ParseOption(arg);
if (options.inspector_enabled()) {
// Use custom platform since the gin platform does not work correctly
// with node's inspector agent
platform_.reset(v8::platform::CreateDefaultPlatform());
inspector->Start(platform_.get(), nullptr, options);
}
}
} // namespace atom
<commit_msg>Convert arg string to utf8 on Windows<commit_after>// Copyright (c) 2014 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "atom/browser/node_debugger.h"
#include "base/command_line.h"
#include "base/strings/utf_string_conversions.h"
#include "libplatform/libplatform.h"
namespace atom {
NodeDebugger::NodeDebugger(node::Environment* env) : env_(env) {
}
NodeDebugger::~NodeDebugger() {
}
void NodeDebugger::Start() {
auto inspector = env_->inspector_agent();
if (inspector == nullptr)
return;
node::DebugOptions options;
for (auto& arg : base::CommandLine::ForCurrentProcess()->argv()) {
#if defined(OS_WIN)
options.ParseOption(base::UTF16ToUTF8(arg));
#else
options.ParseOption(arg);
#endif
}
if (options.inspector_enabled()) {
// Use custom platform since the gin platform does not work correctly
// with node's inspector agent
platform_.reset(v8::platform::CreateDefaultPlatform());
inspector->Start(platform_.get(), nullptr, options);
}
}
} // namespace atom
<|endoftext|> |
<commit_before>//
// AdvancedADSREnvelope.hpp
// AudioKit
//
// Created by Jeff Cooper on 5/21/20.
// Copyright © 2020 AudioKit. All rights reserved.
//
// Attack, Hold, Decay, Sustain, Release-hold, Release envelope
// 1) Attack fades in from 0 for attackSamples
// 2) Holds value at 1 for holdSamples
// 3) Decays to sustainFraction for decaySamples
// 4) Holds value at sustainFraction until release / noteOff
// 5) Holds value at sustainFraction for releaseHoldSamples
// 6) Fades to 0 for releaseSamples
#include "EnvelopeGeneratorBase.hpp"
namespace AudioKitCore
{
struct AHDSHREnvelopeParameters
{
float sampleRateHz;
float attackSamples, holdSamples, decaySamples, releaseHoldSamples, releaseSamples;
float sustainFraction; // [0.0, 1.0]
AHDSHREnvelopeParameters();
void init(float newSampleRateHz, float attackSeconds, float holdSeconds, float decaySeconds, float susFraction,
float releaseHoldSeconds, float releaseSeconds);
void init(float attackSeconds, float holdSeconds, float decaySeconds, float susFraction,
float releaseHoldSeconds, float releaseSeconds);
void updateSampleRate(float newSampleRateHz);
void setAttackDurationSeconds(float attackSeconds) { attackSamples = attackSeconds * sampleRateHz; }
float getAttackDurationSeconds() { return attackSamples / sampleRateHz; }
void setHoldDurationSeconds(float holdSeconds) { holdSamples = holdSeconds * sampleRateHz; }
float getHoldDurationSeconds() { return holdSamples / sampleRateHz; }
void setDecayDurationSeconds(float decaySeconds) { decaySamples = decaySeconds * sampleRateHz; }
float getDecayDurationSeconds() { return decaySamples / sampleRateHz; }
void setReleaseHoldDurationSeconds(float releaseHoldSeconds) { releaseHoldSamples = releaseHoldSeconds * sampleRateHz; }
float getReleaseHoldDurationSeconds() { return releaseHoldSamples / sampleRateHz; }
void setReleaseDurationSeconds(float releaseSeconds) { releaseSamples = releaseSeconds * sampleRateHz; }
float getReleaseDurationSeconds() { return releaseSamples / sampleRateHz; }
};
struct AHDSHREnvelope
{
AHDSHREnvelopeParameters* pParameters; // many ADSREnvelopes can share a common set of parameters
enum EG_Segment
{
kIdle = 0,
kSilence,
kAttack,
kHold,
kDecay,
kSustain,
kReleaseHold,
kRelease
};
enum CurvatureType
{
kLinear, // all segments linear
kAnalogLike, // models CEM3310 integrated circuit
kLinearInDb // decay and release are linear-in-dB
};
void init(CurvatureType curvatureType = kAnalogLike);
void updateParams();
void start(); // called for note-on
void restart(); // quickly dampen note then start again
void release(); // called for note-off
void reset(); // reset to idle state
bool isIdle() { return env.getCurrentSegmentIndex() == kIdle; }
bool isPreStarting() { return env.getCurrentSegmentIndex() == kSilence; }
bool isReleasing() { return env.getCurrentSegmentIndex() == kRelease; }
inline float getValue()
{
return env.getValue();
}
inline float getSample()
{
float sample;
env.getSample(sample);
return sample;
}
protected:
MultiSegmentEnvelopeGenerator env;
MultiSegmentEnvelopeGenerator::Descriptor envDesc;
};
}
<commit_msg>better isReleasing calculation on aksample ahdshr envelope<commit_after>//
// AdvancedADSREnvelope.hpp
// AudioKit
//
// Created by Jeff Cooper on 5/21/20.
// Copyright © 2020 AudioKit. All rights reserved.
//
// Attack, Hold, Decay, Sustain, Release-hold, Release envelope
// 1) Attack fades in from 0 for attackSamples
// 2) Holds value at 1 for holdSamples
// 3) Decays to sustainFraction for decaySamples
// 4) Holds value at sustainFraction until release / noteOff
// 5) Holds value at sustainFraction for releaseHoldSamples
// 6) Fades to 0 for releaseSamples
#include "EnvelopeGeneratorBase.hpp"
namespace AudioKitCore
{
struct AHDSHREnvelopeParameters
{
float sampleRateHz;
float attackSamples, holdSamples, decaySamples, releaseHoldSamples, releaseSamples;
float sustainFraction; // [0.0, 1.0]
AHDSHREnvelopeParameters();
void init(float newSampleRateHz, float attackSeconds, float holdSeconds, float decaySeconds, float susFraction,
float releaseHoldSeconds, float releaseSeconds);
void init(float attackSeconds, float holdSeconds, float decaySeconds, float susFraction,
float releaseHoldSeconds, float releaseSeconds);
void updateSampleRate(float newSampleRateHz);
void setAttackDurationSeconds(float attackSeconds) { attackSamples = attackSeconds * sampleRateHz; }
float getAttackDurationSeconds() { return attackSamples / sampleRateHz; }
void setHoldDurationSeconds(float holdSeconds) { holdSamples = holdSeconds * sampleRateHz; }
float getHoldDurationSeconds() { return holdSamples / sampleRateHz; }
void setDecayDurationSeconds(float decaySeconds) { decaySamples = decaySeconds * sampleRateHz; }
float getDecayDurationSeconds() { return decaySamples / sampleRateHz; }
void setReleaseHoldDurationSeconds(float releaseHoldSeconds) { releaseHoldSamples = releaseHoldSeconds * sampleRateHz; }
float getReleaseHoldDurationSeconds() { return releaseHoldSamples / sampleRateHz; }
void setReleaseDurationSeconds(float releaseSeconds) { releaseSamples = releaseSeconds * sampleRateHz; }
float getReleaseDurationSeconds() { return releaseSamples / sampleRateHz; }
};
struct AHDSHREnvelope
{
AHDSHREnvelopeParameters* pParameters; // many ADSREnvelopes can share a common set of parameters
enum EG_Segment
{
kIdle = 0,
kSilence,
kAttack,
kHold,
kDecay,
kSustain,
kReleaseHold,
kRelease
};
enum CurvatureType
{
kLinear, // all segments linear
kAnalogLike, // models CEM3310 integrated circuit
kLinearInDb // decay and release are linear-in-dB
};
void init(CurvatureType curvatureType = kAnalogLike);
void updateParams();
void start(); // called for note-on
void restart(); // quickly dampen note then start again
void release(); // called for note-off
void reset(); // reset to idle state
bool isIdle() { return env.getCurrentSegmentIndex() == kIdle; }
bool isPreStarting() { return env.getCurrentSegmentIndex() == kSilence; }
bool isReleasing() {
return env.getCurrentSegmentIndex() == kReleaseHold || env.getCurrentSegmentIndex() == kRelease;
}
inline float getValue()
{
return env.getValue();
}
inline float getSample()
{
float sample;
env.getSample(sample);
return sample;
}
protected:
MultiSegmentEnvelopeGenerator env;
MultiSegmentEnvelopeGenerator::Descriptor envDesc;
};
}
<|endoftext|> |
<commit_before>// @(#)root/rint:$Name: $:$Id: TRint.cxx,v 1.17 2002/11/18 23:02:19 rdm Exp $
// Author: Rene Brun 17/02/95
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
//////////////////////////////////////////////////////////////////////////
// //
// Rint //
// //
// Rint is the ROOT Interactive Interface. It allows interactive access //
// to the ROOT system via the CINT C/C++ interpreter. //
// //
//////////////////////////////////////////////////////////////////////////
#include "TROOT.h"
#include "TClass.h"
#include "TVirtualX.h"
#include "Getline.h"
#include "TStyle.h"
#include "TObjectTable.h"
#include "TClassTable.h"
#include "TStopwatch.h"
#include "TBenchmark.h"
#include "TRint.h"
#include "TSystem.h"
#include "TEnv.h"
#include "TSysEvtHandler.h"
#include "TError.h"
#include "TException.h"
#include "TInterpreter.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TFile.h"
#include "TMapFile.h"
#include "TTabCom.h"
#include "TError.h"
#ifdef R__UNIX
#include <signal.h>
extern "C" {
extern int G__get_security_error();
extern int G__genericerror(const char* msg);
}
#endif
//----- Interrupt signal handler -----------------------------------------------
//______________________________________________________________________________
class TInterruptHandler : public TSignalHandler {
public:
TInterruptHandler() : TSignalHandler(kSigInterrupt, kFALSE) { }
Bool_t Notify();
};
//______________________________________________________________________________
Bool_t TInterruptHandler::Notify()
{
// TRint interrupt handler.
if (fDelay) {
fDelay++;
return kTRUE;
}
// make sure we use the sbrk heap (in case of mapped files)
gMmallocDesc = 0;
if (!G__get_security_error())
G__genericerror("\n *** Break *** keyboard interrupt");
else {
Break("TInterruptHandler::Notify", "keyboard interrupt");
if (TROOT::Initialized()) {
Getlinem(kInit, "Root > ");
gInterpreter->RewindDictionary();
Throw(GetSignal());
}
}
return kTRUE;
}
//----- Terminal Input file handler --------------------------------------------
//______________________________________________________________________________
class TTermInputHandler : public TFileHandler {
public:
TTermInputHandler(int fd) : TFileHandler(fd, 1) { }
Bool_t Notify();
Bool_t ReadNotify() { return Notify(); }
};
//______________________________________________________________________________
Bool_t TTermInputHandler::Notify()
{
return gApplication->HandleTermInput();
}
ClassImp(TRint)
//______________________________________________________________________________
TRint::TRint(const char *appClassName, int *argc, char **argv, void *options,
int numOptions, Bool_t noLogo)
: TApplication(appClassName, argc, argv, options, numOptions)
{
// Create an application environment. The TRint environment provides an
// interface to the WM manager functionality and eventloop via inheritance
// of TApplication and in addition provides interactive access to
// the CINT C++ interpreter via the command line.
fNcmd = 0;
fDefaultPrompt = "root [%d] ";
fInterrupt = kFALSE;
gBenchmark = new TBenchmark();
if (!noLogo && !NoLogoOpt())
PrintLogo();
// Everybody expects iostream to be available, so load it...
#ifndef WIN32
ProcessLine("#include <iostream>",kTRUE);
#endif
// Allow the usage of ClassDef and ClassImp in interpreted macros
ProcessLine("#include <RtypesCint.h>",kTRUE);
// The following libs are also useful to have,
// make sure they are loaded...
gROOT->LoadClass("TGeometry", "Graf3d");
gROOT->LoadClass("TTree", "Tree");
gROOT->LoadClass("TMatrix", "Matrix");
gROOT->LoadClass("TMinuit", "Minuit");
gROOT->LoadClass("TPostScript", "Postscript");
gROOT->LoadClass("TCanvas", "Gpad");
gROOT->LoadClass("THtml", "Html");
// Load user functions
const char *logon;
logon = gEnv->GetValue("Rint.Load", (char*)0);
if (logon) {
char *mac = gSystem->Which(TROOT::GetMacroPath(), logon, kReadPermission);
if (mac)
ProcessLine(Form(".L %s",logon),kTRUE);
delete [] mac;
}
// Execute logon macro
logon = gEnv->GetValue("Rint.Logon", (char*)0);
if (logon && !NoLogOpt()) {
char *mac = gSystem->Which(TROOT::GetMacroPath(), logon, kReadPermission);
if (mac)
ProcessFile(logon);
delete [] mac;
}
gInterpreter->SaveContext();
gInterpreter->SaveGlobalsContext();
// Install interrupt and terminal input handlers
TInterruptHandler *ih = new TInterruptHandler();
ih->Add();
SetSignalHandler(ih);
TTermInputHandler *th = new TTermInputHandler(0);
th->Add();
// Goto into raw terminal input mode
char defhist[128];
#ifndef R__VMS
sprintf(defhist, "%s/.root_hist", gSystem->Getenv("HOME"));
#else
sprintf(defhist, "%s.root_hist", gSystem->Getenv("HOME"));
#endif
logon = gEnv->GetValue("Rint.History", defhist);
Gl_histinit((char *)logon);
Gl_windowchanged();
// Setup for tab completion
gTabCom = new TTabCom;
}
//______________________________________________________________________________
TRint::~TRint()
{
}
//______________________________________________________________________________
void TRint::Run(Bool_t retrn)
{
// Main application eventloop. First process files given on the command
// line and then go into the main application event loop, unless the -q
// command line option was specfied in which case the program terminates.
// When retrun is true this method returns even when -q was specified.
Getlinem(kInit, GetPrompt());
// Process shell command line input files
if (InputFiles()) {
TObjString *file;
TIter next(InputFiles());
RETRY {
while ((file = (TObjString *)next())) {
char cmd[256];
if (file->String().EndsWith(".root")) {
const char *rfile = (const char*)file->String();
Printf("\nAttaching file %s...", rfile);
char *base = StrDup(gSystem->BaseName(rfile));
char *s = strchr(base, '.'); *s = 0;
sprintf(cmd, "TFile *%s = TFile::Open(\"%s\")", base, rfile);
delete [] base;
} else {
Printf("\nProcessing %s...", (const char*)file->String());
sprintf(cmd, ".x %s", (const char*)file->String());
}
Getlinem(kCleanUp, 0);
Gl_histadd(cmd);
fNcmd++;
ProcessLine(cmd);
}
} ENDTRY;
if (QuitOpt()) {
if (retrn) return;
Terminate(0);
}
ClearInputFiles();
Getlinem(kInit, GetPrompt());
}
if (QuitOpt()) {
printf("\n");
if (retrn) return;
Terminate(0);
}
TApplication::Run(retrn);
Getlinem(kCleanUp, 0);
}
//______________________________________________________________________________
void TRint::PrintLogo()
{
// Print the ROOT logo on standard output.
Int_t iday,imonth,iyear;
static const char *months[] = {"January","February","March","April","May",
"June","July","August","September","October",
"November","December"};
const char *root_version = gROOT->GetVersion();
Int_t idatqq = gROOT->GetVersionDate();
iday = idatqq%100;
imonth = (idatqq/100)%100;
iyear = (idatqq/10000);
char *root_date = Form("%d %s %4d",iday,months[imonth-1],iyear);
Printf(" *******************************************");
Printf(" * *");
Printf(" * W E L C O M E to R O O T *");
Printf(" * *");
Printf(" * Version%10s %17s *", root_version, root_date);
// Printf(" * Development version *");
Printf(" * *");
Printf(" * You are welcome to visit our Web site *");
Printf(" * http://root.cern.ch *");
Printf(" * *");
Printf(" *******************************************");
if (strstr(gVirtualX->GetName(), "TTF")) {
Int_t major, minor, patch;
//TTF::Version(major, minor, patch);
// avoid dependency on libGraf and hard code, will not change too often
major = 2; minor = 1; patch = 3;
Printf("\nFreeType Engine v%d.%d.%d used to render TrueType fonts.",
major, minor, patch);
}
#ifdef _REENTRANT
else
printf("\n");
Printf("Compiled for %s with thread support.", gSystem->GetBuildArch());
#else
else
printf("\n");
Printf("Compiled for %s.", gSystem->GetBuildArch());
#endif
gInterpreter->PrintIntro();
#ifdef R__UNIX
// Popdown X logo, only if started with -splash option
for (int i = 0; i < Argc(); i++)
if (!strcmp(Argv(i), "-splash"))
kill(getppid(), SIGUSR1);
#endif
}
//______________________________________________________________________________
char *TRint::GetPrompt()
{
// Get prompt from interpreter. Either "root [n]" or "end with '}'".
char *s = gInterpreter->GetPrompt();
if (s[0])
strcpy(fPrompt, s);
else
sprintf(fPrompt, fDefaultPrompt.Data(), fNcmd);
return fPrompt;
}
//______________________________________________________________________________
const char *TRint::SetPrompt(const char *newPrompt)
{
// Set a new default prompt. It returns the previous prompt.
// The prompt may contain a %d which will be replaced by the commend
// number. The default prompt is "root [%d] ". The maximum length of
// the prompt is 55 characters. To set the prompt in an interactive
// session do:
// root [0] ((TRint*)gROOT->GetApplication())->SetPrompt("aap> ")
// aap>
static TString op = fDefaultPrompt;
if (newPrompt && strlen(newPrompt) <= 55)
fDefaultPrompt = newPrompt;
else
Error("SetPrompt", "newPrompt too long (> 55 characters)");
return op.Data();
}
//______________________________________________________________________________
Bool_t TRint::HandleTermInput()
{
// Handle input coming from terminal.
static TStopwatch timer;
char *line;
if ((line = Getlinem(kOneChar, 0))) {
if (line[0] == 0 && Gl_eof())
Terminate(0);
if (gROOT->Timer()) timer.Start();
Gl_histadd(line);
char *s = line;
while (s && *s == ' ') s++; // strip-off leading blanks
s[strlen(s)-1] = '\0'; // strip also '\n' off
fInterrupt = kFALSE;
if (!gInterpreter->GetMore() && strlen(s) != 0) fNcmd++;
ProcessLine(s);
if (strstr(s,".reset") != s)
gInterpreter->EndOfLineAction();
if (gROOT->Timer()) timer.Print();
gTabCom->ClearAll();
Getlinem(kInit, GetPrompt());
}
return kTRUE;
}
//______________________________________________________________________________
void TRint::Terminate(int status)
{
// Terminate the application. Reset the terminal to sane mode and call
// the logoff macro defined via Rint.Logoff environment variable.
Getlinem(kCleanUp, 0);
if (ReturnFromRun()) {
gSystem->ExitLoop();
} else {
//Execute logoff macro
const char *logoff;
logoff = gEnv->GetValue("Rint.Logoff", (char*)0);
if (logoff && !NoLogOpt()) {
char *mac = gSystem->Which(TROOT::GetMacroPath(), logoff, kReadPermission);
if (mac)
ProcessFile(logoff);
delete [] mac;
}
gSystem->Exit(status);
}
}
<commit_msg>By default include<iostream> on Windows<commit_after>// @(#)root/rint:$Name: $:$Id: TRint.cxx,v 1.18 2003/01/22 11:23:03 rdm Exp $
// Author: Rene Brun 17/02/95
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
//////////////////////////////////////////////////////////////////////////
// //
// Rint //
// //
// Rint is the ROOT Interactive Interface. It allows interactive access //
// to the ROOT system via the CINT C/C++ interpreter. //
// //
//////////////////////////////////////////////////////////////////////////
#include "TROOT.h"
#include "TClass.h"
#include "TVirtualX.h"
#include "Getline.h"
#include "TStyle.h"
#include "TObjectTable.h"
#include "TClassTable.h"
#include "TStopwatch.h"
#include "TBenchmark.h"
#include "TRint.h"
#include "TSystem.h"
#include "TEnv.h"
#include "TSysEvtHandler.h"
#include "TError.h"
#include "TException.h"
#include "TInterpreter.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TFile.h"
#include "TMapFile.h"
#include "TTabCom.h"
#include "TError.h"
#ifdef R__UNIX
#include <signal.h>
extern "C" {
extern int G__get_security_error();
extern int G__genericerror(const char* msg);
}
#endif
//----- Interrupt signal handler -----------------------------------------------
//______________________________________________________________________________
class TInterruptHandler : public TSignalHandler {
public:
TInterruptHandler() : TSignalHandler(kSigInterrupt, kFALSE) { }
Bool_t Notify();
};
//______________________________________________________________________________
Bool_t TInterruptHandler::Notify()
{
// TRint interrupt handler.
if (fDelay) {
fDelay++;
return kTRUE;
}
// make sure we use the sbrk heap (in case of mapped files)
gMmallocDesc = 0;
if (!G__get_security_error())
G__genericerror("\n *** Break *** keyboard interrupt");
else {
Break("TInterruptHandler::Notify", "keyboard interrupt");
if (TROOT::Initialized()) {
Getlinem(kInit, "Root > ");
gInterpreter->RewindDictionary();
Throw(GetSignal());
}
}
return kTRUE;
}
//----- Terminal Input file handler --------------------------------------------
//______________________________________________________________________________
class TTermInputHandler : public TFileHandler {
public:
TTermInputHandler(int fd) : TFileHandler(fd, 1) { }
Bool_t Notify();
Bool_t ReadNotify() { return Notify(); }
};
//______________________________________________________________________________
Bool_t TTermInputHandler::Notify()
{
return gApplication->HandleTermInput();
}
ClassImp(TRint)
//______________________________________________________________________________
TRint::TRint(const char *appClassName, int *argc, char **argv, void *options,
int numOptions, Bool_t noLogo)
: TApplication(appClassName, argc, argv, options, numOptions)
{
// Create an application environment. The TRint environment provides an
// interface to the WM manager functionality and eventloop via inheritance
// of TApplication and in addition provides interactive access to
// the CINT C++ interpreter via the command line.
fNcmd = 0;
fDefaultPrompt = "root [%d] ";
fInterrupt = kFALSE;
gBenchmark = new TBenchmark();
if (!noLogo && !NoLogoOpt())
PrintLogo();
// Everybody expects iostream to be available, so load it...
ProcessLine("#include <iostream>",kTRUE);
// Allow the usage of ClassDef and ClassImp in interpreted macros
ProcessLine("#include <RtypesCint.h>",kTRUE);
// The following libs are also useful to have,
// make sure they are loaded...
gROOT->LoadClass("TGeometry", "Graf3d");
gROOT->LoadClass("TTree", "Tree");
gROOT->LoadClass("TMatrix", "Matrix");
gROOT->LoadClass("TMinuit", "Minuit");
gROOT->LoadClass("TPostScript", "Postscript");
gROOT->LoadClass("TCanvas", "Gpad");
gROOT->LoadClass("THtml", "Html");
// Load user functions
const char *logon;
logon = gEnv->GetValue("Rint.Load", (char*)0);
if (logon) {
char *mac = gSystem->Which(TROOT::GetMacroPath(), logon, kReadPermission);
if (mac)
ProcessLine(Form(".L %s",logon),kTRUE);
delete [] mac;
}
// Execute logon macro
logon = gEnv->GetValue("Rint.Logon", (char*)0);
if (logon && !NoLogOpt()) {
char *mac = gSystem->Which(TROOT::GetMacroPath(), logon, kReadPermission);
if (mac)
ProcessFile(logon);
delete [] mac;
}
gInterpreter->SaveContext();
gInterpreter->SaveGlobalsContext();
// Install interrupt and terminal input handlers
TInterruptHandler *ih = new TInterruptHandler();
ih->Add();
SetSignalHandler(ih);
TTermInputHandler *th = new TTermInputHandler(0);
th->Add();
// Goto into raw terminal input mode
char defhist[128];
#ifndef R__VMS
sprintf(defhist, "%s/.root_hist", gSystem->Getenv("HOME"));
#else
sprintf(defhist, "%s.root_hist", gSystem->Getenv("HOME"));
#endif
logon = gEnv->GetValue("Rint.History", defhist);
Gl_histinit((char *)logon);
Gl_windowchanged();
// Setup for tab completion
gTabCom = new TTabCom;
}
//______________________________________________________________________________
TRint::~TRint()
{
}
//______________________________________________________________________________
void TRint::Run(Bool_t retrn)
{
// Main application eventloop. First process files given on the command
// line and then go into the main application event loop, unless the -q
// command line option was specfied in which case the program terminates.
// When retrun is true this method returns even when -q was specified.
Getlinem(kInit, GetPrompt());
// Process shell command line input files
if (InputFiles()) {
TObjString *file;
TIter next(InputFiles());
RETRY {
while ((file = (TObjString *)next())) {
char cmd[256];
if (file->String().EndsWith(".root")) {
const char *rfile = (const char*)file->String();
Printf("\nAttaching file %s...", rfile);
char *base = StrDup(gSystem->BaseName(rfile));
char *s = strchr(base, '.'); *s = 0;
sprintf(cmd, "TFile *%s = TFile::Open(\"%s\")", base, rfile);
delete [] base;
} else {
Printf("\nProcessing %s...", (const char*)file->String());
sprintf(cmd, ".x %s", (const char*)file->String());
}
Getlinem(kCleanUp, 0);
Gl_histadd(cmd);
fNcmd++;
ProcessLine(cmd);
}
} ENDTRY;
if (QuitOpt()) {
if (retrn) return;
Terminate(0);
}
ClearInputFiles();
Getlinem(kInit, GetPrompt());
}
if (QuitOpt()) {
printf("\n");
if (retrn) return;
Terminate(0);
}
TApplication::Run(retrn);
Getlinem(kCleanUp, 0);
}
//______________________________________________________________________________
void TRint::PrintLogo()
{
// Print the ROOT logo on standard output.
Int_t iday,imonth,iyear;
static const char *months[] = {"January","February","March","April","May",
"June","July","August","September","October",
"November","December"};
const char *root_version = gROOT->GetVersion();
Int_t idatqq = gROOT->GetVersionDate();
iday = idatqq%100;
imonth = (idatqq/100)%100;
iyear = (idatqq/10000);
char *root_date = Form("%d %s %4d",iday,months[imonth-1],iyear);
Printf(" *******************************************");
Printf(" * *");
Printf(" * W E L C O M E to R O O T *");
Printf(" * *");
Printf(" * Version%10s %17s *", root_version, root_date);
// Printf(" * Development version *");
Printf(" * *");
Printf(" * You are welcome to visit our Web site *");
Printf(" * http://root.cern.ch *");
Printf(" * *");
Printf(" *******************************************");
if (strstr(gVirtualX->GetName(), "TTF")) {
Int_t major, minor, patch;
//TTF::Version(major, minor, patch);
// avoid dependency on libGraf and hard code, will not change too often
major = 2; minor = 1; patch = 3;
Printf("\nFreeType Engine v%d.%d.%d used to render TrueType fonts.",
major, minor, patch);
}
#ifdef _REENTRANT
else
printf("\n");
Printf("Compiled for %s with thread support.", gSystem->GetBuildArch());
#else
else
printf("\n");
Printf("Compiled for %s.", gSystem->GetBuildArch());
#endif
gInterpreter->PrintIntro();
#ifdef R__UNIX
// Popdown X logo, only if started with -splash option
for (int i = 0; i < Argc(); i++)
if (!strcmp(Argv(i), "-splash"))
kill(getppid(), SIGUSR1);
#endif
}
//______________________________________________________________________________
char *TRint::GetPrompt()
{
// Get prompt from interpreter. Either "root [n]" or "end with '}'".
char *s = gInterpreter->GetPrompt();
if (s[0])
strcpy(fPrompt, s);
else
sprintf(fPrompt, fDefaultPrompt.Data(), fNcmd);
return fPrompt;
}
//______________________________________________________________________________
const char *TRint::SetPrompt(const char *newPrompt)
{
// Set a new default prompt. It returns the previous prompt.
// The prompt may contain a %d which will be replaced by the commend
// number. The default prompt is "root [%d] ". The maximum length of
// the prompt is 55 characters. To set the prompt in an interactive
// session do:
// root [0] ((TRint*)gROOT->GetApplication())->SetPrompt("aap> ")
// aap>
static TString op = fDefaultPrompt;
if (newPrompt && strlen(newPrompt) <= 55)
fDefaultPrompt = newPrompt;
else
Error("SetPrompt", "newPrompt too long (> 55 characters)");
return op.Data();
}
//______________________________________________________________________________
Bool_t TRint::HandleTermInput()
{
// Handle input coming from terminal.
static TStopwatch timer;
char *line;
if ((line = Getlinem(kOneChar, 0))) {
if (line[0] == 0 && Gl_eof())
Terminate(0);
if (gROOT->Timer()) timer.Start();
Gl_histadd(line);
char *s = line;
while (s && *s == ' ') s++; // strip-off leading blanks
s[strlen(s)-1] = '\0'; // strip also '\n' off
fInterrupt = kFALSE;
if (!gInterpreter->GetMore() && strlen(s) != 0) fNcmd++;
ProcessLine(s);
if (strstr(s,".reset") != s)
gInterpreter->EndOfLineAction();
if (gROOT->Timer()) timer.Print();
gTabCom->ClearAll();
Getlinem(kInit, GetPrompt());
}
return kTRUE;
}
//______________________________________________________________________________
void TRint::Terminate(int status)
{
// Terminate the application. Reset the terminal to sane mode and call
// the logoff macro defined via Rint.Logoff environment variable.
Getlinem(kCleanUp, 0);
if (ReturnFromRun()) {
gSystem->ExitLoop();
} else {
//Execute logoff macro
const char *logoff;
logoff = gEnv->GetValue("Rint.Logoff", (char*)0);
if (logoff && !NoLogOpt()) {
char *mac = gSystem->Which(TROOT::GetMacroPath(), logoff, kReadPermission);
if (mac)
ProcessFile(logoff);
delete [] mac;
}
gSystem->Exit(status);
}
}
<|endoftext|> |
<commit_before>#include <string>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "rpc/server.h"
#include "rpc/client.h"
#include "log_service_impl.h"
using namespace std;
using namespace rpc;
using namespace rlog;
RLogService *g_ls = NULL;
Server *g_server = NULL;
static void signal_handler(int sig) {
Log_info("caught signal %d, stopping server now", sig);
delete g_server;
delete g_ls;
exit(0);
}
int main(int argc, char* argv[]) {
string bind_addr = "0.0.0.0:8848";
printf("usage: %s [bind_addr=%s]\n", argv[0], bind_addr.c_str());
if (argc >= 2) {
bind_addr = argv[1];
if (bind_addr.find(":") == string::npos) {
bind_addr = "0.0.0.0:" + bind_addr;
}
}
Log::set_level(Log::INFO);
g_ls = new RLogServiceImpl;
g_server = new Server;
g_server->reg(g_ls);
if (g_server->start(bind_addr.c_str()) != 0) {
delete g_server;
delete g_ls;
exit(1);
}
signal(SIGPIPE, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGALRM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
for (;;) {
sleep(100);
}
// should not reach here
verify(0);
return 0;
}
<commit_msg>using condvar to stop the rlogserver<commit_after>#include <string>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "rpc/server.h"
#include "rpc/client.h"
#include "log_service_impl.h"
using namespace std;
using namespace rpc;
using namespace rlog;
Mutex g_stop_mutex;
CondVar g_stop_condvar;
bool g_stop_flag = false;
static void signal_handler(int sig) {
Log_info("caught signal %d, stopping server now", sig);
g_stop_flag = true;
g_stop_condvar.signal();
}
int main(int argc, char* argv[]) {
string bind_addr = "0.0.0.0:8848";
printf("usage: %s [bind_addr=%s]\n", argv[0], bind_addr.c_str());
if (argc >= 2) {
bind_addr = argv[1];
if (bind_addr.find(":") == string::npos) {
bind_addr = "0.0.0.0:" + bind_addr;
}
}
Log::set_level(Log::INFO);
RLogService* log_service = new RLogServiceImpl;
Server* server = new Server;
server->reg(log_service);
int ret;
if ((ret = server->start(bind_addr.c_str())) == 0) {
signal(SIGPIPE, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGALRM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
g_stop_mutex.lock();
while (g_stop_flag == false) {
g_stop_condvar.wait(g_stop_mutex);
}
g_stop_mutex.unlock();
delete server;
delete log_service;
}
return ret;
}
<|endoftext|> |
<commit_before>#include "Display.h"
#include <CommCtrl.h>
#include "../3RVX/DisplayManager.h"
#include "../3RVX/LanguageTranslator.h"
#include "../3RVX/Logger.h"
#include "../3RVX/Settings.h"
#include "resource.h"
void Display::Initialize() {
using std::placeholders::_1;
INIT_CONTROL(CHK_ONTOP, Checkbox, _onTop);
INIT_CONTROL(CHK_FULLSCREEN, Checkbox, _hideFullscreen);
INIT_CONTROL(CMB_POSITION, ComboBox, _position);
_position.OnSelectionChange
= std::bind(&Display::OnPositionChange, this);
INIT_CONTROL(LBL_CUSTOMX, Label, _customX);
INIT_CONTROL(ED_CUSTOMX, EditBox, _positionX);
INIT_CONTROL(LBL_CUSTOMY, Label, _customY);
INIT_CONTROL(ED_CUSTOMY, EditBox, _positionY);
INIT_CONTROL(CHK_EDGE, Checkbox, _customDistance);
_customDistance.OnClick = std::bind(&Display::OnCustomCheckChange, this);
INIT_CONTROL(SP_EDGE, Spinner, _edgeSpinner);
_edgeSpinner.Buddy(ED_EDGE);
INIT_CONTROL(LBL_DISPLAYDEV, Label, _displayDevLabel);
INIT_CONTROL(CMB_MONITOR, ComboBox, _displayDevice);
INIT_CONTROL(CMB_ANIMATION, ComboBox, _hideAnimation);
_hideAnimation.OnSelectionChange
= std::bind(&Display::OnAnimationChange, this);
INIT_CONTROL(LBL_HIDEDELAY, Label, _hideDelayLabel);
INIT_CONTROL(SP_HIDEDELAY, Spinner, _hideDelay);
_hideDelay.Buddy(ED_HIDEDELAY);
_hideDelay.OnSpin = std::bind(&Display::OnAnimationSpin, this, _1);
INIT_CONTROL(LBL_HIDESPEED, Label, _hideSpeedLabel);
INIT_CONTROL(SP_HIDESPEED, Spinner, _hideSpeed);
_hideSpeed.Buddy(ED_HIDESPEED);
_hideSpeed.OnSpin = std::bind(&Display::OnAnimationSpin, this, _1);
}
void Display::LoadSettings() {
Settings *settings = Settings::Instance();
LanguageTranslator *translator = settings->Translator();
/* Translations */
_allMonitorStr = translator->Translate(_allMonitorStr);
_primaryMonitorStr = translator->Translate(_primaryMonitorStr);
_customPositionStr = translator->Translate(_customPositionStr);
_noAnimStr = translator->Translate(_noAnimStr);
/* Visibility Settings */
_onTop.Checked(settings->AlwaysOnTop());
_hideFullscreen.Checked(settings->HideFullscreen());
/* Position on Screen*/
for (std::wstring position : settings->OSDPosNames) {
_position.AddItem(position);
}
_position.Select((int) settings->OSDPosition());
/* Custom positions/offsets */
_positionX.Text(settings->OSDX());
_positionY.Text(settings->OSDY());
_customDistance.Checked(
settings->OSDEdgeOffset() != Settings::DefaultOSDOffset);
_edgeSpinner.Text(settings->OSDEdgeOffset());
_edgeSpinner.Range(MIN_EDGE, MAX_EDGE);
/* Display Devices */
_displayDevice.AddItem(primaryMonitorStr);
_displayDevice.AddItem(allMonitorStr);
std::list<DISPLAY_DEVICE> devices = DisplayManager::ListAllDevices();
for (DISPLAY_DEVICE dev : devices) {
std::wstring devString(dev.DeviceName);
_displayDevice.AddItem(devString);
}
std::wstring monitorName = settings->Monitor();
if (monitorName == L"") {
monitorName = primaryMonitorStr;
} else if (monitorName == L"*") {
monitorName = allMonitorStr;
}
_displayDevice.Select(monitorName);
/* Animation Settings */
for (std::wstring anim : AnimationTypes::HideAnimationNames) {
_hideAnimation.AddItem(anim);
}
_hideAnimation.Select((int) settings->HideAnim());
_hideDelay.Range(MIN_MS, MAX_MS);
_hideDelay.Text(settings->HideDelay());
_hideSpeed.Range(MIN_MS, MAX_MS);
_hideSpeed.Text(settings->HideSpeed());
/* Refresh control states */
OnPositionChange();
OnCustomCheckChange();
OnAnimationChange();
}
void Display::SaveSettings() {
if (_hWnd == NULL) {
return;
}
CLOG(L"Saving: Display");
Settings *settings = Settings::Instance();
settings->AlwaysOnTop(_onTop.Checked());
settings->HideFullscreen(_hideFullscreen.Checked());
Settings::OSDPos pos = (Settings::OSDPos) _position.SelectionIndex();
settings->OSDPosition(pos);
if (pos == Settings::OSDPos::Custom) {
settings->OSDX(_positionX.TextAsInt());
settings->OSDY(_positionY.TextAsInt());
}
if (_customDistance.Checked()) {
settings->OSDEdgeOffset(_edgeSpinner.TextAsInt());
} else {
/* We have to write the default here, just in case somebody unchecked
* the checkbox. */
settings->OSDEdgeOffset(Settings::DefaultOSDOffset);
}
std::wstring monitor = _displayDevice.Selection();
int monitorIdx = _displayDevice.SelectionIndex();
if (monitorIdx == 0) {
monitor = L"";
} else if (monitorIdx == 1) {
monitor = L"*";
}
settings->Monitor(monitor);
settings->HideAnim(
(AnimationTypes::HideAnimation) _hideAnimation.SelectionIndex());
settings->HideDelay(_hideDelay.TextAsInt());
settings->HideSpeed(_hideSpeed.TextAsInt());
}
bool Display::OnAnimationChange() {
_hideSpeed.Enabled(_hideAnimation.Selection() != noAnimStr);
return true;
}
bool Display::OnAnimationSpin(NMUPDOWN *ud) {
/* Increase the up/down spin increment: */
ud->iDelta *= ANIM_SPIN_INCREMENT;
return FALSE; /* Allows the change */
}
bool Display::OnCustomCheckChange() {
_edgeSpinner.Enabled(_customDistance.Checked());
return true;
}
bool Display::OnPositionChange() {
bool isCustom = (_position.Selection() == customPositionStr);
_customX.Enabled(isCustom);
_customY.Enabled(isCustom);
_positionX.Enabled(isCustom);
_positionY.Enabled(isCustom);
return true;
}
<commit_msg>Translate OSD positions<commit_after>#include "Display.h"
#include <CommCtrl.h>
#include "../3RVX/DisplayManager.h"
#include "../3RVX/LanguageTranslator.h"
#include "../3RVX/Logger.h"
#include "../3RVX/Settings.h"
#include "resource.h"
void Display::Initialize() {
using std::placeholders::_1;
INIT_CONTROL(CHK_ONTOP, Checkbox, _onTop);
INIT_CONTROL(CHK_FULLSCREEN, Checkbox, _hideFullscreen);
INIT_CONTROL(CMB_POSITION, ComboBox, _position);
_position.OnSelectionChange
= std::bind(&Display::OnPositionChange, this);
INIT_CONTROL(LBL_CUSTOMX, Label, _customX);
INIT_CONTROL(ED_CUSTOMX, EditBox, _positionX);
INIT_CONTROL(LBL_CUSTOMY, Label, _customY);
INIT_CONTROL(ED_CUSTOMY, EditBox, _positionY);
INIT_CONTROL(CHK_EDGE, Checkbox, _customDistance);
_customDistance.OnClick = std::bind(&Display::OnCustomCheckChange, this);
INIT_CONTROL(SP_EDGE, Spinner, _edgeSpinner);
_edgeSpinner.Buddy(ED_EDGE);
INIT_CONTROL(LBL_DISPLAYDEV, Label, _displayDevLabel);
INIT_CONTROL(CMB_MONITOR, ComboBox, _displayDevice);
INIT_CONTROL(CMB_ANIMATION, ComboBox, _hideAnimation);
_hideAnimation.OnSelectionChange
= std::bind(&Display::OnAnimationChange, this);
INIT_CONTROL(LBL_HIDEDELAY, Label, _hideDelayLabel);
INIT_CONTROL(SP_HIDEDELAY, Spinner, _hideDelay);
_hideDelay.Buddy(ED_HIDEDELAY);
_hideDelay.OnSpin = std::bind(&Display::OnAnimationSpin, this, _1);
INIT_CONTROL(LBL_HIDESPEED, Label, _hideSpeedLabel);
INIT_CONTROL(SP_HIDESPEED, Spinner, _hideSpeed);
_hideSpeed.Buddy(ED_HIDESPEED);
_hideSpeed.OnSpin = std::bind(&Display::OnAnimationSpin, this, _1);
}
void Display::LoadSettings() {
Settings *settings = Settings::Instance();
LanguageTranslator *translator = settings->Translator();
/* Translations */
_allMonitorStr = translator->Translate(_allMonitorStr);
_primaryMonitorStr = translator->Translate(_primaryMonitorStr);
_customPositionStr = translator->Translate(_customPositionStr);
_noAnimStr = translator->Translate(_noAnimStr);
/* Visibility Settings */
_onTop.Checked(settings->AlwaysOnTop());
_hideFullscreen.Checked(settings->HideFullscreen());
/* Position on Screen*/
for (std::wstring position : settings->OSDPosNames) {
_position.AddItem(translator->Translate(position));
}
_position.Select((int) settings->OSDPosition());
/* Custom positions/offsets */
_positionX.Text(settings->OSDX());
_positionY.Text(settings->OSDY());
_customDistance.Checked(
settings->OSDEdgeOffset() != Settings::DefaultOSDOffset);
_edgeSpinner.Text(settings->OSDEdgeOffset());
_edgeSpinner.Range(MIN_EDGE, MAX_EDGE);
/* Display Devices */
_displayDevice.AddItem(primaryMonitorStr);
_displayDevice.AddItem(allMonitorStr);
std::list<DISPLAY_DEVICE> devices = DisplayManager::ListAllDevices();
for (DISPLAY_DEVICE dev : devices) {
std::wstring devString(dev.DeviceName);
_displayDevice.AddItem(devString);
}
std::wstring monitorName = settings->Monitor();
if (monitorName == L"") {
monitorName = primaryMonitorStr;
} else if (monitorName == L"*") {
monitorName = allMonitorStr;
}
_displayDevice.Select(monitorName);
/* Animation Settings */
for (std::wstring anim : AnimationTypes::HideAnimationNames) {
_hideAnimation.AddItem(anim);
}
_hideAnimation.Select((int) settings->HideAnim());
_hideDelay.Range(MIN_MS, MAX_MS);
_hideDelay.Text(settings->HideDelay());
_hideSpeed.Range(MIN_MS, MAX_MS);
_hideSpeed.Text(settings->HideSpeed());
/* Refresh control states */
OnPositionChange();
OnCustomCheckChange();
OnAnimationChange();
}
void Display::SaveSettings() {
if (_hWnd == NULL) {
return;
}
CLOG(L"Saving: Display");
Settings *settings = Settings::Instance();
settings->AlwaysOnTop(_onTop.Checked());
settings->HideFullscreen(_hideFullscreen.Checked());
Settings::OSDPos pos = (Settings::OSDPos) _position.SelectionIndex();
settings->OSDPosition(pos);
if (pos == Settings::OSDPos::Custom) {
settings->OSDX(_positionX.TextAsInt());
settings->OSDY(_positionY.TextAsInt());
}
if (_customDistance.Checked()) {
settings->OSDEdgeOffset(_edgeSpinner.TextAsInt());
} else {
/* We have to write the default here, just in case somebody unchecked
* the checkbox. */
settings->OSDEdgeOffset(Settings::DefaultOSDOffset);
}
std::wstring monitor = _displayDevice.Selection();
int monitorIdx = _displayDevice.SelectionIndex();
if (monitorIdx == 0) {
monitor = L"";
} else if (monitorIdx == 1) {
monitor = L"*";
}
settings->Monitor(monitor);
settings->HideAnim(
(AnimationTypes::HideAnimation) _hideAnimation.SelectionIndex());
settings->HideDelay(_hideDelay.TextAsInt());
settings->HideSpeed(_hideSpeed.TextAsInt());
}
bool Display::OnAnimationChange() {
_hideSpeed.Enabled(_hideAnimation.Selection() != noAnimStr);
return true;
}
bool Display::OnAnimationSpin(NMUPDOWN *ud) {
/* Increase the up/down spin increment: */
ud->iDelta *= ANIM_SPIN_INCREMENT;
return FALSE; /* Allows the change */
}
bool Display::OnCustomCheckChange() {
_edgeSpinner.Enabled(_customDistance.Checked());
return true;
}
bool Display::OnPositionChange() {
bool isCustom = (_position.Selection() == customPositionStr);
_customX.Enabled(isCustom);
_customY.Enabled(isCustom);
_positionX.Enabled(isCustom);
_positionY.Enabled(isCustom);
return true;
}
<|endoftext|> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.