text
stringlengths 54
60.6k
|
|---|
<commit_before>#include "aerial_autonomy/controllers/rpyt_based_position_controller.h"
bool RPYTBasedPositionController::runImplementation(
std::tuple<VelocityYawRate, PositionYaw> sensor_data, PositionYaw goal,
RollPitchYawRateThrust &control) {
auto velocity = std::get<0>(sensor_data);
auto position = std::get<1>(sensor_data);
VelocityYawRate velocity_command;
position_controller_.setGoal(goal, true);
bool control_success = position_controller_.run(position, velocity_command);
if (control_success) {
rpyt_velocity_controller_.setGoal(velocity_command);
control_success &= rpyt_velocity_controller_.run(
std::make_tuple(velocity, position.yaw), control);
}
return control_success;
}
ControllerStatus RPYTBasedPositionController::isConvergedImplementation(
std::tuple<VelocityYawRate, PositionYaw> sensor_data, PositionYaw goal) {
auto velocity = std::get<0>(sensor_data);
auto position = std::get<1>(sensor_data);
auto controller_status = rpyt_velocity_controller_.isConverged(
std::make_tuple(velocity, position.yaw));
controller_status += position_controller_.isConverged(position);
return controller_status;
}
<commit_msg>Show debug for all rpyt based position controller internal controllers<commit_after>#include "aerial_autonomy/controllers/rpyt_based_position_controller.h"
bool RPYTBasedPositionController::runImplementation(
std::tuple<VelocityYawRate, PositionYaw> sensor_data, PositionYaw goal,
RollPitchYawRateThrust &control) {
auto velocity = std::get<0>(sensor_data);
auto position = std::get<1>(sensor_data);
VelocityYawRate velocity_command;
position_controller_.setGoal(goal, true);
bool control_success = position_controller_.run(position, velocity_command);
if (control_success) {
rpyt_velocity_controller_.setGoal(velocity_command);
control_success &= rpyt_velocity_controller_.run(
std::make_tuple(velocity, position.yaw), control);
}
return control_success;
}
ControllerStatus RPYTBasedPositionController::isConvergedImplementation(
std::tuple<VelocityYawRate, PositionYaw> sensor_data, PositionYaw goal) {
auto velocity = std::get<0>(sensor_data);
auto position = std::get<1>(sensor_data);
ControllerStatus controller_status(ControllerStatus::Completed);
controller_status += rpyt_velocity_controller_.isConverged(
std::make_tuple(velocity, position.yaw));
controller_status += position_controller_.isConverged(position);
return controller_status;
}
<|endoftext|> |
<commit_before>/*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
*
* This file is part of ZLMediaKit(https://github.com/xiongziliang/ZLMediaKit).
*
* Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree.
*/
#include <algorithm>
#include "PlayerBase.h"
#include "Rtsp/RtspPlayerImp.h"
#include "Rtmp/RtmpPlayerImp.h"
#include "Http/HlsPlayer.h"
using namespace toolkit;
namespace mediakit {
//字符串是否以xx结尾
static bool end_of(const string &str, const string &substr){
auto pos = str.rfind(substr);
return pos != string::npos && pos == str.size() - substr.size();
}
PlayerBase::Ptr PlayerBase::createPlayer(const EventPoller::Ptr &poller,const string &strUrl) {
static auto releasePlayer = [](PlayerBase *ptr){
onceToken token(nullptr,[&](){
delete ptr;
});
ptr->teardown();
};
string prefix = FindField(strUrl.data(), NULL, "://");
if (strcasecmp("rtsps",prefix.data()) == 0) {
return PlayerBase::Ptr(new TcpClientWithSSL<RtspPlayerImp>(poller),releasePlayer);
}
if (strcasecmp("rtsp",prefix.data()) == 0) {
return PlayerBase::Ptr(new RtspPlayerImp(poller),releasePlayer);
}
if (strcasecmp("rtmps",prefix.data()) == 0) {
return PlayerBase::Ptr(new TcpClientWithSSL<RtmpPlayerImp>(poller),releasePlayer);
}
if (strcasecmp("rtmp",prefix.data()) == 0) {
return PlayerBase::Ptr(new RtmpPlayerImp(poller),releasePlayer);
}
if ((strcasecmp("http",prefix.data()) == 0 || strcasecmp("https",prefix.data()) == 0) && end_of(strUrl, ".m3u8")) {
return PlayerBase::Ptr(new HlsPlayerImp(poller),releasePlayer);
}
return PlayerBase::Ptr(new RtspPlayerImp(poller),releasePlayer);
}
PlayerBase::PlayerBase() {
this->mINI::operator[](kTimeoutMS) = 10000;
this->mINI::operator[](kMediaTimeoutMS) = 5000;
this->mINI::operator[](kBeatIntervalMS) = 5000;
this->mINI::operator[](kMaxAnalysisMS) = 5000;
}
///////////////////////////Demuxer//////////////////////////////
bool Demuxer::isInited(int analysisMs) {
if(analysisMs && _ticker.createdTime() > analysisMs){
//analysisMs毫秒后强制初始化完毕
return true;
}
if (_videoTrack && !_videoTrack->ready()) {
//视频未准备好
return false;
}
if (_audioTrack && !_audioTrack->ready()) {
//音频未准备好
return false;
}
return true;
}
vector<Track::Ptr> Demuxer::getTracks(bool trackReady) const {
vector<Track::Ptr> ret;
if(_videoTrack){
if(trackReady){
if(_videoTrack->ready()){
ret.emplace_back(_videoTrack);
}
}else{
ret.emplace_back(_videoTrack);
}
}
if(_audioTrack){
if(trackReady){
if(_audioTrack->ready()){
ret.emplace_back(_audioTrack);
}
}else{
ret.emplace_back(_audioTrack);
}
}
return std::move(ret);
}
float Demuxer::getDuration() const {
return _fDuration;
}
void Demuxer::onAddTrack(const Track::Ptr &track){
if(_listener){
_listener->onAddTrack(track);
}
}
void Demuxer::setTrackListener(Demuxer::Listener *listener) {
_listener = listener;
}
} /* namespace mediakit */
<commit_msg>hls播放器兼容带参数的url<commit_after>/*
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
*
* This file is part of ZLMediaKit(https://github.com/xiongziliang/ZLMediaKit).
*
* Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree.
*/
#include <algorithm>
#include "PlayerBase.h"
#include "Rtsp/RtspPlayerImp.h"
#include "Rtmp/RtmpPlayerImp.h"
#include "Http/HlsPlayer.h"
using namespace toolkit;
namespace mediakit {
//字符串是否以xx结尾
static bool end_of(const string &str, const string &substr){
auto pos = str.rfind(substr);
return pos != string::npos && pos == str.size() - substr.size();
}
PlayerBase::Ptr PlayerBase::createPlayer(const EventPoller::Ptr &poller,const string &url_in) {
static auto releasePlayer = [](PlayerBase *ptr){
onceToken token(nullptr,[&](){
delete ptr;
});
ptr->teardown();
};
string url = url_in;
string prefix = FindField(url.data(), NULL, "://");
auto pos = url.find('?');
if (pos != string::npos) {
//去除？后面的字符串
url = url.substr(0, pos);
}
if (strcasecmp("rtsps",prefix.data()) == 0) {
return PlayerBase::Ptr(new TcpClientWithSSL<RtspPlayerImp>(poller),releasePlayer);
}
if (strcasecmp("rtsp",prefix.data()) == 0) {
return PlayerBase::Ptr(new RtspPlayerImp(poller),releasePlayer);
}
if (strcasecmp("rtmps",prefix.data()) == 0) {
return PlayerBase::Ptr(new TcpClientWithSSL<RtmpPlayerImp>(poller),releasePlayer);
}
if (strcasecmp("rtmp",prefix.data()) == 0) {
return PlayerBase::Ptr(new RtmpPlayerImp(poller),releasePlayer);
}
if ((strcasecmp("http",prefix.data()) == 0 || strcasecmp("https",prefix.data()) == 0) && end_of(url, ".m3u8")) {
return PlayerBase::Ptr(new HlsPlayerImp(poller),releasePlayer);
}
return PlayerBase::Ptr(new RtspPlayerImp(poller),releasePlayer);
}
PlayerBase::PlayerBase() {
this->mINI::operator[](kTimeoutMS) = 10000;
this->mINI::operator[](kMediaTimeoutMS) = 5000;
this->mINI::operator[](kBeatIntervalMS) = 5000;
this->mINI::operator[](kMaxAnalysisMS) = 5000;
}
///////////////////////////Demuxer//////////////////////////////
bool Demuxer::isInited(int analysisMs) {
if(analysisMs && _ticker.createdTime() > analysisMs){
//analysisMs毫秒后强制初始化完毕
return true;
}
if (_videoTrack && !_videoTrack->ready()) {
//视频未准备好
return false;
}
if (_audioTrack && !_audioTrack->ready()) {
//音频未准备好
return false;
}
return true;
}
vector<Track::Ptr> Demuxer::getTracks(bool trackReady) const {
vector<Track::Ptr> ret;
if(_videoTrack){
if(trackReady){
if(_videoTrack->ready()){
ret.emplace_back(_videoTrack);
}
}else{
ret.emplace_back(_videoTrack);
}
}
if(_audioTrack){
if(trackReady){
if(_audioTrack->ready()){
ret.emplace_back(_audioTrack);
}
}else{
ret.emplace_back(_audioTrack);
}
}
return std::move(ret);
}
float Demuxer::getDuration() const {
return _fDuration;
}
void Demuxer::onAddTrack(const Track::Ptr &track){
if(_listener){
_listener->onAddTrack(track);
}
}
void Demuxer::setTrackListener(Demuxer::Listener *listener) {
_listener = listener;
}
} /* namespace mediakit */
<|endoftext|> |
<commit_before>// Copyright 2015, Chris Blume
// 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 Chris Blume 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.
#ifndef MAX_COMPILING_CONFIGURATION_STANDARDLIBRARY_HPP
#define MAX_COMPILING_CONFIGURATION_STANDARDLIBRARY_HPP
// __AVR_LIBC_VERSION__
// #define __AVR_LIBC_MAJOR__ 1
// #define __AVR_LIBC_MINOR__ 6
// #define __AVR_LIBC_REVISION__ 7
#endif // #ifndef MAX_COMPILING_CONFIGURATION_STANDARDLIBRARY_HPP<commit_msg>Adding comments to the standard library file.<commit_after>// Copyright 2015, Chris Blume
// 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 Chris Blume 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.
#ifndef MAX_COMPILING_CONFIGURATION_STANDARDLIBRARY_HPP
#define MAX_COMPILING_CONFIGURATION_STANDARDLIBRARY_HPP
// __AVR_LIBC_VERSION__
// #define __AVR_LIBC_MAJOR__ 1
// #define __AVR_LIBC_MINOR__ 6
// #define __AVR_LIBC_REVISION__ 7
// GCC ships with libstdc++
// Clang ships with libc++
#endif // #ifndef MAX_COMPILING_CONFIGURATION_STANDARDLIBRARY_HPP
<|endoftext|> |
<commit_before>#include "GL.h"
#include "PrimitiveRenderer.h"
#include <VBO.h>
#include "../system/StringUtils.h"
#include <iostream>
using namespace std;
PrimitiveRenderer::PrimitiveRenderer() {
}
static set<int> readCompressedFormats() {
set<int> r;
GLint num_compressed_format;
glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &num_compressed_format);
if (num_compressed_format > 0) {
GLint * compressed_format = new GLint[num_compressed_format * sizeof(GLint)];
glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compressed_format);
for (unsigned int i = 0; i < num_compressed_format; i++) {
r.insert(compressed_format[i]);
}
delete[] compressed_format;
}
return r;
}
static set<string> readExtensions() {
set<string> r;
GLint numExtensions;
glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
if (numExtensions > 0) {
for (int i = 0; i < numExtensions; i++) {
const GLubyte * e = glGetStringi(GL_EXTENSIONS, i);
r.insert((const char *)e);
}
}
return r;
}
void
PrimitiveRenderer::initializeBase() {
#ifdef _WIN32
GLenum err = glewInit();
if (GLEW_OK != err) {
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
assert(0);
}
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
#endif
glPolygonOffset(1, 2);
glClearColor(0.98f, 0.98f, 0.98f, 1.0f);
glActiveTexture(GL_TEXTURE0);
glStencilFuncSeparate(GL_FRONT, GL_EQUAL, 0, 0xff);
glStencilFuncSeparate(GL_BACK, GL_NEVER, 0, 0xff);
glStencilOpSeparate(GL_FRONT, GL_DECR_WRAP, GL_KEEP, GL_KEEP);
glStencilOpSeparate(GL_BACK, GL_INCR_WRAP, GL_KEEP, GL_KEEP);
#if 0
#if 1
static const GLfloat light0_pos[4] = { -50.0f, 50.0f, 0.0f, 0.0f };
#else
static const GLfloat light0_pos[4] = { 0.0f, 0.0f, +50.0f, 0.0f };
#endif
// white light
static const GLfloat light0_color[4] = { 0.6f, 0.6f, 0.6f, 1.0f };
static const GLfloat light1_pos[4] = { 50.0f, 50.0f, 0.0f, 0.0f };
// cold blue light
static const GLfloat light1_color[4] = { 0.4f, 0.4f, 1.0f, 1.0f };
#endif
#if 0
/* light */
glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT1, GL_POSITION, light1_pos);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_color);
glEnable(GL_LIGHT1);
#endif
set<int> compressed_formats = readCompressedFormats();
set<string> extensions = readExtensions();
// GL_ARB_ES2_compatibility
// GL_ARB_ES3_compatibility
// GL_ARB_texture_storage
// GL_ARB_compressed_texture_pixel_storage
// GL_EXT_abgr, GL_EXT_bgra
has_dxt1 = extensions.count("GL_EXT_texture_compression_dxt1");
has_etc1 = extensions.count("OES_compressed_ETC1_RGB8_texture");
has_rgtc = extensions.count("GL_ARB_texture_compression_rgtc") || extensions.count("GL_EXT_texture_compression_rgtc");
// GL_IMG_texture_compression_pvrtc"
// GL_AMD_compressed_ATC_texture / GL_ATI_texture_compression_atitc
// GL_OES_texture_compression_S3TC / GL_EXT_texture_compression_s3tc
// EXT_texture_rg : RED and RG modes
const char * version_str = (const char *)glGetString(GL_VERSION);
if (version_str) {
// OpenGL ES 3.0 Apple A7 GPU - 75.9.3
// 3.0 Mesa 11.0.2
cerr << "got version: " << version_str << endl;
vector<string> parts = StringUtils::split(version_str);
if (parts.size() >= 3 && parts[0] == "OpenGL" && parts[1] == "ES") {
const string & es_version = parts[2];
cerr << "got OpenGL ES: " << es_version << endl;
if (es_version == "3.0") {
cerr << "has etc1" << endl;
has_etc1 = true;
is_es3 = true;
}
has_rgb565 = true;
} else if (parts.size() >= 2 && parts[1] == "Mesa") {
has_rgb565 = true;
} else {
assert(0);
}
}
assert(has_rgb565);
int ii;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &ii);
max_texture_size = ii;
cerr << "Maximum texture size is " << max_texture_size << endl;
// MAX_VERTEX_TEXTURE_IMAGE_UNITS => how many textures a vertex shader can read
}
void
PrimitiveRenderer::blend(bool t) {
if (t != blend_enabled) {
blend_enabled = t;
if (t) glEnable(GL_BLEND);
else glDisable(GL_BLEND);
}
}
void
PrimitiveRenderer::stencilTest(bool t) {
if (t != stencil_test_enabled) {
stencil_test_enabled = t;
if (t) glEnable(GL_STENCIL_TEST);
else glDisable(GL_STENCIL_TEST);
}
}
void
PrimitiveRenderer::stencilMask(int m) {
if (m != current_stencil_mask) {
current_stencil_mask = m;
glStencilMask(m);
}
}
void
PrimitiveRenderer::depthTest(bool t) {
if (t != depth_test_enabled) {
depth_test_enabled = t;
if (t) glEnable(GL_DEPTH_TEST);
else glDisable(GL_DEPTH_TEST);
}
}
void
PrimitiveRenderer::depthMask(bool m) {
if (m != current_depth_mask) {
current_depth_mask = m;
glDepthMask(m ? GL_TRUE : GL_FALSE);
}
}
void
PrimitiveRenderer::cullFace(bool t) {
if (t != cull_face_enabled) {
cull_face_enabled = t;
if (t) glEnable(GL_CULL_FACE);
else glDisable(GL_CULL_FACE);
}
}
void
PrimitiveRenderer::setLineWidth(float w) {
if (w != current_line_width) {
current_line_width = w;
glLineWidth(w);
}
}
void
PrimitiveRenderer::bind(const canvas::TextureRef & texture) {
int id = texture.getTextureId();
if (!id) {
cerr << "trying to bind zero tex" << endl;
assert(0);
} else if (id != current_texture_2d) {
current_texture_2d = id;
glBindTexture(GL_TEXTURE_2D, id);
}
}
void
PrimitiveRenderer::bind(const VBO & vbo) {
int a = vbo.getVertexArrayId();
if (!a) {
cerr << "trying to bind zero vao" << endl;
assert(0);
} else if (a != current_vertex_array) {
current_vertex_array = a;
glBindVertexArray(a);
// glBindBuffer(GL_ARRAY_BUFFER, vbo.getVertexBufferId());
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo.getIndexBufferId());
}
}
void
PrimitiveRenderer::use(const gpufw::shader_program & program) {
int id = program.getProgramObjectId();
if (!id) {
assert(0);
} else if (id != current_program) {
current_program = id;
glUseProgram(id);
}
}
void
PrimitiveRenderer::clear(int clear_bits) {
int gl_bits = 0;
if (clear_bits & COLOR_BUFFER_BIT) {
colorMask(true, true, true, true);
gl_bits |= GL_COLOR_BUFFER_BIT;
}
if (clear_bits & DEPTH_BUFFER_BIT || clear_bits & DEPTH_STENCIL_BUFFER_BIT) {
depthMask(true);
gl_bits |= GL_DEPTH_BUFFER_BIT;
}
if (clear_bits & STENCIL_BUFFER_BIT || clear_bits & DEPTH_STENCIL_BUFFER_BIT) {
stencilMask(0xff);
gl_bits |= GL_STENCIL_BUFFER_BIT;
}
if (gl_bits) {
glClear(gl_bits);
}
}
void
PrimitiveRenderer::colorMask(bool r, bool g, bool b, bool a) {
if (r != current_red_mask ||
g != current_green_mask ||
b != current_blue_mask ||
a != current_alpha_mask) {
current_red_mask = r;
current_green_mask = g;
current_blue_mask = b;
current_alpha_mask = a;
glColorMask( r ? GL_TRUE : GL_FALSE,
g ? GL_TRUE : GL_FALSE,
b ? GL_TRUE : GL_FALSE,
a ? GL_TRUE : GL_FALSE
);
}
}
void
PrimitiveRenderer::setCompositionMode(CompositionMode mode) {
if (mode != current_composition_mode) {
current_composition_mode = mode;
switch (mode) {
case COPY:
glBlendFunc(GL_ONE, GL_ZERO);
break;
case NORMAL:
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
break;
case MULTIPLY:
glBlendFunc(GL_ZERO, GL_SRC_COLOR);
break;
}
}
}
void
PrimitiveRenderer::viewport(unsigned int x, unsigned int y, unsigned int w, unsigned int h) {
if (w != current_display_size.x || h != current_display_size.y) {
current_display_size = glm::ivec2(w, h);
cerr << "updating viewport\n";
glViewport(0, 0, (unsigned int)(w * display_scale), (unsigned int)(h * display_scale));
}
}
void
PrimitiveRenderer::pushGroupMarker(const char * name) {
#ifdef GL_ES
glPushGroupMarkerEXT(0, name);
#endif
}
void
PrimitiveRenderer::popGroupMarker() {
#ifdef GL_ES
glPopGroupMarkerEXT();
#endif
}
void
PrimitiveRenderer::invalidateFramebuffer(int bits) {
int n = 0;
GLenum v[4];
if (bits & STENCIL_BUFFER_BIT) {
v[n++] = GL_STENCIL_ATTACHMENT;
}
if (bits & DEPTH_BUFFER_BIT) {
v[n++] = GL_DEPTH_ATTACHMENT;
}
if (n) {
if (is_es3) {
glInvalidateFramebuffer(GL_FRAMEBUFFER, n, &v[0]);
} else {
#ifdef GL_ES
// glBindFramebuffer(GL_FRAMEBUFFER, current_framebuffer);
// glDiscardFramebufferEXT(GL_FRAMEBUFFER, n, &v[0]);
#endif
}
}
}
<commit_msg>make VBO binding work without vertex array objects<commit_after>#include "GL.h"
#include "PrimitiveRenderer.h"
#include <VBO.h>
#include "../system/StringUtils.h"
#include <iostream>
using namespace std;
PrimitiveRenderer::PrimitiveRenderer() {
}
static set<int> readCompressedFormats() {
set<int> r;
GLint num_compressed_format;
glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &num_compressed_format);
if (num_compressed_format > 0) {
GLint * compressed_format = new GLint[num_compressed_format * sizeof(GLint)];
glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compressed_format);
for (unsigned int i = 0; i < num_compressed_format; i++) {
r.insert(compressed_format[i]);
}
delete[] compressed_format;
}
return r;
}
static set<string> readExtensions() {
set<string> r;
GLint numExtensions;
glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
if (numExtensions > 0) {
for (int i = 0; i < numExtensions; i++) {
const GLubyte * e = glGetStringi(GL_EXTENSIONS, i);
r.insert((const char *)e);
}
}
return r;
}
void
PrimitiveRenderer::initializeBase() {
#ifdef _WIN32
GLenum err = glewInit();
if (GLEW_OK != err) {
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
assert(0);
}
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
#endif
glPolygonOffset(1, 2);
glClearColor(0.98f, 0.98f, 0.98f, 1.0f);
glActiveTexture(GL_TEXTURE0);
glStencilFuncSeparate(GL_FRONT, GL_EQUAL, 0, 0xff);
glStencilFuncSeparate(GL_BACK, GL_NEVER, 0, 0xff);
glStencilOpSeparate(GL_FRONT, GL_DECR_WRAP, GL_KEEP, GL_KEEP);
glStencilOpSeparate(GL_BACK, GL_INCR_WRAP, GL_KEEP, GL_KEEP);
#if 0
#if 1
static const GLfloat light0_pos[4] = { -50.0f, 50.0f, 0.0f, 0.0f };
#else
static const GLfloat light0_pos[4] = { 0.0f, 0.0f, +50.0f, 0.0f };
#endif
// white light
static const GLfloat light0_color[4] = { 0.6f, 0.6f, 0.6f, 1.0f };
static const GLfloat light1_pos[4] = { 50.0f, 50.0f, 0.0f, 0.0f };
// cold blue light
static const GLfloat light1_color[4] = { 0.4f, 0.4f, 1.0f, 1.0f };
#endif
#if 0
/* light */
glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT1, GL_POSITION, light1_pos);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_color);
glEnable(GL_LIGHT1);
#endif
set<int> compressed_formats = readCompressedFormats();
set<string> extensions = readExtensions();
// GL_ARB_ES2_compatibility
// GL_ARB_ES3_compatibility
// GL_ARB_texture_storage
// GL_ARB_compressed_texture_pixel_storage
// GL_EXT_abgr, GL_EXT_bgra
has_dxt1 = extensions.count("GL_EXT_texture_compression_dxt1");
has_etc1 = extensions.count("OES_compressed_ETC1_RGB8_texture");
has_rgtc = extensions.count("GL_ARB_texture_compression_rgtc") || extensions.count("GL_EXT_texture_compression_rgtc");
// GL_IMG_texture_compression_pvrtc"
// GL_AMD_compressed_ATC_texture / GL_ATI_texture_compression_atitc
// GL_OES_texture_compression_S3TC / GL_EXT_texture_compression_s3tc
// EXT_texture_rg : RED and RG modes
const char * version_str = (const char *)glGetString(GL_VERSION);
if (version_str) {
// OpenGL ES 3.0 Apple A7 GPU - 75.9.3
// 3.0 Mesa 11.0.2
cerr << "got version: " << version_str << endl;
vector<string> parts = StringUtils::split(version_str);
if (parts.size() >= 3 && parts[0] == "OpenGL" && parts[1] == "ES") {
const string & es_version = parts[2];
cerr << "got OpenGL ES: " << es_version << endl;
if (es_version == "3.0") {
cerr << "has etc1" << endl;
has_etc1 = true;
is_es3 = true;
}
has_rgb565 = true;
} else if (parts.size() >= 2 && parts[1] == "Mesa") {
has_rgb565 = true;
} else {
assert(0);
}
}
assert(has_rgb565);
int ii;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &ii);
max_texture_size = ii;
cerr << "Maximum texture size is " << max_texture_size << endl;
// MAX_VERTEX_TEXTURE_IMAGE_UNITS => how many textures a vertex shader can read
}
void
PrimitiveRenderer::blend(bool t) {
if (t != blend_enabled) {
blend_enabled = t;
if (t) glEnable(GL_BLEND);
else glDisable(GL_BLEND);
}
}
void
PrimitiveRenderer::stencilTest(bool t) {
if (t != stencil_test_enabled) {
stencil_test_enabled = t;
if (t) glEnable(GL_STENCIL_TEST);
else glDisable(GL_STENCIL_TEST);
}
}
void
PrimitiveRenderer::stencilMask(int m) {
if (m != current_stencil_mask) {
current_stencil_mask = m;
glStencilMask(m);
}
}
void
PrimitiveRenderer::depthTest(bool t) {
if (t != depth_test_enabled) {
depth_test_enabled = t;
if (t) glEnable(GL_DEPTH_TEST);
else glDisable(GL_DEPTH_TEST);
}
}
void
PrimitiveRenderer::depthMask(bool m) {
if (m != current_depth_mask) {
current_depth_mask = m;
glDepthMask(m ? GL_TRUE : GL_FALSE);
}
}
void
PrimitiveRenderer::cullFace(bool t) {
if (t != cull_face_enabled) {
cull_face_enabled = t;
if (t) glEnable(GL_CULL_FACE);
else glDisable(GL_CULL_FACE);
}
}
void
PrimitiveRenderer::setLineWidth(float w) {
if (w != current_line_width) {
current_line_width = w;
glLineWidth(w);
}
}
void
PrimitiveRenderer::bind(const canvas::TextureRef & texture) {
int id = texture.getTextureId();
if (!id) {
cerr << "trying to bind zero tex" << endl;
assert(0);
} else if (id != current_texture_2d) {
current_texture_2d = id;
glBindTexture(GL_TEXTURE_2D, id);
}
}
void
PrimitiveRenderer::bind(const VBO & vbo) {
if (vbo.hasVertexArrayObjects()) {
int a = vbo.getVertexArrayId();
if (!a) {
cerr << "trying to bind zero vao" << endl;
assert(0);
} else if (a != current_vertex_array) {
current_vertex_array = a;
glBindVertexArray(a);
}
} else {
glBindBuffer(GL_ARRAY_BUFFER, vbo.getVertexBufferId());
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo.getIndexBufferId());
vbo.setPointers();
}
}
void
PrimitiveRenderer::use(const gpufw::shader_program & program) {
int id = program.getProgramObjectId();
if (!id) {
assert(0);
} else if (id != current_program) {
current_program = id;
glUseProgram(id);
}
}
void
PrimitiveRenderer::clear(int clear_bits) {
int gl_bits = 0;
if (clear_bits & COLOR_BUFFER_BIT) {
colorMask(true, true, true, true);
gl_bits |= GL_COLOR_BUFFER_BIT;
}
if (clear_bits & DEPTH_BUFFER_BIT || clear_bits & DEPTH_STENCIL_BUFFER_BIT) {
depthMask(true);
gl_bits |= GL_DEPTH_BUFFER_BIT;
}
if (clear_bits & STENCIL_BUFFER_BIT || clear_bits & DEPTH_STENCIL_BUFFER_BIT) {
stencilMask(0xff);
gl_bits |= GL_STENCIL_BUFFER_BIT;
}
if (gl_bits) {
glClear(gl_bits);
}
}
void
PrimitiveRenderer::colorMask(bool r, bool g, bool b, bool a) {
if (r != current_red_mask ||
g != current_green_mask ||
b != current_blue_mask ||
a != current_alpha_mask) {
current_red_mask = r;
current_green_mask = g;
current_blue_mask = b;
current_alpha_mask = a;
glColorMask( r ? GL_TRUE : GL_FALSE,
g ? GL_TRUE : GL_FALSE,
b ? GL_TRUE : GL_FALSE,
a ? GL_TRUE : GL_FALSE
);
}
}
void
PrimitiveRenderer::setCompositionMode(CompositionMode mode) {
if (mode != current_composition_mode) {
current_composition_mode = mode;
switch (mode) {
case COPY:
glBlendFunc(GL_ONE, GL_ZERO);
break;
case NORMAL:
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
break;
case MULTIPLY:
glBlendFunc(GL_ZERO, GL_SRC_COLOR);
break;
}
}
}
void
PrimitiveRenderer::viewport(unsigned int x, unsigned int y, unsigned int w, unsigned int h) {
if (w != current_display_size.x || h != current_display_size.y) {
current_display_size = glm::ivec2(w, h);
cerr << "updating viewport\n";
glViewport(0, 0, (unsigned int)(w * display_scale), (unsigned int)(h * display_scale));
}
}
void
PrimitiveRenderer::pushGroupMarker(const char * name) {
#ifdef GL_ES
glPushGroupMarkerEXT(0, name);
#endif
}
void
PrimitiveRenderer::popGroupMarker() {
#ifdef GL_ES
glPopGroupMarkerEXT();
#endif
}
void
PrimitiveRenderer::invalidateFramebuffer(int bits) {
int n = 0;
GLenum v[4];
if (bits & STENCIL_BUFFER_BIT) {
v[n++] = GL_STENCIL_ATTACHMENT;
}
if (bits & DEPTH_BUFFER_BIT) {
v[n++] = GL_DEPTH_ATTACHMENT;
}
if (n) {
if (is_es3) {
glInvalidateFramebuffer(GL_FRAMEBUFFER, n, &v[0]);
} else {
#ifdef GL_ES
// glBindFramebuffer(GL_FRAMEBUFFER, current_framebuffer);
// glDiscardFramebufferEXT(GL_FRAMEBUFFER, n, &v[0]);
#endif
}
}
}
<|endoftext|> |
<commit_before>
/**
* @file /home/ryan/programming/atl/test/test_parser.cpp
* @author Ryan Domigan <ryan_domigan@[email protected]>
* Created on Dec 16, 2014
*/
#include <gtest/gtest.h>
#include "../atl.hpp"
#include "../helpers.hpp"
#include "../debug.hpp"
#include <iostream>
#include <vector>
#include <sstream>
using namespace atl;
using namespace std;
struct ParserTest : public ::testing::Test {
Atl atl;
};
TEST_F(ParserTest, test_atoms)
{
ASSERT_EQ(2, unwrap<Fixnum>(atl.parse.string_("2")).value);
ASSERT_EQ("Hello, world!", unwrap<String>(atl.parse.string_("\"Hello, world!\"")).value);
}
TEST_F(ParserTest, test_simple_int_list) {
auto parsed = atl.parse.string_("(1 2 3)");
auto ast = unwrap<Ast>(parsed);
auto expected = vector<Any>{
wrap(1),
wrap(2),
wrap(3)
};
for(auto& vv : zip(ast, expected)) {
#ifdef DEBUGGING
cout << "parsed: " << printer::any(*get<0>(vv)) << "\nexpected: " << printer::any(*get<1>(vv)) << endl;
#endif
ASSERT_EQ(*get<0>(vv), *get<1>(vv));
}
}
void _check_nested(AstData const& parsed, AstData const& expected)
{
for(auto& vv : zip(parsed, expected))
{
ASSERT_EQ((*get<0>(vv))._tag,
(*get<1>(vv))._tag);
if(is<Ast>(*get<0>(vv)))
_check_nested(unwrap<AstData>((*get<0>(vv))),
unwrap<AstData>((*get<1>(vv))));
else
{
#ifdef DEBUGGING
cout << "parsed: " << printer::any(*get<0>(vv))
<< "\nexpected: " << printer::any(*get<1>(vv))
<< endl;
#endif
ASSERT_EQ(*get<0>(vv), *get<1>(vv));
}
}
}
TEST_F(ParserTest, test_empty_list)
{
Arena arena;
using namespace make_ast;
auto parsed = atl.parse.string_("()");
auto expected =
make()
(ast_alloc(arena));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, nested_int_list)
{
Arena arena;
using namespace make_ast;
auto parsed = atl.parse.string_("(1 2 (4 5) 3)");
auto expected =
make(lift(1),
lift(2),
make(lift(4),
lift(5)),
lift(3))
(ast_alloc(arena));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, TestQuote) {
using namespace make_ast;
auto parsed = atl.parse.string_("'(2 3)");
auto expected =
make(lift<Quote>(),
make(lift(2),
lift(3)))
(ast_alloc(atl.gc));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, test_nested_quote)
{
using namespace make_ast;
auto parsed = atl.parse.string_("(1 '(2 3) 4)");
auto expected = make
(lift(1),
make(lift<Quote>(),
make(lift(2),
lift(3))),
lift(4))
(ast_alloc(atl.gc));
_check_nested(*unwrap<Ast>(parsed).value,
*expected.value);
}
TEST_F(ParserTest, test_stream_parsing)
{
string contents = "(a b c)";
stringstream as_stream(contents);
auto a = unwrap<Ast>(atl.parse.string_(contents));
auto b = unwrap<Ast>(atl.parse.stream(as_stream));
for(auto& vv : zip(a, b))
ASSERT_EQ(unwrap<Symbol>(*get<0>(vv)).name,
unwrap<Symbol>(*get<1>(vv)).name);
}
TEST_F(ParserTest, test_multi_line_stream_parsing)
{
string contents = "(1 2 3)\n\n(4 5 6)";
stringstream as_stream(contents);
auto a = unwrap<Ast>(atl.parse.stream(as_stream));
auto b = unwrap<Ast>(atl.parse.stream(as_stream));
vector<int> expected = {1, 2, 3};
for(auto& vv : zip(a, expected))
ASSERT_EQ(unwrap<Fixnum>(*get<0>(vv)).value,
*get<1>(vv));
expected = {4, 5, 6};
for(auto& vv : zip(b, expected))
ASSERT_EQ(unwrap<Fixnum>(*get<0>(vv)).value,
*get<1>(vv));
}
TEST_F(ParserTest, test_comments)
{
string contents = ";; (a b c)\n (2 3 4)";
auto res = unwrap<Ast>(atl.parse.string_(contents));
auto expected = vector<Any>{
wrap(2),
wrap(3),
wrap(4)
};
for(auto& vv : zip(res, expected))
ASSERT_EQ(unwrap<Fixnum>(*get<0>(vv)).value,
unwrap<Fixnum>(*get<1>(vv)).value);
}
<commit_msg>Test parsing from stream<commit_after>
/**
* @file /home/ryan/programming/atl/test/test_parser.cpp
* @author Ryan Domigan <ryan_domigan@[email protected]>
* Created on Dec 16, 2014
*/
#include <gtest/gtest.h>
#include "../atl.hpp"
#include "../helpers.hpp"
#include "../debug.hpp"
#include <iostream>
#include <vector>
#include <sstream>
using namespace atl;
using namespace std;
struct ParserTest : public ::testing::Test {
Atl atl;
};
TEST_F(ParserTest, test_atoms)
{
ASSERT_EQ(2, unwrap<Fixnum>(atl.parse.string_("2")).value);
ASSERT_EQ("Hello, world!", unwrap<String>(atl.parse.string_("\"Hello, world!\"")).value);
}
TEST_F(ParserTest, test_simple_int_list) {
auto parsed = atl.parse.string_("(1 2 3)");
auto ast = unwrap<Ast>(parsed);
auto expected = vector<Any>{
wrap(1),
wrap(2),
wrap(3)
};
for(auto& vv : zip(ast, expected)) {
#ifdef DEBUGGING
cout << "parsed: " << printer::any(*get<0>(vv)) << "\nexpected: " << printer::any(*get<1>(vv)) << endl;
#endif
ASSERT_EQ(*get<0>(vv), *get<1>(vv));
}
}
void _check_nested(AstData const& parsed, AstData const& expected)
{
for(auto& vv : zip(parsed, expected))
{
ASSERT_EQ((*get<0>(vv))._tag,
(*get<1>(vv))._tag);
if(is<Ast>(*get<0>(vv)))
_check_nested(unwrap<AstData>((*get<0>(vv))),
unwrap<AstData>((*get<1>(vv))));
else
{
#ifdef DEBUGGING
cout << "parsed: " << printer::any(*get<0>(vv))
<< "\nexpected: " << printer::any(*get<1>(vv))
<< endl;
#endif
ASSERT_EQ(*get<0>(vv), *get<1>(vv));
}
}
}
TEST_F(ParserTest, test_empty_list)
{
Arena arena;
using namespace make_ast;
auto parsed = atl.parse.string_("()");
auto expected =
make()
(ast_alloc(arena));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, nested_int_list)
{
Arena arena;
using namespace make_ast;
auto parsed = atl.parse.string_("(1 2 (4 5) 3)");
auto expected =
make(lift(1),
lift(2),
make(lift(4),
lift(5)),
lift(3))
(ast_alloc(arena));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, test_parsing_int_list_from_stream)
{
Arena arena;
using namespace make_ast;
std::stringstream input{"(1 2 (4 5) 3) foo"};
auto parsed = atl.parse.stream(input);
auto expected =
make(lift(1),
lift(2),
make(lift(4),
lift(5)),
lift(3))
(ast_alloc(arena));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, TestQuote) {
using namespace make_ast;
auto parsed = atl.parse.string_("'(2 3)");
auto expected =
make(lift<Quote>(),
make(lift(2),
lift(3)))
(ast_alloc(atl.gc));
_check_nested(*expected.value,
*unwrap<Ast>(parsed).value);
}
TEST_F(ParserTest, test_nested_quote)
{
using namespace make_ast;
auto parsed = atl.parse.string_("(1 '(2 3) 4)");
auto expected = make
(lift(1),
make(lift<Quote>(),
make(lift(2),
lift(3))),
lift(4))
(ast_alloc(atl.gc));
_check_nested(*unwrap<Ast>(parsed).value,
*expected.value);
}
TEST_F(ParserTest, test_stream_parsing)
{
string contents = "(a b c)";
stringstream as_stream(contents);
auto a = unwrap<Ast>(atl.parse.string_(contents));
auto b = unwrap<Ast>(atl.parse.stream(as_stream));
for(auto& vv : zip(a, b))
ASSERT_EQ(unwrap<Symbol>(*get<0>(vv)).name,
unwrap<Symbol>(*get<1>(vv)).name);
}
TEST_F(ParserTest, test_multi_line_stream_parsing)
{
string contents = "(1 2 3)\n\n(4 5 6)";
stringstream as_stream(contents);
auto a = unwrap<Ast>(atl.parse.stream(as_stream));
auto b = unwrap<Ast>(atl.parse.stream(as_stream));
vector<int> expected = {1, 2, 3};
for(auto& vv : zip(a, expected))
ASSERT_EQ(unwrap<Fixnum>(*get<0>(vv)).value,
*get<1>(vv));
expected = {4, 5, 6};
for(auto& vv : zip(b, expected))
ASSERT_EQ(unwrap<Fixnum>(*get<0>(vv)).value,
*get<1>(vv));
}
TEST_F(ParserTest, test_comments)
{
string contents = ";; (a b c)\n (2 3 4)";
auto res = unwrap<Ast>(atl.parse.string_(contents));
auto expected = vector<Any>{
wrap(2),
wrap(3),
wrap(4)
};
for(auto& vv : zip(res, expected))
ASSERT_EQ(unwrap<Fixnum>(*get<0>(vv)).value,
unwrap<Fixnum>(*get<1>(vv)).value);
}
<|endoftext|> |
<commit_before>#include "i_audio.h"
#include "platform/model_value.h"
#include "platform/i_platform.h"
namespace {
float left( float x )
{
if( x < 0.0f )
return 1.f - 1.f / ( 2.f + 2.f * std::abs( x / 1e3 ) );
else
return 1.f / ( 2.f + 2.f * ( x / 1e3 ) );
}
float right( float x )
{
return left( -x );
}
}
void Mixer::Mix( AudioBuffer& Dest, AudioFiles_t& Files, size_t const Size )
{
if( !Size )
{
return;
}
glm::vec2 playerPos;
ModelValue const& PlayerModel = RootModel::Get()["player"];
if( PlayerModel.IsValid() )
{
ModelValue const& mx=PlayerModel["x"];
ModelValue const& my=PlayerModel["y"];
if ( mx.IsValid() && my.IsValid() )
{
playerPos.x = double(mx);
playerPos.y = double(my);
}
}
size_t const DestChannels = Dest.GetChannels();
float** Tmp = new float*[DestChannels];
for( size_t i = 0; i < DestChannels; ++i )
{
Tmp[i] = new float[Size];
memset( Tmp[i], 0, sizeof( float )*Size );
}
for( AudioFiles_t::iterator i = Files.begin(), e = Files.end(); i != e; ++i )
{
AudioFile& f = *i;
float Weight = mAudioTypeRelativeWeights[f.GetType()];
AudioBuffer& Buf = f.GetBuffer();
float l = 1.0, r = 1.0;
if( f.GetType() == audio::Effect )
{
glm::vec2 const& pos = f.GetPosition();
glm::vec2 const dif = pos - playerPos;
const float DistWeight = 1.f / ( 1.f + glm::dot( dif, dif ) / 1e6 );
Weight *= DistWeight;
l = left( dif.x );
r = right( dif.x );
}
size_t CommonChannels = std::min<size_t>( Buf.GetChannels(), DestChannels );
for( size_t Ch = 0; Ch < CommonChannels; ++Ch )
{
float const* SrcBuf = Buf.GetData( Ch );
float* DstBuf = Tmp[Ch];
for( size_t j = 0; j < Size; ++j )
{
( *DstBuf++ ) += ( Ch == 0 ? l : r ) * Weight * ( *SrcBuf++ );
}
}
Buf.Read( Size );
}
Dest.Write( Tmp, Size );
for( size_t i = 0; i < DestChannels; ++i )
{
delete[] Tmp[i];
}
delete[] Tmp;
}
Mixer::Mixer()
{
// todo: make it adjustable
mAudioTypeRelativeWeights[audio::Music] = 0.35f;
mAudioTypeRelativeWeights[audio::Effect] = 0.2f;
mAudioTypeRelativeWeights[audio::Speech] = 0.45f;
}
<commit_msg>M: positioned sound has a cap. Modified the magic number of distance/sound weight not to hear shooting from the other corner of the map.<commit_after>#include "i_audio.h"
#include "platform/model_value.h"
#include "platform/i_platform.h"
namespace {
float left( float x )
{
if( x < 0.0f )
return 1.f - 1.f / ( 2.f + 2.f * std::abs( x / 1e3 ) );
else
return 1.f / ( 2.f + 2.f * ( x / 1e3 ) );
}
float right( float x )
{
return left( -x );
}
}
void Mixer::Mix( AudioBuffer& Dest, AudioFiles_t& Files, size_t const Size )
{
if( !Size )
{
return;
}
glm::vec2 playerPos;
ModelValue const& PlayerModel = RootModel::Get()["player"];
if( PlayerModel.IsValid() )
{
ModelValue const& mx=PlayerModel["x"];
ModelValue const& my=PlayerModel["y"];
if ( mx.IsValid() && my.IsValid() )
{
playerPos.x = double(mx);
playerPos.y = double(my);
}
}
size_t const DestChannels = Dest.GetChannels();
float** Tmp = new float*[DestChannels];
for( size_t i = 0; i < DestChannels; ++i )
{
Tmp[i] = new float[Size];
memset( Tmp[i], 0, sizeof( float )*Size );
}
for( AudioFiles_t::iterator i = Files.begin(), e = Files.end(); i != e; ++i )
{
AudioFile& f = *i;
float Weight = mAudioTypeRelativeWeights[f.GetType()];
AudioBuffer& Buf = f.GetBuffer();
float l = 1.0, r = 1.0;
if( f.GetType() == audio::Effect )
{
glm::vec2 const& pos = f.GetPosition();
glm::vec2 const dif = pos - playerPos;
const float DistWeight = std::max(1.f / ( 1.f + glm::dot( dif, dif ) / 7e5 )-0.1,0.0);
Weight *= DistWeight;
l = left( dif.x );
r = right( dif.x );
}
size_t CommonChannels = std::min<size_t>( Buf.GetChannels(), DestChannels );
for( size_t Ch = 0; Ch < CommonChannels; ++Ch )
{
float const* SrcBuf = Buf.GetData( Ch );
float* DstBuf = Tmp[Ch];
for( size_t j = 0; j < Size; ++j )
{
( *DstBuf++ ) += ( Ch == 0 ? l : r ) * Weight * ( *SrcBuf++ );
}
}
Buf.Read( Size );
}
Dest.Write( Tmp, Size );
for( size_t i = 0; i < DestChannels; ++i )
{
delete[] Tmp[i];
}
delete[] Tmp;
}
Mixer::Mixer()
{
// todo: make it adjustable
mAudioTypeRelativeWeights[audio::Music] = 0.35f;
mAudioTypeRelativeWeights[audio::Effect] = 0.2f;
mAudioTypeRelativeWeights[audio::Speech] = 0.45f;
}
<|endoftext|> |
<commit_before>#pragma once
#include <map>
#include <memory>
#include <unordered_map>
#include <json.hpp>
#include <mos/gfx/animation.hpp>
#include <mos/gfx/character.hpp>
#include <mos/gfx/font.hpp>
#include <mos/gfx/material.hpp>
#include <mos/gfx/mesh.hpp>
#include <mos/gfx/model.hpp>
#include <mos/gfx/texture_2d.hpp>
#include <mos/gfx/light.hpp>
#include <mos/gfx/environment_light.hpp>
namespace mos {
namespace gfx {
/** Handles heavy render assets, such as Textures and meshes. Caches things internally, so nothing is loaded twice. */
class Assets final {
public:
using MeshMap = std::unordered_map<std::string, std::shared_ptr<Mesh>>;
using TextureMap = std::unordered_map<std::string, std::shared_ptr<Texture2D>>;
using MeshPair = std::pair<std::string, std::shared_ptr<Mesh>>;
using TexturePair = std::pair<std::string, std::shared_ptr<Texture2D>>;
using MaterialPair = std::pair<std::string, std::shared_ptr<Material>>;
using SharedMaterial = std::shared_ptr<Material>;
/** @param directory The directory where the assets exist, relative to the run directory. */
Assets(const std::string directory = "assets/");
Assets(const Assets &assets) = delete;
~Assets();
/** Loads a Model from a *.model file.*/
Model model(const std::string &path, const glm::mat4 &parent_transform = glm::mat4(1.0f));
/** Loads an animation from meshes specified in *.animation file. */
Animation animation(const std::string &path);
/** Loads a Material from a *.material file into a Material object. */
Material material(const std::string &path);
/** Loads a Light from a *.light file into a Light object. */
Light light(const std::string &path, const glm::mat4 &parent_transform = glm::mat4(1.0f));
/** Loads a EnvironmentLight from a *.environment_light. */
EnvironmentLight environment_light(const std::string &path, const glm::mat4& parent_transform = glm::mat4(1.0f));
/** Loads a Mesh from a *.mesh file and caches it internally. */
SharedMesh mesh(const std::string &path);
/** Loads Texture2D from a *.png file and caches it internally. */
SharedTexture2D
texture(const std::string &path,
const bool color_data = true,
const bool mipmaps = true,
const Texture2D::Wrap &wrap = Texture2D::Wrap::REPEAT);
/** Remove all unused assets. */
void clear_unused();
std::string directory() const;
private:
Model model_value(const nlohmann::json &value, const glm::mat4 &parent_transform);
const std::string directory_;
MeshMap meshes_;
TextureMap textures_;
};
}
}<commit_msg>Check<commit_after>#pragma once
#include <map>
#include <memory>
#include <unordered_map>
#include <json.hpp>
#include <mos/gfx/animation.hpp>
#include <mos/gfx/character.hpp>
#include <mos/gfx/font.hpp>
#include <mos/gfx/material.hpp>
#include <mos/gfx/mesh.hpp>
#include <mos/gfx/model.hpp>
#include <mos/gfx/texture_2d.hpp>
#include <mos/gfx/light.hpp>
#include <mos/gfx/environment_light.hpp>
namespace mos {
namespace gfx {
/** Handles heavy render assets, such as Textures and meshes. Caches things internally, so nothing is loaded twice. */
class Assets final {
public:
using MeshMap = std::unordered_map<std::string, std::shared_ptr<Mesh>>;
using TextureMap = std::unordered_map<std::string, std::shared_ptr<Texture2D>>;
using MeshPair = std::pair<std::string, std::shared_ptr<Mesh>>;
using TexturePair = std::pair<std::string, std::shared_ptr<Texture2D>>;
using MaterialPair = std::pair<std::string, std::shared_ptr<Material>>;
using SharedMaterial = std::shared_ptr<Material>;
/** @param directory The directory where the assets exist, relative to the run directory. */
Assets(const std::string directory = "assets/");
Assets(const Assets &assets) = delete;
~Assets();
/** Loads a Model from a *.model file.*/
Model model(const std::string &path, const glm::mat4 &parent_transform = glm::mat4(1.0f));
/** Loads a Model from a json structure */
Model model_value(const nlohmann::json &value, const glm::mat4 &parent_transform = glm::mat4(1.0f));
/** Loads an animation from meshes specified in *.animation file. */
Animation animation(const std::string &path);
/** Loads a Material from a *.material file into a Material object. */
Material material(const std::string &path);
/** Loads a Light from a *.light file into a Light object. */
Light light(const std::string &path, const glm::mat4 &parent_transform = glm::mat4(1.0f));
/** Loads a EnvironmentLight from a *.environment_light. */
EnvironmentLight environment_light(const std::string &path, const glm::mat4& parent_transform = glm::mat4(1.0f));
/** Loads a Mesh from a *.mesh file and caches it internally. */
SharedMesh mesh(const std::string &path);
/** Loads Texture2D from a *.png file and caches it internally. */
SharedTexture2D
texture(const std::string &path,
const bool color_data = true,
const bool mipmaps = true,
const Texture2D::Wrap &wrap = Texture2D::Wrap::REPEAT);
/** Remove all unused assets. */
void clear_unused();
std::string directory() const;
private:
const std::string directory_;
MeshMap meshes_;
TextureMap textures_;
};
}
}<|endoftext|> |
<commit_before>/*
This .cpp file will be used to find all the points in the published .pcd object
model that are viewable from the pose passed in as a parameter
Attributes:
- Has no main
- filled with functions that are mainly private. The only public method will
be a method called from generate views and returns our quantification value
that indicates the percent of points on the object that are seen by that view
To do:
- need to subscirbe to the topic we are pushing the .pcd pointcloud to in
the file rvizView
*/
#include <findPoints.h>
class findPoints(){
//Public function to get the pose from generateViews.cpp
public void quantifyDataInView(const geometry_msgs::Pose ¤t_view)_{
//subscibes to the cloud topic containing the pointcloud of the object we are scanning
// MAY HAVE TO CHANGE /cloud to cloud
ros::Subscriber sub = n.subscribe("/cloud", 1000, cloudCallback);
//call functions
//type cone cone = makeCone(*current_view);
/*
Looping structure that generates lines from the pose and within the cone's width view
loop:
contains a total value to count the number of lines that hit a point on the object
calls function and passes the line, function checks weather or not it hits the object we are scanning
*/
//retirn vaue whihc will be the percent (lines that hit / lines generated)
}
// in preivous method we subscribe to the same topic
// to which the pcd object has been published to
// we subscribe to that topic "/cloud" and expect the callBackFunction to get passed
// the pcd object
void cloudCallback(const sensor_msgs::PointCloud2::ConstPtr& pcdObject){
// we get the pcd object -- like the spray bottle, etc
}
private [type of cone] makeCone(pose){
//returns generated cone stucture at the pise
}
private boolean validLine(/*The line object, the .pcd object*/){
//checks to see if the line hits a point on the object
//returns t/f depending on if it hits or not
}
}
<commit_msg>Negligible change<commit_after>/*
This .cpp file will be used to find all the points in the published .pcd object
model that are viewable from the pose passed in as a parameter
Attributes:
- Has no main
- filled with functions that are mainly private. The only public method will
be a method called from generate views and returns our quantification value
that indicates the percent of points on the object that are seen by that view
To do:
- need to subscirbe to the topic we are pushing the .pcd pointcloud to in
the file rvizView
*/
#include <findPoints.h>
class findPoints(){
//Public function to get the pose from generateViews.cpp
public void quantifyDataInView(const geometry_msgs::Pose ¤t_view)_{
//subscibes to the cloud topic containing the pointcloud of the object we are scanning
// MAY HAVE TO CHANGE /cloud to cloud
ros::Subscriber sub = n.subscribe("/cloud", 1000, cloudCallback);
//call functions
//type cone cone = makeCone(*current_view);
/*
Looping structure that generates lines from the pose and within the cone's width view
loop:
contains a total value to count the number of lines that hit a point on the object
calls function and passes the line, function checks weather or not it hits the object we are scanning
*/
//retirn vaue whihc will be the percent (lines that hit / lines generated)
}
// in preivous method we subscribe to the same topic
// to which the pcd object has been published to
// we subscribe to that topic "/cloud" and expect the callBackFunction to get passed
// the pcd object
void cloudCallback(const sensor_msgs::PointCloud2::ConstPtr& pcdObject){
// we get the pcd object -- like the spray bottle, etc
}
private [type of cone] makeCone(pose){
//returns generated cone stucture at the pise
}
private boolean validLine(/*The line object, the .pcd object*/){
//checks to see if the line hits a point on the object
//returns t/f depending on if it hits or not
}
}
<|endoftext|> |
<commit_before>//===- AliasAnalysis.cpp - Generic Alias Analysis Interface Implementation -==//
//
// This file implements the generic AliasAnalysis interface which is used as the
// common interface used by all clients and implementations of alias analysis.
//
// This file also implements the default version of the AliasAnalysis interface
// that is to be used when no other implementation is specified. This does some
// simple tests that detect obvious cases: two different global pointers cannot
// alias, a global cannot alias a malloc, two different mallocs cannot alias,
// etc.
//
// This alias analysis implementation really isn't very good for anything, but
// it is very fast, and makes a nice clean default implementation. Because it
// handles lots of little corner cases, other, more complex, alias analysis
// implementations may choose to rely on this pass to resolve these simple and
// easy cases.
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/BasicBlock.h"
#include "llvm/iMemory.h"
#include "llvm/Target/TargetData.h"
// Register the AliasAnalysis interface, providing a nice name to refer to.
namespace {
RegisterAnalysisGroup<AliasAnalysis> Z("Alias Analysis");
}
AliasAnalysis::ModRefResult
AliasAnalysis::getModRefInfo(LoadInst *L, Value *P, unsigned Size) {
return alias(L->getOperand(0), TD->getTypeSize(L->getType()),
P, Size) ? Ref : NoModRef;
}
AliasAnalysis::ModRefResult
AliasAnalysis::getModRefInfo(StoreInst *S, Value *P, unsigned Size) {
return alias(S->getOperand(1), TD->getTypeSize(S->getOperand(0)->getType()),
P, Size) ? Mod : NoModRef;
}
// AliasAnalysis destructor: DO NOT move this to the header file for
// AliasAnalysis or else clients of the AliasAnalysis class may not depend on
// the AliasAnalysis.o file in the current .a file, causing alias analysis
// support to not be included in the tool correctly!
//
AliasAnalysis::~AliasAnalysis() {}
/// setTargetData - Subclasses must call this method to initialize the
/// AliasAnalysis interface before any other methods are called.
///
void AliasAnalysis::InitializeAliasAnalysis(Pass *P) {
TD = &P->getAnalysis<TargetData>();
}
// getAnalysisUsage - All alias analysis implementations should invoke this
// directly (using AliasAnalysis::getAnalysisUsage(AU)) to make sure that
// TargetData is required by the pass.
void AliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<TargetData>(); // All AA's need TargetData.
}
/// canBasicBlockModify - Return true if it is possible for execution of the
/// specified basic block to modify the value pointed to by Ptr.
///
bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB,
const Value *Ptr, unsigned Size) {
return canInstructionRangeModify(BB.front(), BB.back(), Ptr, Size);
}
/// canInstructionRangeModify - Return true if it is possible for the execution
/// of the specified instructions to modify the value pointed to by Ptr. The
/// instructions to consider are all of the instructions in the range of [I1,I2]
/// INCLUSIVE. I1 and I2 must be in the same basic block.
///
bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1,
const Instruction &I2,
const Value *Ptr, unsigned Size) {
assert(I1.getParent() == I2.getParent() &&
"Instructions not in same basic block!");
BasicBlock::iterator I = const_cast<Instruction*>(&I1);
BasicBlock::iterator E = const_cast<Instruction*>(&I2);
++E; // Convert from inclusive to exclusive range.
for (; I != E; ++I) // Check every instruction in range
if (getModRefInfo(I, const_cast<Value*>(Ptr), Size) & Mod)
return true;
return false;
}
// Because of the way .a files work, we must force the BasicAA implementation to
// be pulled in if the AliasAnalysis classes are pulled in. Otherwise we run
// the risk of AliasAnalysis being used, but the default implementation not
// being linked into the tool that uses it.
//
extern void BasicAAStub();
static IncludeFile INCLUDE_BASICAA_CPP((void*)&BasicAAStub);
<commit_msg>Add new -no-aa implementation<commit_after>//===- AliasAnalysis.cpp - Generic Alias Analysis Interface Implementation -==//
//
// This file implements the generic AliasAnalysis interface which is used as the
// common interface used by all clients and implementations of alias analysis.
//
// This file also implements the default version of the AliasAnalysis interface
// that is to be used when no other implementation is specified. This does some
// simple tests that detect obvious cases: two different global pointers cannot
// alias, a global cannot alias a malloc, two different mallocs cannot alias,
// etc.
//
// This alias analysis implementation really isn't very good for anything, but
// it is very fast, and makes a nice clean default implementation. Because it
// handles lots of little corner cases, other, more complex, alias analysis
// implementations may choose to rely on this pass to resolve these simple and
// easy cases.
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/BasicBlock.h"
#include "llvm/iMemory.h"
#include "llvm/Target/TargetData.h"
// Register the AliasAnalysis interface, providing a nice name to refer to.
namespace {
RegisterAnalysisGroup<AliasAnalysis> Z("Alias Analysis");
}
AliasAnalysis::ModRefResult
AliasAnalysis::getModRefInfo(LoadInst *L, Value *P, unsigned Size) {
return alias(L->getOperand(0), TD->getTypeSize(L->getType()),
P, Size) ? Ref : NoModRef;
}
AliasAnalysis::ModRefResult
AliasAnalysis::getModRefInfo(StoreInst *S, Value *P, unsigned Size) {
return alias(S->getOperand(1), TD->getTypeSize(S->getOperand(0)->getType()),
P, Size) ? Mod : NoModRef;
}
// AliasAnalysis destructor: DO NOT move this to the header file for
// AliasAnalysis or else clients of the AliasAnalysis class may not depend on
// the AliasAnalysis.o file in the current .a file, causing alias analysis
// support to not be included in the tool correctly!
//
AliasAnalysis::~AliasAnalysis() {}
/// setTargetData - Subclasses must call this method to initialize the
/// AliasAnalysis interface before any other methods are called.
///
void AliasAnalysis::InitializeAliasAnalysis(Pass *P) {
TD = &P->getAnalysis<TargetData>();
}
// getAnalysisUsage - All alias analysis implementations should invoke this
// directly (using AliasAnalysis::getAnalysisUsage(AU)) to make sure that
// TargetData is required by the pass.
void AliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<TargetData>(); // All AA's need TargetData.
}
/// canBasicBlockModify - Return true if it is possible for execution of the
/// specified basic block to modify the value pointed to by Ptr.
///
bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB,
const Value *Ptr, unsigned Size) {
return canInstructionRangeModify(BB.front(), BB.back(), Ptr, Size);
}
/// canInstructionRangeModify - Return true if it is possible for the execution
/// of the specified instructions to modify the value pointed to by Ptr. The
/// instructions to consider are all of the instructions in the range of [I1,I2]
/// INCLUSIVE. I1 and I2 must be in the same basic block.
///
bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1,
const Instruction &I2,
const Value *Ptr, unsigned Size) {
assert(I1.getParent() == I2.getParent() &&
"Instructions not in same basic block!");
BasicBlock::iterator I = const_cast<Instruction*>(&I1);
BasicBlock::iterator E = const_cast<Instruction*>(&I2);
++E; // Convert from inclusive to exclusive range.
for (; I != E; ++I) // Check every instruction in range
if (getModRefInfo(I, const_cast<Value*>(Ptr), Size) & Mod)
return true;
return false;
}
// Because of the way .a files work, we must force the BasicAA implementation to
// be pulled in if the AliasAnalysis classes are pulled in. Otherwise we run
// the risk of AliasAnalysis being used, but the default implementation not
// being linked into the tool that uses it.
//
extern void BasicAAStub();
static IncludeFile INCLUDE_BASICAA_CPP((void*)&BasicAAStub);
namespace {
struct NoAA : public ImmutablePass, public AliasAnalysis {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AliasAnalysis::getAnalysisUsage(AU);
}
virtual void initializePass() {
InitializeAliasAnalysis(this);
}
};
// Register this pass...
RegisterOpt<NoAA>
X("no-aa", "No Alias Analysis (always returns 'may' alias)");
// Declare that we implement the AliasAnalysis interface
RegisterAnalysisGroup<AliasAnalysis, NoAA> Y;
} // End of anonymous namespace
<|endoftext|> |
<commit_before>//This program checks to see if the camera can see the target at different poses.
//Assumes a flat rectangular target.
#include <iostream>
#include <vector>
#include <industrial_extrinsic_cal/conical_pose_generator.h>
#include <industrial_extrinsic_cal/targets_yaml_parser.h>
#include <Eigen/Dense>
#include <Eigen/Eigen>
#include <Eigen/Core>
#include <boost/shared_ptr.hpp>
#include <industrial_extrinsic_cal/target.h>
#include <industrial_extrinsic_cal/targets_yaml_parser.h>
#include <ros/ros.h>
#include <ros/node_handle.h>
#include <geometry_msgs/PoseArray.h>
#include <eigen_conversions/eigen_msg.h>
#include "applicable_pose_generator/pose_reachability_filter.h"
#include <tf2_ros/transform_listener.h>
#include <geometry_msgs/TransformStamped.h>
#include <geometry_msgs/Twist.h>
#include <industrial_extrinsic_cal/ros_transform_interface.h>
#include "tf/transform_datatypes.h"
using std::vector;
using std::string;
using industrial_extrinsic_cal::Target;
// local function prototypes
void imagePoint(Eigen::Vector3d TargetPoint, double fx, double fy, double cx, double cy, double &u, double &v,Eigen::Affine3d cameraPose);
geometry_msgs::PoseArray create_all_poses(double poseHeight, double spacing_in_z, double angleOfCone, int numberOfStopsForPhotos, Eigen::Vector2d center_point_of_target );
int addingFactorial(int lastAdded);
Eigen::Vector2d finds_middle_of_target(Eigen::Vector3d corner_points[4], double center_Of_TargetX, double center_Of_TargetY);
//cvoid creates_listener_to_tfs(const std::string from_frame, const std::string to_frame , ros::Time now,const tf::TransformListener tf_listener, tf::StampedTransform tf_transform);
int main(int argc, char **argv)
{
ros::init(argc, argv, "node");
sleep(2);
ros::NodeHandle n("~");
int image_width = 1080;
int image_height = 1080;
double fy=529.4;
double fx =529.2;
double cx = image_width/2;//assumes that lense is ligned up with sensor
double cy = image_height/2;//assums that lense is ligned up with sensor
int numberOfStopsForPhotos= 8; // controlls amount of stops for each ring
double poseHeight = 1.2;
double angleOfCone = M_PI/3;
int num_poses = numberOfStopsForPhotos*3+1;
double spacing_in_z = .25;
double center_Of_TargetX;
double center_Of_TargetY;
Eigen::Vector2d center_point_of_target;
const std::string& from_frame = "world";
const std::string& to_frame = "target";
ros::Time now = ros::Time::now();
tf::TransformListener tf_listener;
tf::StampedTransform tf_transform;
// creates_listener_to_tfs(from_frame, to_frame, now, tf_listener,tf_transform);
while (!tf_listener.waitForTransform(from_frame, to_frame, now, ros::Duration(1.0)))
{
now = ros::Time::now();
ROS_INFO("waiting for tranform from %s to %s", from_frame.c_str(), to_frame.c_str());
}
try
{
tf_listener.lookupTransform(from_frame, to_frame, now, tf_transform);
}
catch (tf::TransformException& ex)
{
ROS_ERROR("%s", ex.what());
}
//reads in information about target
string targetFile = "/home/lawrencelewis/catkin_ws/src/industrial_calibration/industrial_extrinsic_cal/yaml/ical_srv_target.yaml";
vector<boost::shared_ptr<Target>> myYamlDefinedTargets;
if(!parseTargets(targetFile , myYamlDefinedTargets))
{
ROS_ERROR("file name bad");
return 0;
}
boost::shared_ptr<Target> Mytarget = myYamlDefinedTargets[0];
//finds the max values to be used as corner points
double xMax,yMax,xMin,yMin;
ROS_INFO("target name = %s num_points = %d size of pts_ = %d",Mytarget->target_name_,Mytarget->num_points_,(int)Mytarget->pts_.size());
xMax = Mytarget->pts_[0].x;
xMin = Mytarget->pts_[0].x;
yMax = Mytarget->pts_[0].y;
yMin = Mytarget->pts_[0].y;
for(int i=0;i<Mytarget->num_points_;i++){
if(Mytarget->pts_[i].x > xMax) xMax = Mytarget->pts_[i].x;
if(Mytarget->pts_[i].y > yMax) yMax = Mytarget->pts_[i].y;
if(Mytarget->pts_[i].x < xMin) xMin = Mytarget->pts_[i].x;
if(Mytarget->pts_[i].y < yMin) yMin = Mytarget->pts_[i].y;
}
Eigen::Vector3d corner_points[4];
corner_points[0] = Eigen::Vector3d((xMin-xMax/2)/5,(yMin-yMax/2)/5,0);
corner_points[1] = Eigen::Vector3d((xMax-xMax/2)/5,(yMin-yMax/2)/5,0);
corner_points[2] = Eigen::Vector3d((xMin-xMax/2)/5,(yMax-yMax/2)/5,0);
corner_points[3] = Eigen::Vector3d((xMax-xMax/2)/5,(yMax-yMax/2)/5,0);
center_point_of_target = finds_middle_of_target(corner_points, center_Of_TargetX,center_Of_TargetY);
// creates camera transforms in the shape of a cone
ros::Publisher pub = n.advertise<geometry_msgs::PoseArray>("topic", 1, true);
// radius of the cone = (poseHeight/ std::tan(angleOfCone))
// to increase amount of rings per height decrease the "l" incrementer and starting point by same factor
geometry_msgs::PoseArray msg = create_all_poses(poseHeight, spacing_in_z, angleOfCone, numberOfStopsForPhotos, center_point_of_target );
//creates target rectangle
geometry_msgs::Pose pnt1,pnt2,pnt3,pnt4;
pnt1.position.x = corner_points[0][0];
pnt1.position.y = corner_points[0][1];
pnt1.position.z = corner_points[0][2];
pnt1.orientation.w = 1.0;
pnt1.orientation.x = 0.0;
pnt1.orientation.y = 0.0;
pnt1.orientation.z = 0.0;
pnt2.position.x = corner_points[1][0];
pnt2.position.y = corner_points[1][1];
pnt2.position.z = corner_points[1][2];
pnt2.orientation.w = 1.0;
pnt2.orientation.x = 0.0;
pnt2.orientation.y = 0.0;
pnt2.orientation.z = 0.0;
pnt3.position.x = corner_points[2][0];
pnt3.position.y = corner_points[2][1];
pnt3.position.z = corner_points[2][2];
pnt3.orientation.w = 1.0;
pnt3.orientation.x = 0.0;
pnt3.orientation.y = 0.0;
pnt3.orientation.z = 0.0;
pnt4.position.x = corner_points[3][0];
pnt4.position.y = corner_points[3][1];
pnt4.position.z = corner_points[3][2];
pnt4.orientation.w = 1.0;
pnt4.orientation.x = 0.0;
pnt4.orientation.y = 0.0;
pnt4.orientation.z = 0.0;
msg.poses.push_back(pnt1);
msg.poses.push_back(pnt2);
msg.poses.push_back(pnt3);
msg.poses.push_back(pnt4);
// convert the messages back into poses
EigenSTL::vector_Affine3d AllcameraPoses(msg.poses.size());
geometry_msgs::PoseArray msg2;
for(int i=0; i< msg.poses.size(); i++)
{
tf::poseMsgToEigen(msg.poses[i],AllcameraPoses[i]);
}
// filters out unreachable and un seable poses
int num_created_poses = AllcameraPoses.size();
for(int j=0;j<num_created_poses;j++)
{
bool accept_pose = true;
for(int i=0;i<4;i++)
{
create_chain_take_pose_inverse_kinamatics::chain_creation reachability_filter;
double u=0;
double v=0;
imagePoint(corner_points[i], fx, fy, cx, cy, u, v,AllcameraPoses[j]);
if(u<0 || u>=image_width || v<0 || v>= image_height )
{
ROS_ERROR("u,v = %lf %lf but image size = %d %d",u,v,image_width,image_height);
accept_pose = false;
}
double x_part = tf_transform.getOrigin().x();
double y_part = tf_transform.getOrigin().y();
double z_part = tf_transform.getOrigin().z();
//ROS_INFO("%lf %lf %lf", tf_transform.getOrigin().x(), tf_transform.getOrigin().y(), tf_transform.getOrigin().z());
tf::Quaternion Q;
tf_transform.getBasis().getRotation(Q);
Eigen::Affine3d R;
R.setIdentity();
R.translate(Eigen::Vector3d(x_part,y_part,z_part));
R.rotate(Eigen::Quaterniond(Q.getW(), Q.getX(), Q.getY(), Q.getZ()));
Eigen::Matrix3Xd m = R.rotation();
Eigen::Vector3d vec = R.translation();
if(!reachability_filter.chain_Parse(R*AllcameraPoses[j]))
{
ROS_ERROR("Robot unable to reach the location");
accept_pose = false;
}
}
if(accept_pose)
{
geometry_msgs::Pose pose;
ROS_INFO("adding an accepted pose");
tf::poseEigenToMsg(AllcameraPoses[j], pose);
msg2.poses.push_back(pose);
}
}
ros::Publisher pub2 = n.advertise<geometry_msgs::PoseArray>("topic2", 1, true);
msg2.header.frame_id = "target";
msg2.header.stamp = ros::Time::now();
ros::Rate r(10); // 10 hz
while (ros::ok())
{
pub2.publish(msg2);
pub.publish(msg);
ros::spinOnce();
r.sleep();
}
} //end of main
// Transforms a point into the camera frame then projects the new point into the 2d screen
void imagePoint(Eigen::Vector3d TargetPoint , double fx, double fy, double cx, double cy, double &u, double &v,Eigen::Affine3d cameraPose )
{
Eigen::Vector3d cp;
cp = cameraPose.inverse() * TargetPoint;
double divider = cp.z();
if(divider <= .0001)
{
ROS_ERROR("Camera can't be here");
}
if(divider == 0) divider = 1.0;
u = fx*(cp.x()/divider) + cx;
v = fy*(cp.y()/divider) + cy;
}
int addingFactorial(int lastAdded)
{
int sumation = 0;
while(lastAdded>0)
{
sumation = sumation +lastAdded;
lastAdded = lastAdded-1;
}
return sumation;
}
int findingMidpoint(int pointOne, int pointTwo)
{
int midpoint;
return midpoint;
}
//creates a listener that keeps track of the transform from the camera to the robot
//void creates_listener_to_tfs(const std::string& from_frame, const std::string& to_frame , ros::Time now,const tf::TransformListener tf_listener, tf::StampedTransform tf_transform)
//{
// return;
//}
Eigen::Vector2d finds_middle_of_target(Eigen::Vector3d corner_points[4], double center_Of_TargetX, double center_Of_TargetY)
{
Eigen::Vector2d center_point;
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
if(corner_points[i][0] != corner_points[j][0])
{
center_Of_TargetX = (corner_points[i][0] + corner_points[j][0]) / 2;
}
if(corner_points[i][1] != corner_points[j][1])
{
center_Of_TargetY = (corner_points[i][1] + corner_points[j][1]) / 2;
}
}
}
center_point[0]=center_Of_TargetX;
center_point[1]=center_Of_TargetY;
return center_point;
}
geometry_msgs::PoseArray create_all_poses(double poseHeight, double spacing_in_z, double angleOfCone, int numberOfStopsForPhotos, Eigen::Vector2d center_point_of_target )
{
geometry_msgs::PoseArray msg;
int extra_Counter = 0;
for(double j=0; j<=poseHeight; j=j+spacing_in_z)
{
for(double l = (std::tan(angleOfCone))*spacing_in_z ; l<=(std::tan(angleOfCone) * (j) ); l = l+(std::tan(angleOfCone))*spacing_in_z)
{
EigenSTL::vector_Affine3d cameraPoses = getConicalPoses(numberOfStopsForPhotos, j, l);
msg.header.frame_id = "target";
msg.header.stamp = ros::Time::now();
extra_Counter ++;
for(int i=0; i<cameraPoses.size(); i++ )
{
geometry_msgs::Pose pose;
//cameraPoses[i]
tf::poseEigenToMsg(cameraPoses[i], pose);
ROS_INFO("adding a pose");
pose.position.x = pose.position.x + center_point_of_target[0];
pose.position.y = pose.position.y + center_point_of_target[1];
msg.poses.push_back(pose);
}
}
numberOfStopsForPhotos ++;
}
return msg;
}
<commit_msg>Edited check points so that it has more functions<commit_after>//This program checks to see if the camera can see the target at different poses.
//Assumes a flat rectangular target.
#include <iostream>
#include <vector>
#include <industrial_extrinsic_cal/conical_pose_generator.h>
#include <industrial_extrinsic_cal/targets_yaml_parser.h>
#include <Eigen/Dense>
#include <Eigen/Eigen>
#include <Eigen/Core>
#include <boost/shared_ptr.hpp>
#include <industrial_extrinsic_cal/target.h>
#include <industrial_extrinsic_cal/targets_yaml_parser.h>
#include <ros/ros.h>
#include <ros/node_handle.h>
#include <geometry_msgs/PoseArray.h>
#include <eigen_conversions/eigen_msg.h>
#include "applicable_pose_generator/pose_reachability_filter.h"
#include <tf2_ros/transform_listener.h>
#include <geometry_msgs/TransformStamped.h>
#include <geometry_msgs/Twist.h>
#include <industrial_extrinsic_cal/ros_transform_interface.h>
#include "tf/transform_datatypes.h"
using std::vector;
using std::string;
using industrial_extrinsic_cal::Target;
// local function prototypes
geometry_msgs::PoseArray pose_filters(geometry_msgs::PoseArray msg2, tf::StampedTransform tf_transform, int image_width, int image_height, EigenSTL::vector_Affine3d AllcameraPoses,Eigen::Vector3d corner_points[4],double fx, double fy, double cx, double cy );
void imagePoint(Eigen::Vector3d TargetPoint, double fx, double fy, double cx, double cy, double &u, double &v,Eigen::Affine3d cameraPose);
geometry_msgs::PoseArray create_all_poses(double poseHeight, double spacing_in_z, double angleOfCone, int numberOfStopsForPhotos, Eigen::Vector2d center_point_of_target );
int addingFactorial(int lastAdded);
Eigen::Vector2d finds_middle_of_target(Eigen::Vector3d corner_points[4], double center_Of_TargetX, double center_Of_TargetY);
//cvoid creates_listener_to_tfs(const std::string from_frame, const std::string to_frame , ros::Time now,const tf::TransformListener tf_listener, tf::StampedTransform tf_transform);
int main(int argc, char **argv)
{
ros::init(argc, argv, "node");
sleep(2);
ros::NodeHandle n("~");
int image_width = 1080;
int image_height = 1080;
double fy=529.4;
double fx =529.2;
double cx = image_width/2;//assumes that lense is ligned up with sensor
double cy = image_height/2;//assums that lense is ligned up with sensor
int numberOfStopsForPhotos= 8; // controlls amount of stops for each ring
double poseHeight = 1.2;
double angleOfCone = M_PI/3;
int num_poses = numberOfStopsForPhotos*3+1;
double spacing_in_z = .25;
double center_Of_TargetX;
double center_Of_TargetY;
Eigen::Vector2d center_point_of_target;
const std::string& from_frame = "world";
const std::string& to_frame = "target";
ros::Time now = ros::Time::now();
tf::TransformListener tf_listener;
tf::StampedTransform tf_transform;
while (!tf_listener.waitForTransform(from_frame, to_frame, now, ros::Duration(1.0)))
{
now = ros::Time::now();
ROS_INFO("waiting for tranform from %s to %s", from_frame.c_str(), to_frame.c_str());
}
try
{
tf_listener.lookupTransform(from_frame, to_frame, now, tf_transform);
}
catch (tf::TransformException& ex)
{
ROS_ERROR("%s", ex.what());
}
//reads in information about target
string targetFile = "/home/lawrencelewis/catkin_ws/src/industrial_calibration/industrial_extrinsic_cal/yaml/ical_srv_target.yaml";
vector<boost::shared_ptr<Target>> myYamlDefinedTargets;
if(!parseTargets(targetFile , myYamlDefinedTargets))
{
ROS_ERROR("file name bad");
return 0;
}
boost::shared_ptr<Target> Mytarget = myYamlDefinedTargets[0];
//finds the max values to be used as corner points
double xMax,yMax,xMin,yMin;
ROS_INFO("target name = %s num_points = %d size of pts_ = %d",Mytarget->target_name_,Mytarget->num_points_,(int)Mytarget->pts_.size());
xMax = Mytarget->pts_[0].x;
xMin = Mytarget->pts_[0].x;
yMax = Mytarget->pts_[0].y;
yMin = Mytarget->pts_[0].y;
for(int i=0;i<Mytarget->num_points_;i++){
if(Mytarget->pts_[i].x > xMax) xMax = Mytarget->pts_[i].x;
if(Mytarget->pts_[i].y > yMax) yMax = Mytarget->pts_[i].y;
if(Mytarget->pts_[i].x < xMin) xMin = Mytarget->pts_[i].x;
if(Mytarget->pts_[i].y < yMin) yMin = Mytarget->pts_[i].y;
}
Eigen::Vector3d corner_points[4];
corner_points[0] = Eigen::Vector3d((xMin-xMax/2)/5,(yMin-yMax/2)/5,0);
corner_points[1] = Eigen::Vector3d((xMax-xMax/2)/5,(yMin-yMax/2)/5,0);
corner_points[2] = Eigen::Vector3d((xMin-xMax/2)/5,(yMax-yMax/2)/5,0);
corner_points[3] = Eigen::Vector3d((xMax-xMax/2)/5,(yMax-yMax/2)/5,0);
center_point_of_target = finds_middle_of_target(corner_points, center_Of_TargetX,center_Of_TargetY);
// creates camera transforms in the shape of a cone
ros::Publisher pub = n.advertise<geometry_msgs::PoseArray>("topic", 1, true);
// radius of the cone = (poseHeight/ std::tan(angleOfCone))
// to increase amount of rings per height decrease the "l" incrementer and starting point by same factor
geometry_msgs::PoseArray msg = create_all_poses(poseHeight, spacing_in_z, angleOfCone, numberOfStopsForPhotos, center_point_of_target );
//creates target rectangle
geometry_msgs::Pose pnt1,pnt2,pnt3,pnt4;
pnt1.position.x = corner_points[0][0];
pnt1.position.y = corner_points[0][1];
pnt1.position.z = corner_points[0][2];
pnt1.orientation.w = 1.0;
pnt1.orientation.x = 0.0;
pnt1.orientation.y = 0.0;
pnt1.orientation.z = 0.0;
pnt2.position.x = corner_points[1][0];
pnt2.position.y = corner_points[1][1];
pnt2.position.z = corner_points[1][2];
pnt2.orientation.w = 1.0;
pnt2.orientation.x = 0.0;
pnt2.orientation.y = 0.0;
pnt2.orientation.z = 0.0;
pnt3.position.x = corner_points[2][0];
pnt3.position.y = corner_points[2][1];
pnt3.position.z = corner_points[2][2];
pnt3.orientation.w = 1.0;
pnt3.orientation.x = 0.0;
pnt3.orientation.y = 0.0;
pnt3.orientation.z = 0.0;
pnt4.position.x = corner_points[3][0];
pnt4.position.y = corner_points[3][1];
pnt4.position.z = corner_points[3][2];
pnt4.orientation.w = 1.0;
pnt4.orientation.x = 0.0;
pnt4.orientation.y = 0.0;
pnt4.orientation.z = 0.0;
msg.poses.push_back(pnt1);
msg.poses.push_back(pnt2);
msg.poses.push_back(pnt3);
msg.poses.push_back(pnt4);
// convert the messages back into poses
EigenSTL::vector_Affine3d AllcameraPoses(msg.poses.size());
geometry_msgs::PoseArray msg2;
for(int i=0; i< msg.poses.size(); i++)
{
tf::poseMsgToEigen(msg.poses[i],AllcameraPoses[i]);
}
// filters out unreachable and un seable poses
geometry_msgs::PoseArray filtered_msgs = pose_filters(msg2,tf_transform, image_width, image_height, AllcameraPoses, corner_points, fx, fy, cx, cy );
ros::Publisher pub2 = n.advertise<geometry_msgs::PoseArray>("topic2", 1, true);
filtered_msgs.header.frame_id = "target";
filtered_msgs.header.stamp = ros::Time::now();
ros::Rate r(10); // 10 hz
while (ros::ok())
{
pub2.publish(filtered_msgs);
pub.publish(msg);
ros::spinOnce();
r.sleep();
}
} //end of main
// Transforms a point into the camera frame then projects the new point into the 2d screen
void imagePoint(Eigen::Vector3d TargetPoint , double fx, double fy, double cx, double cy, double &u, double &v,Eigen::Affine3d cameraPose )
{
Eigen::Vector3d cp;
cp = cameraPose.inverse() * TargetPoint;
double divider = cp.z();
if(divider <= .0001)
{
ROS_ERROR("Camera can't be here");
}
if(divider == 0) divider = 1.0;
u = fx*(cp.x()/divider) + cx;
v = fy*(cp.y()/divider) + cy;
}
int addingFactorial(int lastAdded)
{
int sumation = 0;
while(lastAdded>0)
{
sumation = sumation +lastAdded;
lastAdded = lastAdded-1;
}
return sumation;
}
int findingMidpoint(int pointOne, int pointTwo)
{
int midpoint;
return midpoint;
}
Eigen::Vector2d finds_middle_of_target(Eigen::Vector3d corner_points[4], double center_Of_TargetX, double center_Of_TargetY)
{
Eigen::Vector2d center_point;
for(int i=0; i<4; i++)
{
for(int j=0; j<4; j++)
{
if(corner_points[i][0] != corner_points[j][0])
{
center_Of_TargetX = (corner_points[i][0] + corner_points[j][0]) / 2;
}
if(corner_points[i][1] != corner_points[j][1])
{
center_Of_TargetY = (corner_points[i][1] + corner_points[j][1]) / 2;
}
}
}
center_point[0]=center_Of_TargetX;
center_point[1]=center_Of_TargetY;
return center_point;
}
geometry_msgs::PoseArray create_all_poses(double poseHeight, double spacing_in_z, double angleOfCone, int numberOfStopsForPhotos, Eigen::Vector2d center_point_of_target )
{
geometry_msgs::PoseArray msg;
int extra_Counter = 0;
for(double j=0; j<=poseHeight; j=j+spacing_in_z)
{
for(double l = (std::tan(angleOfCone))*spacing_in_z ; l<=(std::tan(angleOfCone) * (j) ); l = l+(std::tan(angleOfCone))*spacing_in_z)
{
EigenSTL::vector_Affine3d cameraPoses = getConicalPoses(numberOfStopsForPhotos, j, l);
msg.header.frame_id = "target";
msg.header.stamp = ros::Time::now();
extra_Counter ++;
for(int i=0; i<cameraPoses.size(); i++ )
{
geometry_msgs::Pose pose;
//cameraPoses[i]
tf::poseEigenToMsg(cameraPoses[i], pose);
ROS_INFO("adding a pose");
pose.position.x = pose.position.x + center_point_of_target[0];
pose.position.y = pose.position.y + center_point_of_target[1];
msg.poses.push_back(pose);
}
}
numberOfStopsForPhotos ++;
}
return msg;
}
geometry_msgs::PoseArray pose_filters(geometry_msgs::PoseArray msg2, tf::StampedTransform tf_transform, int image_width, int image_height, EigenSTL::vector_Affine3d AllcameraPoses,Eigen::Vector3d corner_points[4],double fx, double fy, double cx, double cy )
{
int num_created_poses = AllcameraPoses.size();
for(int j=0;j<num_created_poses;j++)
{
bool accept_pose = true;
for(int i=0;i<4;i++)
{
create_chain_take_pose_inverse_kinamatics::chain_creation reachability_filter;
double u=0;
double v=0;
imagePoint(corner_points[i], fx, fy, cx, cy, u, v,AllcameraPoses[j]);
if(u<0 || u>=image_width || v<0 || v>= image_height )
{
ROS_ERROR("u,v = %lf %lf but image size = %d %d",u,v,image_width,image_height);
accept_pose = false;
}
double x_part = tf_transform.getOrigin().x();
double y_part = tf_transform.getOrigin().y();
double z_part = tf_transform.getOrigin().z();
//ROS_INFO("%lf %lf %lf", tf_transform.getOrigin().x(), tf_transform.getOrigin().y(), tf_transform.getOrigin().z());
tf::Quaternion Q;
tf_transform.getBasis().getRotation(Q);
Eigen::Affine3d R;
R.setIdentity();
R.translate(Eigen::Vector3d(x_part,y_part,z_part));
R.rotate(Eigen::Quaterniond(Q.getW(), Q.getX(), Q.getY(), Q.getZ()));
Eigen::Matrix3Xd m = R.rotation();
Eigen::Vector3d vec = R.translation();
if(!reachability_filter.chain_Parse(R*AllcameraPoses[j]))
{
ROS_ERROR("Robot unable to reach the location");
accept_pose = false;
}
}
if(accept_pose)
{
geometry_msgs::Pose pose;
ROS_INFO("adding an accepted pose");
tf::poseEigenToMsg(AllcameraPoses[j], pose);
msg2.poses.push_back(pose);
}
}
return msg2;
}
<|endoftext|> |
<commit_before>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/test/test_suite.h"
class V2TestSuite : public base::TestSuite {
public:
V2TestSuite(int argc, char** argv) : base::TestSuite(argc, argv) {}
protected:
virtual void Initialize() {
base::TestSuite::Initialize();
}
};
int main(int argc, char **argv) {
return V2TestSuite(argc, argv).Run();
}
<commit_msg>ui/views: Get rid of V2TestSuite class.<commit_after>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/test/test_suite.h"
int main(int argc, char** argv) {
return base::TestSuite(argc, argv).Run();
}
<|endoftext|> |
<commit_before>// Copyright (c) 2013, 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.
#ifndef NIX_GROUP_H
#define NIX_GROUP_H
#include <string>
#include <nix/hdf5/hdf5include.hpp>
#include <nix/hdf5/BaseHDF5.hpp>
#include <nix/hdf5/DataSetHDF5.hpp>
#include <nix/hdf5/DataSpace.hpp>
#include <nix/Hydra.hpp>
#include <nix/Platform.hpp>
#include <boost/optional.hpp>
namespace nix {
namespace hdf5 {
struct optGroup;
/**
* TODO documentation
*/
class NIXAPI Group : public BaseHDF5 {
public:
Group();
Group(hid_t hid);
Group(const Group &other);
Group(const H5::Group &h5group);
bool hasObject(const std::string &path) const;
size_t objectCount() const;
std::string objectName(size_t index) const;
bool hasData(const std::string &name) const;
DataSet createData(const std::string &name,
const H5::DataType &fileType,
const H5::DataSpace &fileSpace, const H5::DSetCreatPropList &cpList) const;
DataSet createData(const std::string &name, DataType dtype, const NDSize &size) const;
DataSet createData(const std::string &name, const H5::DataType &fileType,
const NDSize &size, const NDSize &maxsize = {}, const NDSize &chunks = {},
bool maxSizeUnlimited = true, bool guessChunks = true) const;
DataSet openData(const std::string &name) const;
void removeData(const std::string &name);
template<typename T>
void setData(const std::string &name, const T &value);
template<typename T>
bool getData(const std::string &name, T &value) const;
bool hasGroup(const std::string &name) const;
/**
* @brief Open and eventually create a group with the given name
* inside this group. If creation is not allowed (bool
* param is "false") and the group does not exist an error
* is thrown.
*
* @param name The name of the group to create.
* @param create Whether to create the group if it does not yet exist
*
* @return The opened group.
*/
Group openGroup(const std::string &name, bool create = true) const;
/**
* @brief Create an {@link optGroup} functor that can be used to
* open and eventually create an optional group inside this
* group.
*
* @param name The name of the group to create.
*
* @return The opened group.
*/
optGroup openOptGroup(const std::string &name);
void removeGroup(const std::string &name);
void renameGroup(const std::string &old_name, const std::string &new_name);
/**
* @brief Look for the first sub-group in the group with the given
* attribute that is set to the given string value and return it
* if found. Return empty optional if not found.
*
* @param attribute The name of the attribute to search.
* @param value The value of the attribute to search.
*
* @return The name of the first group object found.
*/
boost::optional<Group> findGroupByAttribute(const std::string &attribute, const std::string &value) const;
/**
* @brief Look for the first sub-data in the group with the given
* attribute that is set to the given string value and return it
* if found. Return empty optional if not found.
*
* @param attribute The name of the attribute to search.
* @param value The value of the attribute to search.
*
* @return The name of the first dataset object found.
*/
boost::optional<DataSet> findDataByAttribute(const std::string &attribute, const std::string &value) const;
/**
* @brief Look for the first sub-data in the group with the given
* name (value). If none cannot be found then search for an attribute that
* is set to the given string value and return that if found.
* Returns an empty optional otherwise.
*
* @param attribute The name of the attribute to search.
* @param value The name of the Group or the value of the attribute to look for.
*
* @return Optional containing the located Group or empty optional otherwise.
*/
boost::optional<Group> findGroupByNameOrAttribute(std::string const &attribute, std::string const &value) const;
/**
* @brief Look for the first sub-data in the group with the given
* name (value). If none cannot be found then search for an attribute that
* is set to the given string value and return that if found.
* Returns an empty optional otherwise.
*
* @param attribute The name of the attribute to search.
* @param value The name of the Group or the value of the attribute to look for.
*
* @return Optional containing the located Dataset or empty optional otherwise.
*/
boost::optional<DataSet> findDataByNameOrAttribute(std::string const &attribute, std::string const &value) const;
/**
* @brief Create a new hard link with the given name inside this group,
* that points to the target group.
*
* @param target The target of the link to create.
* @param linkname The name of the link to create.
*
* @return The linked group.
*/
Group createLink(const Group &target, const std::string &link_name);
/**
* @brief Renames all links of the object defined by the old name.
*
* This method will only change the links where the last part of the path
* is the old name.
*
* @param old_name The old name of the object
* @param new_name The new name of the object
*
* @return True if all links where changed successfully.
*/
bool renameAllLinks(const std::string &old_name, const std::string &new_name);
/**
* @brief Removes all links to the object defined by the given name.
*
* @param name The name of the object to remove.
*
* @return True if all links were deleted.
*/
bool removeAllLinks(const std::string &name);
H5::Group h5Group() const;
virtual ~Group();
private:
bool objectOfType(const std::string &name, H5O_type_t type) const;
}; // group Group
//template functions
template<typename T>
void Group::setData(const std::string &name, const T &value)
{
const Hydra<const T> hydra(value);
DataType dtype = hydra.element_data_type();
NDSize shape = hydra.shape();
DataSet ds;
if (!hasData(name)) {
ds = DataSet::create(h5Group(), name, dtype, shape);
} else {
ds = openData(name);
ds.setExtent(shape);
}
ds.write(dtype, shape, hydra.data());
}
template<typename T>
bool Group::getData(const std::string &name, T &value) const
{
if (!hasData(name)) {
return false;
}
Hydra<T> hydra(value);
DataSet ds = openData(name);
DataType dtype = hydra.element_data_type();
NDSize shape = ds.size();
hydra.resize(shape);
ds.read(dtype, shape, hydra.data());
return true;
}
/**
* Helper struct that works as a functor like {@link Group::openGroup}:
*
* Open and eventually create a group with the given name inside
* this group. If creation is not allowed (bool param is "false") and
* the group does not exist an error is thrown. If creation is not
* allowed (bool param is "false") and the group does not exist an
* unset optional is returned.
*/
struct NIXAPI optGroup {
mutable boost::optional<Group> g;
Group parent;
std::string g_name;
public:
optGroup(const Group &parent, const std::string &g_name);
optGroup(){};
/**
* @brief Open and eventually create a group with the given name
* inside this group. If creation is not allowed (bool
* param is "false") and the group does not exist an unset
* optional is returned.
*
* @param create Whether to create the group if it does not yet exist
*
* @return An optional with the opened group or unset.
*/
boost::optional<Group> operator() (bool create = false) const;
};
} // namespace hdf5
} // namespace nix
#endif /* NIX_GROUP_H */
<commit_msg>Group::setData: DataSet::create → group.create<commit_after>// Copyright (c) 2013, 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.
#ifndef NIX_GROUP_H
#define NIX_GROUP_H
#include <string>
#include <nix/hdf5/hdf5include.hpp>
#include <nix/hdf5/BaseHDF5.hpp>
#include <nix/hdf5/DataSetHDF5.hpp>
#include <nix/hdf5/DataSpace.hpp>
#include <nix/Hydra.hpp>
#include <nix/Platform.hpp>
#include <boost/optional.hpp>
namespace nix {
namespace hdf5 {
struct optGroup;
/**
* TODO documentation
*/
class NIXAPI Group : public BaseHDF5 {
public:
Group();
Group(hid_t hid);
Group(const Group &other);
Group(const H5::Group &h5group);
bool hasObject(const std::string &path) const;
size_t objectCount() const;
std::string objectName(size_t index) const;
bool hasData(const std::string &name) const;
DataSet createData(const std::string &name,
const H5::DataType &fileType,
const H5::DataSpace &fileSpace, const H5::DSetCreatPropList &cpList) const;
DataSet createData(const std::string &name, DataType dtype, const NDSize &size) const;
DataSet createData(const std::string &name, const H5::DataType &fileType,
const NDSize &size, const NDSize &maxsize = {}, const NDSize &chunks = {},
bool maxSizeUnlimited = true, bool guessChunks = true) const;
DataSet openData(const std::string &name) const;
void removeData(const std::string &name);
template<typename T>
void setData(const std::string &name, const T &value);
template<typename T>
bool getData(const std::string &name, T &value) const;
bool hasGroup(const std::string &name) const;
/**
* @brief Open and eventually create a group with the given name
* inside this group. If creation is not allowed (bool
* param is "false") and the group does not exist an error
* is thrown.
*
* @param name The name of the group to create.
* @param create Whether to create the group if it does not yet exist
*
* @return The opened group.
*/
Group openGroup(const std::string &name, bool create = true) const;
/**
* @brief Create an {@link optGroup} functor that can be used to
* open and eventually create an optional group inside this
* group.
*
* @param name The name of the group to create.
*
* @return The opened group.
*/
optGroup openOptGroup(const std::string &name);
void removeGroup(const std::string &name);
void renameGroup(const std::string &old_name, const std::string &new_name);
/**
* @brief Look for the first sub-group in the group with the given
* attribute that is set to the given string value and return it
* if found. Return empty optional if not found.
*
* @param attribute The name of the attribute to search.
* @param value The value of the attribute to search.
*
* @return The name of the first group object found.
*/
boost::optional<Group> findGroupByAttribute(const std::string &attribute, const std::string &value) const;
/**
* @brief Look for the first sub-data in the group with the given
* attribute that is set to the given string value and return it
* if found. Return empty optional if not found.
*
* @param attribute The name of the attribute to search.
* @param value The value of the attribute to search.
*
* @return The name of the first dataset object found.
*/
boost::optional<DataSet> findDataByAttribute(const std::string &attribute, const std::string &value) const;
/**
* @brief Look for the first sub-data in the group with the given
* name (value). If none cannot be found then search for an attribute that
* is set to the given string value and return that if found.
* Returns an empty optional otherwise.
*
* @param attribute The name of the attribute to search.
* @param value The name of the Group or the value of the attribute to look for.
*
* @return Optional containing the located Group or empty optional otherwise.
*/
boost::optional<Group> findGroupByNameOrAttribute(std::string const &attribute, std::string const &value) const;
/**
* @brief Look for the first sub-data in the group with the given
* name (value). If none cannot be found then search for an attribute that
* is set to the given string value and return that if found.
* Returns an empty optional otherwise.
*
* @param attribute The name of the attribute to search.
* @param value The name of the Group or the value of the attribute to look for.
*
* @return Optional containing the located Dataset or empty optional otherwise.
*/
boost::optional<DataSet> findDataByNameOrAttribute(std::string const &attribute, std::string const &value) const;
/**
* @brief Create a new hard link with the given name inside this group,
* that points to the target group.
*
* @param target The target of the link to create.
* @param linkname The name of the link to create.
*
* @return The linked group.
*/
Group createLink(const Group &target, const std::string &link_name);
/**
* @brief Renames all links of the object defined by the old name.
*
* This method will only change the links where the last part of the path
* is the old name.
*
* @param old_name The old name of the object
* @param new_name The new name of the object
*
* @return True if all links where changed successfully.
*/
bool renameAllLinks(const std::string &old_name, const std::string &new_name);
/**
* @brief Removes all links to the object defined by the given name.
*
* @param name The name of the object to remove.
*
* @return True if all links were deleted.
*/
bool removeAllLinks(const std::string &name);
H5::Group h5Group() const;
virtual ~Group();
private:
bool objectOfType(const std::string &name, H5O_type_t type) const;
}; // group Group
//template functions
template<typename T>
void Group::setData(const std::string &name, const T &value)
{
const Hydra<const T> hydra(value);
DataType dtype = hydra.element_data_type();
NDSize shape = hydra.shape();
DataSet ds;
if (!hasData(name)) {
ds = createData(name, dtype, shape);
} else {
ds = openData(name);
ds.setExtent(shape);
}
ds.write(dtype, shape, hydra.data());
}
template<typename T>
bool Group::getData(const std::string &name, T &value) const
{
if (!hasData(name)) {
return false;
}
Hydra<T> hydra(value);
DataSet ds = openData(name);
DataType dtype = hydra.element_data_type();
NDSize shape = ds.size();
hydra.resize(shape);
ds.read(dtype, shape, hydra.data());
return true;
}
/**
* Helper struct that works as a functor like {@link Group::openGroup}:
*
* Open and eventually create a group with the given name inside
* this group. If creation is not allowed (bool param is "false") and
* the group does not exist an error is thrown. If creation is not
* allowed (bool param is "false") and the group does not exist an
* unset optional is returned.
*/
struct NIXAPI optGroup {
mutable boost::optional<Group> g;
Group parent;
std::string g_name;
public:
optGroup(const Group &parent, const std::string &g_name);
optGroup(){};
/**
* @brief Open and eventually create a group with the given name
* inside this group. If creation is not allowed (bool
* param is "false") and the group does not exist an unset
* optional is returned.
*
* @param create Whether to create the group if it does not yet exist
*
* @return An optional with the opened group or unset.
*/
boost::optional<Group> operator() (bool create = false) const;
};
} // namespace hdf5
} // namespace nix
#endif /* NIX_GROUP_H */
<|endoftext|> |
<commit_before>#include <unistd.h>
#include <event/event_callback.h>
#include <event/event_main.h>
#include <io/net/tcp_server.h>
/*
* XXX
* Register stop interest.
*/
#define RFC864_STRING "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ "
#define RFC864_LEN (sizeof RFC864_STRING - 1)
#define WIDTH 72
class ChargenClient {
LogHandle log_;
Socket *client_;
Action *action_;
Buffer data_;
public:
ChargenClient(Socket *client)
: log_("/chargen/client"),
client_(client),
action_(NULL),
data_()
{
unsigned i;
for (i = 0; i < RFC864_LEN; i++) {
size_t resid = WIDTH;
if (RFC864_LEN - i >= resid) {
data_.append((const uint8_t *)&RFC864_STRING[i], resid);
} else {
data_.append((const uint8_t *)&RFC864_STRING[i], RFC864_LEN - i);
resid -= RFC864_LEN - i;
data_.append((const uint8_t *)RFC864_STRING, resid);
}
data_.append("\r\n");
}
INFO(log_) << "Client connected: " << client_->getpeername();
EventCallback *cb = callback(this, &ChargenClient::shutdown_complete);
action_ = client_->shutdown(true, false, cb);
}
~ChargenClient()
{
ASSERT(client_ == NULL);
ASSERT(action_ == NULL);
}
void close_complete(void)
{
action_->cancel();
action_ = NULL;
ASSERT(client_ != NULL);
delete client_;
client_ = NULL;
delete this;
}
void shutdown_complete(Event e)
{
action_->cancel();
action_ = NULL;
switch (e.type_) {
case Event::Done:
break;
case Event::Error:
ERROR(log_) << "Error during shutdown: " << e;
break;
default:
HALT(log_) << "Unexpected event: " << e;
return;
}
schedule_write();
}
void write_complete(Event e)
{
action_->cancel();
action_ = NULL;
switch (e.type_) {
case Event::Done:
break;
case Event::Error:
ERROR(log_) << "Error during write: " << e;
schedule_close();
return;
default:
HALT(log_) << "Unexpected event: " << e;
schedule_close();
return;
}
schedule_write();
}
void schedule_close(void)
{
ASSERT(action_ == NULL);
ASSERT(client_ != NULL);
SimpleCallback *cb = callback(this, &ChargenClient::close_complete);
action_ = client_->close(cb);
}
void schedule_write(void)
{
ASSERT(action_ == NULL);
ASSERT(client_ != NULL);
Buffer tmp(data_);
EventCallback *cb = callback(this, &ChargenClient::write_complete);
action_ = client_->write(&tmp, cb);
}
};
class ChargenListener {
LogHandle log_;
TCPServer *server_;
Action *action_;
public:
ChargenListener(void)
: log_("/chargen/listener"),
server_(NULL),
action_(NULL)
{
server_ = TCPServer::listen(SocketAddressFamilyIP, "[0.0.0.0]:0");
ASSERT(server_ != NULL);
INFO(log_) << "Listener created on: " << server_->getsockname();
SocketEventCallback *cb = callback(this, &ChargenListener::accept_complete);
action_ = server_->accept(cb);
}
~ChargenListener()
{
ASSERT(server_ != NULL);
delete server_;
server_ = NULL;
ASSERT(action_ == NULL);
}
void accept_complete(Event e, Socket *socket)
{
action_->cancel();
action_ = NULL;
switch (e.type_) {
case Event::Done:
break;
case Event::Error:
ERROR(log_) << "Error in accept: " << e;
break;
default:
HALT(log_) << "Unexpected event: " << e;
return;
}
if (e.type_ == Event::Done) {
ASSERT(socket != NULL);
new ChargenClient(socket);
}
SocketEventCallback *cb = callback(this, &ChargenListener::accept_complete);
action_ = server_->accept(cb);
}
};
int
main(void)
{
ChargenListener listener;
event_main();
}
<commit_msg>Use SimpleServer for a bit of the old boilerplate.<commit_after>#include <unistd.h>
#include <event/event_callback.h>
#include <event/event_main.h>
#include <event/event_system.h>
#include <io/net/tcp_server.h>
#include <io/socket/simple_server.h>
/*
* XXX
* Register stop interest.
*/
#define RFC864_STRING "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ "
#define RFC864_LEN (sizeof RFC864_STRING - 1)
#define WIDTH 72
class ChargenClient {
LogHandle log_;
Socket *client_;
Action *action_;
Buffer data_;
public:
ChargenClient(Socket *client)
: log_("/chargen/client"),
client_(client),
action_(NULL),
data_()
{
unsigned i;
for (i = 0; i < RFC864_LEN; i++) {
size_t resid = WIDTH;
if (RFC864_LEN - i >= resid) {
data_.append((const uint8_t *)&RFC864_STRING[i], resid);
} else {
data_.append((const uint8_t *)&RFC864_STRING[i], RFC864_LEN - i);
resid -= RFC864_LEN - i;
data_.append((const uint8_t *)RFC864_STRING, resid);
}
data_.append("\r\n");
}
INFO(log_) << "Client connected: " << client_->getpeername();
EventCallback *cb = callback(this, &ChargenClient::shutdown_complete);
action_ = client_->shutdown(true, false, cb);
}
~ChargenClient()
{
ASSERT(client_ == NULL);
ASSERT(action_ == NULL);
}
void close_complete(void)
{
action_->cancel();
action_ = NULL;
ASSERT(client_ != NULL);
delete client_;
client_ = NULL;
delete this;
}
void shutdown_complete(Event e)
{
action_->cancel();
action_ = NULL;
switch (e.type_) {
case Event::Done:
break;
case Event::Error:
ERROR(log_) << "Error during shutdown: " << e;
break;
default:
HALT(log_) << "Unexpected event: " << e;
return;
}
schedule_write();
}
void write_complete(Event e)
{
action_->cancel();
action_ = NULL;
switch (e.type_) {
case Event::Done:
break;
case Event::Error:
ERROR(log_) << "Error during write: " << e;
schedule_close();
return;
default:
HALT(log_) << "Unexpected event: " << e;
schedule_close();
return;
}
schedule_write();
}
void schedule_close(void)
{
ASSERT(action_ == NULL);
ASSERT(client_ != NULL);
SimpleCallback *cb = callback(this, &ChargenClient::close_complete);
action_ = client_->close(cb);
}
void schedule_write(void)
{
ASSERT(action_ == NULL);
ASSERT(client_ != NULL);
Buffer tmp(data_);
EventCallback *cb = callback(this, &ChargenClient::write_complete);
action_ = client_->write(&tmp, cb);
}
};
class ChargenListener : public SimpleServer<TCPServer> {
public:
ChargenListener(void)
: SimpleServer<TCPServer>("/chargen/listener", SocketAddressFamilyIP, "[::]:0")
{ }
~ChargenListener()
{ }
void client_connected(Socket *socket)
{
new ChargenClient(socket);
}
};
int
main(void)
{
new ChargenListener();
event_main();
}
<|endoftext|> |
<commit_before>/* Definition of the pqxx::stream_to class.
*
* pqxx::stream_to enables optimized batch updates to a database table.
*
* DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/stream_to.hxx instead.
*
* Copyright (c) 2000-2021, Jeroen T. Vermeulen.
*
* See COPYING for copyright license. If you did not receive a file called
* COPYING with this source code, please notify the distributor of this
* mistake, or contact the author.
*/
#ifndef PQXX_H_STREAM_TO
#define PQXX_H_STREAM_TO
#include "pqxx/compiler-public.hxx"
#include "pqxx/internal/compiler-internal-pre.hxx"
#include "pqxx/separated_list.hxx"
#include "pqxx/transaction_base.hxx"
namespace pqxx
{
/// Efficiently write data directly to a database table.
/** If you wish to insert rows of data into a table, you can compose INSERT
* statements and execute them. But it's slow and tedious, and you need to
* worry about quoting and escaping the data.
*
* If you're just inserting a single row, it probably won't matter much. You
* can use prepared or parameterised statements to take care of the escaping
* for you. But if you're inserting large numbers of rows you will want
* something better.
*
* Inserting rows one by one using INSERT statements involves a lot of
* pointless overhead, especially when you are working with a remote database
* server over the network. You may end up sending each row over the network
* as a separate query, and waiting for a reply. Do it "in bulk" using
* @c stream_to, and you may find that it goes many times faster. Sometimes
* you gain orders of magnitude in speed.
*
* Here's how it works: you create a @c stream_to stream to start writing to
* your table. You will probably want to specify the columns. Then, you
* feed your data into the stream one row at a time. And finally, you call the
* stream's @c complete() to tell it to finalise the operation, wait for
* completion, and check for errors.
*
* So how do you feed a row of data into the stream? There's several ways, but
* the preferred one is to call its @c write_values. Pass the field values as
* arguments. Doesn't matter what type they are, as long as libpqxx knows how
* to convert them to PostgreSQL's text format: @c int, @c std::string or
* @c std:string_view, @c float and @c double, @c bool... lots of basic types
* are supported. If some of the values are null, feel free to use
* @c std::optional, @c std::shared_ptr, or @c std::unique_ptr.
*
* The arguments' types don't even have to match the fields' SQL types. If you
* want to insert an @c int into a @c DECIMAL column, that's your choice -- it
* will produce a @c DECIMAL value which happens to be integral. Insert a
* @c float into a @c VARCHAR column? That's fine, you'll get a string whose
* contents happen to read like a number. And so on. You can even insert
* different types of value in the same column on different rows. If you have
* a code path where a particular field is always null, just insert @c nullptr.
*
* There is another way to insert rows: the @c << ("shift-left") operator.
* It's not as fast and it doesn't support variable arguments: each row must be
* either a @c std::tuple or something iterable, such as a @c std::vector, or
* anything else with a @c begin and @c end.
*
* @warning While a stream is active, you cannot execute queries, open a
* pipeline, etc. on the same transaction. A transaction can have at most one
* object of a type derived from @c pqxx::internal::transactionfocus active on
* it at a time.
*/
class PQXX_LIBEXPORT stream_to : internal::transactionfocus
{
public:
/// Create a stream, without specifying columns.
/** Fields will be inserted in whatever order the columns have in the
* database.
*
* You'll probably want to specify the columns, so that the mapping between
* your data fields and the table is explicit in your code, and not hidden
* in an "implicit contract" between your code and your schema.
*/
stream_to(transaction_base &, std::string_view table_name);
/// Create a stream, specifying column names as a container of strings.
template<typename Columns>
stream_to(
transaction_base &, std::string_view table_name, Columns const &columns);
/// Create a stream, specifying column names as a sequence of strings.
template<typename Iter>
stream_to(
transaction_base &, std::string_view table_name, Iter columns_begin,
Iter columns_end);
~stream_to() noexcept;
/// Does this stream still need to @c complete()?
[[nodiscard]] operator bool() const noexcept { return not m_finished; }
/// Has this stream been through its concluding @c complete()?
[[nodiscard]] bool operator!() const noexcept { return m_finished; }
/// Complete the operation, and check for errors.
/** Always call this to close the stream in an orderly fashion, even after
* an error. (In the case of an error, abort the transaction afterwards.)
*
* The only circumstance where it's safe to skip this is after an error, if
* you're discarding the entire connection.
*/
void complete();
/// Insert a row of data.
/** Returns a reference to the stream, so you can chain the calls.
*
* The @c row can be a tuple, or any type that can be iterated. Each
* item becomes a field in the row, in the same order as the columns you
* specified when creating the stream.
*
* If you don't already happen to have your fields in the form of a tuple or
* container, prefer @c write_values. It's faster and more convenient.
*/
template<typename Row> stream_to &operator<<(Row const &row)
{
write_row(row);
return *this;
}
/// Stream a `stream_from` straight into a `stream_to`.
/** This can be useful when copying between different databases. If the
* source and the destination are on the same database, you'll get better
* performance doing it all in a regular query.
*/
stream_to &operator<<(stream_from &);
/// Insert a row of data, given in the form of a @c std::tuple or container.
/** The @c row can be a tuple, or any type that can be iterated. Each
* item becomes a field in the row, in the same order as the columns you
* specified when creating the stream.
*
* The preferred way to insert a row is @c write_values.
*/
template<typename Row> void write_row(Row const &row)
{
fill_buffer(row);
write_buffer();
}
/// Insert values as a row.
/** This is the recommended way of inserting data. Pass your field values,
* of any convertible type.
*/
template<typename... Ts> void write_values(const Ts &...fields)
{
fill_buffer(fields...);
write_buffer();
}
private:
bool m_finished = false;
/// Reusable buffer for a row. Saves doing an allocation for each row.
std::string m_buffer;
/// Reusable buffer for converting/escaping a field.
std::string m_field_buf;
/// Write a row of raw text-format data into the destination table.
void write_raw_line(std::string_view);
/// Write a row of data from @c m_buffer into the destination table.
/** Resets the buffer for the next row.
*/
void write_buffer();
/// COPY encoding for a null field, plus subsequent separator.
static constexpr std::string_view null_field{"\\N\t"};
/// Estimate buffer space needed for a field which is always null.
template<typename T>
static std::enable_if_t<nullness<T>::always_null, std::size_t>
estimate_buffer(T const &)
{
return std::size(null_field);
}
/// Estimate buffer space needed for field f.
/** The estimate is not very precise. We don't actually know how much space
* we'll need once the escaping comes in.
*/
template<typename T>
static std::enable_if_t<not nullness<T>::always_null, std::size_t>
estimate_buffer(T const &field)
{
return is_null(field) ? std::size(null_field) : size_buffer(field);
}
/// Append escaped version of @c m_field_buf to @c m_buffer, plus a tab.
void escape_field_to_buffer(std::string_view);
/// Append string representation for @c f to @c m_buffer.
/** This is for the general case, where the field may contain a value.
*
* Also appends a tab. The tab is meant to be a separator, not a terminator,
* so if you write any fields at all, you'll end up with one tab too many
* at the end of the buffer.
*/
template<typename Field>
std::enable_if_t<not nullness<Field>::always_null>
append_to_buffer(Field const &f)
{
// We append each field, terminated by a tab. That will leave us with
// one tab too many, assuming we write any fields at all; we remove that
// at the end.
if (is_null(f))
{
// Easy. Append null and tab in one go.
m_buffer.append(null_field);
}
else
{
// Convert f into m_buffer.
using traits = string_traits<Field>;
auto const budget{estimate_buffer(f)};
auto const offset{std::size(m_buffer)};
if constexpr (std::is_arithmetic_v<Field>)
{
// Specially optimised for "safe" types, which never need any
// escaping. Convert straight into m_buffer.
// The budget we get from size_buffer() includes room for the trailing
// zero, which we must remove. But we're also inserting tabs between
// fields, so we re-purpose the extra byte for that.
auto const total{offset + budget};
m_buffer.resize(total);
char *const end{traits::into_buf(
m_buffer.data() + offset, m_buffer.data() + total, f)};
*(end - 1) = '\t';
// Shrink to fit. Keep the tab though.
m_buffer.resize(static_cast<std::size_t>(end - m_buffer.data()));
}
else
{
// TODO: Specialise string/string_view/zview to skip to_buf()!
// This field may need escaping. First convert the value into
// m_field_buffer, then escape into its final place.
m_field_buf.resize(budget);
escape_field_to_buffer(traits::to_buf(
m_field_buf.data(), m_field_buf.data() + std::size(m_field_buf), f));
}
}
}
/// Append string representation for a null field to @c m_buffer.
/** This special case is for types which are always null.
*
* Also appends a tab. The tab is meant to be a separator, not a terminator,
* so if you write any fields at all, you'll end up with one tab too many
* at the end of the buffer.
*/
template<typename Field>
std::enable_if_t<nullness<Field>::always_null>
append_to_buffer(Field const &)
{
m_buffer.append(null_field);
}
/// Write raw COPY line into @c m_buffer, based on a container of fields.
template<typename Container> void fill_buffer(Container const &c)
{
// To avoid unnecessary allocations and deallocations, we run through c
// twice: once to determine how much buffer space we may need, and once to
// actually write it into the buffer.
std::size_t budget{0};
for (auto const &f : c) budget += estimate_buffer(f);
m_buffer.reserve(budget);
for (auto const &f : c) append_to_buffer(f);
}
/// Estimate how many buffer bytes we need to write tuple.
template<typename Tuple, std::size_t... indexes>
static std::size_t
budget_tuple(Tuple const &t, std::index_sequence<indexes...>)
{
return (estimate_buffer(std::get<indexes>(t)) + ...);
}
/// Write tuple of fields to @c m_buffer.
template<typename Tuple, std::size_t... indexes>
void append_tuple(Tuple const &t, std::index_sequence<indexes...>)
{
(append_to_buffer(std::get<indexes>(t)), ...);
}
/// Write raw COPY line into @c m_buffer, based on a tuple of fields.
template<typename... Elts> void fill_buffer(std::tuple<Elts...> const &t)
{
using indexes = std::make_index_sequence<sizeof...(Elts)>;
m_buffer.reserve(budget_tuple(t, indexes{}));
append_tuple(t, indexes{});
}
void set_up(transaction_base &, std::string_view table_name);
void set_up(
transaction_base &, std::string_view table_name, std::string_view columns);
/// Write raw COPY line into @c m_buffer, based on varargs fields.
template<typename... Ts> void fill_buffer(const Ts &...fields)
{
(..., append_to_buffer(fields));
}
constexpr static std::string_view s_classname{"stream_to"};
};
template<typename Columns>
inline stream_to::stream_to(
transaction_base &tb, std::string_view table_name, Columns const &columns) :
stream_to{tb, table_name, std::begin(columns), std::end(columns)}
{}
template<typename Iter>
inline stream_to::stream_to(
transaction_base &tb, std::string_view table_name, Iter columns_begin,
Iter columns_end) :
internal::transactionfocus{tb, s_classname, table_name}
{
set_up(tb, table_name, separated_list(",", columns_begin, columns_end));
}
} // namespace pqxx
#include "pqxx/internal/compiler-internal-post.hxx"
#endif
<commit_msg>Doc note.<commit_after>/* Definition of the pqxx::stream_to class.
*
* pqxx::stream_to enables optimized batch updates to a database table.
*
* DO NOT INCLUDE THIS FILE DIRECTLY; include pqxx/stream_to.hxx instead.
*
* Copyright (c) 2000-2021, Jeroen T. Vermeulen.
*
* See COPYING for copyright license. If you did not receive a file called
* COPYING with this source code, please notify the distributor of this
* mistake, or contact the author.
*/
#ifndef PQXX_H_STREAM_TO
#define PQXX_H_STREAM_TO
#include "pqxx/compiler-public.hxx"
#include "pqxx/internal/compiler-internal-pre.hxx"
#include "pqxx/separated_list.hxx"
#include "pqxx/transaction_base.hxx"
namespace pqxx
{
/// Efficiently write data directly to a database table.
/** If you wish to insert rows of data into a table, you can compose INSERT
* statements and execute them. But it's slow and tedious, and you need to
* worry about quoting and escaping the data.
*
* If you're just inserting a single row, it probably won't matter much. You
* can use prepared or parameterised statements to take care of the escaping
* for you. But if you're inserting large numbers of rows you will want
* something better.
*
* Inserting rows one by one using INSERT statements involves a lot of
* pointless overhead, especially when you are working with a remote database
* server over the network. You may end up sending each row over the network
* as a separate query, and waiting for a reply. Do it "in bulk" using
* @c stream_to, and you may find that it goes many times faster. Sometimes
* you gain orders of magnitude in speed.
*
* Here's how it works: you create a @c stream_to stream to start writing to
* your table. You will probably want to specify the columns. Then, you
* feed your data into the stream one row at a time. And finally, you call the
* stream's @c complete() to tell it to finalise the operation, wait for
* completion, and check for errors.
*
* (You @i must complete the stream before committing or aborting the
* transaction. The connection is in a special state while the stream is
* active, where it can't process commands, and can't commit or abort a
* transaction.)
*
* So how do you feed a row of data into the stream? There's several ways, but
* the preferred one is to call its @c write_values. Pass the field values as
* arguments. Doesn't matter what type they are, as long as libpqxx knows how
* to convert them to PostgreSQL's text format: @c int, @c std::string or
* @c std:string_view, @c float and @c double, @c bool... lots of basic types
* are supported. If some of the values are null, feel free to use
* @c std::optional, @c std::shared_ptr, or @c std::unique_ptr.
*
* The arguments' types don't even have to match the fields' SQL types. If you
* want to insert an @c int into a @c DECIMAL column, that's your choice -- it
* will produce a @c DECIMAL value which happens to be integral. Insert a
* @c float into a @c VARCHAR column? That's fine, you'll get a string whose
* contents happen to read like a number. And so on. You can even insert
* different types of value in the same column on different rows. If you have
* a code path where a particular field is always null, just insert @c nullptr.
*
* There is another way to insert rows: the @c << ("shift-left") operator.
* It's not as fast and it doesn't support variable arguments: each row must be
* either a @c std::tuple or something iterable, such as a @c std::vector, or
* anything else with a @c begin and @c end.
*
* @warning While a stream is active, you cannot execute queries, open a
* pipeline, etc. on the same transaction. A transaction can have at most one
* object of a type derived from @c pqxx::internal::transactionfocus active on
* it at a time.
*/
class PQXX_LIBEXPORT stream_to : internal::transactionfocus
{
public:
/// Create a stream, without specifying columns.
/** Fields will be inserted in whatever order the columns have in the
* database.
*
* You'll probably want to specify the columns, so that the mapping between
* your data fields and the table is explicit in your code, and not hidden
* in an "implicit contract" between your code and your schema.
*/
stream_to(transaction_base &, std::string_view table_name);
/// Create a stream, specifying column names as a container of strings.
template<typename Columns>
stream_to(
transaction_base &, std::string_view table_name, Columns const &columns);
/// Create a stream, specifying column names as a sequence of strings.
template<typename Iter>
stream_to(
transaction_base &, std::string_view table_name, Iter columns_begin,
Iter columns_end);
~stream_to() noexcept;
/// Does this stream still need to @c complete()?
[[nodiscard]] operator bool() const noexcept { return not m_finished; }
/// Has this stream been through its concluding @c complete()?
[[nodiscard]] bool operator!() const noexcept { return m_finished; }
/// Complete the operation, and check for errors.
/** Always call this to close the stream in an orderly fashion, even after
* an error. (In the case of an error, abort the transaction afterwards.)
*
* The only circumstance where it's safe to skip this is after an error, if
* you're discarding the entire connection.
*/
void complete();
/// Insert a row of data.
/** Returns a reference to the stream, so you can chain the calls.
*
* The @c row can be a tuple, or any type that can be iterated. Each
* item becomes a field in the row, in the same order as the columns you
* specified when creating the stream.
*
* If you don't already happen to have your fields in the form of a tuple or
* container, prefer @c write_values. It's faster and more convenient.
*/
template<typename Row> stream_to &operator<<(Row const &row)
{
write_row(row);
return *this;
}
/// Stream a `stream_from` straight into a `stream_to`.
/** This can be useful when copying between different databases. If the
* source and the destination are on the same database, you'll get better
* performance doing it all in a regular query.
*/
stream_to &operator<<(stream_from &);
/// Insert a row of data, given in the form of a @c std::tuple or container.
/** The @c row can be a tuple, or any type that can be iterated. Each
* item becomes a field in the row, in the same order as the columns you
* specified when creating the stream.
*
* The preferred way to insert a row is @c write_values.
*/
template<typename Row> void write_row(Row const &row)
{
fill_buffer(row);
write_buffer();
}
/// Insert values as a row.
/** This is the recommended way of inserting data. Pass your field values,
* of any convertible type.
*/
template<typename... Ts> void write_values(const Ts &...fields)
{
fill_buffer(fields...);
write_buffer();
}
private:
bool m_finished = false;
/// Reusable buffer for a row. Saves doing an allocation for each row.
std::string m_buffer;
/// Reusable buffer for converting/escaping a field.
std::string m_field_buf;
/// Write a row of raw text-format data into the destination table.
void write_raw_line(std::string_view);
/// Write a row of data from @c m_buffer into the destination table.
/** Resets the buffer for the next row.
*/
void write_buffer();
/// COPY encoding for a null field, plus subsequent separator.
static constexpr std::string_view null_field{"\\N\t"};
/// Estimate buffer space needed for a field which is always null.
template<typename T>
static std::enable_if_t<nullness<T>::always_null, std::size_t>
estimate_buffer(T const &)
{
return std::size(null_field);
}
/// Estimate buffer space needed for field f.
/** The estimate is not very precise. We don't actually know how much space
* we'll need once the escaping comes in.
*/
template<typename T>
static std::enable_if_t<not nullness<T>::always_null, std::size_t>
estimate_buffer(T const &field)
{
return is_null(field) ? std::size(null_field) : size_buffer(field);
}
/// Append escaped version of @c m_field_buf to @c m_buffer, plus a tab.
void escape_field_to_buffer(std::string_view);
/// Append string representation for @c f to @c m_buffer.
/** This is for the general case, where the field may contain a value.
*
* Also appends a tab. The tab is meant to be a separator, not a terminator,
* so if you write any fields at all, you'll end up with one tab too many
* at the end of the buffer.
*/
template<typename Field>
std::enable_if_t<not nullness<Field>::always_null>
append_to_buffer(Field const &f)
{
// We append each field, terminated by a tab. That will leave us with
// one tab too many, assuming we write any fields at all; we remove that
// at the end.
if (is_null(f))
{
// Easy. Append null and tab in one go.
m_buffer.append(null_field);
}
else
{
// Convert f into m_buffer.
using traits = string_traits<Field>;
auto const budget{estimate_buffer(f)};
auto const offset{std::size(m_buffer)};
if constexpr (std::is_arithmetic_v<Field>)
{
// Specially optimised for "safe" types, which never need any
// escaping. Convert straight into m_buffer.
// The budget we get from size_buffer() includes room for the trailing
// zero, which we must remove. But we're also inserting tabs between
// fields, so we re-purpose the extra byte for that.
auto const total{offset + budget};
m_buffer.resize(total);
char *const end{traits::into_buf(
m_buffer.data() + offset, m_buffer.data() + total, f)};
*(end - 1) = '\t';
// Shrink to fit. Keep the tab though.
m_buffer.resize(static_cast<std::size_t>(end - m_buffer.data()));
}
else
{
// TODO: Specialise string/string_view/zview to skip to_buf()!
// This field may need escaping. First convert the value into
// m_field_buffer, then escape into its final place.
m_field_buf.resize(budget);
escape_field_to_buffer(traits::to_buf(
m_field_buf.data(), m_field_buf.data() + std::size(m_field_buf), f));
}
}
}
/// Append string representation for a null field to @c m_buffer.
/** This special case is for types which are always null.
*
* Also appends a tab. The tab is meant to be a separator, not a terminator,
* so if you write any fields at all, you'll end up with one tab too many
* at the end of the buffer.
*/
template<typename Field>
std::enable_if_t<nullness<Field>::always_null>
append_to_buffer(Field const &)
{
m_buffer.append(null_field);
}
/// Write raw COPY line into @c m_buffer, based on a container of fields.
template<typename Container> void fill_buffer(Container const &c)
{
// To avoid unnecessary allocations and deallocations, we run through c
// twice: once to determine how much buffer space we may need, and once to
// actually write it into the buffer.
std::size_t budget{0};
for (auto const &f : c) budget += estimate_buffer(f);
m_buffer.reserve(budget);
for (auto const &f : c) append_to_buffer(f);
}
/// Estimate how many buffer bytes we need to write tuple.
template<typename Tuple, std::size_t... indexes>
static std::size_t
budget_tuple(Tuple const &t, std::index_sequence<indexes...>)
{
return (estimate_buffer(std::get<indexes>(t)) + ...);
}
/// Write tuple of fields to @c m_buffer.
template<typename Tuple, std::size_t... indexes>
void append_tuple(Tuple const &t, std::index_sequence<indexes...>)
{
(append_to_buffer(std::get<indexes>(t)), ...);
}
/// Write raw COPY line into @c m_buffer, based on a tuple of fields.
template<typename... Elts> void fill_buffer(std::tuple<Elts...> const &t)
{
using indexes = std::make_index_sequence<sizeof...(Elts)>;
m_buffer.reserve(budget_tuple(t, indexes{}));
append_tuple(t, indexes{});
}
void set_up(transaction_base &, std::string_view table_name);
void set_up(
transaction_base &, std::string_view table_name, std::string_view columns);
/// Write raw COPY line into @c m_buffer, based on varargs fields.
template<typename... Ts> void fill_buffer(const Ts &...fields)
{
(..., append_to_buffer(fields));
}
constexpr static std::string_view s_classname{"stream_to"};
};
template<typename Columns>
inline stream_to::stream_to(
transaction_base &tb, std::string_view table_name, Columns const &columns) :
stream_to{tb, table_name, std::begin(columns), std::end(columns)}
{}
template<typename Iter>
inline stream_to::stream_to(
transaction_base &tb, std::string_view table_name, Iter columns_begin,
Iter columns_end) :
internal::transactionfocus{tb, s_classname, table_name}
{
set_up(tb, table_name, separated_list(",", columns_begin, columns_end));
}
} // namespace pqxx
#include "pqxx/internal/compiler-internal-post.hxx"
#endif
<|endoftext|> |
<commit_before>/*
* Copyright (c) 2001, 2003-2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Nathan Binkert
*/
#ifndef __BASE_INTMATH_HH__
#define __BASE_INTMATH_HH__
#include <cassert>
#include "base/misc.hh"
#include "base/types.hh"
// Returns the prime number one less than n.
int prevPrime(int n);
// Determine if a number is prime
template <class T>
inline bool
isPrime(T n)
{
T i;
if (n == 2 || n == 3)
return true;
// Don't try every odd number to prove if it is a prime.
// Toggle between every 2nd and 4th number.
// (This is because every 6th odd number is divisible by 3.)
for (i = 5; i*i <= n; i += 6) {
if (((n % i) == 0 ) || ((n % (i + 2)) == 0) ) {
return false;
}
}
return true;
}
template <class T>
inline T
leastSigBit(T n)
{
return n & ~(n - 1);
}
template <class T>
inline bool
isPowerOf2(T n)
{
return n != 0 && leastSigBit(n) == n;
}
inline uint64_t
power(uint32_t n, uint32_t e)
{
if (e > 20)
warn("Warning, power() function is quite slow for large exponents\n");
if (e == 0)
return 1;
uint64_t result = n;
uint64_t old_result = 0;
for (int x = 1; x < e; x++) {
old_result = result;
result *= n;
if (old_result > result)
warn("power() overflowed!\n");
}
return result;
}
inline int
floorLog2(unsigned x)
{
assert(x > 0);
int y = 0;
if (x & 0xffff0000) { y += 16; x >>= 16; }
if (x & 0x0000ff00) { y += 8; x >>= 8; }
if (x & 0x000000f0) { y += 4; x >>= 4; }
if (x & 0x0000000c) { y += 2; x >>= 2; }
if (x & 0x00000002) { y += 1; }
return y;
}
inline int
floorLog2(unsigned long x)
{
assert(x > 0);
int y = 0;
#if defined(__LP64__)
if (x & ULL(0xffffffff00000000)) { y += 32; x >>= 32; }
#endif
if (x & 0xffff0000) { y += 16; x >>= 16; }
if (x & 0x0000ff00) { y += 8; x >>= 8; }
if (x & 0x000000f0) { y += 4; x >>= 4; }
if (x & 0x0000000c) { y += 2; x >>= 2; }
if (x & 0x00000002) { y += 1; }
return y;
}
inline int
floorLog2(unsigned long long x)
{
assert(x > 0);
int y = 0;
if (x & ULL(0xffffffff00000000)) { y += 32; x >>= 32; }
if (x & ULL(0x00000000ffff0000)) { y += 16; x >>= 16; }
if (x & ULL(0x000000000000ff00)) { y += 8; x >>= 8; }
if (x & ULL(0x00000000000000f0)) { y += 4; x >>= 4; }
if (x & ULL(0x000000000000000c)) { y += 2; x >>= 2; }
if (x & ULL(0x0000000000000002)) { y += 1; }
return y;
}
inline int
floorLog2(int x)
{
assert(x > 0);
return floorLog2((unsigned)x);
}
inline int
floorLog2(long x)
{
assert(x > 0);
return floorLog2((unsigned long)x);
}
inline int
floorLog2(long long x)
{
assert(x > 0);
return floorLog2((unsigned long long)x);
}
template <class T>
inline int
ceilLog2(T n)
{
if (n == 1)
return 0;
return floorLog2(n - (T)1) + 1;
}
template <class T>
inline T
floorPow2(T n)
{
return (T)1 << floorLog2(n);
}
template <class T>
inline T
ceilPow2(T n)
{
return (T)1 << ceilLog2(n);
}
template <class T, class U>
inline T
divCeil(const T& a, const U& b)
{
return (a + b - 1) / b;
}
template <class T>
inline T
roundUp(T val, int align)
{
T mask = (T)align - 1;
return (val + mask) & ~mask;
}
template <class T>
inline T
roundDown(T val, int align)
{
T mask = (T)align - 1;
return val & ~mask;
}
inline bool
isHex(char c)
{
return (c >= '0' && c <= '9') ||
(c >= 'A' && c <= 'F') ||
(c >= 'a' && c <= 'f');
}
inline bool
isOct(char c)
{
return c >= '0' && c <= '7';
}
inline bool
isDec(char c)
{
return c >= '0' && c <= '9';
}
inline int
hex2Int(char c)
{
if (c >= '0' && c <= '9')
return (c - '0');
if (c >= 'A' && c <= 'F')
return (c - 'A') + 10;
if (c >= 'a' && c <= 'f')
return (c - 'a') + 10;
return 0;
}
#endif // __BASE_INTMATH_HH__
<commit_msg>base: Add const to intmath and be more flexible with typing<commit_after>/*
* Copyright (c) 2001, 2003-2005 The Regents of The University of Michigan
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Authors: Nathan Binkert
*/
#ifndef __BASE_INTMATH_HH__
#define __BASE_INTMATH_HH__
#include <cassert>
#include "base/misc.hh"
#include "base/types.hh"
// Returns the prime number one less than n.
int prevPrime(int n);
// Determine if a number is prime
template <class T>
inline bool
isPrime(const T& n)
{
T i;
if (n == 2 || n == 3)
return true;
// Don't try every odd number to prove if it is a prime.
// Toggle between every 2nd and 4th number.
// (This is because every 6th odd number is divisible by 3.)
for (i = 5; i*i <= n; i += 6) {
if (((n % i) == 0 ) || ((n % (i + 2)) == 0) ) {
return false;
}
}
return true;
}
template <class T>
inline T
leastSigBit(const T& n)
{
return n & ~(n - 1);
}
template <class T>
inline bool
isPowerOf2(const T& n)
{
return n != 0 && leastSigBit(n) == n;
}
inline uint64_t
power(uint32_t n, uint32_t e)
{
if (e > 20)
warn("Warning, power() function is quite slow for large exponents\n");
if (e == 0)
return 1;
uint64_t result = n;
uint64_t old_result = 0;
for (int x = 1; x < e; x++) {
old_result = result;
result *= n;
if (old_result > result)
warn("power() overflowed!\n");
}
return result;
}
inline int
floorLog2(unsigned x)
{
assert(x > 0);
int y = 0;
if (x & 0xffff0000) { y += 16; x >>= 16; }
if (x & 0x0000ff00) { y += 8; x >>= 8; }
if (x & 0x000000f0) { y += 4; x >>= 4; }
if (x & 0x0000000c) { y += 2; x >>= 2; }
if (x & 0x00000002) { y += 1; }
return y;
}
inline int
floorLog2(unsigned long x)
{
assert(x > 0);
int y = 0;
#if defined(__LP64__)
if (x & ULL(0xffffffff00000000)) { y += 32; x >>= 32; }
#endif
if (x & 0xffff0000) { y += 16; x >>= 16; }
if (x & 0x0000ff00) { y += 8; x >>= 8; }
if (x & 0x000000f0) { y += 4; x >>= 4; }
if (x & 0x0000000c) { y += 2; x >>= 2; }
if (x & 0x00000002) { y += 1; }
return y;
}
inline int
floorLog2(unsigned long long x)
{
assert(x > 0);
int y = 0;
if (x & ULL(0xffffffff00000000)) { y += 32; x >>= 32; }
if (x & ULL(0x00000000ffff0000)) { y += 16; x >>= 16; }
if (x & ULL(0x000000000000ff00)) { y += 8; x >>= 8; }
if (x & ULL(0x00000000000000f0)) { y += 4; x >>= 4; }
if (x & ULL(0x000000000000000c)) { y += 2; x >>= 2; }
if (x & ULL(0x0000000000000002)) { y += 1; }
return y;
}
inline int
floorLog2(int x)
{
assert(x > 0);
return floorLog2((unsigned)x);
}
inline int
floorLog2(long x)
{
assert(x > 0);
return floorLog2((unsigned long)x);
}
inline int
floorLog2(long long x)
{
assert(x > 0);
return floorLog2((unsigned long long)x);
}
template <class T>
inline int
ceilLog2(const T& n)
{
if (n == 1)
return 0;
return floorLog2(n - (T)1) + 1;
}
template <class T>
inline T
floorPow2(const T& n)
{
return (T)1 << floorLog2(n);
}
template <class T>
inline T
ceilPow2(const T& n)
{
return (T)1 << ceilLog2(n);
}
template <class T, class U>
inline T
divCeil(const T& a, const U& b)
{
return (a + b - 1) / b;
}
template <class T, class U>
inline T
roundUp(const T& val, const U& align)
{
T mask = (T)align - 1;
return (val + mask) & ~mask;
}
template <class T, class U>
inline T
roundDown(const T& val, const U& align)
{
T mask = (T)align - 1;
return val & ~mask;
}
inline bool
isHex(char c)
{
return (c >= '0' && c <= '9') ||
(c >= 'A' && c <= 'F') ||
(c >= 'a' && c <= 'f');
}
inline bool
isOct(char c)
{
return c >= '0' && c <= '7';
}
inline bool
isDec(char c)
{
return c >= '0' && c <= '9';
}
inline int
hex2Int(char c)
{
if (c >= '0' && c <= '9')
return (c - '0');
if (c >= 'A' && c <= 'F')
return (c - 'A') + 10;
if (c >= 'a' && c <= 'f')
return (c - 'a') + 10;
return 0;
}
#endif // __BASE_INTMATH_HH__
<|endoftext|> |
<commit_before>/*************************************************************************
*
* $RCSfile: dlgedview.cxx,v $
*
* $Revision: 1.9 $
*
* last change: $Author: vg $ $Date: 2003-05-22 08:43:53 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef _BASCTL_DLGEDVIEW_HXX
#include "dlgedview.hxx"
#endif
#ifndef _BASCTL_DLGED_HXX
#include "dlged.hxx"
#endif
#ifndef _BASCTL_DLGEDPAGE_HXX
#include <dlgedpage.hxx>
#endif
#ifndef _SVXIDS_HRC
#include <svx/svxids.hrc>
#endif
#ifndef _SFXVIEWFRM_HXX
#include <sfx2/viewfrm.hxx>
#endif
#include <basidesh.hxx>
#include <iderdll.hxx>
TYPEINIT1( DlgEdView, SdrView );
//----------------------------------------------------------------------------
DlgEdView::DlgEdView( SdrModel* pModel, OutputDevice* pOut, DlgEditor* pEditor )
:SdrView( pModel, pOut )
,pDlgEditor( pEditor )
{
}
//----------------------------------------------------------------------------
DlgEdView::~DlgEdView()
{
}
//----------------------------------------------------------------------------
void DlgEdView::MarkListHasChanged()
{
SdrView::MarkListHasChanged();
DlgEdHint aHint( DLGED_HINT_SELECTIONCHANGED );
if ( pDlgEditor )
{
pDlgEditor->Broadcast( aHint );
pDlgEditor->UpdatePropertyBrowserDelayed();
}
}
//----------------------------------------------------------------------------
void DlgEdView::MakeVisible( const Rectangle& rRect, Window& rWin )
{
// visible area
MapMode aMap( rWin.GetMapMode() );
Point aOrg( aMap.GetOrigin() );
Size aVisSize( rWin.GetOutputSize() );
Rectangle RectTmp( Point(-aOrg.X(),-aOrg.Y()), aVisSize );
Rectangle aVisRect( RectTmp );
// check, if rectangle is inside visible area
if ( !aVisRect.IsInside( rRect ) )
{
// calculate scroll distance; the rectangle must be inside the visible area
sal_Int32 nScrollX = 0, nScrollY = 0;
sal_Int32 nVisLeft = aVisRect.Left();
sal_Int32 nVisRight = aVisRect.Right();
sal_Int32 nVisTop = aVisRect.Top();
sal_Int32 nVisBottom = aVisRect.Bottom();
sal_Int32 nDeltaX = pDlgEditor->GetHScroll()->GetLineSize();
sal_Int32 nDeltaY = pDlgEditor->GetVScroll()->GetLineSize();
while ( rRect.Right() > nVisRight + nScrollX )
nScrollX += nDeltaX;
while ( rRect.Left() < nVisLeft + nScrollX )
nScrollX -= nDeltaX;
while ( rRect.Bottom() > nVisBottom + nScrollY )
nScrollY += nDeltaY;
while ( rRect.Top() < nVisTop + nScrollY )
nScrollY -= nDeltaY;
// don't scroll beyond the page size
Size aPageSize = pDlgEditor->GetPage()->GetSize();
sal_Int32 nPageWidth = aPageSize.Width();
sal_Int32 nPageHeight = aPageSize.Height();
if ( nVisRight + nScrollX > nPageWidth )
nScrollX = nPageWidth - nVisRight;
if ( nVisLeft + nScrollX < 0 )
nScrollX = -nVisLeft;
if ( nVisBottom + nScrollY > nPageHeight )
nScrollY = nPageHeight - nVisBottom;
if ( nVisTop + nScrollY < 0 )
nScrollY = -nVisTop;
// scroll window
rWin.Update();
rWin.Scroll( -nScrollX, -nScrollY );
aMap.SetOrigin( Point( aOrg.X() - nScrollX, aOrg.Y() - nScrollY ) );
rWin.SetMapMode( aMap );
rWin.Update();
rWin.Invalidate();
// update scroll bars
if ( pDlgEditor )
pDlgEditor->UpdateScrollBars();
DlgEdHint aHint( DLGED_HINT_WINDOWSCROLLED );
if ( pDlgEditor )
pDlgEditor->Broadcast( aHint );
}
}
//----------------------------------------------------------------------------
<commit_msg>INTEGRATION: CWS ooo19126 (1.9.312); FILE MERGED 2005/09/05 13:55:55 rt 1.9.312.1: #i54170# Change license header: remove SISSL<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: dlgedview.cxx,v $
*
* $Revision: 1.10 $
*
* last change: $Author: rt $ $Date: 2005-09-07 20:15:45 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _BASCTL_DLGEDVIEW_HXX
#include "dlgedview.hxx"
#endif
#ifndef _BASCTL_DLGED_HXX
#include "dlged.hxx"
#endif
#ifndef _BASCTL_DLGEDPAGE_HXX
#include <dlgedpage.hxx>
#endif
#ifndef _SVXIDS_HRC
#include <svx/svxids.hrc>
#endif
#ifndef _SFXVIEWFRM_HXX
#include <sfx2/viewfrm.hxx>
#endif
#include <basidesh.hxx>
#include <iderdll.hxx>
TYPEINIT1( DlgEdView, SdrView );
//----------------------------------------------------------------------------
DlgEdView::DlgEdView( SdrModel* pModel, OutputDevice* pOut, DlgEditor* pEditor )
:SdrView( pModel, pOut )
,pDlgEditor( pEditor )
{
}
//----------------------------------------------------------------------------
DlgEdView::~DlgEdView()
{
}
//----------------------------------------------------------------------------
void DlgEdView::MarkListHasChanged()
{
SdrView::MarkListHasChanged();
DlgEdHint aHint( DLGED_HINT_SELECTIONCHANGED );
if ( pDlgEditor )
{
pDlgEditor->Broadcast( aHint );
pDlgEditor->UpdatePropertyBrowserDelayed();
}
}
//----------------------------------------------------------------------------
void DlgEdView::MakeVisible( const Rectangle& rRect, Window& rWin )
{
// visible area
MapMode aMap( rWin.GetMapMode() );
Point aOrg( aMap.GetOrigin() );
Size aVisSize( rWin.GetOutputSize() );
Rectangle RectTmp( Point(-aOrg.X(),-aOrg.Y()), aVisSize );
Rectangle aVisRect( RectTmp );
// check, if rectangle is inside visible area
if ( !aVisRect.IsInside( rRect ) )
{
// calculate scroll distance; the rectangle must be inside the visible area
sal_Int32 nScrollX = 0, nScrollY = 0;
sal_Int32 nVisLeft = aVisRect.Left();
sal_Int32 nVisRight = aVisRect.Right();
sal_Int32 nVisTop = aVisRect.Top();
sal_Int32 nVisBottom = aVisRect.Bottom();
sal_Int32 nDeltaX = pDlgEditor->GetHScroll()->GetLineSize();
sal_Int32 nDeltaY = pDlgEditor->GetVScroll()->GetLineSize();
while ( rRect.Right() > nVisRight + nScrollX )
nScrollX += nDeltaX;
while ( rRect.Left() < nVisLeft + nScrollX )
nScrollX -= nDeltaX;
while ( rRect.Bottom() > nVisBottom + nScrollY )
nScrollY += nDeltaY;
while ( rRect.Top() < nVisTop + nScrollY )
nScrollY -= nDeltaY;
// don't scroll beyond the page size
Size aPageSize = pDlgEditor->GetPage()->GetSize();
sal_Int32 nPageWidth = aPageSize.Width();
sal_Int32 nPageHeight = aPageSize.Height();
if ( nVisRight + nScrollX > nPageWidth )
nScrollX = nPageWidth - nVisRight;
if ( nVisLeft + nScrollX < 0 )
nScrollX = -nVisLeft;
if ( nVisBottom + nScrollY > nPageHeight )
nScrollY = nPageHeight - nVisBottom;
if ( nVisTop + nScrollY < 0 )
nScrollY = -nVisTop;
// scroll window
rWin.Update();
rWin.Scroll( -nScrollX, -nScrollY );
aMap.SetOrigin( Point( aOrg.X() - nScrollX, aOrg.Y() - nScrollY ) );
rWin.SetMapMode( aMap );
rWin.Update();
rWin.Invalidate();
// update scroll bars
if ( pDlgEditor )
pDlgEditor->UpdateScrollBars();
DlgEdHint aHint( DLGED_HINT_WINDOWSCROLLED );
if ( pDlgEditor )
pDlgEditor->Broadcast( aHint );
}
}
//----------------------------------------------------------------------------
<|endoftext|> |
<commit_before>//===- llvm/unittest/Object/Disassembler.cpp ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm-c/Disassembler.h"
#include "llvm/Support/TargetSelect.h"
#include "gtest/gtest.h"
using namespace llvm;
static const char *symbolLookupCallback(void *DisInfo, uint64_t ReferenceValue,
uint64_t *ReferenceType,
uint64_t ReferencePC,
const char **ReferenceName) {
*ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
return nullptr;
}
TEST(Disassembler, X86Test) {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
uint8_t Bytes[] = {0x90, 0x90, 0xeb, 0xfd};
uint8_t *BytesP = Bytes;
const char OutStringSize = 100;
char OutString[OutStringSize];
LLVMDisasmContextRef DCR = LLVMCreateDisasm("x86_64-pc-linux", nullptr, 0,
nullptr, symbolLookupCallback);
if (!DCR)
return;
size_t InstSize;
unsigned NumBytes = sizeof(Bytes);
unsigned PC = 0;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 1U);
EXPECT_EQ(StringRef(OutString), "\tnop");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 1U);
EXPECT_EQ(StringRef(OutString), "\tnop");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 2U);
EXPECT_EQ(StringRef(OutString), "\tjmp\t0x1");
LLVMDisasmDispose(DCR);
}
TEST(Disassembler, WebAssemblyTest) {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
uint8_t Bytes[] = {0x6a, 0x42, 0x7F, 0x35, 0x01, 0x10};
uint8_t *BytesP = Bytes;
const char OutStringSize = 100;
char OutString[OutStringSize];
LLVMDisasmContextRef DCR = LLVMCreateDisasm(
"wasm32-unknown-unknown-elf", nullptr, 0, nullptr, symbolLookupCallback);
if (!DCR)
return;
size_t InstSize;
unsigned NumBytes = sizeof(Bytes);
unsigned PC = 0;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 1U);
EXPECT_EQ(StringRef(OutString), "\ti32.add \t$0=, $0, $0");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 2U);
EXPECT_EQ(StringRef(OutString), "\ti64.const\t$0=, -1");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 3U);
EXPECT_EQ(StringRef(OutString), "\ti64.load32_u\t$0=, 16($0):p2align=1");
LLVMDisasmDispose(DCR);
}
<commit_msg>[WebAssembly] Fixed disassembler unit test failure.<commit_after>//===- llvm/unittest/Object/Disassembler.cpp ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm-c/Disassembler.h"
#include "llvm/Support/TargetSelect.h"
#include "gtest/gtest.h"
using namespace llvm;
static const char *symbolLookupCallback(void *DisInfo, uint64_t ReferenceValue,
uint64_t *ReferenceType,
uint64_t ReferencePC,
const char **ReferenceName) {
*ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
return nullptr;
}
TEST(Disassembler, X86Test) {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
uint8_t Bytes[] = {0x90, 0x90, 0xeb, 0xfd};
uint8_t *BytesP = Bytes;
const char OutStringSize = 100;
char OutString[OutStringSize];
LLVMDisasmContextRef DCR = LLVMCreateDisasm("x86_64-pc-linux", nullptr, 0,
nullptr, symbolLookupCallback);
if (!DCR)
return;
size_t InstSize;
unsigned NumBytes = sizeof(Bytes);
unsigned PC = 0;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 1U);
EXPECT_EQ(StringRef(OutString), "\tnop");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 1U);
EXPECT_EQ(StringRef(OutString), "\tnop");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 2U);
EXPECT_EQ(StringRef(OutString), "\tjmp\t0x1");
LLVMDisasmDispose(DCR);
}
TEST(Disassembler, WebAssemblyTest) {
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllDisassemblers();
uint8_t Bytes[] = {0x6a, 0x42, 0x7F, 0x35, 0x01, 0x10};
uint8_t *BytesP = Bytes;
const char OutStringSize = 100;
char OutString[OutStringSize];
LLVMDisasmContextRef DCR = LLVMCreateDisasm(
"wasm32-unknown-unknown-elf", nullptr, 0, nullptr, symbolLookupCallback);
if (!DCR)
return;
size_t InstSize;
unsigned NumBytes = sizeof(Bytes);
unsigned PC = 0;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 1U);
EXPECT_EQ(StringRef(OutString), "\ti32.add ");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 2U);
EXPECT_EQ(StringRef(OutString), "\ti64.const\t-1");
PC += InstSize;
BytesP += InstSize;
NumBytes -= InstSize;
InstSize = LLVMDisasmInstruction(DCR, BytesP, NumBytes, PC, OutString,
OutStringSize);
EXPECT_EQ(InstSize, 3U);
EXPECT_EQ(StringRef(OutString), "\ti64.load32_u\t16, :p2align=1");
LLVMDisasmDispose(DCR);
}
<|endoftext|> |
<commit_before>/*
This file is part of KitchenSync.
Copyright (c) 2004 Cornelius Schumacher <[email protected]>
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; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#include "remotekonnectorconfig.h"
#include "remotekonnector.h"
#include <libkcal/resourcelocal.h>
#include <kconfig.h>
#include <klocale.h>
#include <kabc/resourcefile.h>
#include <kmessagebox.h>
#include <kinputdialog.h>
#include <klineedit.h>
#include <qinputdialog.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
using namespace KSync;
RemoteKonnectorConfig::RemoteKonnectorConfig( QWidget *parent )
: KRES::ConfigWidget( parent, 0 )
{
QBoxLayout *topLayout = new QVBoxLayout( this );
QPushButton *button = new QPushButton( i18n("Standard Setup..."), this );
topLayout->addWidget( button );
connect( button, SIGNAL( clicked() ), SLOT( setupStandard() ) );
topLayout->addWidget( new QLabel( i18n("Calendar file:"), this ) );
mCalendarUrl = new KURLRequester( this );
mCalendarUrl->setMode( KFile::File );
topLayout->addWidget( mCalendarUrl );
topLayout->addSpacing( 4 );
topLayout->addWidget( new QLabel( i18n("Address book file:"), this ) );
mAddressBookUrl = new KURLRequester( this );
mAddressBookUrl->setMode( KFile::File );
topLayout->addWidget( mAddressBookUrl );
}
RemoteKonnectorConfig::~RemoteKonnectorConfig()
{
}
void RemoteKonnectorConfig::loadSettings( KRES::Resource *r )
{
RemoteKonnector *konnector = dynamic_cast<RemoteKonnector *>( r );
if ( konnector ) {
mCalendarUrl->setURL( konnector->calendarUrl() );
mAddressBookUrl->setURL( konnector->addressBookUrl() );
}
}
void RemoteKonnectorConfig::saveSettings( KRES::Resource *r )
{
RemoteKonnector *konnector = dynamic_cast<RemoteKonnector *>( r );
if ( konnector ) {
konnector->setCalendarUrl( mCalendarUrl->url() );
konnector->setAddressBookUrl( mAddressBookUrl->url() );
}
}
void RemoteKonnectorConfig::setupStandard()
{
bool ok = false;
QString hostname = QInputDialog::getText( i18n( "Remote Host" ), i18n( "Enter remote host name" ),
QLineEdit::Normal, QString::null, &ok, this );
if ( hostname.isEmpty() || !ok )
return;
QString username = QInputDialog::getText( i18n( "Remote User" ), i18n( "Enter remote user name" ),
QLineEdit::Normal, QString::null, &ok, this );
if ( username.isEmpty() || !ok )
return;
QString urlBase = "fish://" + hostname + "/~" + username + "/";
mCalendarUrl->setURL( urlBase + ".kde/share/apps/korganizer/std.ics" );
mAddressBookUrl->setURL( urlBase + ".kde/share/apps/kabc/std.vcf" );
}
#include "remotekonnectorconfig.moc"
<commit_msg>Use KInputDialog instead of QInputDialog and fix the strings according to the style guide.<commit_after>/*
This file is part of KitchenSync.
Copyright (c) 2004 Cornelius Schumacher <[email protected]>
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; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#include "remotekonnectorconfig.h"
#include "remotekonnector.h"
#include <libkcal/resourcelocal.h>
#include <kconfig.h>
#include <klocale.h>
#include <kabc/resourcefile.h>
#include <kmessagebox.h>
#include <kinputdialog.h>
#include <klineedit.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
using namespace KSync;
RemoteKonnectorConfig::RemoteKonnectorConfig( QWidget *parent )
: KRES::ConfigWidget( parent, 0 )
{
QBoxLayout *topLayout = new QVBoxLayout( this );
QPushButton *button = new QPushButton( i18n("Standard Setup..."), this );
topLayout->addWidget( button );
connect( button, SIGNAL( clicked() ), SLOT( setupStandard() ) );
topLayout->addWidget( new QLabel( i18n("Calendar file:"), this ) );
mCalendarUrl = new KURLRequester( this );
mCalendarUrl->setMode( KFile::File );
topLayout->addWidget( mCalendarUrl );
topLayout->addSpacing( 4 );
topLayout->addWidget( new QLabel( i18n("Address book file:"), this ) );
mAddressBookUrl = new KURLRequester( this );
mAddressBookUrl->setMode( KFile::File );
topLayout->addWidget( mAddressBookUrl );
}
RemoteKonnectorConfig::~RemoteKonnectorConfig()
{
}
void RemoteKonnectorConfig::loadSettings( KRES::Resource *r )
{
RemoteKonnector *konnector = dynamic_cast<RemoteKonnector *>( r );
if ( konnector ) {
mCalendarUrl->setURL( konnector->calendarUrl() );
mAddressBookUrl->setURL( konnector->addressBookUrl() );
}
}
void RemoteKonnectorConfig::saveSettings( KRES::Resource *r )
{
RemoteKonnector *konnector = dynamic_cast<RemoteKonnector *>( r );
if ( konnector ) {
konnector->setCalendarUrl( mCalendarUrl->url() );
konnector->setAddressBookUrl( mAddressBookUrl->url() );
}
}
void RemoteKonnectorConfig::setupStandard()
{
bool ok = false;
QString hostname = KInputDialog::getText( i18n( "Remote Host" ), i18n( "Enter remote host name:" ),
QString::null, &ok, this );
if ( hostname.isEmpty() || !ok )
return;
QString username = KInputDialog::getText( i18n( "Remote User" ), i18n( "Enter remote user name:" ),
QString::null, &ok, this );
if ( username.isEmpty() || !ok )
return;
QString urlBase = "fish://" + hostname + "/~" + username + "/";
mCalendarUrl->setURL( urlBase + ".kde/share/apps/korganizer/std.ics" );
mAddressBookUrl->setURL( urlBase + ".kde/share/apps/kabc/std.vcf" );
}
#include "remotekonnectorconfig.moc"
<|endoftext|> |
<commit_before>#include <algorithm>
#include "audiere.h"
#include "mixer.hpp"
#include "output.hpp"
#include "resampler.hpp"
////////////////////////////////////////////////////////////////////////////////
Mixer::Mixer()
{
}
////////////////////////////////////////////////////////////////////////////////
Mixer::~Mixer()
{
// assume all streams have been removed
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::GetFormat(int& channel_count, int& sample_rate, int& bits_per_sample)
{
channel_count = 2;
sample_rate = 44100;
bits_per_sample = 16;
}
////////////////////////////////////////////////////////////////////////////////
int
Mixer::Read(const int sample_count, void* samples)
{
if (m_sources.size() == 0) {
memset(samples, 0, 4 * sample_count);
return sample_count;
}
static const int BUFFER_SIZE = 4096;
// create buffers in which to mix
adr_s32 mix_buffer[BUFFER_SIZE];
adr_s16 stream_buffer[BUFFER_SIZE * 2];
std::fill(mix_buffer, mix_buffer + BUFFER_SIZE, 0);
adr_s16* out = (adr_s16*)samples;
int left = sample_count;
while (left > 0) {
int playing = 0;
int to_mix = std::min(BUFFER_SIZE, left);
SourceMap::iterator s = m_sources.begin();
for (; s != m_sources.end(); ++s) {
if (s->second.is_playing) {
Read(s->first, s->second, to_mix, stream_buffer);
for (int i = 0; i < to_mix * 2; ++i) {
mix_buffer[i] += stream_buffer[i];
}
++playing;
}
}
// do the division
if (playing != 0) {
for (int i = 0; i < to_mix * 2; ++i) {
*out++ = mix_buffer[i] / playing;
}
}
left -= to_mix;
}
return sample_count;
}
////////////////////////////////////////////////////////////////////////////////
bool
Mixer::Reset()
{
return true;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::AddSource(ISampleSource* source)
{
// initial source attributes
SourceAttributes sa;
sa.resampler = new Resampler(source);
sa.last_l = 0;
sa.last_r = 0;
sa.is_playing = true;
sa.volume = ADR_VOLUME_MAX;
m_sources[source] = sa;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::RemoveSource(ISampleSource* source)
{
delete m_sources[source].resampler;
m_sources.erase(source);
}
////////////////////////////////////////////////////////////////////////////////
bool
Mixer::IsPlaying(ISampleSource* source)
{
return m_sources[source].is_playing;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::SetPlaying(ISampleSource* source, bool is_playing)
{
m_sources[source].is_playing = is_playing;
}
////////////////////////////////////////////////////////////////////////////////
int
Mixer::GetVolume(ISampleSource* source)
{
return m_sources[source].volume;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::SetVolume(ISampleSource* source, int volume)
{
m_sources[source].volume = volume;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::Read(ISampleSource* source,
SourceAttributes& attr,
int to_mix,
adr_s16* buffer) // size = to_mix * 4
{
unsigned read = attr.resampler->Read(to_mix, buffer);
if (read == 0) {
attr.is_playing = false;
}
// grab them early so we don't lose optimizations due to aliasing
adr_s16 l = attr.last_l;
adr_s16 r = attr.last_r;
adr_s16* out = buffer;
for (int i = 0; i < read; ++i) {
*out = *out * attr.volume / 255;
++out;
*out = *out * attr.volume / 255;
++out;
}
if (read >= 0) {
l = out[-2];
r = out[-1];
}
for (int i = read; i < to_mix; ++i) {
*out++ = l;
*out++ = r;
}
attr.last_l = l;
attr.last_r = r;
}
////////////////////////////////////////////////////////////////////////////////
<commit_msg>fixed noisy crap in Linux (Theo Reed)<commit_after>#include <algorithm>
#include "audiere.h"
#include "mixer.hpp"
#include "output.hpp"
#include "resampler.hpp"
////////////////////////////////////////////////////////////////////////////////
Mixer::Mixer()
{
}
////////////////////////////////////////////////////////////////////////////////
Mixer::~Mixer()
{
// assume all streams have been removed
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::GetFormat(int& channel_count, int& sample_rate, int& bits_per_sample)
{
channel_count = 2;
sample_rate = 44100;
bits_per_sample = 16;
}
////////////////////////////////////////////////////////////////////////////////
int
Mixer::Read(const int sample_count, void* samples)
{
// are any sources playing?
bool any_playing = false;
SourceMap::iterator i = m_sources.begin();
while (i != m_sources.end()) {
any_playing |= i->second.is_playing;
++i;
}
// if not, return zeroed samples
if (!any_playing) {
memset(samples, 0, 4 * sample_count);
return sample_count;
}
static const int BUFFER_SIZE = 4096;
// create buffers in which to mix
adr_s32 mix_buffer[BUFFER_SIZE];
adr_s16 stream_buffer[BUFFER_SIZE * 2];
std::fill(mix_buffer, mix_buffer + BUFFER_SIZE, 0);
adr_s16* out = (adr_s16*)samples;
int left = sample_count;
while (left > 0) {
int playing = 0;
int to_mix = std::min(BUFFER_SIZE, left);
SourceMap::iterator s = m_sources.begin();
for (; s != m_sources.end(); ++s) {
if (s->second.is_playing) {
Read(s->first, s->second, to_mix, stream_buffer);
for (int i = 0; i < to_mix * 2; ++i) {
mix_buffer[i] += stream_buffer[i];
}
++playing;
}
}
// do the division
if (playing != 0) {
for (int i = 0; i < to_mix * 2; ++i) {
*out++ = mix_buffer[i] / playing;
}
}
left -= to_mix;
}
return sample_count;
}
////////////////////////////////////////////////////////////////////////////////
bool
Mixer::Reset()
{
return true;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::AddSource(ISampleSource* source)
{
// initial source attributes
SourceAttributes sa;
sa.resampler = new Resampler(source);
sa.last_l = 0;
sa.last_r = 0;
sa.is_playing = true;
sa.volume = ADR_VOLUME_MAX;
m_sources[source] = sa;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::RemoveSource(ISampleSource* source)
{
delete m_sources[source].resampler;
m_sources.erase(source);
}
////////////////////////////////////////////////////////////////////////////////
bool
Mixer::IsPlaying(ISampleSource* source)
{
return m_sources[source].is_playing;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::SetPlaying(ISampleSource* source, bool is_playing)
{
m_sources[source].is_playing = is_playing;
}
////////////////////////////////////////////////////////////////////////////////
int
Mixer::GetVolume(ISampleSource* source)
{
return m_sources[source].volume;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::SetVolume(ISampleSource* source, int volume)
{
m_sources[source].volume = volume;
}
////////////////////////////////////////////////////////////////////////////////
void
Mixer::Read(ISampleSource* source,
SourceAttributes& attr,
int to_mix,
adr_s16* buffer) // size = to_mix * 4
{
unsigned read = attr.resampler->Read(to_mix, buffer);
if (read == 0) {
attr.is_playing = false;
}
// grab them early so we don't lose optimizations due to aliasing
adr_s16 l = attr.last_l;
adr_s16 r = attr.last_r;
adr_s16* out = buffer;
for (int i = 0; i < read; ++i) {
*out = *out * attr.volume / 255;
++out;
*out = *out * attr.volume / 255;
++out;
}
if (read >= 0) {
l = out[-2];
r = out[-1];
}
for (int i = read; i < to_mix; ++i) {
*out++ = l;
*out++ = r;
}
attr.last_l = l;
attr.last_r = r;
}
////////////////////////////////////////////////////////////////////////////////
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: b2ituple.cxx,v $
*
* $Revision: 1.5 $
*
* last change: $Author: obo $ $Date: 2006-09-17 08:06:55 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basegfx.hxx"
#ifndef _BGFX_TUPLE_B2ITUPLE_HXX
#include <basegfx/tuple/b2ituple.hxx>
#endif
#ifndef _BGFX_TUPLE_B2DTUPLE_HXX
#include <basegfx/tuple/b2dtuple.hxx>
#endif
#ifndef INCLUDED_RTL_INSTANCE_HXX
#include <rtl/instance.hxx>
#endif
namespace { struct EmptyTuple : public rtl::Static<basegfx::B2ITuple, EmptyTuple> {}; }
namespace basegfx
{
const B2ITuple& B2ITuple::getEmptyTuple()
{
return EmptyTuple::get();
}
// external operators
//////////////////////////////////////////////////////////////////////////
B2ITuple minimum(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aMin(
(rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
(rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY());
return aMin;
}
B2ITuple maximum(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aMax(
(rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
(rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY());
return aMax;
}
B2ITuple absolute(const B2ITuple& rTup)
{
B2ITuple aAbs(
(0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
(0 > rTup.getY()) ? -rTup.getY() : rTup.getY());
return aAbs;
}
B2DTuple interpolate(const B2ITuple& rOld1, const B2ITuple& rOld2, double t)
{
B2DTuple aInt(
((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
return aInt;
}
B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2)
{
B2DTuple aAvg(
(rOld1.getX() + rOld2.getX()) * 0.5,
(rOld1.getY() + rOld2.getY()) * 0.5);
return aAvg;
}
B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2, const B2ITuple& rOld3)
{
B2DTuple aAvg(
(rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
(rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
return aAvg;
}
B2ITuple operator+(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aSum(rTupA);
aSum += rTupB;
return aSum;
}
B2ITuple operator-(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aSub(rTupA);
aSub -= rTupB;
return aSub;
}
B2ITuple operator/(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aDiv(rTupA);
aDiv /= rTupB;
return aDiv;
}
B2ITuple operator*(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aMul(rTupA);
aMul *= rTupB;
return aMul;
}
B2ITuple operator*(const B2ITuple& rTup, sal_Int32 t)
{
B2ITuple aNew(rTup);
aNew *= t;
return aNew;
}
B2ITuple operator*(sal_Int32 t, const B2ITuple& rTup)
{
B2ITuple aNew(rTup);
aNew *= t;
return aNew;
}
B2ITuple operator/(const B2ITuple& rTup, sal_Int32 t)
{
B2ITuple aNew(rTup);
aNew /= t;
return aNew;
}
B2ITuple operator/(sal_Int32 t, const B2ITuple& rTup)
{
B2ITuple aNew(t, t);
B2ITuple aTmp(rTup);
aNew /= aTmp;
return aNew;
}
} // end of namespace basegfx
// eof
<commit_msg>INTEGRATION: CWS changefileheader (1.5.60); FILE MERGED 2008/04/01 15:01:16 thb 1.5.60.3: #i85898# Stripping all external header guards 2008/04/01 10:48:16 thb 1.5.60.2: #i85898# Stripping all external header guards 2008/03/28 16:05:57 rt 1.5.60.1: #i87441# Change license header to LPGL v3.<commit_after>/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: b2ituple.cxx,v $
* $Revision: 1.6 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basegfx.hxx"
#include <basegfx/tuple/b2ituple.hxx>
#include <basegfx/tuple/b2dtuple.hxx>
#include <rtl/instance.hxx>
namespace { struct EmptyTuple : public rtl::Static<basegfx::B2ITuple, EmptyTuple> {}; }
namespace basegfx
{
const B2ITuple& B2ITuple::getEmptyTuple()
{
return EmptyTuple::get();
}
// external operators
//////////////////////////////////////////////////////////////////////////
B2ITuple minimum(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aMin(
(rTupB.getX() < rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
(rTupB.getY() < rTupA.getY()) ? rTupB.getY() : rTupA.getY());
return aMin;
}
B2ITuple maximum(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aMax(
(rTupB.getX() > rTupA.getX()) ? rTupB.getX() : rTupA.getX(),
(rTupB.getY() > rTupA.getY()) ? rTupB.getY() : rTupA.getY());
return aMax;
}
B2ITuple absolute(const B2ITuple& rTup)
{
B2ITuple aAbs(
(0 > rTup.getX()) ? -rTup.getX() : rTup.getX(),
(0 > rTup.getY()) ? -rTup.getY() : rTup.getY());
return aAbs;
}
B2DTuple interpolate(const B2ITuple& rOld1, const B2ITuple& rOld2, double t)
{
B2DTuple aInt(
((rOld2.getX() - rOld1.getX()) * t) + rOld1.getX(),
((rOld2.getY() - rOld1.getY()) * t) + rOld1.getY());
return aInt;
}
B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2)
{
B2DTuple aAvg(
(rOld1.getX() + rOld2.getX()) * 0.5,
(rOld1.getY() + rOld2.getY()) * 0.5);
return aAvg;
}
B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2, const B2ITuple& rOld3)
{
B2DTuple aAvg(
(rOld1.getX() + rOld2.getX() + rOld3.getX()) * (1.0 / 3.0),
(rOld1.getY() + rOld2.getY() + rOld3.getY()) * (1.0 / 3.0));
return aAvg;
}
B2ITuple operator+(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aSum(rTupA);
aSum += rTupB;
return aSum;
}
B2ITuple operator-(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aSub(rTupA);
aSub -= rTupB;
return aSub;
}
B2ITuple operator/(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aDiv(rTupA);
aDiv /= rTupB;
return aDiv;
}
B2ITuple operator*(const B2ITuple& rTupA, const B2ITuple& rTupB)
{
B2ITuple aMul(rTupA);
aMul *= rTupB;
return aMul;
}
B2ITuple operator*(const B2ITuple& rTup, sal_Int32 t)
{
B2ITuple aNew(rTup);
aNew *= t;
return aNew;
}
B2ITuple operator*(sal_Int32 t, const B2ITuple& rTup)
{
B2ITuple aNew(rTup);
aNew *= t;
return aNew;
}
B2ITuple operator/(const B2ITuple& rTup, sal_Int32 t)
{
B2ITuple aNew(rTup);
aNew /= t;
return aNew;
}
B2ITuple operator/(sal_Int32 t, const B2ITuple& rTup)
{
B2ITuple aNew(t, t);
B2ITuple aTmp(rTup);
aNew /= aTmp;
return aNew;
}
} // end of namespace basegfx
// eof
<|endoftext|> |
<commit_before>//===- llvm/unittest/Support/MD5Test.cpp - MD5 tests ----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements unit tests for the MD5 functions.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/MD5.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
void TestMD5Sum(ArrayRef<unsigned char> Input, StringRef Final) {
MD5 Hash;
Hash.update(Input);
MD5::MD5Result MD5Res;
Hash.final(MD5Res);
SmallString<32> Res;
MD5::stringifyResult(MD5Res, Res);
EXPECT_EQ(Res, Final);
}
TEST(MD5Test, MD5) {
TestMD5Sum(ArrayRef<unsigned char>((const unsigned char *)"", (size_t) 0),
"d41d8cd98f00b204e9800998ecf8427e");
TestMD5Sum(ArrayRef<unsigned char>((const unsigned char *)"a", (size_t) 1),
"0cc175b9c0f1b6a831c399e269772661");
TestMD5Sum(ArrayRef<unsigned char>(
(const unsigned char *)"abcdefghijklmnopqrstuvwxyz",
(size_t) 26),
"c3fcd3d76192e4007dfb496cca67e13b");
}
}
<commit_msg>Add a comment and some tests including the NULL byte.<commit_after>//===- llvm/unittest/Support/MD5Test.cpp - MD5 tests ----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements unit tests for the MD5 functions.
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/MD5.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
/// \brief Tests an arbitrary set of bytes passed as \p Input.
void TestMD5Sum(ArrayRef<unsigned char> Input, StringRef Final) {
MD5 Hash;
Hash.update(Input);
MD5::MD5Result MD5Res;
Hash.final(MD5Res);
SmallString<32> Res;
MD5::stringifyResult(MD5Res, Res);
EXPECT_EQ(Res, Final);
}
TEST(MD5Test, MD5) {
TestMD5Sum(ArrayRef<unsigned char>((const unsigned char *)"", (size_t) 0),
"d41d8cd98f00b204e9800998ecf8427e");
TestMD5Sum(ArrayRef<unsigned char>((const unsigned char *)"a", (size_t) 1),
"0cc175b9c0f1b6a831c399e269772661");
TestMD5Sum(ArrayRef<unsigned char>(
(const unsigned char *)"abcdefghijklmnopqrstuvwxyz",
(size_t) 26),
"c3fcd3d76192e4007dfb496cca67e13b");
TestMD5Sum(ArrayRef<unsigned char>((const unsigned char *)"\0", (size_t) 1),
"93b885adfe0da089cdf634904fd59f71");
TestMD5Sum(ArrayRef<unsigned char>((const unsigned char *)"a\0", (size_t) 2),
"4144e195f46de78a3623da7364d04f11");
TestMD5Sum(ArrayRef<unsigned char>(
(const unsigned char *)"abcdefghijklmnopqrstuvwxyz\0",
(size_t) 27),
"81948d1f1554f58cd1a56ebb01f808cb");
}
}
<|endoftext|> |
<commit_before>#ifndef LIBTEN_SHARED_POOL_HH
#define LIBTEN_SHARED_POOL_HH
#include "task/rendez.hh"
#include "ten/logging.hh"
#include <boost/call_traits.hpp>
#include <set>
#include <deque>
namespace ten {
namespace detail {
template <typename T> class scoped_resource;
}
//! thread and task safe pool of shared resources
//
//! useful for connection pools and other types of shared resources
template <typename ResourceT, typename ScopeT = detail::scoped_resource<ResourceT> >
class shared_pool {
public:
// use this scoped_resource type to RAII resources from the pool
typedef ScopeT scoped_resource;
typedef std::deque<std::shared_ptr<ResourceT> > queue_type;
typedef std::set<std::shared_ptr<ResourceT> > set_type;
typedef std::function<std::shared_ptr<ResourceT> ()> alloc_func;
protected:
template <typename TT> friend class detail::scoped_resource;
qutex _mut;
rendez _not_empty;
queue_type _q;
set_type _set;
std::string _name;
alloc_func _new_resource;
ssize_t _max;
public:
shared_pool(const std::string &name_,
const alloc_func &alloc_,
ssize_t max_ = -1)
: _name(name_),
_new_resource(alloc_),
_max(max_)
{}
shared_pool(const shared_pool &) = delete;
shared_pool &operator =(const shared_pool &) = delete;
size_t size() {
std::unique_lock<qutex> lk(_mut);
return _set.size();
}
void clear() {
std::unique_lock<qutex> lk(_mut);
_q.clear();
_set.clear();
}
const std::string &name() const { return _name; }
protected:
bool is_not_empty() const { return !_q.empty(); }
std::shared_ptr<ResourceT> acquire() {
std::unique_lock<qutex> lk(_mut);
return create_or_acquire_nolock(lk);
}
// internal, does not lock mutex
std::shared_ptr<ResourceT> create_or_acquire_nolock(std::unique_lock<qutex> &lk) {
std::shared_ptr<ResourceT> c;
if (_q.empty()) {
// need to create a new resource
if (_max < 0 || _set.size() < (size_t)_max) {
try {
c = _new_resource();
CHECK(c) << "new_resource failed for pool: " << _name;
DVLOG(5) << "inserting to shared_pool(" << _name << "): " << c;
_set.insert(c);
} catch (std::exception &e) {
LOG(ERROR) << "exception creating new resource for pool: " <<_name << " " << e.what();
throw;
}
} else {
// can't create anymore we're at max, try waiting
while (_q.empty()) {
_not_empty.sleep(lk);
}
CHECK(!_q.empty());
c = _q.front();
_q.pop_front();
}
} else {
// pop resource from front of queue
c = _q.front();
_q.pop_front();
}
CHECK(c) << "acquire shared resource failed in pool: " << _name;
return c;
}
bool insert(std::shared_ptr<ResourceT> &c) {
// add a resource to the pool. use with care
std::unique_lock<qutex> lk(_mut);
auto p = _set.insert(c);
if (p.second) {
_q.push_front(c);
_not_empty.wakeup();
}
return p.second;
}
void release(std::shared_ptr<ResourceT> &c) {
std::unique_lock<qutex> lk(_mut);
// don't add resource to queue if it was removed from _set
if (_set.count(c)) {
_q.push_front(c);
_not_empty.wakeup();
}
}
// return a defective resource to the pool
// get a new one back.
std::shared_ptr<ResourceT> exchange(std::shared_ptr<ResourceT> &c) {
std::unique_lock<qutex> lk(_mut);
// remove bad resource
if (c) {
_set.erase(c);
c.reset();
}
return create_or_acquire_nolock(lk);
}
void destroy(std::shared_ptr<ResourceT> &c) {
std::unique_lock<qutex> lk(_mut);
// remove bad resource
DVLOG(5) << "shared_pool(" << _name
<< ") destroy in set? " << _set.count(c)
<< " : " << c << " rc: " << c.use_count();
_set.erase(c);
typename queue_type::iterator i = find(_q.begin(), _q.end(), c);
if (i!=_q.end()) { _q.erase(i); }
c.reset();
// replace the destroyed resource
std::shared_ptr<ResourceT> cc = _new_resource();
_set.insert(cc);
_q.push_front(cc);
cc.reset();
_not_empty.wakeup();
}
};
namespace detail {
// do not use this class directly, instead use your shared_pool<>::scoped_resource
template <typename T> class scoped_resource {
public:
typedef typename boost::call_traits<shared_pool<T> >::reference poolref;
protected:
poolref _pool;
std::shared_ptr<T> _c;
public:
explicit scoped_resource(poolref p)
: _pool(p) {
_c = _pool.acquire();
}
~scoped_resource() {
if (!_c) return;
_pool.release(_c);
// XXX: use destroy once done() has been added everywhere
//_pool.destroy(_c);
}
void exchange() {
_c = _pool.exchange(_c);
}
void destroy() {
_pool.destroy(_c);
}
void acquire() {
if (_c) return;
_c = _pool.acquire();
}
void done() {
_pool.release(_c);
_c.reset();
}
T *operator->() {
if (!_c) throw std::runtime_error("null pointer");
return _c.get();
}
};
} // end detail namespace
} // end namespace ten
#endif // LIBTEN_SHARED_POOL_HH
<commit_msg>make shared_pool destroy resources not marked done<commit_after>#ifndef LIBTEN_SHARED_POOL_HH
#define LIBTEN_SHARED_POOL_HH
#include "task/rendez.hh"
#include "ten/logging.hh"
#include <boost/call_traits.hpp>
#include <set>
#include <deque>
namespace ten {
namespace detail {
template <typename T> class scoped_resource;
}
//! thread and task safe pool of shared resources
//
//! useful for connection pools and other types of shared resources
template <typename ResourceT, typename ScopeT = detail::scoped_resource<ResourceT> >
class shared_pool {
public:
// use this scoped_resource type to RAII resources from the pool
typedef ScopeT scoped_resource;
typedef std::deque<std::shared_ptr<ResourceT> > queue_type;
typedef std::set<std::shared_ptr<ResourceT> > set_type;
typedef std::function<std::shared_ptr<ResourceT> ()> alloc_func;
protected:
template <typename TT> friend class detail::scoped_resource;
qutex _mut;
rendez _not_empty;
queue_type _q;
set_type _set;
std::string _name;
alloc_func _new_resource;
ssize_t _max;
public:
shared_pool(const std::string &name_,
const alloc_func &alloc_,
ssize_t max_ = -1)
: _name(name_),
_new_resource(alloc_),
_max(max_)
{}
shared_pool(const shared_pool &) = delete;
shared_pool &operator =(const shared_pool &) = delete;
size_t size() {
std::unique_lock<qutex> lk(_mut);
return _set.size();
}
void clear() {
std::unique_lock<qutex> lk(_mut);
_q.clear();
_set.clear();
}
const std::string &name() const { return _name; }
protected:
bool is_not_empty() const { return !_q.empty(); }
std::shared_ptr<ResourceT> acquire() {
std::unique_lock<qutex> lk(_mut);
return create_or_acquire_nolock(lk);
}
// internal, does not lock mutex
std::shared_ptr<ResourceT> create_or_acquire_nolock(std::unique_lock<qutex> &lk) {
std::shared_ptr<ResourceT> c;
if (_q.empty()) {
// need to create a new resource
if (_max < 0 || _set.size() < (size_t)_max) {
try {
c = _new_resource();
CHECK(c) << "new_resource failed for pool: " << _name;
DVLOG(4) << "inserting to shared_pool(" << _name << "): " << c;
_set.insert(c);
} catch (std::exception &e) {
LOG(ERROR) << "exception creating new resource for pool: " <<_name << " " << e.what();
throw;
}
} else {
// can't create anymore we're at max, try waiting
while (_q.empty()) {
_not_empty.sleep(lk);
}
CHECK(!_q.empty());
c = _q.front();
_q.pop_front();
}
} else {
// pop resource from front of queue
c = _q.front();
_q.pop_front();
}
CHECK(c) << "acquire shared resource failed in pool: " << _name;
return c;
}
bool insert(std::shared_ptr<ResourceT> &c) {
// add a resource to the pool. use with care
std::unique_lock<qutex> lk(_mut);
auto p = _set.insert(c);
if (p.second) {
_q.push_front(c);
_not_empty.wakeup();
}
return p.second;
}
void release(std::shared_ptr<ResourceT> &c) {
std::unique_lock<qutex> lk(_mut);
// don't add resource to queue if it was removed from _set
if (_set.count(c)) {
_q.push_front(c);
_not_empty.wakeup();
}
}
// return a defective resource to the pool
// get a new one back.
std::shared_ptr<ResourceT> exchange(std::shared_ptr<ResourceT> &c) {
std::unique_lock<qutex> lk(_mut);
// remove bad resource
if (c) {
_set.erase(c);
c.reset();
}
return create_or_acquire_nolock(lk);
}
void destroy(std::shared_ptr<ResourceT> &c) {
std::unique_lock<qutex> lk(_mut);
// remove bad resource
DVLOG(4) << "shared_pool(" << _name
<< ") destroy in set? " << _set.count(c)
<< " : " << c << " rc: " << c.use_count();
_set.erase(c);
typename queue_type::iterator i = find(_q.begin(), _q.end(), c);
if (i!=_q.end()) { _q.erase(i); }
c.reset();
// replace the destroyed resource
std::shared_ptr<ResourceT> cc = _new_resource();
_set.insert(cc);
_q.push_front(cc);
cc.reset();
_not_empty.wakeup();
}
};
namespace detail {
// do not use this class directly, instead use your shared_pool<>::scoped_resource
template <typename T> class scoped_resource {
public:
typedef typename boost::call_traits<shared_pool<T> >::reference poolref;
protected:
poolref _pool;
std::shared_ptr<T> _c;
public:
explicit scoped_resource(poolref p)
: _pool(p) {
_c = _pool.acquire();
}
//! must call done() to return the resource to the pool
//! otherwise we destroy it because a timeout or other exception
//! could have occured causing the resource state to be in transition
~scoped_resource() {
if (!_c) return;
_pool.destroy(_c);
}
void exchange() {
_c = _pool.exchange(_c);
}
void destroy() {
_pool.destroy(_c);
}
void acquire() {
if (_c) return;
_c = _pool.acquire();
}
void done() {
_pool.release(_c);
_c.reset();
}
T *operator->() {
if (!_c) throw std::runtime_error("null pointer");
return _c.get();
}
};
} // end detail namespace
} // end namespace ten
#endif // LIBTEN_SHARED_POOL_HH
<|endoftext|> |
<commit_before>#ifndef MIDIFILE_HPP
#define MIDIFILE_HPP
/**
* Name: MidiFile.hpp
* Purpose: C++ re-write of the python module MidiFile.py
* Author: Mohamed Abdel Maksoud <mohamed at amaksoud.com>
* Created: 2015/02/11
*-----------------------------------------------------------------------------
*/
#include <string.h>
#include <stdint.h>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <assert.h>
using std::string;
using std::vector;
using std::set;
namespace MidiFile
{
const int TICKSPERBEAT = 128;
int writeVarLength(uint32_t val, uint8_t *buffer)
{
/*
Accept an input, and write a MIDI-compatible variable length stream
The MIDI format is a little strange, and makes use of so-called variable
length quantities. These quantities are a stream of bytes. If the most
significant bit is 1, then more bytes follow. If it is zero, then the
byte in question is the last in the stream
*/
int size = 0;
uint8_t result, little_endian[4];
result = val & 0x7F;
little_endian[size++] = result;
val = val >> 7;
while (val > 0)
{
result = val & 0x7F;
result = result | 0x80;
little_endian[size++] = result;
val = val >> 7;
}
for (int i=0; i<size; i++)
{
buffer[i] = little_endian[size-i-1];
}
return size;
}
int writeBigEndian4(uint32_t val, uint8_t *buf)
{
buf[0] = val >> 24;
buf[1] = val >> 16 & 0xff;
buf[2] = val >> 8 & 0xff;
buf[3] = val & 0xff;
return 4;
}
int writeBigEndian2(uint16_t val, uint8_t *buf)
{
buf[0] = val >> 8 & 0xff;
buf[1] = val & 0xff;
return 2;
}
class MIDIHeader
{
// Class to encapsulate the MIDI header structure.
uint16_t numTracks;
uint16_t ticksPerBeat;
public:
MIDIHeader(uint16_t nTracks, uint16_t ticksPB=TICKSPERBEAT): numTracks(nTracks), ticksPerBeat(ticksPB) {}
inline int writeToBuffer(uint8_t *buffer, int start=0) const
{
// chunk ID
buffer[start++] = 'M'; buffer[start++] = 'T'; buffer[start++] = 'h'; buffer[start++] = 'd';
// chunk size (6 bytes always)
buffer[start++] = 0; buffer[start++] = 0; buffer[start++] = 0; buffer[start++] = 0x06;
// format: 1 (multitrack)
buffer[start++] = 0; buffer[start++] = 0x01;
start += writeBigEndian2(numTracks, buffer+start);
start += writeBigEndian2(ticksPerBeat, buffer+start);
return start;
}
};
struct Event
{
uint32_t time;
uint32_t tempo;
string trackName;
enum {NOTE_ON, NOTE_OFF, TEMPO, PROG_CHANGE, TRACK_NAME} type;
// TODO make a union to save up space
uint8_t pitch;
uint8_t programNumber;
uint8_t duration;
uint8_t volume;
uint8_t channel;
Event() {time=tempo=pitch=programNumber=duration=volume=channel=0; trackName="";}
inline int writeToBuffer(uint8_t *buffer) const
{
uint8_t code, fourbytes[4];
int size=0;
switch (type)
{
case NOTE_ON:
code = 0x9 << 4 | channel;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = pitch;
buffer[size++] = volume;
break;
case NOTE_OFF:
code = 0x8 << 4 | channel;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = pitch;
buffer[size++] = volume;
break;
case TEMPO:
code = 0xFF;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = 0x51;
buffer[size++] = 0x03;
writeBigEndian4(int(60000000.0 / tempo), fourbytes);
//printf("tempo of %x translates to ", tempo);
// for (int i=0; i<3; i++) printf("%02x ", fourbytes[i+1]);
// printf("\n");
buffer[size++] = fourbytes[1];
buffer[size++] = fourbytes[2];
buffer[size++] = fourbytes[3];
break;
case PROG_CHANGE:
code = 0xC << 4 | channel;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = programNumber;
break;
case TRACK_NAME:
size += writeVarLength(time, buffer+size);
buffer[size++] = 0xFF;
buffer[size++] = 0x03;
size += writeVarLength(trackName.size(), buffer+size);
trackName.copy((char *)(&buffer[size]), trackName.size());
size += trackName.size();
// buffer[size++] = '\0';
// buffer[size++] = '\0';
break;
}
return size;
} // writeEventsToBuffer
// events are sorted by their time
inline bool operator < (const Event& b) const {
return this->time < b.time;
}
};
template<const int MAX_TRACK_SIZE>
class MIDITrack
{
// A class that encapsulates a MIDI track
// Nested class definitions.
vector<Event> events;
public:
uint8_t channel;
MIDITrack(): channel(0) {}
inline void addEvent(const Event &e)
{
Event E = e;
events.push_back(E);
}
inline void addNote(uint8_t pitch, uint8_t volume, double time, double duration)
{
Event event; event.channel = channel;
event.volume = volume;
event.type = Event::NOTE_ON; event.pitch = pitch; event.time= (uint32_t) (time * TICKSPERBEAT);
addEvent(event);
event.type = Event::NOTE_OFF; event.pitch = pitch; event.time=(uint32_t) ((time+duration) * TICKSPERBEAT);
addEvent(event);
//printf("note: %d-%d\n", (uint32_t) time * TICKSPERBEAT, (uint32_t)((time+duration) * TICKSPERBEAT));
}
inline void addName(const string &name, uint32_t time)
{
Event event; event.channel = channel;
event.type = Event::TRACK_NAME; event.time=time; event.trackName = name;
addEvent(event);
}
inline void addProgramChange(uint8_t prog, uint32_t time)
{
Event event; event.channel = channel;
event.type = Event::PROG_CHANGE; event.time=time; event.programNumber = prog;
addEvent(event);
}
inline void addTempo(uint8_t tempo, uint32_t time)
{
Event event; event.channel = channel;
event.type = Event::TEMPO; event.time=time; event.tempo = tempo;
addEvent(event);
}
inline int writeMIDIToBuffer(uint8_t *buffer, int start=0) const
{
// Write the meta data and note data to the packed MIDI stream.
// Process the events in the eventList
start += writeEventsToBuffer(buffer, start);
// Write MIDI close event.
buffer[start++] = 0x00;
buffer[start++] = 0xFF;
buffer[start++] = 0x2F;
buffer[start++] = 0x00;
// return the entire length of the data and write to the header
return start;
}
inline int writeEventsToBuffer(uint8_t *buffer, int start=0) const
{
// Write the events in MIDIEvents to the MIDI stream.
vector<Event> _events = events;
std::sort(_events.begin(), _events.end());
vector<Event>::const_iterator it;
uint32_t time_last = 0, tmp;
for (it = _events.begin(); it!=_events.end(); ++it)
{
Event e = *it;
if (e.time < time_last){
printf("error: e.time=%d time_last=%d\n", e.time, time_last);
assert(false);
}
tmp = e.time;
e.time -= time_last;
time_last = tmp;
start += e.writeToBuffer(buffer+start);
if (start >= MAX_TRACK_SIZE) {
break;
}
}
return start;
}
inline int writeToBuffer(uint8_t *buffer, int start=0) const
{
uint8_t eventsBuffer[MAX_TRACK_SIZE];
uint32_t events_size = writeMIDIToBuffer(eventsBuffer);
//printf(">> track %lu events took 0x%x bytes\n", events.size(), events_size);
// chunk ID
buffer[start++] = 'M'; buffer[start++] = 'T'; buffer[start++] = 'r'; buffer[start++] = 'k';
// chunk size
start += writeBigEndian4(events_size, buffer+start);
// copy events data
memmove(buffer+start, eventsBuffer, events_size);
start += events_size;
return start;
}
};
}; // namespace
#endif
<commit_msg>adding license text<commit_after>#ifndef MIDIFILE_HPP
#define MIDIFILE_HPP
/**
* Name: MidiFile.hpp
* Purpose: C++ re-write of (parts of) the functionality provided by
* the python midutil module (https://code.google.com/p/midiutil/)
* by Mark Conway Wirt.
* Author: Mohamed Abdel Maksoud <mohamed at amaksoud.com>
* Created: 2015/02/11
* License:
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*-----------------------------------------------------------------------------
*/
#include <string.h>
#include <stdint.h>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <assert.h>
using std::string;
using std::vector;
using std::set;
namespace MidiFile
{
const int TICKSPERBEAT = 128;
int writeVarLength(uint32_t val, uint8_t *buffer)
{
/*
Accept an input, and write a MIDI-compatible variable length stream
The MIDI format is a little strange, and makes use of so-called variable
length quantities. These quantities are a stream of bytes. If the most
significant bit is 1, then more bytes follow. If it is zero, then the
byte in question is the last in the stream
*/
int size = 0;
uint8_t result, little_endian[4];
result = val & 0x7F;
little_endian[size++] = result;
val = val >> 7;
while (val > 0)
{
result = val & 0x7F;
result = result | 0x80;
little_endian[size++] = result;
val = val >> 7;
}
for (int i=0; i<size; i++)
{
buffer[i] = little_endian[size-i-1];
}
return size;
}
int writeBigEndian4(uint32_t val, uint8_t *buf)
{
buf[0] = val >> 24;
buf[1] = val >> 16 & 0xff;
buf[2] = val >> 8 & 0xff;
buf[3] = val & 0xff;
return 4;
}
int writeBigEndian2(uint16_t val, uint8_t *buf)
{
buf[0] = val >> 8 & 0xff;
buf[1] = val & 0xff;
return 2;
}
class MIDIHeader
{
// Class to encapsulate the MIDI header structure.
uint16_t numTracks;
uint16_t ticksPerBeat;
public:
MIDIHeader(uint16_t nTracks, uint16_t ticksPB=TICKSPERBEAT): numTracks(nTracks), ticksPerBeat(ticksPB) {}
inline int writeToBuffer(uint8_t *buffer, int start=0) const
{
// chunk ID
buffer[start++] = 'M'; buffer[start++] = 'T'; buffer[start++] = 'h'; buffer[start++] = 'd';
// chunk size (6 bytes always)
buffer[start++] = 0; buffer[start++] = 0; buffer[start++] = 0; buffer[start++] = 0x06;
// format: 1 (multitrack)
buffer[start++] = 0; buffer[start++] = 0x01;
start += writeBigEndian2(numTracks, buffer+start);
start += writeBigEndian2(ticksPerBeat, buffer+start);
return start;
}
};
struct Event
{
uint32_t time;
uint32_t tempo;
string trackName;
enum {NOTE_ON, NOTE_OFF, TEMPO, PROG_CHANGE, TRACK_NAME} type;
// TODO make a union to save up space
uint8_t pitch;
uint8_t programNumber;
uint8_t duration;
uint8_t volume;
uint8_t channel;
Event() {time=tempo=pitch=programNumber=duration=volume=channel=0; trackName="";}
inline int writeToBuffer(uint8_t *buffer) const
{
uint8_t code, fourbytes[4];
int size=0;
switch (type)
{
case NOTE_ON:
code = 0x9 << 4 | channel;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = pitch;
buffer[size++] = volume;
break;
case NOTE_OFF:
code = 0x8 << 4 | channel;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = pitch;
buffer[size++] = volume;
break;
case TEMPO:
code = 0xFF;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = 0x51;
buffer[size++] = 0x03;
writeBigEndian4(int(60000000.0 / tempo), fourbytes);
//printf("tempo of %x translates to ", tempo);
// for (int i=0; i<3; i++) printf("%02x ", fourbytes[i+1]);
// printf("\n");
buffer[size++] = fourbytes[1];
buffer[size++] = fourbytes[2];
buffer[size++] = fourbytes[3];
break;
case PROG_CHANGE:
code = 0xC << 4 | channel;
size += writeVarLength(time, buffer+size);
buffer[size++] = code;
buffer[size++] = programNumber;
break;
case TRACK_NAME:
size += writeVarLength(time, buffer+size);
buffer[size++] = 0xFF;
buffer[size++] = 0x03;
size += writeVarLength(trackName.size(), buffer+size);
trackName.copy((char *)(&buffer[size]), trackName.size());
size += trackName.size();
// buffer[size++] = '\0';
// buffer[size++] = '\0';
break;
}
return size;
} // writeEventsToBuffer
// events are sorted by their time
inline bool operator < (const Event& b) const {
return this->time < b.time;
}
};
template<const int MAX_TRACK_SIZE>
class MIDITrack
{
// A class that encapsulates a MIDI track
// Nested class definitions.
vector<Event> events;
public:
uint8_t channel;
MIDITrack(): channel(0) {}
inline void addEvent(const Event &e)
{
Event E = e;
events.push_back(E);
}
inline void addNote(uint8_t pitch, uint8_t volume, double time, double duration)
{
Event event; event.channel = channel;
event.volume = volume;
event.type = Event::NOTE_ON; event.pitch = pitch; event.time= (uint32_t) (time * TICKSPERBEAT);
addEvent(event);
event.type = Event::NOTE_OFF; event.pitch = pitch; event.time=(uint32_t) ((time+duration) * TICKSPERBEAT);
addEvent(event);
//printf("note: %d-%d\n", (uint32_t) time * TICKSPERBEAT, (uint32_t)((time+duration) * TICKSPERBEAT));
}
inline void addName(const string &name, uint32_t time)
{
Event event; event.channel = channel;
event.type = Event::TRACK_NAME; event.time=time; event.trackName = name;
addEvent(event);
}
inline void addProgramChange(uint8_t prog, uint32_t time)
{
Event event; event.channel = channel;
event.type = Event::PROG_CHANGE; event.time=time; event.programNumber = prog;
addEvent(event);
}
inline void addTempo(uint8_t tempo, uint32_t time)
{
Event event; event.channel = channel;
event.type = Event::TEMPO; event.time=time; event.tempo = tempo;
addEvent(event);
}
inline int writeMIDIToBuffer(uint8_t *buffer, int start=0) const
{
// Write the meta data and note data to the packed MIDI stream.
// Process the events in the eventList
start += writeEventsToBuffer(buffer, start);
// Write MIDI close event.
buffer[start++] = 0x00;
buffer[start++] = 0xFF;
buffer[start++] = 0x2F;
buffer[start++] = 0x00;
// return the entire length of the data and write to the header
return start;
}
inline int writeEventsToBuffer(uint8_t *buffer, int start=0) const
{
// Write the events in MIDIEvents to the MIDI stream.
vector<Event> _events = events;
std::sort(_events.begin(), _events.end());
vector<Event>::const_iterator it;
uint32_t time_last = 0, tmp;
for (it = _events.begin(); it!=_events.end(); ++it)
{
Event e = *it;
if (e.time < time_last){
printf("error: e.time=%d time_last=%d\n", e.time, time_last);
assert(false);
}
tmp = e.time;
e.time -= time_last;
time_last = tmp;
start += e.writeToBuffer(buffer+start);
if (start >= MAX_TRACK_SIZE) {
break;
}
}
return start;
}
inline int writeToBuffer(uint8_t *buffer, int start=0) const
{
uint8_t eventsBuffer[MAX_TRACK_SIZE];
uint32_t events_size = writeMIDIToBuffer(eventsBuffer);
//printf(">> track %lu events took 0x%x bytes\n", events.size(), events_size);
// chunk ID
buffer[start++] = 'M'; buffer[start++] = 'T'; buffer[start++] = 'r'; buffer[start++] = 'k';
// chunk size
start += writeBigEndian4(events_size, buffer+start);
// copy events data
memmove(buffer+start, eventsBuffer, events_size);
start += events_size;
return start;
}
};
}; // namespace
#endif
<|endoftext|> |
<commit_before>/*************************************************************************
*
* $RCSfile: sbintern.cxx,v $
*
* $Revision: 1.5 $
*
* last change: $Author: obo $ $Date: 2004-03-17 13:32:02 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef _SHL_HXX //autogen
#include <tools/shl.hxx>
#endif
#include "sbintern.hxx"
#include "sbunoobj.hxx"
#include "token.hxx" // Tokenizer
#include "symtbl.hxx" // Symbolverwaltung
#include "parser.hxx" // Parser
#include "codegen.hxx" // Code-Generator
#pragma hdrstop
SV_IMPL_PTRARR(SbErrorStack, SbErrorStackEntry*)
SbiGlobals* GetSbData()
{
SbiGlobals** pp = (SbiGlobals**) ::GetAppData( SHL_SBC );
SbiGlobals* p = *pp;
if( !p )
p = *pp = new SbiGlobals;
return p;
}
SbiGlobals::SbiGlobals()
{
pInst = NULL;
pMod = NULL;
pSbFac= NULL;
pUnoFac = NULL;
pTypeFac = NULL;
pOLEFac = NULL;
pCompMod = NULL; // JSM
nInst = 0;
nCode = 0;
nLine = 0;
nCol1 = nCol2 = 0;
bCompiler = FALSE;
bGlobalInitErr = FALSE;
bRunInit = FALSE;
eLanguageMode = SB_LANG_BASIC;
pErrStack = NULL;
pTransliterationWrapper = NULL;
bBlockCompilerError = FALSE;
}
SbiGlobals::~SbiGlobals()
{
delete pErrStack;
delete pSbFac;
delete pUnoFac;
delete pTransliterationWrapper;
}
<commit_msg>INTEGRATION: CWS xmlbasic (1.5.60); FILE MERGED 2004/10/21 10:24:39 tbe 1.5.60.1: #i22747# XML filter adaptors and macros<commit_after>/*************************************************************************
*
* $RCSfile: sbintern.cxx,v $
*
* $Revision: 1.6 $
*
* last change: $Author: hr $ $Date: 2004-11-09 12:24:33 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef _SHL_HXX //autogen
#include <tools/shl.hxx>
#endif
#include "sbintern.hxx"
#include "sbunoobj.hxx"
#include "token.hxx" // Tokenizer
#include "symtbl.hxx" // Symbolverwaltung
#include "parser.hxx" // Parser
#include "codegen.hxx" // Code-Generator
#include "basmgr.hxx"
#pragma hdrstop
SV_IMPL_PTRARR(SbErrorStack, SbErrorStackEntry*)
SbiGlobals* GetSbData()
{
SbiGlobals** pp = (SbiGlobals**) ::GetAppData( SHL_SBC );
SbiGlobals* p = *pp;
if( !p )
p = *pp = new SbiGlobals;
return p;
}
SbiGlobals::SbiGlobals()
{
pInst = NULL;
pMod = NULL;
pSbFac= NULL;
pUnoFac = NULL;
pTypeFac = NULL;
pOLEFac = NULL;
pCompMod = NULL; // JSM
nInst = 0;
nCode = 0;
nLine = 0;
nCol1 = nCol2 = 0;
bCompiler = FALSE;
bGlobalInitErr = FALSE;
bRunInit = FALSE;
eLanguageMode = SB_LANG_BASIC;
pErrStack = NULL;
pTransliterationWrapper = NULL;
bBlockCompilerError = FALSE;
pAppBasMgr = NULL;
}
SbiGlobals::~SbiGlobals()
{
delete pErrStack;
delete pSbFac;
delete pUnoFac;
delete pTransliterationWrapper;
}
<|endoftext|> |
<commit_before>// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <[email protected]>
//
// 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"
template<typename MatrixType> void verifySizeOf(const MatrixType&)
{
typedef typename MatrixType::Scalar Scalar;
if (MatrixType::RowsAtCompileTime!=Dynamic && MatrixType::ColsAtCompileTime!=Dynamic)
VERIFY(sizeof(MatrixType)==static_cast<int>(sizeof(Scalar))*MatrixType::SizeAtCompileTime);
else
VERIFY(sizeof(MatrixType)==sizeof(Scalar*) + 2 * sizeof(typename MatrixType::Index));
}
void test_sizeof()
{
CALL_SUBTEST(verifySizeOf(Matrix<float, 1, 1>()) );
CALL_SUBTEST(verifySizeOf(Matrix4d()) );
CALL_SUBTEST(verifySizeOf(Matrix<double, 4, 2>()) );
CALL_SUBTEST(verifySizeOf(Matrix<bool, 7, 5>()) );
CALL_SUBTEST(verifySizeOf(MatrixXcf(3, 3)) );
CALL_SUBTEST(verifySizeOf(MatrixXi(8, 12)) );
CALL_SUBTEST(verifySizeOf(MatrixXcd(20, 20)) );
CALL_SUBTEST(verifySizeOf(Matrix<float, 100, 100>()) );
VERIFY(sizeof(std::complex<float>) == 2*sizeof(float));
VERIFY(sizeof(std::complex<double>) == 2*sizeof(double));
}
<commit_msg>fix icc warning #68<commit_after>// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <[email protected]>
//
// 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"
template<typename MatrixType> void verifySizeOf(const MatrixType&)
{
typedef typename MatrixType::Scalar Scalar;
if (MatrixType::RowsAtCompileTime!=Dynamic && MatrixType::ColsAtCompileTime!=Dynamic)
VERIFY(sizeof(MatrixType)==sizeof(Scalar)*size_t(MatrixType::SizeAtCompileTime));
else
VERIFY(sizeof(MatrixType)==sizeof(Scalar*) + 2 * sizeof(typename MatrixType::Index));
}
void test_sizeof()
{
CALL_SUBTEST(verifySizeOf(Matrix<float, 1, 1>()) );
CALL_SUBTEST(verifySizeOf(Matrix4d()) );
CALL_SUBTEST(verifySizeOf(Matrix<double, 4, 2>()) );
CALL_SUBTEST(verifySizeOf(Matrix<bool, 7, 5>()) );
CALL_SUBTEST(verifySizeOf(MatrixXcf(3, 3)) );
CALL_SUBTEST(verifySizeOf(MatrixXi(8, 12)) );
CALL_SUBTEST(verifySizeOf(MatrixXcd(20, 20)) );
CALL_SUBTEST(verifySizeOf(Matrix<float, 100, 100>()) );
VERIFY(sizeof(std::complex<float>) == 2*sizeof(float));
VERIFY(sizeof(std::complex<double>) == 2*sizeof(double));
}
<|endoftext|> |
<commit_before>#include "io.cpp"
#include <iostream>
using namespace std;
int main()
{
<<<<<<< HEAD
cout << "პირველი C++ პროგრამა\n";
read_file ();
=======
cout << "პირველი С++ პროგრამა\n";
>>>>>>> 9affd72bff47a4fee0bc1ca2b8dc189478691479
cin.get();
}
<commit_msg>კიდევ რაღაც წავშალე<commit_after>#include "io.cpp"
#include <iostream>
using namespace std;
int main()
{
cout << "პირველი C++ პროგრამა\n";
cin.get();
}
<|endoftext|> |
<commit_before>/***************************************************************************
* Copyright (C) 1998-2010 by authors (see AUTHORS.txt ) *
* *
* This file is part of LuxRays. *
* *
* LuxRays is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* LuxRays is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* LuxRays website: http://www.luxrender.net *
***************************************************************************/
#include "renderconfig.h"
string SLG_LABEL = "SmallLuxGPU v" SLG_VERSION_MAJOR "." SLG_VERSION_MINOR " (LuxRays demo: http://www.luxrender.net)";
RenderingConfig::RenderingConfig(const bool lowLatency, const string &sceneFileName, const unsigned int w,
const unsigned int h, const unsigned int nativeThreadCount,
const bool useCPUs, const bool useGPUs,
const unsigned int forceGPUWorkSize) {
screenRefreshInterval = 100;
Init(lowLatency, sceneFileName, w, h, nativeThreadCount, useCPUs, useGPUs,
forceGPUWorkSize, 3);
}
RenderingConfig::RenderingConfig(const string &fileName) {
cerr << "Reading configuration file: " << fileName << endl;
cfg.LoadFile(fileName);
cerr << "Configuration: " << endl;
vector<string> keys = cfg.GetAllKeys();
for (vector<string>::iterator i = keys.begin(); i != keys.end(); ++i)
cerr << " " << *i << " = " << cfg.GetString(*i, "") << endl;
}
RenderingConfig::~RenderingConfig() {
StopAllRenderThreads();
for (size_t i = 0; i < renderThreads.size(); ++i)
delete renderThreads[i];
delete ctx;
delete scene;
delete film;
}
void RenderingConfig::Init() {
const bool lowLatency = cfg.GetInt("opencl.latency.mode", 1);
const string sceneFileName = cfg.GetString("scene.file", "scenes/luxball.scn");
const unsigned int w = cfg.GetInt("image.width", 640);
const unsigned int h = cfg.GetInt("image.height", 480);
const unsigned int nativeThreadCount = cfg.GetInt("opencl.nativethread.count", 2);
const bool useCPUs = (cfg.GetInt("opencl.cpu.use", 0) == 1);
const bool useGPUs = (cfg.GetInt("opencl.gpu.use", 1) == 1);
const unsigned int forceGPUWorkSize = cfg.GetInt("opencl.gpu.workgroup.size", 64);
const unsigned int filmType = cfg.GetInt("screen.type",3 );
const unsigned int oclPlatformIndex = cfg.GetInt("opencl.platform.index", 0);
const string oclDeviceConfig = cfg.GetString("opencl.devices.select", "");
const unsigned int oclDeviceThreads = cfg.GetInt("opencl.renderthread.count", 0);
screenRefreshInterval = cfg.GetInt("screen.refresh.interval", 100);
Init(lowLatency, sceneFileName, w, h, nativeThreadCount,
useCPUs, useGPUs, forceGPUWorkSize, filmType,
oclPlatformIndex, oclDeviceThreads, oclDeviceConfig);
StopAllRenderThreads();
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->ClearPaths();
scene->camera->fieldOfView = cfg.GetFloat("scene.fieldofview", 45.f);
scene->maxPathDepth = cfg.GetInt("path.maxdepth", 3);
scene->shadowRayCount = cfg.GetInt("path.shadowrays", 1);
scene->rrDepth = cfg.GetInt("path.russianroulette.depth", scene->rrDepth);
scene->rrProb = cfg.GetInt("path.russianroulette.prob", scene->rrProb);
StartAllRenderThreads();
}
void RenderingConfig::Init(const bool lowLatency, const string &sceneFileName, const unsigned int w,
const unsigned int h, const unsigned int nativeThreadCount,
const bool useCPUs, const bool useGPUs,
const unsigned int forceGPUWorkSize, const unsigned int filmType,
const unsigned int oclPlatformIndex,
const unsigned int oclDeviceThreads, const string &oclDeviceConfig) {
captionBuffer[0] = '\0';
// Create LuxRays context
ctx = new Context(DebugHandler ,oclPlatformIndex);
// Create the scene
switch (filmType) {
case 0:
cerr << "Film type: StandardFilm" << endl;
film = new StandardFilm(lowLatency, w, h);
break;
case 1:
cerr << "Film type: BluredStandardFilm" << endl;
film = new BluredStandardFilm(lowLatency, w, h);
break;
case 2:
cerr << "Film type: GaussianFilm" << endl;
film = new GaussianFilm(lowLatency, w, h);
break;
case 3:
cerr << "Film type: FastGaussianFilm" << endl;
film = new FastGaussianFilm(lowLatency, w, h);
break;
default:
throw runtime_error("Requested an unknown film type");
}
scene = new Scene(ctx, lowLatency, sceneFileName, film);
// Start OpenCL devices
SetUpOpenCLDevices(lowLatency, useCPUs, useGPUs, forceGPUWorkSize, oclDeviceThreads, oclDeviceConfig);
// Start Native threads
SetUpNativeDevices(nativeThreadCount);
const size_t deviceCount = intersectionCPUDevices.size() + intersectionGPUDevices.size();
if (deviceCount <= 0)
throw runtime_error("Unable to find any appropiate IntersectionDevice");
intersectionCPUGPUDevices.resize(deviceCount);
if (intersectionGPUDevices.size() > 0)
copy(intersectionGPUDevices.begin(), intersectionGPUDevices.end(),
intersectionCPUGPUDevices.begin());
if (intersectionCPUDevices.size() > 0)
copy(intersectionCPUDevices.begin(), intersectionCPUDevices.end(),
intersectionCPUGPUDevices.begin() + intersectionGPUDevices.size());
// Set the Luxrays SataSet
ctx->SetDataSet(scene->dataSet);
intersectionAllDevices = ctx->GetIntersectionDevices();
// Create and start render threads
size_t renderThreadCount = intersectionAllDevices.size();
cerr << "Starting "<< renderThreadCount << " render threads" << endl;
for (size_t i = 0; i < renderThreadCount; ++i) {
if (intersectionAllDevices[i]->GetType() == DEVICE_TYPE_NATIVE_THREAD) {
NativeRenderThread *t = new NativeRenderThread(i,
(NativeThreadIntersectionDevice *)intersectionAllDevices[i], scene, lowLatency);
renderThreads.push_back(t);
} else {
DeviceRenderThread *t = new DeviceRenderThread(i,
intersectionAllDevices[i], scene, lowLatency);
renderThreads.push_back(t);
}
}
film->StartSampleTime();
StartAllRenderThreads();
}
void RenderingConfig::ReInit(const bool reallocBuffers, const unsigned int w, unsigned int h) {
// First stop all devices
StopAllRenderThreads();
// Check if I have to reallocate buffers
if (reallocBuffers)
film->Init(w, h);
else
film->Reset();
scene->camera->Update();
// Restart all devices
StartAllRenderThreads();
}
void RenderingConfig::SetMaxPathDepth(const int delta) {
// First stop all devices
StopAllRenderThreads();
film->Reset();
scene->maxPathDepth = max<unsigned int>(2, scene->maxPathDepth + delta);
// Restart all devices
StartAllRenderThreads();
}
void RenderingConfig::SetShadowRays(const int delta) {
// First stop all devices
StopAllRenderThreads();
scene->shadowRayCount = max<unsigned int>(1, scene->shadowRayCount + delta);
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->ClearPaths();
// Restart all devices
StartAllRenderThreads();
}
void RenderingConfig::SetUpOpenCLDevices(const bool lowLatency, const bool useCPUs, const bool useGPUs,
const unsigned int forceGPUWorkSize, const unsigned int oclDeviceThreads, const string &oclDeviceConfig) {
std::vector<DeviceDescription *> descs = ctx->GetAvailableDeviceDescriptions();
DeviceDescription::Filter(DEVICE_TYPE_OPENCL, descs);
// Device info
bool haveSelectionString = (oclDeviceConfig.length() > 0);
if (haveSelectionString && (oclDeviceConfig.length() != descs.size())) {
stringstream ss;
ss << "OpenCL device selection string has the wrong length, must be " <<
descs.size() << " instead of " << oclDeviceConfig.length();
throw runtime_error(ss.str().c_str());
}
std::vector<DeviceDescription *> selectedDescs;
for (size_t i = 0; i < descs.size(); ++i) {
OpenCLDeviceDescription *desc = (OpenCLDeviceDescription *)descs[i];
if (haveSelectionString) {
if (oclDeviceConfig.at(i) == '1') {
if (desc->GetOpenCLType() == OCL_DEVICE_TYPE_GPU)
desc->SetForceWorkGroupSize(forceGPUWorkSize);
selectedDescs.push_back(desc);
}
} else {
if ((useCPUs && desc->GetOpenCLType() == OCL_DEVICE_TYPE_CPU) ||
(useGPUs && desc->GetOpenCLType() == OCL_DEVICE_TYPE_GPU)) {
if (desc->GetOpenCLType() == OCL_DEVICE_TYPE_GPU)
desc->SetForceWorkGroupSize(forceGPUWorkSize);
selectedDescs.push_back(descs[i]);
}
}
}
if (selectedDescs.size() == 0)
cerr << "No OpenCL device selected" << endl;
else {
// Allocate devices
const size_t gpuRenderThreadCount = ((oclDeviceThreads < 1) || (selectedDescs.size() == 0)) ?
(2 * selectedDescs.size()) : oclDeviceThreads;
if ((oclDeviceThreads == 1) && (selectedDescs.size() == 1)) {
// Optimize the special case of one render thread and one GPU
intersectionGPUDevices = ctx->AddIntersectionDevices(selectedDescs);
} else if ((oclDeviceThreads > 1) && (selectedDescs.size() == 1)) {
// Optimize the special case of many render thread and one GPU
intersectionGPUDevices = ctx->AddVirtualM2OIntersectionDevices(gpuRenderThreadCount, selectedDescs);
} else {
// Create and start the virtual devices (only if there is more than one GPUs)
intersectionGPUDevices = ctx->AddVirtualM2MIntersectionDevices(gpuRenderThreadCount, selectedDescs);
}
cerr << "OpenCL Devices used: ";
for (size_t i = 0; i < intersectionGPUDevices.size(); ++i)
cerr << "[" << intersectionGPUDevices[i]->GetName() << "]";
cerr << endl;
}
}
void RenderingConfig::SetUpNativeDevices(const unsigned int nativeThreadCount) {
std::vector<DeviceDescription *> descs = ctx->GetAvailableDeviceDescriptions();
DeviceDescription::Filter(DEVICE_TYPE_NATIVE_THREAD, descs);
std::vector<DeviceDescription *> selectedDescs;
for (size_t i = 0; i < nativeThreadCount; ++i) {
if (i < descs.size())
selectedDescs.push_back(descs[i]);
else
selectedDescs.push_back(descs[descs.size() - 1]);
}
if (selectedDescs.size() == 0)
cerr << "No Native thread device selected" << endl;
else {
// Allocate devices
intersectionCPUDevices = ctx->AddIntersectionDevices(selectedDescs);
cerr << "Native Devices used: ";
for (size_t i = 0; i < intersectionCPUDevices.size(); ++i)
cerr << "[" << intersectionCPUDevices[i]->GetName() << "]";
cerr << endl;
}
}
void RenderingConfig::StartAllRenderThreads() {
ctx->Start();
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->Start();
}
void RenderingConfig::StopAllRenderThreads() {
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->Interrupt();
ctx->Interrupt();
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->Stop();
ctx->Stop();
}
<commit_msg>Using virtual devices only if required<commit_after>/***************************************************************************
* Copyright (C) 1998-2010 by authors (see AUTHORS.txt ) *
* *
* This file is part of LuxRays. *
* *
* LuxRays is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 3 of the License, or *
* (at your option) any later version. *
* *
* LuxRays is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
* LuxRays website: http://www.luxrender.net *
***************************************************************************/
#include "renderconfig.h"
string SLG_LABEL = "SmallLuxGPU v" SLG_VERSION_MAJOR "." SLG_VERSION_MINOR " (LuxRays demo: http://www.luxrender.net)";
RenderingConfig::RenderingConfig(const bool lowLatency, const string &sceneFileName, const unsigned int w,
const unsigned int h, const unsigned int nativeThreadCount,
const bool useCPUs, const bool useGPUs,
const unsigned int forceGPUWorkSize) {
screenRefreshInterval = 100;
Init(lowLatency, sceneFileName, w, h, nativeThreadCount, useCPUs, useGPUs,
forceGPUWorkSize, 3);
}
RenderingConfig::RenderingConfig(const string &fileName) {
cerr << "Reading configuration file: " << fileName << endl;
cfg.LoadFile(fileName);
cerr << "Configuration: " << endl;
vector<string> keys = cfg.GetAllKeys();
for (vector<string>::iterator i = keys.begin(); i != keys.end(); ++i)
cerr << " " << *i << " = " << cfg.GetString(*i, "") << endl;
}
RenderingConfig::~RenderingConfig() {
StopAllRenderThreads();
for (size_t i = 0; i < renderThreads.size(); ++i)
delete renderThreads[i];
delete ctx;
delete scene;
delete film;
}
void RenderingConfig::Init() {
const bool lowLatency = cfg.GetInt("opencl.latency.mode", 1);
const string sceneFileName = cfg.GetString("scene.file", "scenes/luxball.scn");
const unsigned int w = cfg.GetInt("image.width", 640);
const unsigned int h = cfg.GetInt("image.height", 480);
const unsigned int nativeThreadCount = cfg.GetInt("opencl.nativethread.count", 2);
const bool useCPUs = (cfg.GetInt("opencl.cpu.use", 0) == 1);
const bool useGPUs = (cfg.GetInt("opencl.gpu.use", 1) == 1);
const unsigned int forceGPUWorkSize = cfg.GetInt("opencl.gpu.workgroup.size", 64);
const unsigned int filmType = cfg.GetInt("screen.type",3 );
const unsigned int oclPlatformIndex = cfg.GetInt("opencl.platform.index", 0);
const string oclDeviceConfig = cfg.GetString("opencl.devices.select", "");
const unsigned int oclDeviceThreads = cfg.GetInt("opencl.renderthread.count", 0);
screenRefreshInterval = cfg.GetInt("screen.refresh.interval", 100);
Init(lowLatency, sceneFileName, w, h, nativeThreadCount,
useCPUs, useGPUs, forceGPUWorkSize, filmType,
oclPlatformIndex, oclDeviceThreads, oclDeviceConfig);
StopAllRenderThreads();
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->ClearPaths();
scene->camera->fieldOfView = cfg.GetFloat("scene.fieldofview", 45.f);
scene->maxPathDepth = cfg.GetInt("path.maxdepth", 3);
scene->shadowRayCount = cfg.GetInt("path.shadowrays", 1);
scene->rrDepth = cfg.GetInt("path.russianroulette.depth", scene->rrDepth);
scene->rrProb = cfg.GetInt("path.russianroulette.prob", scene->rrProb);
StartAllRenderThreads();
}
void RenderingConfig::Init(const bool lowLatency, const string &sceneFileName, const unsigned int w,
const unsigned int h, const unsigned int nativeThreadCount,
const bool useCPUs, const bool useGPUs,
const unsigned int forceGPUWorkSize, const unsigned int filmType,
const unsigned int oclPlatformIndex,
const unsigned int oclDeviceThreads, const string &oclDeviceConfig) {
captionBuffer[0] = '\0';
// Create LuxRays context
ctx = new Context(DebugHandler ,oclPlatformIndex);
// Create the scene
switch (filmType) {
case 0:
cerr << "Film type: StandardFilm" << endl;
film = new StandardFilm(lowLatency, w, h);
break;
case 1:
cerr << "Film type: BluredStandardFilm" << endl;
film = new BluredStandardFilm(lowLatency, w, h);
break;
case 2:
cerr << "Film type: GaussianFilm" << endl;
film = new GaussianFilm(lowLatency, w, h);
break;
case 3:
cerr << "Film type: FastGaussianFilm" << endl;
film = new FastGaussianFilm(lowLatency, w, h);
break;
default:
throw runtime_error("Requested an unknown film type");
}
scene = new Scene(ctx, lowLatency, sceneFileName, film);
// Start OpenCL devices
SetUpOpenCLDevices(lowLatency, useCPUs, useGPUs, forceGPUWorkSize, oclDeviceThreads, oclDeviceConfig);
// Start Native threads
SetUpNativeDevices(nativeThreadCount);
const size_t deviceCount = intersectionCPUDevices.size() + intersectionGPUDevices.size();
if (deviceCount <= 0)
throw runtime_error("Unable to find any appropiate IntersectionDevice");
intersectionCPUGPUDevices.resize(deviceCount);
if (intersectionGPUDevices.size() > 0)
copy(intersectionGPUDevices.begin(), intersectionGPUDevices.end(),
intersectionCPUGPUDevices.begin());
if (intersectionCPUDevices.size() > 0)
copy(intersectionCPUDevices.begin(), intersectionCPUDevices.end(),
intersectionCPUGPUDevices.begin() + intersectionGPUDevices.size());
// Set the Luxrays SataSet
ctx->SetDataSet(scene->dataSet);
intersectionAllDevices = ctx->GetIntersectionDevices();
// Create and start render threads
size_t renderThreadCount = intersectionAllDevices.size();
cerr << "Starting "<< renderThreadCount << " render threads" << endl;
for (size_t i = 0; i < renderThreadCount; ++i) {
if (intersectionAllDevices[i]->GetType() == DEVICE_TYPE_NATIVE_THREAD) {
NativeRenderThread *t = new NativeRenderThread(i,
(NativeThreadIntersectionDevice *)intersectionAllDevices[i], scene, lowLatency);
renderThreads.push_back(t);
} else {
DeviceRenderThread *t = new DeviceRenderThread(i,
intersectionAllDevices[i], scene, lowLatency);
renderThreads.push_back(t);
}
}
film->StartSampleTime();
StartAllRenderThreads();
}
void RenderingConfig::ReInit(const bool reallocBuffers, const unsigned int w, unsigned int h) {
// First stop all devices
StopAllRenderThreads();
// Check if I have to reallocate buffers
if (reallocBuffers)
film->Init(w, h);
else
film->Reset();
scene->camera->Update();
// Restart all devices
StartAllRenderThreads();
}
void RenderingConfig::SetMaxPathDepth(const int delta) {
// First stop all devices
StopAllRenderThreads();
film->Reset();
scene->maxPathDepth = max<unsigned int>(2, scene->maxPathDepth + delta);
// Restart all devices
StartAllRenderThreads();
}
void RenderingConfig::SetShadowRays(const int delta) {
// First stop all devices
StopAllRenderThreads();
scene->shadowRayCount = max<unsigned int>(1, scene->shadowRayCount + delta);
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->ClearPaths();
// Restart all devices
StartAllRenderThreads();
}
void RenderingConfig::SetUpOpenCLDevices(const bool lowLatency, const bool useCPUs, const bool useGPUs,
const unsigned int forceGPUWorkSize, const unsigned int oclDeviceThreads, const string &oclDeviceConfig) {
std::vector<DeviceDescription *> descs = ctx->GetAvailableDeviceDescriptions();
DeviceDescription::Filter(DEVICE_TYPE_OPENCL, descs);
// Device info
bool haveSelectionString = (oclDeviceConfig.length() > 0);
if (haveSelectionString && (oclDeviceConfig.length() != descs.size())) {
stringstream ss;
ss << "OpenCL device selection string has the wrong length, must be " <<
descs.size() << " instead of " << oclDeviceConfig.length();
throw runtime_error(ss.str().c_str());
}
std::vector<DeviceDescription *> selectedDescs;
for (size_t i = 0; i < descs.size(); ++i) {
OpenCLDeviceDescription *desc = (OpenCLDeviceDescription *)descs[i];
if (haveSelectionString) {
if (oclDeviceConfig.at(i) == '1') {
if (desc->GetOpenCLType() == OCL_DEVICE_TYPE_GPU)
desc->SetForceWorkGroupSize(forceGPUWorkSize);
selectedDescs.push_back(desc);
}
} else {
if ((useCPUs && desc->GetOpenCLType() == OCL_DEVICE_TYPE_CPU) ||
(useGPUs && desc->GetOpenCLType() == OCL_DEVICE_TYPE_GPU)) {
if (desc->GetOpenCLType() == OCL_DEVICE_TYPE_GPU)
desc->SetForceWorkGroupSize(forceGPUWorkSize);
selectedDescs.push_back(descs[i]);
}
}
}
if (selectedDescs.size() == 0)
cerr << "No OpenCL device selected" << endl;
else {
// Allocate devices
const size_t gpuRenderThreadCount = (oclDeviceThreads < 1) ?
(2 * selectedDescs.size()) : oclDeviceThreads;
if ((gpuRenderThreadCount == 1) && (selectedDescs.size() == 1)) {
// Optimize the special case of one render thread and one GPU
intersectionGPUDevices = ctx->AddIntersectionDevices(selectedDescs);
} else if ((gpuRenderThreadCount > 1) && (selectedDescs.size() == 1)) {
// Optimize the special case of many render thread and one GPU
intersectionGPUDevices = ctx->AddVirtualM2OIntersectionDevices(gpuRenderThreadCount, selectedDescs);
} else {
// Create and start the virtual devices (only if there is more than one GPUs)
intersectionGPUDevices = ctx->AddVirtualM2MIntersectionDevices(gpuRenderThreadCount, selectedDescs);
}
cerr << "OpenCL Devices used: ";
for (size_t i = 0; i < intersectionGPUDevices.size(); ++i)
cerr << "[" << intersectionGPUDevices[i]->GetName() << "]";
cerr << endl;
}
}
void RenderingConfig::SetUpNativeDevices(const unsigned int nativeThreadCount) {
std::vector<DeviceDescription *> descs = ctx->GetAvailableDeviceDescriptions();
DeviceDescription::Filter(DEVICE_TYPE_NATIVE_THREAD, descs);
std::vector<DeviceDescription *> selectedDescs;
for (size_t i = 0; i < nativeThreadCount; ++i) {
if (i < descs.size())
selectedDescs.push_back(descs[i]);
else
selectedDescs.push_back(descs[descs.size() - 1]);
}
if (selectedDescs.size() == 0)
cerr << "No Native thread device selected" << endl;
else {
// Allocate devices
intersectionCPUDevices = ctx->AddIntersectionDevices(selectedDescs);
cerr << "Native Devices used: ";
for (size_t i = 0; i < intersectionCPUDevices.size(); ++i)
cerr << "[" << intersectionCPUDevices[i]->GetName() << "]";
cerr << endl;
}
}
void RenderingConfig::StartAllRenderThreads() {
ctx->Start();
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->Start();
}
void RenderingConfig::StopAllRenderThreads() {
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->Interrupt();
ctx->Interrupt();
for (size_t i = 0; i < renderThreads.size(); ++i)
renderThreads[i]->Stop();
ctx->Stop();
}
<|endoftext|> |
<commit_before>// Copyright (c) 2020 by Robert Bosch GmbH. 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 "iceoryx_posh/internal/popo/building_blocks/chunk_receiver.hpp"
#include "iceoryx_posh/internal/log/posh_logging.hpp"
#include "iceoryx_utils/error_handling/error_handling.hpp"
namespace iox
{
namespace popo
{
ChunkReceiver::ChunkReceiver(cxx::not_null<MemberType_t* const> chunkReceiverDataPtr) noexcept
: ChunkQueuePopper(static_cast<ChunkQueuePopper::MemberType_t* const>(chunkReceiverDataPtr))
{
}
const ChunkReceiver::MemberType_t* ChunkReceiver::getMembers() const noexcept
{
return reinterpret_cast<const MemberType_t*>(ChunkQueuePopper::getMembers());
}
ChunkReceiver::MemberType_t* ChunkReceiver::getMembers() noexcept
{
return reinterpret_cast<MemberType_t*>(ChunkQueuePopper::getMembers());
}
cxx::expected<cxx::optional<const mepoo::ChunkHeader*>, ChunkReceiverError> ChunkReceiver::get() noexcept
{
auto popRet = this->pop();
if (popRet.has_value())
{
auto sharedChunk = *popRet;
// if the application holds too many chunks, don't provide more
if (getMembers()->m_chunksInUse.insert(sharedChunk))
{
return cxx::success<cxx::optional<const mepoo::ChunkHeader*>>(sharedChunk.getChunkHeader());
}
else
{
// release the chunk
sharedChunk = nullptr;
return cxx::error<ChunkReceiverError>(ChunkReceiverError::TOO_MANY_CHUNKS_HELD_IN_PARALLEL);
}
}
else
{
// no new chunk
return cxx::success<cxx::optional<const mepoo::ChunkHeader*>>(cxx::nullopt_t());
}
}
void ChunkReceiver::release(const mepoo::ChunkHeader* chunkHeader) noexcept
{
mepoo::SharedChunk chunk(nullptr);
if (!getMembers()->m_chunksInUse.remove(chunkHeader, chunk))
{
errorHandler(Error::kPOPO__CHUNK_RECEIVER_INVALID_CHUNK_TO_RELEASE_FROM_USER, nullptr, ErrorLevel::SEVERE);
}
}
void ChunkReceiver::releaseAll() noexcept
{
getMembers()->m_chunksInUse.cleanup();
this->clear();
}
} // namespace popo
} // namespace iox
<commit_msg>iox-#157: fixed syntax error by adding a const cast<commit_after>// Copyright (c) 2020 by Robert Bosch GmbH. 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 "iceoryx_posh/internal/popo/building_blocks/chunk_receiver.hpp"
#include "iceoryx_posh/internal/log/posh_logging.hpp"
#include "iceoryx_utils/error_handling/error_handling.hpp"
namespace iox
{
namespace popo
{
ChunkReceiver::ChunkReceiver(cxx::not_null<MemberType_t* const> chunkReceiverDataPtr) noexcept
: ChunkQueuePopper(static_cast<ChunkQueuePopper::MemberType_t* const>(chunkReceiverDataPtr))
{
}
const ChunkReceiver::MemberType_t* ChunkReceiver::getMembers() const noexcept
{
return reinterpret_cast<const MemberType_t*>(ChunkQueuePopper::getMembers());
}
ChunkReceiver::MemberType_t* ChunkReceiver::getMembers() noexcept
{
return reinterpret_cast<MemberType_t*>(ChunkQueuePopper::getMembers());
}
cxx::expected<cxx::optional<const mepoo::ChunkHeader*>, ChunkReceiverError> ChunkReceiver::get() noexcept
{
auto popRet = this->pop();
if (popRet.has_value())
{
auto sharedChunk = *popRet;
// if the application holds too many chunks, don't provide more
if (getMembers()->m_chunksInUse.insert(sharedChunk))
{
return cxx::success<cxx::optional<const mepoo::ChunkHeader*>>(
const_cast<const mepoo::ChunkHeader*>(sharedChunk.getChunkHeader()));
}
else
{
// release the chunk
sharedChunk = nullptr;
return cxx::error<ChunkReceiverError>(ChunkReceiverError::TOO_MANY_CHUNKS_HELD_IN_PARALLEL);
}
}
else
{
// no new chunk
return cxx::success<cxx::optional<const mepoo::ChunkHeader*>>(cxx::nullopt_t());
}
}
void ChunkReceiver::release(const mepoo::ChunkHeader* chunkHeader) noexcept
{
mepoo::SharedChunk chunk(nullptr);
if (!getMembers()->m_chunksInUse.remove(chunkHeader, chunk))
{
errorHandler(Error::kPOPO__CHUNK_RECEIVER_INVALID_CHUNK_TO_RELEASE_FROM_USER, nullptr, ErrorLevel::SEVERE);
}
}
void ChunkReceiver::releaseAll() noexcept
{
getMembers()->m_chunksInUse.cleanup();
this->clear();
}
} // namespace popo
} // namespace iox
<|endoftext|> |
<commit_before>//===-- StackProtector.cpp - Stack Protector Insertion --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This pass inserts stack protectors into functions which need them. A variable
// with a random value in it is stored onto the stack before the local variables
// are allocated. Upon exiting the block, the stored value is checked. If it's
// changed, then there was some sort of violation and the program aborts.
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "stack-protector"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/ADT/APInt.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLowering.h"
using namespace llvm;
// Enable stack protectors.
static cl::opt<unsigned>
SSPBufferSize("stack-protector-buffer-size", cl::init(8),
cl::desc("The lower bound for a buffer to be considered for "
"stack smashing protection."));
namespace {
class VISIBILITY_HIDDEN StackProtector : public FunctionPass {
/// Level - The level of stack protection.
SSP::StackProtectorLevel Level;
/// TLI - Keep a pointer of a TargetLowering to consult for determining
/// target type sizes.
const TargetLowering *TLI;
/// FailBB - Holds the basic block to jump to when the stack protector check
/// fails.
BasicBlock *FailBB;
/// StackProtFrameSlot - The place on the stack that the stack protector
/// guard is kept.
AllocaInst *StackProtFrameSlot;
/// StackGuardVar - The global variable for the stack guard.
Constant *StackGuardVar;
Function *F;
Module *M;
/// InsertStackProtectorPrologue - Insert code into the entry block that
/// stores the __stack_chk_guard variable onto the stack.
void InsertStackProtectorPrologue();
/// InsertStackProtectorEpilogue - Insert code before the return
/// instructions checking the stack value that was stored in the
/// prologue. If it isn't the same as the original value, then call a
/// "failure" function.
void InsertStackProtectorEpilogue();
/// CreateFailBB - Create a basic block to jump to when the stack protector
/// check fails.
void CreateFailBB();
/// RequiresStackProtector - Check whether or not this function needs a
/// stack protector based upon the stack protector level.
bool RequiresStackProtector() const;
public:
static char ID; // Pass identification, replacement for typeid.
StackProtector() : FunctionPass(&ID), Level(SSP::OFF), TLI(0), FailBB(0) {}
StackProtector(SSP::StackProtectorLevel lvl, const TargetLowering *tli)
: FunctionPass(&ID), Level(lvl), TLI(tli), FailBB(0) {}
virtual bool runOnFunction(Function &Fn);
};
} // end anonymous namespace
char StackProtector::ID = 0;
static RegisterPass<StackProtector>
X("stack-protector", "Insert stack protectors");
FunctionPass *llvm::createStackProtectorPass(SSP::StackProtectorLevel lvl,
const TargetLowering *tli) {
return new StackProtector(lvl, tli);
}
bool StackProtector::runOnFunction(Function &Fn) {
F = &Fn;
M = F->getParent();
if (!RequiresStackProtector()) return false;
InsertStackProtectorPrologue();
InsertStackProtectorEpilogue();
// Cleanup.
FailBB = 0;
StackProtFrameSlot = 0;
StackGuardVar = 0;
return true;
}
/// InsertStackProtectorPrologue - Insert code into the entry block that stores
/// the __stack_chk_guard variable onto the stack.
void StackProtector::InsertStackProtectorPrologue() {
BasicBlock &Entry = F->getEntryBlock();
Instruction &InsertPt = Entry.front();
StackGuardVar = M->getOrInsertGlobal("__stack_chk_guard",
PointerType::getUnqual(Type::Int8Ty));
StackProtFrameSlot = new AllocaInst(PointerType::getUnqual(Type::Int8Ty),
"StackProt_Frame", &InsertPt);
LoadInst *LI = new LoadInst(StackGuardVar, "StackGuard", false, &InsertPt);
new StoreInst(LI, StackProtFrameSlot, false, &InsertPt);
}
/// InsertStackProtectorEpilogue - Insert code before the return instructions
/// checking the stack value that was stored in the prologue. If it isn't the
/// same as the original value, then call a "failure" function.
void StackProtector::InsertStackProtectorEpilogue() {
// Create the basic block to jump to when the guard check fails.
CreateFailBB();
Function::iterator I = F->begin(), E = F->end();
std::vector<BasicBlock*> ReturnBBs;
ReturnBBs.reserve(F->size());
for (; I != E; ++I)
if (isa<ReturnInst>(I->getTerminator()))
ReturnBBs.push_back(I);
if (ReturnBBs.empty()) return; // Odd, but could happen. . .
// Loop through the basic blocks that have return instructions. Convert this:
//
// return:
// ...
// ret ...
//
// into this:
//
// return:
// ...
// %1 = load __stack_chk_guard
// %2 = load <stored stack guard>
// %3 = cmp i1 %1, %2
// br i1 %3, label %SPRet, label %CallStackCheckFailBlk
//
// SP_return:
// ret ...
//
// CallStackCheckFailBlk:
// call void @__stack_chk_fail()
// unreachable
//
for (std::vector<BasicBlock*>::iterator
II = ReturnBBs.begin(), IE = ReturnBBs.end(); II != IE; ++II) {
BasicBlock *BB = *II;
ReturnInst *RI = cast<ReturnInst>(BB->getTerminator());
Function::iterator InsPt = BB; ++InsPt; // Insertion point for new BB.
// Split the basic block before the return instruction.
BasicBlock *NewBB = BB->splitBasicBlock(RI, "SP_return");
// Move the newly created basic block to the point right after the old basic
// block.
NewBB->removeFromParent();
F->getBasicBlockList().insert(InsPt, NewBB);
// Generate the stack protector instructions in the old basic block.
LoadInst *LI2 = new LoadInst(StackGuardVar, "", false, BB);
LoadInst *LI1 = new LoadInst(StackProtFrameSlot, "", true, BB);
ICmpInst *Cmp = new ICmpInst(CmpInst::ICMP_EQ, LI1, LI2, "", BB);
BranchInst::Create(NewBB, FailBB, Cmp, BB);
}
}
/// CreateFailBB - Create a basic block to jump to when the stack protector
/// check fails.
void StackProtector::CreateFailBB() {
assert(!FailBB && "Failure basic block already created?!");
FailBB = BasicBlock::Create("CallStackCheckFailBlk", F);
std::vector<const Type*> Params;
Constant *StackChkFail =
M->getOrInsertFunction("__stack_chk_fail", Type::VoidTy, NULL);
CallInst::Create(StackChkFail, "", FailBB);
new UnreachableInst(FailBB);
}
/// RequiresStackProtector - Check whether or not this function needs a stack
/// protector based upon the stack protector level.
bool StackProtector::RequiresStackProtector() const {
switch (Level) {
default: return false;
case SSP::ALL: return true;
case SSP::SOME: {
// If the size of the local variables allocated on the stack is greater than
// SSPBufferSize, then we require a stack protector.
uint64_t StackSize = 0;
const TargetData *TD = TLI->getTargetData();
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
BasicBlock *BB = I;
for (BasicBlock::iterator
II = BB->begin(), IE = BB->end(); II != IE; ++II)
if (AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
if (ConstantInt *CI = dyn_cast<ConstantInt>(AI->getArraySize())) {
uint64_t Bytes = TD->getTypeSizeInBits(AI->getAllocatedType()) / 8;
const APInt &Size = CI->getValue();
StackSize += Bytes * Size.getZExtValue();
if (SSPBufferSize <= StackSize)
return true;
}
}
}
return false;
}
}
}
<commit_msg>Small simplification of the stack guard type.<commit_after>//===-- StackProtector.cpp - Stack Protector Insertion --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This pass inserts stack protectors into functions which need them. A variable
// with a random value in it is stored onto the stack before the local variables
// are allocated. Upon exiting the block, the stored value is checked. If it's
// changed, then there was some sort of violation and the program aborts.
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "stack-protector"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/ADT/APInt.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetLowering.h"
using namespace llvm;
// Enable stack protectors.
static cl::opt<unsigned>
SSPBufferSize("stack-protector-buffer-size", cl::init(8),
cl::desc("The lower bound for a buffer to be considered for "
"stack smashing protection."));
namespace {
class VISIBILITY_HIDDEN StackProtector : public FunctionPass {
/// Level - The level of stack protection.
SSP::StackProtectorLevel Level;
/// TLI - Keep a pointer of a TargetLowering to consult for determining
/// target type sizes.
const TargetLowering *TLI;
/// FailBB - Holds the basic block to jump to when the stack protector check
/// fails.
BasicBlock *FailBB;
/// StackProtFrameSlot - The place on the stack that the stack protector
/// guard is kept.
AllocaInst *StackProtFrameSlot;
/// StackGuardVar - The global variable for the stack guard.
Constant *StackGuardVar;
Function *F;
Module *M;
/// InsertStackProtectorPrologue - Insert code into the entry block that
/// stores the __stack_chk_guard variable onto the stack.
void InsertStackProtectorPrologue();
/// InsertStackProtectorEpilogue - Insert code before the return
/// instructions checking the stack value that was stored in the
/// prologue. If it isn't the same as the original value, then call a
/// "failure" function.
void InsertStackProtectorEpilogue();
/// CreateFailBB - Create a basic block to jump to when the stack protector
/// check fails.
void CreateFailBB();
/// RequiresStackProtector - Check whether or not this function needs a
/// stack protector based upon the stack protector level.
bool RequiresStackProtector() const;
public:
static char ID; // Pass identification, replacement for typeid.
StackProtector() : FunctionPass(&ID), Level(SSP::OFF), TLI(0), FailBB(0) {}
StackProtector(SSP::StackProtectorLevel lvl, const TargetLowering *tli)
: FunctionPass(&ID), Level(lvl), TLI(tli), FailBB(0) {}
virtual bool runOnFunction(Function &Fn);
};
} // end anonymous namespace
char StackProtector::ID = 0;
static RegisterPass<StackProtector>
X("stack-protector", "Insert stack protectors");
FunctionPass *llvm::createStackProtectorPass(SSP::StackProtectorLevel lvl,
const TargetLowering *tli) {
return new StackProtector(lvl, tli);
}
bool StackProtector::runOnFunction(Function &Fn) {
F = &Fn;
M = F->getParent();
if (!RequiresStackProtector()) return false;
InsertStackProtectorPrologue();
InsertStackProtectorEpilogue();
// Cleanup.
FailBB = 0;
StackProtFrameSlot = 0;
StackGuardVar = 0;
return true;
}
/// InsertStackProtectorPrologue - Insert code into the entry block that stores
/// the __stack_chk_guard variable onto the stack.
void StackProtector::InsertStackProtectorPrologue() {
BasicBlock &Entry = F->getEntryBlock();
Instruction &InsertPt = Entry.front();
const PointerType *GuardTy = PointerType::getUnqual(Type::Int8Ty);
StackGuardVar = M->getOrInsertGlobal("__stack_chk_guard", GuardTy);
StackProtFrameSlot = new AllocaInst(GuardTy, "StackProt_Frame", &InsertPt);
LoadInst *LI = new LoadInst(StackGuardVar, "StackGuard", false, &InsertPt);
new StoreInst(LI, StackProtFrameSlot, false, &InsertPt);
}
/// InsertStackProtectorEpilogue - Insert code before the return instructions
/// checking the stack value that was stored in the prologue. If it isn't the
/// same as the original value, then call a "failure" function.
void StackProtector::InsertStackProtectorEpilogue() {
// Create the basic block to jump to when the guard check fails.
CreateFailBB();
Function::iterator I = F->begin(), E = F->end();
std::vector<BasicBlock*> ReturnBBs;
ReturnBBs.reserve(F->size());
for (; I != E; ++I)
if (isa<ReturnInst>(I->getTerminator()))
ReturnBBs.push_back(I);
if (ReturnBBs.empty()) return; // Odd, but could happen. . .
// Loop through the basic blocks that have return instructions. Convert this:
//
// return:
// ...
// ret ...
//
// into this:
//
// return:
// ...
// %1 = load __stack_chk_guard
// %2 = load <stored stack guard>
// %3 = cmp i1 %1, %2
// br i1 %3, label %SPRet, label %CallStackCheckFailBlk
//
// SP_return:
// ret ...
//
// CallStackCheckFailBlk:
// call void @__stack_chk_fail()
// unreachable
//
for (std::vector<BasicBlock*>::iterator
II = ReturnBBs.begin(), IE = ReturnBBs.end(); II != IE; ++II) {
BasicBlock *BB = *II;
ReturnInst *RI = cast<ReturnInst>(BB->getTerminator());
Function::iterator InsPt = BB; ++InsPt; // Insertion point for new BB.
// Split the basic block before the return instruction.
BasicBlock *NewBB = BB->splitBasicBlock(RI, "SP_return");
// Move the newly created basic block to the point right after the old basic
// block.
NewBB->removeFromParent();
F->getBasicBlockList().insert(InsPt, NewBB);
// Generate the stack protector instructions in the old basic block.
LoadInst *LI2 = new LoadInst(StackGuardVar, "", false, BB);
LoadInst *LI1 = new LoadInst(StackProtFrameSlot, "", true, BB);
ICmpInst *Cmp = new ICmpInst(CmpInst::ICMP_EQ, LI1, LI2, "", BB);
BranchInst::Create(NewBB, FailBB, Cmp, BB);
}
}
/// CreateFailBB - Create a basic block to jump to when the stack protector
/// check fails.
void StackProtector::CreateFailBB() {
assert(!FailBB && "Failure basic block already created?!");
FailBB = BasicBlock::Create("CallStackCheckFailBlk", F);
std::vector<const Type*> Params;
Constant *StackChkFail =
M->getOrInsertFunction("__stack_chk_fail", Type::VoidTy, NULL);
CallInst::Create(StackChkFail, "", FailBB);
new UnreachableInst(FailBB);
}
/// RequiresStackProtector - Check whether or not this function needs a stack
/// protector based upon the stack protector level.
bool StackProtector::RequiresStackProtector() const {
switch (Level) {
default: return false;
case SSP::ALL: return true;
case SSP::SOME: {
// If the size of the local variables allocated on the stack is greater than
// SSPBufferSize, then we require a stack protector.
uint64_t StackSize = 0;
const TargetData *TD = TLI->getTargetData();
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
BasicBlock *BB = I;
for (BasicBlock::iterator
II = BB->begin(), IE = BB->end(); II != IE; ++II)
if (AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
if (ConstantInt *CI = dyn_cast<ConstantInt>(AI->getArraySize())) {
uint64_t Bytes = TD->getTypeSizeInBits(AI->getAllocatedType()) / 8;
const APInt &Size = CI->getValue();
StackSize += Bytes * Size.getZExtValue();
if (SSPBufferSize <= StackSize)
return true;
}
}
}
return false;
}
}
}
<|endoftext|> |
<commit_before>//===-- llvm/Target/TargetSchedule.cpp - Sched Machine Model ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements a wrapper around MCSchedModel that allows the interface
// to benefit from information currently only available in TargetInstrInfo.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/TargetSchedule.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetSubtargetInfo.h"
using namespace llvm;
static cl::opt<bool> EnableSchedModel("schedmodel", cl::Hidden, cl::init(true),
cl::desc("Use TargetSchedModel for latency lookup"));
static cl::opt<bool> EnableSchedItins("scheditins", cl::Hidden, cl::init(true),
cl::desc("Use InstrItineraryData for latency lookup"));
bool TargetSchedModel::hasInstrSchedModel() const {
return EnableSchedModel && SchedModel.hasInstrSchedModel();
}
bool TargetSchedModel::hasInstrItineraries() const {
return EnableSchedItins && !InstrItins.isEmpty();
}
static unsigned gcd(unsigned Dividend, unsigned Divisor) {
// Dividend and Divisor will be naturally swapped as needed.
while(Divisor) {
unsigned Rem = Dividend % Divisor;
Dividend = Divisor;
Divisor = Rem;
};
return Dividend;
}
static unsigned lcm(unsigned A, unsigned B) {
unsigned LCM = (uint64_t(A) * B) / gcd(A, B);
assert((LCM >= A && LCM >= B) && "LCM overflow");
return LCM;
}
void TargetSchedModel::init(const MCSchedModel &sm,
const TargetSubtargetInfo *sti,
const TargetInstrInfo *tii) {
SchedModel = sm;
STI = sti;
TII = tii;
STI->initInstrItins(InstrItins);
unsigned NumRes = SchedModel.getNumProcResourceKinds();
ResourceFactors.resize(NumRes);
ResourceLCM = SchedModel.IssueWidth;
for (unsigned Idx = 0; Idx < NumRes; ++Idx) {
unsigned NumUnits = SchedModel.getProcResource(Idx)->NumUnits;
if (NumUnits > 0)
ResourceLCM = lcm(ResourceLCM, NumUnits);
}
MicroOpFactor = ResourceLCM / SchedModel.IssueWidth;
for (unsigned Idx = 0; Idx < NumRes; ++Idx) {
unsigned NumUnits = SchedModel.getProcResource(Idx)->NumUnits;
ResourceFactors[Idx] = NumUnits ? (ResourceLCM / NumUnits) : 0;
}
}
unsigned TargetSchedModel::getNumMicroOps(const MachineInstr *MI,
const MCSchedClassDesc *SC) const {
if (hasInstrItineraries()) {
int UOps = InstrItins.getNumMicroOps(MI->getDesc().getSchedClass());
return (UOps >= 0) ? UOps : TII->getNumMicroOps(&InstrItins, *MI);
}
if (hasInstrSchedModel()) {
if (!SC)
SC = resolveSchedClass(MI);
if (SC->isValid())
return SC->NumMicroOps;
}
return MI->isTransient() ? 0 : 1;
}
// The machine model may explicitly specify an invalid latency, which
// effectively means infinite latency. Since users of the TargetSchedule API
// don't know how to handle this, we convert it to a very large latency that is
// easy to distinguish when debugging the DAG but won't induce overflow.
static unsigned capLatency(int Cycles) {
return Cycles >= 0 ? Cycles : 1000;
}
/// Return the MCSchedClassDesc for this instruction. Some SchedClasses require
/// evaluation of predicates that depend on instruction operands or flags.
const MCSchedClassDesc *TargetSchedModel::
resolveSchedClass(const MachineInstr *MI) const {
// Get the definition's scheduling class descriptor from this machine model.
unsigned SchedClass = MI->getDesc().getSchedClass();
const MCSchedClassDesc *SCDesc = SchedModel.getSchedClassDesc(SchedClass);
if (!SCDesc->isValid())
return SCDesc;
#ifndef NDEBUG
unsigned NIter = 0;
#endif
while (SCDesc->isVariant()) {
assert(++NIter < 6 && "Variants are nested deeper than the magic number");
SchedClass = STI->resolveSchedClass(SchedClass, MI, this);
SCDesc = SchedModel.getSchedClassDesc(SchedClass);
}
return SCDesc;
}
/// Find the def index of this operand. This index maps to the machine model and
/// is independent of use operands. Def operands may be reordered with uses or
/// merged with uses without affecting the def index (e.g. before/after
/// regalloc). However, an instruction's def operands must never be reordered
/// with respect to each other.
static unsigned findDefIdx(const MachineInstr *MI, unsigned DefOperIdx) {
unsigned DefIdx = 0;
for (unsigned i = 0; i != DefOperIdx; ++i) {
const MachineOperand &MO = MI->getOperand(i);
if (MO.isReg() && MO.isDef())
++DefIdx;
}
return DefIdx;
}
/// Find the use index of this operand. This is independent of the instruction's
/// def operands.
///
/// Note that uses are not determined by the operand's isUse property, which
/// is simply the inverse of isDef. Here we consider any readsReg operand to be
/// a "use". The machine model allows an operand to be both a Def and Use.
static unsigned findUseIdx(const MachineInstr *MI, unsigned UseOperIdx) {
unsigned UseIdx = 0;
for (unsigned i = 0; i != UseOperIdx; ++i) {
const MachineOperand &MO = MI->getOperand(i);
if (MO.isReg() && MO.readsReg())
++UseIdx;
}
return UseIdx;
}
// Top-level API for clients that know the operand indices.
unsigned TargetSchedModel::computeOperandLatency(
const MachineInstr *DefMI, unsigned DefOperIdx,
const MachineInstr *UseMI, unsigned UseOperIdx) const {
if (!hasInstrSchedModel() && !hasInstrItineraries())
return TII->defaultDefLatency(SchedModel, *DefMI);
if (hasInstrItineraries()) {
int OperLatency = 0;
if (UseMI) {
OperLatency = TII->getOperandLatency(&InstrItins, *DefMI, DefOperIdx,
*UseMI, UseOperIdx);
}
else {
unsigned DefClass = DefMI->getDesc().getSchedClass();
OperLatency = InstrItins.getOperandCycle(DefClass, DefOperIdx);
}
if (OperLatency >= 0)
return OperLatency;
// No operand latency was found.
unsigned InstrLatency = TII->getInstrLatency(&InstrItins, *DefMI);
// Expected latency is the max of the stage latency and itinerary props.
// Rather than directly querying InstrItins stage latency, we call a TII
// hook to allow subtargets to specialize latency. This hook is only
// applicable to the InstrItins model. InstrSchedModel should model all
// special cases without TII hooks.
InstrLatency =
std::max(InstrLatency, TII->defaultDefLatency(SchedModel, *DefMI));
return InstrLatency;
}
// hasInstrSchedModel()
const MCSchedClassDesc *SCDesc = resolveSchedClass(DefMI);
unsigned DefIdx = findDefIdx(DefMI, DefOperIdx);
if (DefIdx < SCDesc->NumWriteLatencyEntries) {
// Lookup the definition's write latency in SubtargetInfo.
const MCWriteLatencyEntry *WLEntry =
STI->getWriteLatencyEntry(SCDesc, DefIdx);
unsigned WriteID = WLEntry->WriteResourceID;
unsigned Latency = capLatency(WLEntry->Cycles);
if (!UseMI)
return Latency;
// Lookup the use's latency adjustment in SubtargetInfo.
const MCSchedClassDesc *UseDesc = resolveSchedClass(UseMI);
if (UseDesc->NumReadAdvanceEntries == 0)
return Latency;
unsigned UseIdx = findUseIdx(UseMI, UseOperIdx);
int Advance = STI->getReadAdvanceCycles(UseDesc, UseIdx, WriteID);
if (Advance > 0 && (unsigned)Advance > Latency) // unsigned wrap
return 0;
return Latency - Advance;
}
// If DefIdx does not exist in the model (e.g. implicit defs), then return
// unit latency (defaultDefLatency may be too conservative).
#ifndef NDEBUG
if (SCDesc->isValid() && !DefMI->getOperand(DefOperIdx).isImplicit()
&& !DefMI->getDesc().OpInfo[DefOperIdx].isOptionalDef()
&& SchedModel.isComplete()) {
errs() << "DefIdx " << DefIdx << " exceeds machine model writes for "
<< *DefMI << " (Try with MCSchedModel.CompleteModel set to false)";
llvm_unreachable("incomplete machine model");
}
#endif
// FIXME: Automatically giving all implicit defs defaultDefLatency is
// undesirable. We should only do it for defs that are known to the MC
// desc like flags. Truly implicit defs should get 1 cycle latency.
return DefMI->isTransient() ? 0 : TII->defaultDefLatency(SchedModel, *DefMI);
}
unsigned
TargetSchedModel::computeInstrLatency(const MCSchedClassDesc &SCDesc) const {
unsigned Latency = 0;
for (unsigned DefIdx = 0, DefEnd = SCDesc.NumWriteLatencyEntries;
DefIdx != DefEnd; ++DefIdx) {
// Lookup the definition's write latency in SubtargetInfo.
const MCWriteLatencyEntry *WLEntry =
STI->getWriteLatencyEntry(&SCDesc, DefIdx);
Latency = std::max(Latency, capLatency(WLEntry->Cycles));
}
return Latency;
}
unsigned TargetSchedModel::computeInstrLatency(unsigned Opcode) const {
assert(hasInstrSchedModel() && "Only call this function with a SchedModel");
unsigned SCIdx = TII->get(Opcode).getSchedClass();
const MCSchedClassDesc *SCDesc = SchedModel.getSchedClassDesc(SCIdx);
if (SCDesc->isValid() && !SCDesc->isVariant())
return computeInstrLatency(*SCDesc);
llvm_unreachable("No MI sched latency");
}
unsigned
TargetSchedModel::computeInstrLatency(const MachineInstr *MI,
bool UseDefaultDefLatency) const {
// For the itinerary model, fall back to the old subtarget hook.
// Allow subtargets to compute Bundle latencies outside the machine model.
if (hasInstrItineraries() || MI->isBundle() ||
(!hasInstrSchedModel() && !UseDefaultDefLatency))
return TII->getInstrLatency(&InstrItins, *MI);
if (hasInstrSchedModel()) {
const MCSchedClassDesc *SCDesc = resolveSchedClass(MI);
if (SCDesc->isValid())
return computeInstrLatency(*SCDesc);
}
return TII->defaultDefLatency(SchedModel, *MI);
}
unsigned TargetSchedModel::
computeOutputLatency(const MachineInstr *DefMI, unsigned DefOperIdx,
const MachineInstr *DepMI) const {
if (!SchedModel.isOutOfOrder())
return 1;
// Out-of-order processor can dispatch WAW dependencies in the same cycle.
// Treat predication as a data dependency for out-of-order cpus. In-order
// cpus do not need to treat predicated writes specially.
//
// TODO: The following hack exists because predication passes do not
// correctly append imp-use operands, and readsReg() strangely returns false
// for predicated defs.
unsigned Reg = DefMI->getOperand(DefOperIdx).getReg();
const MachineFunction &MF = *DefMI->getParent()->getParent();
const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
if (!DepMI->readsRegister(Reg, TRI) && TII->isPredicated(*DepMI))
return computeInstrLatency(DefMI);
// If we have a per operand scheduling model, check if this def is writing
// an unbuffered resource. If so, it treated like an in-order cpu.
if (hasInstrSchedModel()) {
const MCSchedClassDesc *SCDesc = resolveSchedClass(DefMI);
if (SCDesc->isValid()) {
for (const MCWriteProcResEntry *PRI = STI->getWriteProcResBegin(SCDesc),
*PRE = STI->getWriteProcResEnd(SCDesc); PRI != PRE; ++PRI) {
if (!SchedModel.getProcResource(PRI->ProcResourceIdx)->BufferSize)
return 1;
}
}
}
return 0;
}
<commit_msg>TargetSchedule: Do not consider subregister definitions as reads.<commit_after>//===-- llvm/Target/TargetSchedule.cpp - Sched Machine Model ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements a wrapper around MCSchedModel that allows the interface
// to benefit from information currently only available in TargetInstrInfo.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/TargetSchedule.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetSubtargetInfo.h"
using namespace llvm;
static cl::opt<bool> EnableSchedModel("schedmodel", cl::Hidden, cl::init(true),
cl::desc("Use TargetSchedModel for latency lookup"));
static cl::opt<bool> EnableSchedItins("scheditins", cl::Hidden, cl::init(true),
cl::desc("Use InstrItineraryData for latency lookup"));
bool TargetSchedModel::hasInstrSchedModel() const {
return EnableSchedModel && SchedModel.hasInstrSchedModel();
}
bool TargetSchedModel::hasInstrItineraries() const {
return EnableSchedItins && !InstrItins.isEmpty();
}
static unsigned gcd(unsigned Dividend, unsigned Divisor) {
// Dividend and Divisor will be naturally swapped as needed.
while(Divisor) {
unsigned Rem = Dividend % Divisor;
Dividend = Divisor;
Divisor = Rem;
};
return Dividend;
}
static unsigned lcm(unsigned A, unsigned B) {
unsigned LCM = (uint64_t(A) * B) / gcd(A, B);
assert((LCM >= A && LCM >= B) && "LCM overflow");
return LCM;
}
void TargetSchedModel::init(const MCSchedModel &sm,
const TargetSubtargetInfo *sti,
const TargetInstrInfo *tii) {
SchedModel = sm;
STI = sti;
TII = tii;
STI->initInstrItins(InstrItins);
unsigned NumRes = SchedModel.getNumProcResourceKinds();
ResourceFactors.resize(NumRes);
ResourceLCM = SchedModel.IssueWidth;
for (unsigned Idx = 0; Idx < NumRes; ++Idx) {
unsigned NumUnits = SchedModel.getProcResource(Idx)->NumUnits;
if (NumUnits > 0)
ResourceLCM = lcm(ResourceLCM, NumUnits);
}
MicroOpFactor = ResourceLCM / SchedModel.IssueWidth;
for (unsigned Idx = 0; Idx < NumRes; ++Idx) {
unsigned NumUnits = SchedModel.getProcResource(Idx)->NumUnits;
ResourceFactors[Idx] = NumUnits ? (ResourceLCM / NumUnits) : 0;
}
}
unsigned TargetSchedModel::getNumMicroOps(const MachineInstr *MI,
const MCSchedClassDesc *SC) const {
if (hasInstrItineraries()) {
int UOps = InstrItins.getNumMicroOps(MI->getDesc().getSchedClass());
return (UOps >= 0) ? UOps : TII->getNumMicroOps(&InstrItins, *MI);
}
if (hasInstrSchedModel()) {
if (!SC)
SC = resolveSchedClass(MI);
if (SC->isValid())
return SC->NumMicroOps;
}
return MI->isTransient() ? 0 : 1;
}
// The machine model may explicitly specify an invalid latency, which
// effectively means infinite latency. Since users of the TargetSchedule API
// don't know how to handle this, we convert it to a very large latency that is
// easy to distinguish when debugging the DAG but won't induce overflow.
static unsigned capLatency(int Cycles) {
return Cycles >= 0 ? Cycles : 1000;
}
/// Return the MCSchedClassDesc for this instruction. Some SchedClasses require
/// evaluation of predicates that depend on instruction operands or flags.
const MCSchedClassDesc *TargetSchedModel::
resolveSchedClass(const MachineInstr *MI) const {
// Get the definition's scheduling class descriptor from this machine model.
unsigned SchedClass = MI->getDesc().getSchedClass();
const MCSchedClassDesc *SCDesc = SchedModel.getSchedClassDesc(SchedClass);
if (!SCDesc->isValid())
return SCDesc;
#ifndef NDEBUG
unsigned NIter = 0;
#endif
while (SCDesc->isVariant()) {
assert(++NIter < 6 && "Variants are nested deeper than the magic number");
SchedClass = STI->resolveSchedClass(SchedClass, MI, this);
SCDesc = SchedModel.getSchedClassDesc(SchedClass);
}
return SCDesc;
}
/// Find the def index of this operand. This index maps to the machine model and
/// is independent of use operands. Def operands may be reordered with uses or
/// merged with uses without affecting the def index (e.g. before/after
/// regalloc). However, an instruction's def operands must never be reordered
/// with respect to each other.
static unsigned findDefIdx(const MachineInstr *MI, unsigned DefOperIdx) {
unsigned DefIdx = 0;
for (unsigned i = 0; i != DefOperIdx; ++i) {
const MachineOperand &MO = MI->getOperand(i);
if (MO.isReg() && MO.isDef())
++DefIdx;
}
return DefIdx;
}
/// Find the use index of this operand. This is independent of the instruction's
/// def operands.
///
/// Note that uses are not determined by the operand's isUse property, which
/// is simply the inverse of isDef. Here we consider any readsReg operand to be
/// a "use". The machine model allows an operand to be both a Def and Use.
static unsigned findUseIdx(const MachineInstr *MI, unsigned UseOperIdx) {
unsigned UseIdx = 0;
for (unsigned i = 0; i != UseOperIdx; ++i) {
const MachineOperand &MO = MI->getOperand(i);
if (MO.isReg() && MO.readsReg() && !MO.isDef())
++UseIdx;
}
return UseIdx;
}
// Top-level API for clients that know the operand indices.
unsigned TargetSchedModel::computeOperandLatency(
const MachineInstr *DefMI, unsigned DefOperIdx,
const MachineInstr *UseMI, unsigned UseOperIdx) const {
if (!hasInstrSchedModel() && !hasInstrItineraries())
return TII->defaultDefLatency(SchedModel, *DefMI);
if (hasInstrItineraries()) {
int OperLatency = 0;
if (UseMI) {
OperLatency = TII->getOperandLatency(&InstrItins, *DefMI, DefOperIdx,
*UseMI, UseOperIdx);
}
else {
unsigned DefClass = DefMI->getDesc().getSchedClass();
OperLatency = InstrItins.getOperandCycle(DefClass, DefOperIdx);
}
if (OperLatency >= 0)
return OperLatency;
// No operand latency was found.
unsigned InstrLatency = TII->getInstrLatency(&InstrItins, *DefMI);
// Expected latency is the max of the stage latency and itinerary props.
// Rather than directly querying InstrItins stage latency, we call a TII
// hook to allow subtargets to specialize latency. This hook is only
// applicable to the InstrItins model. InstrSchedModel should model all
// special cases without TII hooks.
InstrLatency =
std::max(InstrLatency, TII->defaultDefLatency(SchedModel, *DefMI));
return InstrLatency;
}
// hasInstrSchedModel()
const MCSchedClassDesc *SCDesc = resolveSchedClass(DefMI);
unsigned DefIdx = findDefIdx(DefMI, DefOperIdx);
if (DefIdx < SCDesc->NumWriteLatencyEntries) {
// Lookup the definition's write latency in SubtargetInfo.
const MCWriteLatencyEntry *WLEntry =
STI->getWriteLatencyEntry(SCDesc, DefIdx);
unsigned WriteID = WLEntry->WriteResourceID;
unsigned Latency = capLatency(WLEntry->Cycles);
if (!UseMI)
return Latency;
// Lookup the use's latency adjustment in SubtargetInfo.
const MCSchedClassDesc *UseDesc = resolveSchedClass(UseMI);
if (UseDesc->NumReadAdvanceEntries == 0)
return Latency;
unsigned UseIdx = findUseIdx(UseMI, UseOperIdx);
int Advance = STI->getReadAdvanceCycles(UseDesc, UseIdx, WriteID);
if (Advance > 0 && (unsigned)Advance > Latency) // unsigned wrap
return 0;
return Latency - Advance;
}
// If DefIdx does not exist in the model (e.g. implicit defs), then return
// unit latency (defaultDefLatency may be too conservative).
#ifndef NDEBUG
if (SCDesc->isValid() && !DefMI->getOperand(DefOperIdx).isImplicit()
&& !DefMI->getDesc().OpInfo[DefOperIdx].isOptionalDef()
&& SchedModel.isComplete()) {
errs() << "DefIdx " << DefIdx << " exceeds machine model writes for "
<< *DefMI << " (Try with MCSchedModel.CompleteModel set to false)";
llvm_unreachable("incomplete machine model");
}
#endif
// FIXME: Automatically giving all implicit defs defaultDefLatency is
// undesirable. We should only do it for defs that are known to the MC
// desc like flags. Truly implicit defs should get 1 cycle latency.
return DefMI->isTransient() ? 0 : TII->defaultDefLatency(SchedModel, *DefMI);
}
unsigned
TargetSchedModel::computeInstrLatency(const MCSchedClassDesc &SCDesc) const {
unsigned Latency = 0;
for (unsigned DefIdx = 0, DefEnd = SCDesc.NumWriteLatencyEntries;
DefIdx != DefEnd; ++DefIdx) {
// Lookup the definition's write latency in SubtargetInfo.
const MCWriteLatencyEntry *WLEntry =
STI->getWriteLatencyEntry(&SCDesc, DefIdx);
Latency = std::max(Latency, capLatency(WLEntry->Cycles));
}
return Latency;
}
unsigned TargetSchedModel::computeInstrLatency(unsigned Opcode) const {
assert(hasInstrSchedModel() && "Only call this function with a SchedModel");
unsigned SCIdx = TII->get(Opcode).getSchedClass();
const MCSchedClassDesc *SCDesc = SchedModel.getSchedClassDesc(SCIdx);
if (SCDesc->isValid() && !SCDesc->isVariant())
return computeInstrLatency(*SCDesc);
llvm_unreachable("No MI sched latency");
}
unsigned
TargetSchedModel::computeInstrLatency(const MachineInstr *MI,
bool UseDefaultDefLatency) const {
// For the itinerary model, fall back to the old subtarget hook.
// Allow subtargets to compute Bundle latencies outside the machine model.
if (hasInstrItineraries() || MI->isBundle() ||
(!hasInstrSchedModel() && !UseDefaultDefLatency))
return TII->getInstrLatency(&InstrItins, *MI);
if (hasInstrSchedModel()) {
const MCSchedClassDesc *SCDesc = resolveSchedClass(MI);
if (SCDesc->isValid())
return computeInstrLatency(*SCDesc);
}
return TII->defaultDefLatency(SchedModel, *MI);
}
unsigned TargetSchedModel::
computeOutputLatency(const MachineInstr *DefMI, unsigned DefOperIdx,
const MachineInstr *DepMI) const {
if (!SchedModel.isOutOfOrder())
return 1;
// Out-of-order processor can dispatch WAW dependencies in the same cycle.
// Treat predication as a data dependency for out-of-order cpus. In-order
// cpus do not need to treat predicated writes specially.
//
// TODO: The following hack exists because predication passes do not
// correctly append imp-use operands, and readsReg() strangely returns false
// for predicated defs.
unsigned Reg = DefMI->getOperand(DefOperIdx).getReg();
const MachineFunction &MF = *DefMI->getParent()->getParent();
const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
if (!DepMI->readsRegister(Reg, TRI) && TII->isPredicated(*DepMI))
return computeInstrLatency(DefMI);
// If we have a per operand scheduling model, check if this def is writing
// an unbuffered resource. If so, it treated like an in-order cpu.
if (hasInstrSchedModel()) {
const MCSchedClassDesc *SCDesc = resolveSchedClass(DefMI);
if (SCDesc->isValid()) {
for (const MCWriteProcResEntry *PRI = STI->getWriteProcResBegin(SCDesc),
*PRE = STI->getWriteProcResEnd(SCDesc); PRI != PRE; ++PRI) {
if (!SchedModel.getProcResource(PRI->ProcResourceIdx)->BufferSize)
return 1;
}
}
}
return 0;
}
<|endoftext|> |
<commit_before>#pragma once
#include "depthai-shared/common/CameraBoardSocket.hpp"
#include "depthai-shared/common/CameraImageOrientation.hpp"
#include "depthai-shared/datatype/RawCameraControl.hpp"
#include "depthai-shared/properties/Properties.hpp"
namespace dai {
/**
* Specify properties for ColorCamera such as camera ID, ...
*/
struct ColorCameraProperties : PropertiesSerializable<Properties, ColorCameraProperties> {
static constexpr int AUTO = -1;
struct IspScale {
int32_t horizNumerator = 0;
int32_t horizDenominator = 0;
int32_t vertNumerator = 0;
int32_t vertDenominator = 0;
DEPTHAI_SERIALIZE(IspScale, horizNumerator, horizDenominator, vertNumerator, vertDenominator);
};
/**
* Select the camera sensor resolution
*/
enum class SensorResolution : int32_t { THE_1080_P, THE_1200_P, THE_4_K, THE_5_MP, THE_12_MP, THE_13_MP, THE_48_MP, THE_720_P, THE_800_P };
/**
* For 24 bit color these can be either RGB or BGR
*/
enum class ColorOrder : int32_t { BGR, RGB };
/*
* Initial controls applied to ColorCamera node
*/
RawCameraControl initialControl;
/**
* Which socket will color camera use
*/
CameraBoardSocket boardSocket = CameraBoardSocket::AUTO;
/**
* Camera sensor image orientation / pixel readout
*/
CameraImageOrientation imageOrientation = CameraImageOrientation::AUTO;
/**
* For 24 bit color these can be either RGB or BGR
*/
ColorOrder colorOrder = ColorOrder::BGR;
/**
* Are colors interleaved (R1G1B1, R2G2B2, ...) or planar (R1R2..., G1G2..., B1B2)
*/
bool interleaved = true;
/**
* Are values FP16 type (0.0 - 255.0)
*/
bool fp16 = false;
/**
* Preview frame output height
*/
uint32_t previewHeight = 300;
/**
* Preview frame output width
*/
uint32_t previewWidth = 300;
/**
* Preview frame output width
*/
int32_t videoWidth = AUTO;
/**
* Preview frame output height
*/
int32_t videoHeight = AUTO;
/**
* Preview frame output width
*/
int32_t stillWidth = AUTO;
/**
* Preview frame output height
*/
int32_t stillHeight = AUTO;
/**
* Select the camera sensor resolution
*/
SensorResolution resolution = SensorResolution::THE_1080_P;
/**
* Camera sensor FPS
*/
float fps = 30.0;
/**
* Initial sensor crop, -1 signifies center crop
*/
float sensorCropX = AUTO;
float sensorCropY = AUTO;
/**
* Whether to keep aspect ratio of input (video size) or not
*/
bool previewKeepAspectRatio = true;
/**
* Configure scaling for `isp` output.
*/
IspScale ispScale;
/**
* Pool sizes
*/
int numFramesPoolRaw = 3;
int numFramesPoolIsp = 3;
int numFramesPoolVideo = 4;
int numFramesPoolPreview = 4;
int numFramesPoolStill = 4;
};
DEPTHAI_SERIALIZE_EXT(ColorCameraProperties,
initialControl,
boardSocket,
imageOrientation,
colorOrder,
interleaved,
fp16,
previewHeight,
previewWidth,
videoWidth,
videoHeight,
stillWidth,
stillHeight,
resolution,
fps,
sensorCropX,
sensorCropY,
previewKeepAspectRatio,
ispScale,
numFramesPoolRaw,
numFramesPoolIsp,
numFramesPoolVideo,
numFramesPoolPreview,
numFramesPoolStill);
} // namespace dai
<commit_msg>ColorCameraProperties res: add THE_12P0_MP (12.0 4000x3000) and THE_5312X6000<commit_after>#pragma once
#include "depthai-shared/common/CameraBoardSocket.hpp"
#include "depthai-shared/common/CameraImageOrientation.hpp"
#include "depthai-shared/datatype/RawCameraControl.hpp"
#include "depthai-shared/properties/Properties.hpp"
namespace dai {
/**
* Specify properties for ColorCamera such as camera ID, ...
*/
struct ColorCameraProperties : PropertiesSerializable<Properties, ColorCameraProperties> {
static constexpr int AUTO = -1;
struct IspScale {
int32_t horizNumerator = 0;
int32_t horizDenominator = 0;
int32_t vertNumerator = 0;
int32_t vertDenominator = 0;
DEPTHAI_SERIALIZE(IspScale, horizNumerator, horizDenominator, vertNumerator, vertDenominator);
};
/**
* Select the camera sensor resolution
*/
enum class SensorResolution : int32_t { THE_1080_P, THE_1200_P, THE_4_K, THE_5_MP, THE_12_MP, THE_12P0_MP, THE_13_MP, THE_5312X6000, THE_48_MP, THE_720_P, THE_800_P };
/**
* For 24 bit color these can be either RGB or BGR
*/
enum class ColorOrder : int32_t { BGR, RGB };
/*
* Initial controls applied to ColorCamera node
*/
RawCameraControl initialControl;
/**
* Which socket will color camera use
*/
CameraBoardSocket boardSocket = CameraBoardSocket::AUTO;
/**
* Camera sensor image orientation / pixel readout
*/
CameraImageOrientation imageOrientation = CameraImageOrientation::AUTO;
/**
* For 24 bit color these can be either RGB or BGR
*/
ColorOrder colorOrder = ColorOrder::BGR;
/**
* Are colors interleaved (R1G1B1, R2G2B2, ...) or planar (R1R2..., G1G2..., B1B2)
*/
bool interleaved = true;
/**
* Are values FP16 type (0.0 - 255.0)
*/
bool fp16 = false;
/**
* Preview frame output height
*/
uint32_t previewHeight = 300;
/**
* Preview frame output width
*/
uint32_t previewWidth = 300;
/**
* Preview frame output width
*/
int32_t videoWidth = AUTO;
/**
* Preview frame output height
*/
int32_t videoHeight = AUTO;
/**
* Preview frame output width
*/
int32_t stillWidth = AUTO;
/**
* Preview frame output height
*/
int32_t stillHeight = AUTO;
/**
* Select the camera sensor resolution
*/
SensorResolution resolution = SensorResolution::THE_1080_P;
/**
* Camera sensor FPS
*/
float fps = 30.0;
/**
* Initial sensor crop, -1 signifies center crop
*/
float sensorCropX = AUTO;
float sensorCropY = AUTO;
/**
* Whether to keep aspect ratio of input (video size) or not
*/
bool previewKeepAspectRatio = true;
/**
* Configure scaling for `isp` output.
*/
IspScale ispScale;
/**
* Pool sizes
*/
int numFramesPoolRaw = 3;
int numFramesPoolIsp = 3;
int numFramesPoolVideo = 4;
int numFramesPoolPreview = 4;
int numFramesPoolStill = 4;
};
DEPTHAI_SERIALIZE_EXT(ColorCameraProperties,
initialControl,
boardSocket,
imageOrientation,
colorOrder,
interleaved,
fp16,
previewHeight,
previewWidth,
videoWidth,
videoHeight,
stillWidth,
stillHeight,
resolution,
fps,
sensorCropX,
sensorCropY,
previewKeepAspectRatio,
ispScale,
numFramesPoolRaw,
numFramesPoolIsp,
numFramesPoolVideo,
numFramesPoolPreview,
numFramesPoolStill);
} // namespace dai
<|endoftext|> |
<commit_before>#pragma once
#include <depthai-shared/common/EepromData.hpp>
#include <depthai-shared/common/optional.hpp>
#include <nlohmann/json.hpp>
#include "depthai-shared/common/CameraBoardSocket.hpp"
namespace dai {
/**
* Specify properties for StereoDepth
*/
struct StereoDepthProperties {
struct RectificationMesh {
/**
* Uri which points to the mesh array for 'left' input rectification
*/
std::string meshLeftUri;
/**
* Uri which points to the mesh array for 'right' input rectification
*/
std::string meshRightUri;
/**
* Mesh array size in bytes, for each of 'left' and 'right' (need to match)
*/
tl::optional<std::uint32_t> meshSize;
/**
* Distance between mesh points, in the horizontal direction
*/
uint16_t stepWidth = 16;
/**
* Distance between mesh points, in the vertical direction
*/
uint16_t stepHeight = 16;
NLOHMANN_DEFINE_TYPE_INTRUSIVE(RectificationMesh, meshLeftUri, meshRightUri, meshSize, stepWidth, stepHeight);
};
/**
* Median filter config for disparity post-processing
*/
enum class MedianFilter : int32_t { MEDIAN_OFF = 0, KERNEL_3x3 = 3, KERNEL_5x5 = 5, KERNEL_7x7 = 7 };
/**
* Align the disparity/depth to the perspective of a rectified output, or center it
*/
enum class DepthAlign : int32_t { RECTIFIED_RIGHT, RECTIFIED_LEFT, CENTER };
/**
* Calibration data byte array
*/
std::vector<std::uint8_t> calibration;
EepromData calibrationData;
/**
* Set kernel size for disparity/depth median filtering, or disable
*/
MedianFilter median = MedianFilter::KERNEL_5x5;
/**
* Set the disparity/depth alignment to the perspective of a rectified output, or center it
*/
DepthAlign depthAlign = DepthAlign::RECTIFIED_RIGHT;
/**
* Which camera to align disparity/depth to.
* When configured (not AUTO), takes precedence over 'depthAlign'
*/
CameraBoardSocket depthAlignCamera = CameraBoardSocket::AUTO;
/**
* Confidence threshold for disparity calculation, 0..255
*/
std::int32_t confidenceThreshold = 200;
bool enableRectification = true;
/**
* Computes and combines disparities in both L-R and R-L directions, and combine them.
* For better occlusion handling
*/
bool enableLeftRightCheck = false;
/**
* Computes disparity with sub-pixel interpolation (5 fractional bits), suitable for long range
*/
bool enableSubpixel = false;
/**
* Disparity range increased from 96 to 192, combined from full resolution and downscaled images.
* Suitable for short range objects
*/
bool enableExtendedDisparity = false;
/**
* Mirror rectified frames: true to have disparity/depth normal (non-mirrored)
*/
bool rectifyMirrorFrame = true;
/**
* Fill color for missing data at frame edges: grayscale 0..255, or -1 to replicate pixels
*/
std::int32_t rectifyEdgeFillColor = -1;
/**
* Input frame width. Optional (taken from MonoCamera nodes if they exist)
*/
tl::optional<std::int32_t> width;
/**
* Input frame height. Optional (taken from MonoCamera nodes if they exist)
*/
tl::optional<std::int32_t> height;
/**
* Output disparity/depth width. Currently only used when aligning to RGB
*/
tl::optional<std::int32_t> outWidth;
/**
* Output disparity/depth height. Currently only used when aligning to RGB
*/
tl::optional<std::int32_t> outHeight;
/**
* Specify a direct warp mesh to be used for rectification,
* instead of intrinsics + extrinsic matrices
*/
RectificationMesh mesh;
};
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(StereoDepthProperties,
calibration,
calibrationData,
median,
depthAlign,
depthAlignCamera,
confidenceThreshold,
enableRectification,
enableLeftRightCheck,
enableSubpixel,
enableExtendedDisparity,
rectifyMirrorFrame,
rectifyEdgeFillColor,
width,
height,
outWidth,
outHeight,
mesh);
} // namespace dai
<commit_msg>make clangformat<commit_after>#pragma once
#include <depthai-shared/common/EepromData.hpp>
#include <depthai-shared/common/optional.hpp>
#include <nlohmann/json.hpp>
#include "depthai-shared/common/CameraBoardSocket.hpp"
namespace dai {
/**
* Specify properties for StereoDepth
*/
struct StereoDepthProperties {
struct RectificationMesh {
/**
* Uri which points to the mesh array for 'left' input rectification
*/
std::string meshLeftUri;
/**
* Uri which points to the mesh array for 'right' input rectification
*/
std::string meshRightUri;
/**
* Mesh array size in bytes, for each of 'left' and 'right' (need to match)
*/
tl::optional<std::uint32_t> meshSize;
/**
* Distance between mesh points, in the horizontal direction
*/
uint16_t stepWidth = 16;
/**
* Distance between mesh points, in the vertical direction
*/
uint16_t stepHeight = 16;
NLOHMANN_DEFINE_TYPE_INTRUSIVE(RectificationMesh, meshLeftUri, meshRightUri, meshSize, stepWidth, stepHeight);
};
/**
* Median filter config for disparity post-processing
*/
enum class MedianFilter : int32_t { MEDIAN_OFF = 0, KERNEL_3x3 = 3, KERNEL_5x5 = 5, KERNEL_7x7 = 7 };
/**
* Align the disparity/depth to the perspective of a rectified output, or center it
*/
enum class DepthAlign : int32_t { RECTIFIED_RIGHT, RECTIFIED_LEFT, CENTER };
/**
* Calibration data byte array
*/
std::vector<std::uint8_t> calibration;
EepromData calibrationData;
/**
* Set kernel size for disparity/depth median filtering, or disable
*/
MedianFilter median = MedianFilter::KERNEL_5x5;
/**
* Set the disparity/depth alignment to the perspective of a rectified output, or center it
*/
DepthAlign depthAlign = DepthAlign::RECTIFIED_RIGHT;
/**
* Which camera to align disparity/depth to.
* When configured (not AUTO), takes precedence over 'depthAlign'
*/
CameraBoardSocket depthAlignCamera = CameraBoardSocket::AUTO;
/**
* Confidence threshold for disparity calculation, 0..255
*/
std::int32_t confidenceThreshold = 200;
bool enableRectification = true;
/**
* Computes and combines disparities in both L-R and R-L directions, and combine them.
* For better occlusion handling
*/
bool enableLeftRightCheck = false;
/**
* Computes disparity with sub-pixel interpolation (5 fractional bits), suitable for long range
*/
bool enableSubpixel = false;
/**
* Disparity range increased from 96 to 192, combined from full resolution and downscaled images.
* Suitable for short range objects
*/
bool enableExtendedDisparity = false;
/**
* Mirror rectified frames: true to have disparity/depth normal (non-mirrored)
*/
bool rectifyMirrorFrame = true;
/**
* Fill color for missing data at frame edges: grayscale 0..255, or -1 to replicate pixels
*/
std::int32_t rectifyEdgeFillColor = -1;
/**
* Input frame width. Optional (taken from MonoCamera nodes if they exist)
*/
tl::optional<std::int32_t> width;
/**
* Input frame height. Optional (taken from MonoCamera nodes if they exist)
*/
tl::optional<std::int32_t> height;
/**
* Output disparity/depth width. Currently only used when aligning to RGB
*/
tl::optional<std::int32_t> outWidth;
/**
* Output disparity/depth height. Currently only used when aligning to RGB
*/
tl::optional<std::int32_t> outHeight;
/**
* Specify a direct warp mesh to be used for rectification,
* instead of intrinsics + extrinsic matrices
*/
RectificationMesh mesh;
};
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(StereoDepthProperties,
calibration,
calibrationData,
median,
depthAlign,
depthAlignCamera,
confidenceThreshold,
enableRectification,
enableLeftRightCheck,
enableSubpixel,
enableExtendedDisparity,
rectifyMirrorFrame,
rectifyEdgeFillColor,
width,
height,
outWidth,
outHeight,
mesh);
} // namespace dai
<|endoftext|> |
<commit_before>#include "../../../shared/generated/cpp/MediaplayerBase.h"
#include "net/INetRequest.h"
#include "RhoFile.h"
namespace rho {
using namespace apiGenerator;
std::wstring s2ws(const std::string& s)
{
int len;
int slength = (int)s.length() + 1;
len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
wchar_t* buf = new wchar_t[len];
MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
std::wstring r(buf);
delete[] buf;
return r;
}
class CMediaplayerImpl: public CMediaplayerBase
{
public:
CMediaplayerImpl(const rho::String& strID): CMediaplayerBase()
{
}
};
class CMediaplayerSingleton: public CMediaplayerSingletonBase
{
static HANDLE m_hPlayThread; /// Handle to player thread
static HANDLE m_hPlayProcess; /// Handle to player process
static StringW lFilename;
~CMediaplayerSingleton(){}
virtual rho::String getInitialDefaultID();
virtual void enumerate(CMethodResult& oResult);
/**
* Function to kill the player thread so that VideoCapture can unlock
* any in-use media files
*/
void KillPlayer()
{
if (m_hPlayProcess)
{
TerminateProcess(m_hPlayProcess, -1);
WaitForSingleObject(m_hPlayProcess, 500);
CloseHandle(m_hPlayProcess);
m_hPlayProcess = NULL;
}
if (m_hPlayThread)
{
TerminateThread(m_hPlayThread, -1);
CloseHandle(m_hPlayThread);
m_hPlayThread = NULL;
}
}
bool playLocalAudio()
{
LOG(INFO) + __FUNCTION__ + ": playLocalAudio called";
m_hPlayThread = CreateThread(NULL, 0, (&rho::CMediaplayerSingleton::playThreadProc), this, 0, NULL);
return (m_hPlayThread != NULL);
}
rho::StringW replaceString(rho::StringW inputString,
rho::StringW toReplace,
rho::StringW replaceWith)
{
size_t f;
while( (f= inputString.find(toReplace))!= -1)
{
inputString.replace(f, toReplace.length(), replaceWith);
}
return inputString;
}
static DWORD WINAPI playThreadProc(LPVOID lpParam)
{
DWORD dwRet = S_OK;
CMediaplayerSingleton *pMediaplayer = (CMediaplayerSingleton *)lpParam;
if (pMediaplayer)
{
LOG(INFO) + __FUNCTION__ + "pMediaplayer object exists: using lFilename: " + lFilename.c_str();
if (!PlaySound(lFilename.c_str(), NULL, SND_FILENAME|SND_SYNC|SND_NODEFAULT)) {
LOG(INFO) + __FUNCTION__ + " PlaySound function failed ";
dwRet = false;
}
CloseHandle(pMediaplayer->m_hPlayThread);
pMediaplayer->m_hPlayThread = NULL;
}
return dwRet;
}
// Play an audio file.
virtual void start( const rho::String& filename, rho::apiGenerator::CMethodResult& oResult)
{
// Check that the filename is not empty or NULL.
if (!filename.empty() && (!m_hPlayThread))
{
// Download the audio file and store name in lFilename
if(String_startsWith(filename, "http://") || String_startsWith(filename, "https://"))
{
rho::common::CRhoFile::deleteFile("download.wav");
// Networked code
LOG(INFO) + __FUNCTION__ + "Attempting to download the file. " + filename;
NetRequest oNetRequest;
Hashtable<String,String> mapHeaders;
bool overwriteFile = true;
bool createFolders = false;
bool fileExists = false;
String& newfilename = String("download.wav");
// Call the download function with the url and new filename the temp filename to be used.
net::CNetRequestHolder *requestHolder = new net::CNetRequestHolder();
requestHolder->setSslVerifyPeer(false);
NetResponse resp = getNetRequest(requestHolder).pullFile( filename, newfilename, null, &mapHeaders,overwriteFile,createFolders,&fileExists);
delete requestHolder;
if (!resp.isOK())
{
LOG(INFO) + __FUNCTION__ + "Could not download the file";
return; // Don't attempt to play the file.
}
else
{
LOG(INFO) + __FUNCTION__ + "Could download the file";
lFilename = s2ws(newfilename);
}
}
else
{
// Store the local filename away.
lFilename = s2ws(filename);
}
// Launch the audio player.
playLocalAudio();
}
}
// Stop playing an audio file.
virtual void stop(rho::apiGenerator::CMethodResult& oResult)
{
// If the player is currently playing an audio file, stop it.
PlaySound(NULL, NULL, 0);
LOG(INFO) + __FUNCTION__ + " Stopping audio playback";
if (WaitForSingleObject(m_hPlayThread, 500) == WAIT_TIMEOUT)
{
TerminateThread(m_hPlayThread, -1);
CloseHandle(m_hPlayThread);
m_hPlayThread = NULL;
}
}
// Start playing a video file.
virtual void startvideo( const rho::String& filename, rho::apiGenerator::CMethodResult& oResult)
{
// Attempt to kill the player. If we don't do this, WMP holds a lock on the file and we cannot delete it.
KillPlayer();
rho::common::CRhoFile::deleteFile("download.wmv");
// Check that the filename is not empty or NULL.
if (!filename.empty() && (!m_hPlayProcess))
{
PROCESS_INFORMATION pi;
StringW m_lpzFilename;
if (String_startsWith(filename, "http://") || String_startsWith(filename, "https://"))
{
// Networked code
LOG(INFO) + __FUNCTION__ + "Attempting to download the file. " + filename;
NetRequest oNetRequest;
Hashtable<String,String> mapHeaders;
bool overwriteFile = true;
bool createFolders = false;
bool fileExists = false;
String& newfilename = String("download.wmv");
// Call the download function with the url and new filename the temp filename to be used.
net::CNetRequestHolder *requestHolder = new net::CNetRequestHolder();
requestHolder->setSslVerifyPeer(false);
NetResponse resp = getNetRequest(requestHolder).pullFile( filename, newfilename, null, &mapHeaders,overwriteFile,createFolders,&fileExists);
delete requestHolder;
if (!resp.isOK())
{
LOG(INFO) + __FUNCTION__ + "Could not download the file";
return; // Don't attempt to play the file.
}
else
{
LOG(INFO) + __FUNCTION__ + "Could download the file";
m_lpzFilename = s2ws(newfilename);
}
}
else
{
// Local file, just change the name to a format the WM/CE understands.
m_lpzFilename = s2ws(filename);
}
/****************************************/
/*
SR ID - EMBPD00142480
Issue Description - Video files are not getting played in CE devices through Rhoelements application
Fix Provided - WinCE devices accepts only back slash in the path to play media files.
Also CE CreateProcess API doesn't accept quates in the API for meadia file path to handle space.
A conditional fix is given for WM devices and CE devices.
Developer Name - Sabir VT
File Name - Mediaplayer_impl.cpp
Function Name - startvideo
Date - 04/07/2014
*/
/****************************************/
bool bRunningOnWM = false;
OSVERSIONINFO osvi;
memset(&osvi, 0, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osvi);
bRunningOnWM = (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) ||
(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1);
if(bRunningOnWM)
{
//for WM devices, we enter here
/****************************************/
/*
SR ID - EMBPD00128123
Issue Description - Video Files are not getting played in MediaPlayer with Native Application on WM
Fix Provided - Issue was reproducing because of CreateProcess Microsoft API which donot understand the path which consists of space.
Hence we need to put an extra double inverted at the front & at the end of the string.
Developer Name - Abhineet Agarwal
File Name - Mediaplayer_impl.cpp
Function Name - startvideo
Date - 09/06/2014
*/
/****************************************/
m_lpzFilename = L"\"" + m_lpzFilename + L"\"";
}
else
{
//for CE devices we enter here
//replace front slash with back slash if the path contains front slash
m_lpzFilename = replaceString(m_lpzFilename, L"/", L"\\");
}
// Launch the video player.
if (!CreateProcess(L"\\windows\\WMPlayer.exe", m_lpzFilename.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi))
{
// for WinCE CEPlayer we need to set a registry key to make sure it launches full screen
HKEY hKey = 0;
LPCWSTR subkey = L"SOFTWARE\\Microsoft\\CEPlayer";
if( RegOpenKeyEx(HKEY_LOCAL_MACHINE,subkey,0,0,&hKey) == ERROR_SUCCESS)
{
DWORD dwType = REG_DWORD;
DWORD dwData = 1; // Set AlwaysFullSize to 1
RegSetValueEx(hKey, L"AlwaysFullSize", 0, dwType, (BYTE*)&dwData, sizeof(dwData));
RegCloseKey(hKey);
}
if (!CreateProcess(L"\\windows\\CEPlayer.exe", m_lpzFilename.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi))
{
// if CEPlayer doesn't exist either, try VPlayer
if (!CreateProcess(L"\\windows\\VPlayer.exe", m_lpzFilename.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi))
{
LOG(INFO) + __FUNCTION__ + "Error launching MediaPlayer";
return;
}
}
m_hPlayProcess = pi.hProcess;
m_hPlayThread = pi.hThread;
}
m_hPlayProcess = pi.hProcess;
m_hPlayThread = pi.hThread;
}
}
// Stop playing a video file.
virtual void stopvideo(rho::apiGenerator::CMethodResult& oResult)
{
// If the player is currently playing a video file, stop it.
TerminateProcess(m_hPlayProcess, -1);
WaitForSingleObject(m_hPlayProcess, 500);
CloseHandle(m_hPlayThread);
m_hPlayThread = NULL;
CloseHandle(m_hPlayProcess);
m_hPlayProcess = NULL;
LOG(INFO) + __FUNCTION__ + " stopping video player.";
}
virtual void getAllRingtones(rho::apiGenerator::CMethodResult& oResult)
{
// Not implemented in CE
}
virtual void playRingTone( const rho::String& name, rho::apiGenerator::CMethodResult& oResult)
{
// Not implemented in CE
}
virtual void stopRingTone(rho::apiGenerator::CMethodResult& oResult)
{
// Not implemented in CE
}
};
StringW CMediaplayerSingleton::lFilename;
HANDLE CMediaplayerSingleton::m_hPlayThread = NULL;
HANDLE CMediaplayerSingleton::m_hPlayProcess = NULL;
class CMediaplayerFactory: public CMediaplayerFactoryBase
{
~CMediaplayerFactory(){}
virtual IMediaplayerSingleton* createModuleSingleton();
virtual IMediaplayer* createModuleByID(const rho::String& strID);
};
extern "C" void Init_Mediaplayer_extension()
{
CMediaplayerFactory::setInstance( new CMediaplayerFactory() );
Init_Mediaplayer_API();
}
IMediaplayer* CMediaplayerFactory::createModuleByID(const rho::String& strID)
{
return new CMediaplayerImpl(strID);
}
IMediaplayerSingleton* CMediaplayerFactory::createModuleSingleton()
{
return new CMediaplayerSingleton();
}
void CMediaplayerSingleton::enumerate(CMethodResult& oResult)
{
rho::Vector<rho::String> arIDs;
arIDs.addElement("SC1");
arIDs.addElement("SC2");
oResult.set(arIDs);
}
rho::String CMediaplayerSingleton::getInitialDefaultID()
{
CMethodResult oRes;
enumerate(oRes);
rho::Vector<rho::String>& arIDs = oRes.getStringArray();
return arIDs[0];
}
}<commit_msg>EMBPD00143775 [4.1][CE] - Media player is not working for certain audio and video scenarios EMBPD00143777 [4.1][WM]Stop the local video file and also http file in Media Player API<commit_after>#include "../../../shared/generated/cpp/MediaplayerBase.h"
#include "net/INetRequest.h"
#include "RhoFile.h"
namespace rho {
using namespace apiGenerator;
std::wstring s2ws(const std::string& s)
{
int len;
int slength = (int)s.length() + 1;
len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
wchar_t* buf = new wchar_t[len];
MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
std::wstring r(buf);
delete[] buf;
return r;
}
class CMediaplayerImpl: public CMediaplayerBase
{
public:
CMediaplayerImpl(const rho::String& strID): CMediaplayerBase()
{
}
};
class CMediaplayerSingleton: public CMediaplayerSingletonBase
{
static HANDLE m_hPlayThread; /// Handle to play thread
static HANDLE m_hStopMediaEvent;
String szVideoFileName;
static bool m_bIsRunning; //start and stop of playthread decided by this flag
~CMediaplayerSingleton(){}
virtual rho::String getInitialDefaultID();
virtual void enumerate(CMethodResult& oResult);
rho::StringW replaceString(rho::StringW inputString,
rho::StringW toReplace,
rho::StringW replaceWith)
{
size_t f;
while( (f= inputString.find(toReplace))!= -1)
{
inputString.replace(f, toReplace.length(), replaceWith);
}
return inputString;
}
static DWORD WINAPI playThreadProc(LPVOID lpParam)
{
DWORD dwRet = S_OK;
CMediaplayerSingleton *pMediaplayer = (CMediaplayerSingleton *)lpParam;
if (pMediaplayer)
{
m_bIsRunning = true;
pMediaplayer->playMedia();
m_bIsRunning = false;
}
return dwRet;
}
void playMedia()
{
LOG(INFO) + __FUNCTION__ + " starting media player.";
// Check that the filename is not empty or NULL.
if (!szVideoFileName.empty())
{
PROCESS_INFORMATION pi;
StringW m_lpzFilename;
if (String_startsWith(szVideoFileName, "http://") || String_startsWith(szVideoFileName, "https://"))
{
// Networked code
LOG(INFO) + __FUNCTION__ + "Attempting to download the file. " + szVideoFileName;
NetRequest oNetRequest;
Hashtable<String,String> mapHeaders;
bool overwriteFile = true;
bool createFolders = false;
bool fileExists = false;
//get the file extention
String szFileExtn;
size_t extIndex = szVideoFileName.rfind(".");
if(-1 != extIndex)
{
szFileExtn = szVideoFileName.substr( extIndex );
if(!szFileExtn.empty())
{
String& newfilename = String("download") + szFileExtn;
//delete the folder
rho::common::CRhoFile::deleteFile(newfilename.c_str());
// Call the download function with the url and new filename the temp filename to be used.
net::CNetRequestHolder *requestHolder = new net::CNetRequestHolder();
requestHolder->setSslVerifyPeer(false);
NetResponse resp = getNetRequest(requestHolder).pullFile( szVideoFileName, newfilename, null, &mapHeaders,overwriteFile,createFolders,&fileExists);
delete requestHolder;
if (!resp.isOK())
{
LOG(INFO) + __FUNCTION__ + " Could not download the file";
return; // Don't attempt to play the file.
}
else
{
LOG(INFO) + __FUNCTION__ + " Could download the file";
m_lpzFilename = s2ws(newfilename);
}
}
else
{
LOG(INFO) + __FUNCTION__ + " file extention is empty ";
}
}
else
{
LOG(INFO) + __FUNCTION__ + " invalid file extention ";
}
}
else
{
// Local file, just change the name to a format the WM/CE understands.
m_lpzFilename = s2ws(szVideoFileName);
}
if(!m_lpzFilename.empty())
{
String szFile = rho::common::convertToStringA(m_lpzFilename.c_str());
if(rho::common::CRhoFile::isFileExist(szFile.c_str()))
{
/****************************************/
/*
SR ID - EMBPD00142480
Issue Description - Video files are not getting played in CE devices through Rhoelements application
Fix Provided - WinCE devices accepts only back slash in the path to play media files.
Also CE CreateProcess API doesn't accept quates in the API for meadia file path to handle space.
A conditional fix is given for WM devices and CE devices.
Developer Name - Sabir VT
File Name - Mediaplayer_impl.cpp
Function Name - startvideo
Date - 04/07/2014
*/
/****************************************/
bool bRunningOnWM = false;
OSVERSIONINFO osvi;
memset(&osvi, 0, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osvi);
bRunningOnWM = (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) ||
(osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1);
if(bRunningOnWM)
{
//for WM devices, we enter here
/****************************************/
/*
SR ID - EMBPD00128123
Issue Description - Video Files are not getting played in MediaPlayer with Native Application on WM
Fix Provided - Issue was reproducing because of CreateProcess Microsoft API which donot understand the path which consists of space.
Hence we need to put an extra double inverted at the front & at the end of the string.
Developer Name - Abhineet Agarwal
File Name - Mediaplayer_impl.cpp
Function Name - startvideo
Date - 09/06/2014
*/
/****************************************/
m_lpzFilename = L"\"" + m_lpzFilename + L"\"";
}
else
{
//for CE devices we enter here
//replace front slash with back slash if the path contains front slash
m_lpzFilename = replaceString(m_lpzFilename, L"/", L"\\");
}
// Launch the video player.
if (!CreateProcess(L"\\windows\\WMPlayer.exe", m_lpzFilename.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi))
{
// for WinCE CEPlayer we need to set a registry key to make sure it launches full screen
HKEY hKey = 0;
LPCWSTR subkey = L"SOFTWARE\\Microsoft\\CEPlayer";
if( RegOpenKeyEx(HKEY_LOCAL_MACHINE,subkey,0,0,&hKey) == ERROR_SUCCESS)
{
DWORD dwType = REG_DWORD;
DWORD dwData = 1; // Set AlwaysFullSize to 1
RegSetValueEx(hKey, L"AlwaysFullSize", 0, dwType, (BYTE*)&dwData, sizeof(dwData));
RegCloseKey(hKey);
}
if (!CreateProcess(L"\\windows\\CEPlayer.exe", m_lpzFilename.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi))
{
// if CEPlayer doesn't exist either, try VPlayer
if (!CreateProcess(L"\\windows\\VPlayer.exe", m_lpzFilename.c_str(), NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi))
{
LOG(INFO) + __FUNCTION__ + "Error launching MediaPlayer";
return;
}
}
}
//let us wait here till some once closes the process
HANDLE hEvents[2] = {m_hStopMediaEvent, pi.hProcess};
DWORD dwEvent = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
if(0 == dwEvent)
{
TerminateProcess(pi.hProcess, -1);
WaitForSingleObject(pi.hProcess, 500);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
LOG(INFO) + __FUNCTION__ + " stopping media player.";
}
else
{
LOG(INFO) + __FUNCTION__ + " file does not exist ";
}
}
else
{
LOG(INFO) + __FUNCTION__ + " file name is empty ";
}
}
}
// Play an audio file.
virtual void start( const rho::String& filename, rho::apiGenerator::CMethodResult& oResult)
{
startvideo(filename, oResult);
}
// Stop playing an audio file.
virtual void stop(rho::apiGenerator::CMethodResult& oResult)
{
stopvideo(oResult);
}
// Start playing a video file.
virtual void startvideo( const rho::String& filename, rho::apiGenerator::CMethodResult& oResult)
{
LOG(INFO) + __FUNCTION__ + " start video called";
if(false == m_bIsRunning)
{
//if thread not running
szVideoFileName = filename;
m_hPlayThread = CreateThread (NULL, 0, playThreadProc, this, 0, NULL);
}
else
{
LOG(INFO) + __FUNCTION__ + " media player already running";
}
}
// Stop playing a video file.
virtual void stopvideo(rho::apiGenerator::CMethodResult& oResult)
{
LOG(INFO) + __FUNCTION__ + " stop video called.";
if(true == m_bIsRunning)
{
//if thread running
SetEvent(m_hStopMediaEvent);
WaitForSingleObject(m_hPlayThread, INFINITE);
ResetEvent(m_hStopMediaEvent);
CloseHandle(m_hPlayThread);
m_hPlayThread = NULL;
}
else
{
LOG(INFO) + __FUNCTION__ + " media player not running to stop.";
}
}
virtual void getAllRingtones(rho::apiGenerator::CMethodResult& oResult)
{
// Not implemented in CE
}
virtual void playRingTone( const rho::String& name, rho::apiGenerator::CMethodResult& oResult)
{
// Not implemented in CE
}
virtual void stopRingTone(rho::apiGenerator::CMethodResult& oResult)
{
// Not implemented in CE
}
};
HANDLE CMediaplayerSingleton::m_hPlayThread = NULL;
HANDLE CMediaplayerSingleton::m_hStopMediaEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
bool CMediaplayerSingleton::m_bIsRunning = false;
class CMediaplayerFactory: public CMediaplayerFactoryBase
{
~CMediaplayerFactory(){}
virtual IMediaplayerSingleton* createModuleSingleton();
virtual IMediaplayer* createModuleByID(const rho::String& strID);
};
extern "C" void Init_Mediaplayer_extension()
{
CMediaplayerFactory::setInstance( new CMediaplayerFactory() );
Init_Mediaplayer_API();
}
IMediaplayer* CMediaplayerFactory::createModuleByID(const rho::String& strID)
{
return new CMediaplayerImpl(strID);
}
IMediaplayerSingleton* CMediaplayerFactory::createModuleSingleton()
{
return new CMediaplayerSingleton();
}
void CMediaplayerSingleton::enumerate(CMethodResult& oResult)
{
rho::Vector<rho::String> arIDs;
arIDs.addElement("SC1");
arIDs.addElement("SC2");
oResult.set(arIDs);
}
rho::String CMediaplayerSingleton::getInitialDefaultID()
{
CMethodResult oRes;
enumerate(oRes);
rho::Vector<rho::String>& arIDs = oRes.getStringArray();
return arIDs[0];
}
}<|endoftext|> |
<commit_before>/*
* AlgebraicDistance.cpp
*
* Created on: 03.11.2015
* Author: Henning Meyerhenke, Christian Staudt
*/
#include "AlgebraicDistance.h"
#include "../auxiliary/Timer.h"
#include <omp.h>
namespace NetworKit {
AlgebraicDistance::AlgebraicDistance(const Graph& G, count numberSystems, count numberIterations, double omega, index norm) : NodeDistance(G), numSystems(numberSystems), numIters(numberIterations), omega(omega), norm(norm) {
if ((omega < 0.0) || (omega > 1.0)) throw std::invalid_argument("omega must be in [0,1]");
}
void AlgebraicDistance::randomInit() {
// allocate space for loads
loads.resize(numSystems*G.upperNodeIdBound());
#pragma omp parallel for
for (index i = 0; i < loads.size(); ++i) {
loads[i] = Aux::Random::real();
}
}
void AlgebraicDistance::preprocess() {
Aux::Timer running1;
running1.start();
// random init
randomInit();
// main loop
{
std::vector<double> oldLoads(loads.size());
for (index iter = 0; iter < numIters; ++iter) {
// store previous iteration
loads.swap(oldLoads);
G.balancedParallelForNodes([&](node u) {
std::vector<double> val(numSystems, 0.0);
double weightedDeg = 0;
// step 1
G.forNeighborsOf(u, [&](node v, edgeweight weight) {
for (index i = 0; i < numSystems; ++i) {
val[i] += weight * oldLoads[v*numSystems + i];
}
weightedDeg += weight;
});
for (index i = 0; i < numSystems; ++i) {
val[i] /= weightedDeg;
// step 2
loads[u*numSystems + i] = (1 - omega) * oldLoads[u*numSystems + i] + omega * val[i];
}
});
}
}
// normalization. Compute min/max over all nodes per system (and per thread)
std::vector<std::vector<double>> minPerThread(omp_get_max_threads(), std::vector<double>(numSystems, std::numeric_limits<double>::max()));
std::vector<std::vector<double>> maxPerThread(omp_get_max_threads(), std::vector<double>(numSystems, std::numeric_limits<double>::lowest()));
G.parallelForNodes([&](node u) {
auto tid = omp_get_thread_num();
const index startId = u*numSystems;
for (index sys = 0; sys < numSystems; ++sys) {
minPerThread[tid][sys] = std::min(minPerThread[tid][sys], loads[startId + sys]);
maxPerThread[tid][sys] = std::max(maxPerThread[tid][sys], loads[startId + sys]);
}
});
std::vector<double> minPerSystem = std::move(minPerThread[0]);
std::vector<double> maxPerSystem = std::move(maxPerThread[0]);
for (index i = 1; i < minPerThread.size(); ++i) {
for (index sys = 0; sys < numSystems; ++sys) {
minPerSystem[sys] = std::min(minPerSystem[sys], minPerThread[i][sys]);
maxPerSystem[sys] = std::max(maxPerSystem[sys], maxPerThread[i][sys]);
}
}
// set normalized values: new = (min - old) / (min - max)
// normalization is per system
G.parallelForNodes([&](node u) {
const index startId = u*numSystems;
for (index sys = 0; sys < numSystems; ++sys) {
loads[startId + sys] = (minPerSystem[sys] - loads[startId + sys]) / (minPerSystem[sys] - maxPerSystem[sys]);
}
});
// calculate edge scores
if (!G.hasEdgeIds()) {
throw std::runtime_error("edges have not been indexed - call indexEdges first");
}
edgeScores.resize(G.upperEdgeIdBound(), none);
G.parallelForEdges([&](node u, node v, edgeid eid) {
edgeScores[eid] = distance(u, v);
});
running1.stop();
INFO("elapsed millisecs for AD preprocessing: ", running1.elapsedMilliseconds(), "\n");
}
double AlgebraicDistance::distance(node u, node v) {
if (loads.size() == 0) {
throw std::runtime_error("Call preprocess() first.");
}
double result = 0.0;
if (norm == MAX_NORM) {
for (index sys = 0; sys < numSystems; ++sys) {
double absDiff = fabs(loads[u*numSystems + sys] - loads[u*numSystems + sys]);
if (absDiff > result) {
result = absDiff;
}
}
} else {
for (index sys = 0; sys < numSystems; ++sys) {
double absDiff = fabs(loads[u*numSystems + sys] - loads[v*numSystems + sys]);
result += pow(absDiff, norm);
}
result = pow(result, 1.0 / (double) norm);
}
return std::isnan(result) ? 0 : result;
}
std::vector<double> AlgebraicDistance::getEdgeAttribute() {
return edgeScores;
}
} /* namespace NetworKit */
<commit_msg>AlgebraicDistance: Fix MAX-norm<commit_after>/*
* AlgebraicDistance.cpp
*
* Created on: 03.11.2015
* Author: Henning Meyerhenke, Christian Staudt
*/
#include "AlgebraicDistance.h"
#include "../auxiliary/Timer.h"
#include <omp.h>
namespace NetworKit {
AlgebraicDistance::AlgebraicDistance(const Graph& G, count numberSystems, count numberIterations, double omega, index norm) : NodeDistance(G), numSystems(numberSystems), numIters(numberIterations), omega(omega), norm(norm) {
if ((omega < 0.0) || (omega > 1.0)) throw std::invalid_argument("omega must be in [0,1]");
}
void AlgebraicDistance::randomInit() {
// allocate space for loads
loads.resize(numSystems*G.upperNodeIdBound());
#pragma omp parallel for
for (index i = 0; i < loads.size(); ++i) {
loads[i] = Aux::Random::real();
}
}
void AlgebraicDistance::preprocess() {
Aux::Timer running1;
running1.start();
// random init
randomInit();
// main loop
{
std::vector<double> oldLoads(loads.size());
for (index iter = 0; iter < numIters; ++iter) {
// store previous iteration
loads.swap(oldLoads);
G.balancedParallelForNodes([&](node u) {
std::vector<double> val(numSystems, 0.0);
double weightedDeg = 0;
// step 1
G.forNeighborsOf(u, [&](node v, edgeweight weight) {
for (index i = 0; i < numSystems; ++i) {
val[i] += weight * oldLoads[v*numSystems + i];
}
weightedDeg += weight;
});
for (index i = 0; i < numSystems; ++i) {
val[i] /= weightedDeg;
// step 2
loads[u*numSystems + i] = (1 - omega) * oldLoads[u*numSystems + i] + omega * val[i];
}
});
}
}
// normalization. Compute min/max over all nodes per system (and per thread)
std::vector<std::vector<double>> minPerThread(omp_get_max_threads(), std::vector<double>(numSystems, std::numeric_limits<double>::max()));
std::vector<std::vector<double>> maxPerThread(omp_get_max_threads(), std::vector<double>(numSystems, std::numeric_limits<double>::lowest()));
G.parallelForNodes([&](node u) {
auto tid = omp_get_thread_num();
const index startId = u*numSystems;
for (index sys = 0; sys < numSystems; ++sys) {
minPerThread[tid][sys] = std::min(minPerThread[tid][sys], loads[startId + sys]);
maxPerThread[tid][sys] = std::max(maxPerThread[tid][sys], loads[startId + sys]);
}
});
std::vector<double> minPerSystem = std::move(minPerThread[0]);
std::vector<double> maxPerSystem = std::move(maxPerThread[0]);
for (index i = 1; i < minPerThread.size(); ++i) {
for (index sys = 0; sys < numSystems; ++sys) {
minPerSystem[sys] = std::min(minPerSystem[sys], minPerThread[i][sys]);
maxPerSystem[sys] = std::max(maxPerSystem[sys], maxPerThread[i][sys]);
}
}
// set normalized values: new = (min - old) / (min - max)
// normalization is per system
G.parallelForNodes([&](node u) {
const index startId = u*numSystems;
for (index sys = 0; sys < numSystems; ++sys) {
loads[startId + sys] = (minPerSystem[sys] - loads[startId + sys]) / (minPerSystem[sys] - maxPerSystem[sys]);
}
});
// calculate edge scores
if (!G.hasEdgeIds()) {
throw std::runtime_error("edges have not been indexed - call indexEdges first");
}
edgeScores.resize(G.upperEdgeIdBound(), none);
G.parallelForEdges([&](node u, node v, edgeid eid) {
edgeScores[eid] = distance(u, v);
});
running1.stop();
INFO("elapsed millisecs for AD preprocessing: ", running1.elapsedMilliseconds(), "\n");
}
double AlgebraicDistance::distance(node u, node v) {
if (loads.size() == 0) {
throw std::runtime_error("Call preprocess() first.");
}
double result = 0.0;
if (norm == MAX_NORM) {
for (index sys = 0; sys < numSystems; ++sys) {
double absDiff = fabs(loads[u*numSystems + sys] - loads[v*numSystems + sys]);
if (absDiff > result) {
result = absDiff;
}
}
} else {
for (index sys = 0; sys < numSystems; ++sys) {
double absDiff = fabs(loads[u*numSystems + sys] - loads[v*numSystems + sys]);
result += pow(absDiff, norm);
}
result = pow(result, 1.0 / (double) norm);
}
return std::isnan(result) ? 0 : result;
}
std::vector<double> AlgebraicDistance::getEdgeAttribute() {
return edgeScores;
}
} /* namespace NetworKit */
<|endoftext|> |
<commit_before>/**
* Plucked string synthesis using Karplus-Strong algorithm.
*
*/
#include "aquila/synth/KarplusStrongSynthesizer.h"
#include <iostream>
int main(int argc, char** argv)
{
std::cout << "Plucked string synthesis using Karplus-Strong algorithm\n";
const Aquila::FrequencyType SAMPLE_FREQUENCY = 44100;
Aquila::KarplusStrongSynthesizer synth(SAMPLE_FREQUENCY);
// play the C major scale up and down
synth.playNote("c");
synth.playNote("d");
synth.playNote("e");
synth.playNote("f");
synth.playNote("g");
synth.playNote("a");
synth.playNote("b");
synth.playNote("cH");
synth.playNote("pause");
synth.playNote("cH");
synth.playNote("b");
synth.playNote("a");
synth.playNote("g");
synth.playNote("f");
synth.playNote("e");
synth.playNote("d");
synth.playNote("c");
return 0;
}
<commit_msg>Karplus-Strong example can now play notes from external file.<commit_after>/**
* Plucked string synthesis using Karplus-Strong algorithm.
*
*/
#include "aquila/synth/KarplusStrongSynthesizer.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
class NoteReader
{
public:
NoteReader(Aquila::Synthesizer& synthesizer):
m_synthesizer(synthesizer)
{
}
void playString(const std::string& notes)
{
std::istringstream stream(notes);
playStream(stream);
}
void playFile(const std::string& filename)
{
std::ifstream stream(filename);
playStream(stream);
}
void playStream(std::istream& stream)
{
std::string line, note;
unsigned int duration, lineNumber;
while(std::getline(stream, line))
{
lineNumber++;
if (!line.empty())
{
std::istringstream lineStream(line);
if (lineStream >> note >> duration)
{
m_synthesizer.playNote(note, duration);
}
else
{
std::cerr << "Parse error on line " << lineNumber
<< ": '" << line << "'" << std::endl;
}
}
}
}
private:
Aquila::Synthesizer& m_synthesizer;
};
const std::string Cmajor =
"c 500\n"
"d 500\n"
"e 500\n"
"f 500\n"
"g 500\n"
"a 500\n"
"b 500\n"
"cH 500\n"
"pause 500\n"
"cH 500\n"
"b 500\n"
"a 500\n"
"g 500\n"
"f 500\n"
"e 500\n"
"d 500\n"
"c 500\n";
int main(int argc, char** argv)
{
std::cout << "Plucked string synthesis using Karplus-Strong algorithm\n";
const Aquila::FrequencyType SAMPLE_FREQUENCY = 44100;
Aquila::KarplusStrongSynthesizer synth(SAMPLE_FREQUENCY);
NoteReader reader(synth);
if (argc < 2)
{
std::cout << "No filename provided, playing C major scale" << std::endl;
reader.playString(Cmajor);
}
else
{
std::cout << "Playing notes from " << argv[1] << std::endl;
reader.playFile(argv[1]);
}
return 0;
}
<|endoftext|> |
<commit_before>//
// SkyboxNode.m
// testar1
//
// Created by Pasi Kettunen on 12.12.2012.
//
//
#include "Sprite3D.h"
using namespace cocos2d;
#define USE_VBO
#define STRINGIFY(A) #A
//#include "../Shaders/TexturedLighting.es2.vert.h"
#include "Textured.es2.vert.h"
#include "Textured.es2.frag.h"
#include "Colored.es2.frag.h"
Sprite3D* Sprite3D::create(const std::string &modelPath, const std::string &texturePath)
{
auto ret = new Sprite3D;
if( ret && ret->init(modelPath, texturePath)) {
ret->autorelease();
return ret;
}
return nullptr;
}
Sprite3D::Sprite3D()
: _texture(nullptr)
{
}
Sprite3D::~Sprite3D()
{
}
bool Sprite3D::init(const std::string &modelPath, const std::string &texturePath)
{
auto model = new Mesh(modelPath);
if( texturePath.size()) {
setTextureName(texturePath);
}
setModel(model);
return true;
}
void Sprite3D::initializeModel()
{
if (_model) {
_model->generateVertices(_vertices, 0);
//int indexCount = _model->getTriangleIndexCount();
//_indices.resize(indexCount);
_model->generateTriangleIndices(_indices);
_drawable.IndexCount = _indices.size();
delete _model;
_model = NULL;
#ifdef USE_VBO
this->buildBuffers();
#endif
this->updateBlendFunc();
buildProgram( _texture->getName() != 0);
}
}
void Sprite3D::setModel(Mesh *model)
{
_model = model;
this->initializeModel();
}
bool Sprite3D::buildProgram(bool textured)
{
auto shaderProgram = new GLProgram();
// Create the GLSL program.
if (textured) {
shaderProgram->initWithByteArrays(baseVertexShader, baseTexturedFrag);
}
else
shaderProgram->initWithByteArrays(baseVertexShader, baseColoredFrag);
//glUseProgram(_program);
shaderProgram->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_POSITION, GLProgram::VERTEX_ATTRIB_POSITION);
shaderProgram->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_COLOR, GLProgram::VERTEX_ATTRIB_COLOR);
shaderProgram->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_TEX_COORD, GLProgram::VERTEX_ATTRIB_TEX_COORDS);
shaderProgram->link();
shaderProgram->updateUniforms();
// Extract the handles to attributes and uniforms.
_attributes.Position = shaderProgram->getAttribLocation("Position");
_attributes.Normal = shaderProgram->getAttribLocation("Normal");
_uniforms.DiffuseMaterial = shaderProgram->getUniformLocation("DiffuseMaterial");
if (textured) {
_attributes.TextureCoord = shaderProgram->getAttribLocation("TextureCoord");
_uniforms.Sampler = shaderProgram->getUniformLocation("Sampler");
}
else {
_attributes.TextureCoord = 0;
_uniforms.Sampler = 0;
}
_uniforms.NormalMatrix = shaderProgram->getUniformLocation("NormalMatrix");
setShaderProgram(shaderProgram);
return true;
}
#ifdef USE_VBO
void Sprite3D::buildBuffers()
{
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
_vertices.size() * sizeof(_vertices[0]),
&_vertices[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Create a new VBO for the indices
ssize_t indexCount = _indices.size();// model->GetTriangleIndexCount();
GLuint indexBuffer;
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
indexCount * sizeof(GLushort),
&_indices[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
_drawable.VertexBuffer = vertexBuffer;
_drawable.IndexBuffer = indexBuffer;
_drawable.IndexCount = indexCount;
}
#endif
void Sprite3D::draw(Renderer* renderer, const kmMat4 &transform, bool transformUpdated)
{
_customCommand.init(_globalZOrder);
_customCommand.func = CC_CALLBACK_0(Sprite3D::onDraw, this, transform, transformUpdated);
Director::getInstance()->getRenderer()->addCommand(&_customCommand);
}
void Sprite3D::onDraw(const kmMat4 &transform, bool transformUpdated)
{
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// ********** Base Draw *************
getShaderProgram()->use();
getShaderProgram()->setUniformsForBuiltins(transform);
GL::blendFunc( _blendFunc.src, _blendFunc.dst );
kmGLLoadIdentity();
if (_texture->getName()) {
GL::bindTexture2D(_texture->getName());
glUniform1i(_uniforms.Sampler, 0);
GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );
}
else {
GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );
}
// Set the diffuse color.
glUniform3f(_uniforms.DiffuseMaterial,1, 1, 1);
// Initialize various state.
glEnableVertexAttribArray(_attributes.Position);
glEnableVertexAttribArray(_attributes.Normal);
if (_texture->getName())
glEnableVertexAttribArray(_attributes.TextureCoord);
// Set the normal matrix.
// It's orthogonal, so its Inverse-Transpose is itself!
kmMat3 normals;
kmMat3AssignMat4(&normals, &_modelViewTransform);
glUniformMatrix3fv(_uniforms.NormalMatrix, 1, 0, &normals.mat[0]);
// Draw the surface using VBOs
int stride = sizeof(vec3) + sizeof(vec3) + sizeof(vec2);
const GLvoid* normalOffset = (const GLvoid*) sizeof(vec3);
const GLvoid* texCoordOffset = (const GLvoid*) (2 * sizeof(vec3));
GLint position = _attributes.Position;
GLint normal = _attributes.Normal;
GLint texCoord = _attributes.TextureCoord;
glBindBuffer(GL_ARRAY_BUFFER, _drawable.VertexBuffer);
glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, stride, 0);
glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, stride, normalOffset);
if (_texture->getName())
glVertexAttribPointer(texCoord, 2, GL_FLOAT, GL_FALSE, stride, texCoordOffset);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _drawable.IndexBuffer);
glDrawElements(GL_TRIANGLES, _drawable.IndexCount, GL_UNSIGNED_SHORT, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if(_outLine)
{
// ******* Outline Draw **********
glCullFace(GL_FRONT);
_outlineShader->use();
_outlineShader->setUniformsForBuiltins(_modelViewTransform);
//GL::blendFunc( _blendFunc.src, _blendFunc.dst );
kmGLLoadIdentity();
GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );
// Initialize various state.
glEnableVertexAttribArray(_attributesOutline.Position);
glEnableVertexAttribArray(_attributesOutline.Normal);
// Set the normal matrix.
// It's orthogonal, so its Inverse-Transpose is itself!
//kmMat3 normals;
kmMat3AssignMat4(&normals, &_modelViewTransform);
glUniformMatrix3fv(_uniformsOutline.NormalMatrix, 1, 0, &normals.mat[0]);
glUniform1f(_uniformsOutline.OutlineWidth, _outLineWidth);
Color4F fOutlineColor(_outlineColor);
glUniform3f(_uniformsOutline.OutlineColor,fOutlineColor.r,fOutlineColor.g,fOutlineColor.b);
// Draw the surface using VBOs
stride = sizeof(vec3) + sizeof(vec3) + sizeof(vec2);
normalOffset = (const GLvoid*) sizeof(vec3);
position = _attributesOutline.Position;
normal = _attributesOutline.Normal;
glBindBuffer(GL_ARRAY_BUFFER, _drawable.VertexBuffer);
glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, stride, 0);
glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, stride, normalOffset);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _drawable.IndexBuffer);
glDrawElements(GL_TRIANGLES, _drawable.IndexCount, GL_UNSIGNED_SHORT, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _drawable.IndexCount);
glCullFace(GL_BACK);
}
glDisable(GL_DEPTH_TEST);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _drawable.IndexCount);
}
void Sprite3D::setTextureName(const std::string& textureName)
{
auto cache = Director::getInstance()->getTextureCache();
Texture2D *tex = cache->addImage(textureName);
if( tex ) {
this->setTexture(tex);
}
}
void Sprite3D::removeTexture()
{
if( _texture ) {
_texture->release();
this->updateBlendFunc();
buildProgram(_texture->getName() != 0);
}
}
#pragma mark Sprite3D - CocosNodeTexture protocol
void Sprite3D::updateBlendFunc()
{
// it is possible to have an untextured sprite
if( !_texture || ! _texture->hasPremultipliedAlpha() ) {
_blendFunc.src = GL_SRC_ALPHA;
_blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;
} else {
_blendFunc.src = CC_BLEND_SRC;
_blendFunc.dst = CC_BLEND_DST;
}
}
void Sprite3D::setTexture(Texture2D* texture)
{
CCASSERT( texture , "setTexture expects a Texture2D. Invalid argument");
if( _texture != texture ) {
if(_texture)
_texture->release();
_texture = texture;
_texture->retain();
this->updateBlendFunc();
buildProgram( _texture->getName() != 0);
}
}
void Sprite3D::setOutline(float width, Color3B color)
{
if(width >0)
{
_outLine = true;
_outLineWidth = width;
_outlineColor = color;
_outlineShader = new GLProgram();
_outlineShader->initWithByteArrays(outLineShader, blackFrag);
_outlineShader->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_POSITION, GLProgram::VERTEX_ATTRIB_POSITION);
_outlineShader->link();
_outlineShader->updateUniforms();
_attributesOutline.Position = _outlineShader->getAttribLocation("Position");
_attributesOutline.Normal = _outlineShader->getAttribLocation("Normal");
_uniformsOutline.NormalMatrix = _outlineShader->getUniformLocation("NormalMatrix");
_uniformsOutline.OutlineWidth = _outlineShader->getUniformLocation("OutlineWidth");
_uniformsOutline.OutlineColor = _outlineShader->getUniformLocation("OutLineColor");
}
}
<commit_msg>comment code to remove openGL error<commit_after>//
// SkyboxNode.m
// testar1
//
// Created by Pasi Kettunen on 12.12.2012.
//
//
#include "Sprite3D.h"
using namespace cocos2d;
#define USE_VBO
#define STRINGIFY(A) #A
//#include "../Shaders/TexturedLighting.es2.vert.h"
#include "Textured.es2.vert.h"
#include "Textured.es2.frag.h"
#include "Colored.es2.frag.h"
Sprite3D* Sprite3D::create(const std::string &modelPath, const std::string &texturePath)
{
auto ret = new Sprite3D;
if( ret && ret->init(modelPath, texturePath)) {
ret->autorelease();
return ret;
}
return nullptr;
}
Sprite3D::Sprite3D()
: _texture(nullptr)
{
}
Sprite3D::~Sprite3D()
{
}
bool Sprite3D::init(const std::string &modelPath, const std::string &texturePath)
{
auto model = new Mesh(modelPath);
if( texturePath.size()) {
setTextureName(texturePath);
}
setModel(model);
return true;
}
void Sprite3D::initializeModel()
{
if (_model) {
_model->generateVertices(_vertices, 0);
//int indexCount = _model->getTriangleIndexCount();
//_indices.resize(indexCount);
_model->generateTriangleIndices(_indices);
_drawable.IndexCount = _indices.size();
delete _model;
_model = NULL;
#ifdef USE_VBO
this->buildBuffers();
#endif
this->updateBlendFunc();
buildProgram( _texture->getName() != 0);
}
}
void Sprite3D::setModel(Mesh *model)
{
_model = model;
this->initializeModel();
}
bool Sprite3D::buildProgram(bool textured)
{
auto shaderProgram = new GLProgram();
// Create the GLSL program.
if (textured) {
shaderProgram->initWithByteArrays(baseVertexShader, baseTexturedFrag);
}
else
shaderProgram->initWithByteArrays(baseVertexShader, baseColoredFrag);
//glUseProgram(_program);
shaderProgram->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_POSITION, GLProgram::VERTEX_ATTRIB_POSITION);
shaderProgram->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_COLOR, GLProgram::VERTEX_ATTRIB_COLOR);
shaderProgram->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_TEX_COORD, GLProgram::VERTEX_ATTRIB_TEX_COORDS);
shaderProgram->link();
shaderProgram->updateUniforms();
// Extract the handles to attributes and uniforms.
_attributes.Position = shaderProgram->getAttribLocation("Position");
_attributes.Normal = shaderProgram->getAttribLocation("Normal");
_uniforms.DiffuseMaterial = shaderProgram->getUniformLocation("DiffuseMaterial");
if (textured) {
_attributes.TextureCoord = shaderProgram->getAttribLocation("TextureCoord");
_uniforms.Sampler = shaderProgram->getUniformLocation("Sampler");
}
else {
_attributes.TextureCoord = 0;
_uniforms.Sampler = 0;
}
_uniforms.NormalMatrix = shaderProgram->getUniformLocation("NormalMatrix");
setShaderProgram(shaderProgram);
return true;
}
#ifdef USE_VBO
void Sprite3D::buildBuffers()
{
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
_vertices.size() * sizeof(_vertices[0]),
&_vertices[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Create a new VBO for the indices
ssize_t indexCount = _indices.size();// model->GetTriangleIndexCount();
GLuint indexBuffer;
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
indexCount * sizeof(GLushort),
&_indices[0],
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
_drawable.VertexBuffer = vertexBuffer;
_drawable.IndexBuffer = indexBuffer;
_drawable.IndexCount = indexCount;
}
#endif
void Sprite3D::draw(Renderer* renderer, const kmMat4 &transform, bool transformUpdated)
{
_customCommand.init(_globalZOrder);
_customCommand.func = CC_CALLBACK_0(Sprite3D::onDraw, this, transform, transformUpdated);
Director::getInstance()->getRenderer()->addCommand(&_customCommand);
}
void Sprite3D::onDraw(const kmMat4 &transform, bool transformUpdated)
{
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// ********** Base Draw *************
getShaderProgram()->use();
getShaderProgram()->setUniformsForBuiltins(transform);
GL::blendFunc( _blendFunc.src, _blendFunc.dst );
kmGLLoadIdentity();
if (_texture->getName()) {
GL::bindTexture2D(_texture->getName());
glUniform1i(_uniforms.Sampler, 0);
GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX );
}
else {
GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );
}
// Set the diffuse color.
glUniform3f(_uniforms.DiffuseMaterial,1, 1, 1);
// Initialize various state.
glEnableVertexAttribArray(_attributes.Position);
//glEnableVertexAttribArray(_attributes.Normal);
if (_texture->getName())
glEnableVertexAttribArray(_attributes.TextureCoord);
// Set the normal matrix.
// It's orthogonal, so its Inverse-Transpose is itself!
kmMat3 normals;
kmMat3AssignMat4(&normals, &_modelViewTransform);
glUniformMatrix3fv(_uniforms.NormalMatrix, 1, 0, &normals.mat[0]);
// Draw the surface using VBOs
int stride = sizeof(vec3) + sizeof(vec3) + sizeof(vec2);
const GLvoid* normalOffset = (const GLvoid*) sizeof(vec3);
const GLvoid* texCoordOffset = (const GLvoid*) (2 * sizeof(vec3));
GLint position = _attributes.Position;
GLint normal = _attributes.Normal;
GLint texCoord = _attributes.TextureCoord;
glBindBuffer(GL_ARRAY_BUFFER, _drawable.VertexBuffer);
glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, stride, 0);
//glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, stride, normalOffset);
if (_texture->getName())
glVertexAttribPointer(texCoord, 2, GL_FLOAT, GL_FALSE, stride, texCoordOffset);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _drawable.IndexBuffer);
glDrawElements(GL_TRIANGLES, _drawable.IndexCount, GL_UNSIGNED_SHORT, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if(_outLine)
{
// ******* Outline Draw **********
glCullFace(GL_FRONT);
_outlineShader->use();
_outlineShader->setUniformsForBuiltins(_modelViewTransform);
//GL::blendFunc( _blendFunc.src, _blendFunc.dst );
kmGLLoadIdentity();
GL::enableVertexAttribs( GL::VERTEX_ATTRIB_FLAG_POSITION );
// Initialize various state.
glEnableVertexAttribArray(_attributesOutline.Position);
glEnableVertexAttribArray(_attributesOutline.Normal);
// Set the normal matrix.
// It's orthogonal, so its Inverse-Transpose is itself!
//kmMat3 normals;
kmMat3AssignMat4(&normals, &_modelViewTransform);
glUniformMatrix3fv(_uniformsOutline.NormalMatrix, 1, 0, &normals.mat[0]);
glUniform1f(_uniformsOutline.OutlineWidth, _outLineWidth);
Color4F fOutlineColor(_outlineColor);
glUniform3f(_uniformsOutline.OutlineColor,fOutlineColor.r,fOutlineColor.g,fOutlineColor.b);
// Draw the surface using VBOs
stride = sizeof(vec3) + sizeof(vec3) + sizeof(vec2);
normalOffset = (const GLvoid*) sizeof(vec3);
position = _attributesOutline.Position;
normal = _attributesOutline.Normal;
glBindBuffer(GL_ARRAY_BUFFER, _drawable.VertexBuffer);
glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, stride, 0);
glVertexAttribPointer(normal, 3, GL_FLOAT, GL_FALSE, stride, normalOffset);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _drawable.IndexBuffer);
glDrawElements(GL_TRIANGLES, _drawable.IndexCount, GL_UNSIGNED_SHORT, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _drawable.IndexCount);
glCullFace(GL_BACK);
}
glDisable(GL_DEPTH_TEST);
CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _drawable.IndexCount);
}
void Sprite3D::setTextureName(const std::string& textureName)
{
auto cache = Director::getInstance()->getTextureCache();
Texture2D *tex = cache->addImage(textureName);
if( tex ) {
this->setTexture(tex);
}
}
void Sprite3D::removeTexture()
{
if( _texture ) {
_texture->release();
this->updateBlendFunc();
buildProgram(_texture->getName() != 0);
}
}
#pragma mark Sprite3D - CocosNodeTexture protocol
void Sprite3D::updateBlendFunc()
{
// it is possible to have an untextured sprite
if( !_texture || ! _texture->hasPremultipliedAlpha() ) {
_blendFunc.src = GL_SRC_ALPHA;
_blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA;
} else {
_blendFunc.src = CC_BLEND_SRC;
_blendFunc.dst = CC_BLEND_DST;
}
}
void Sprite3D::setTexture(Texture2D* texture)
{
CCASSERT( texture , "setTexture expects a Texture2D. Invalid argument");
if( _texture != texture ) {
if(_texture)
_texture->release();
_texture = texture;
_texture->retain();
this->updateBlendFunc();
buildProgram( _texture->getName() != 0);
}
}
void Sprite3D::setOutline(float width, Color3B color)
{
if(width >0)
{
_outLine = true;
_outLineWidth = width;
_outlineColor = color;
_outlineShader = new GLProgram();
_outlineShader->initWithByteArrays(outLineShader, blackFrag);
_outlineShader->bindAttribLocation(GLProgram::ATTRIBUTE_NAME_POSITION, GLProgram::VERTEX_ATTRIB_POSITION);
_outlineShader->link();
_outlineShader->updateUniforms();
_attributesOutline.Position = _outlineShader->getAttribLocation("Position");
_attributesOutline.Normal = _outlineShader->getAttribLocation("Normal");
_uniformsOutline.NormalMatrix = _outlineShader->getUniformLocation("NormalMatrix");
_uniformsOutline.OutlineWidth = _outlineShader->getUniformLocation("OutlineWidth");
_uniformsOutline.OutlineColor = _outlineShader->getUniformLocation("OutLineColor");
}
}
<|endoftext|> |
<commit_before>#include "PlayerLayer.h"
#include "GameManager.h"
USING_NS_CC;
bool CPlayerLayer::init()
{
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
m_CurrentPlayerId = -1;
m_VisibleSize = CCDirector::sharedDirector()->getVisibleSize();
//int playerNumber = CGameManager::GetInstance()->GetPlayerNumberOfThisGame();
//Init setting
//1.prepare positions for UI.
//2.prepare wating background
//3.set name
m_UIposition[0] = CCPoint(SHARED_PLAYER_UI_UPPER_LEFT_POS);
m_UIposition[1] = CCPoint(SHARED_PLAYER_UI_UPPER_RIGHT_POS);
m_UIposition[2] = CCPoint(SHARED_PLAYER_UI_BELOW_LEFT_POS);
m_UIposition[3] = CCPoint(SHARED_PLAYER_UI_BELOW_RIGHT_POS);
for (int playerId = 0; playerId<MAX_PLAYER_NUM; ++playerId)
{
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId) == -1)
continue;
int position = CGameManager::GetInstance()->GetPlayerTurn(playerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId);
m_BackGround[playerId] = CCSprite::create(SHARED_PLAYERUI_BG_WAIT[position].c_str());
m_BackGround[playerId]->setAnchorPoint(ccp(0,0));
m_BackGround[playerId]->setPosition(m_UIposition[position]);
addChild(m_BackGround[playerId],0);
if(CGameManager::GetInstance()->IsOnlineMode())
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS[4*position+characterId].c_str());
//̸ Ѵ. config ߰ .
m_PlayerName[playerId] = CCLabelTTF::create(CGameManager::GetInstance()->GetPlayerName(playerId).c_str(), GAME_FONT, 50,
CCSizeMake(400, 100), kCCTextAlignmentLeft);
m_PlayerName[playerId]->setAnchorPoint(ccp(0,0));
switch (position)
{
case 0:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+300.0f,m_UIposition[position].y+100.0f));
break;
case 1:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+100.0f,m_UIposition[position].y+100.0f));
break;
case 2:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+300.0f,m_UIposition[position].y+100.0f));
break;
case 3:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+100.0f,m_UIposition[position].y+100.0f));
break;
default:
break;
}
addChild(m_PlayerName[playerId],3);
}
else
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS_OFF[4*position+characterId].c_str());
CCSprite* name = CCSprite::create(SHARED_PLAYERUI_NAME_OFF[4*position+characterId].c_str());
name->setAnchorPoint(ccp(0,0));
name->setPosition(m_UIposition[position]);
addChild(name,3);
}
m_Player[playerId]->setAnchorPoint(ccp(0,0));
m_Player[playerId]->setPosition(m_UIposition[position]);
addChild(m_Player[playerId],2);
}
// (ù° ) ִϸ̼ ֵ update() ش.
update(0);
return true;
}
void CPlayerLayer::update( float dt )
{
//before running the animation, pause all the animations of playerUi.
if (m_CurrentPlayerId != -1)
{
removeChildByTag(10);
//SetWaitingCharacters();
m_Player[m_CurrentPlayerId]->setVisible(true);
}
m_CurrentPlayerId = CGameManager::GetInstance()->GetCurrentPlayerId();
int position = CGameManager::GetInstance()->GetPlayerTurn(m_CurrentPlayerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(m_CurrentPlayerId);
m_Player[m_CurrentPlayerId]->setVisible(false);
removeChildByTag(0);
CCSprite* currentTurnUI = CCSprite::create(SHARED_PLAYERUI_BG_TURN[position].c_str());
currentTurnUI->setTag(0);
currentTurnUI->setAnchorPoint(ccp(0,0));
currentTurnUI->setPosition(m_UIposition[position]);
addChild(currentTurnUI,1);
/////////added////////////
CCSpriteBatchNode* spritebatch;
CCSpriteFrameCache *cache;
if(CGameManager::GetInstance()->IsOnlineMode())
{
spritebatch = CCSpriteBatchNode::create(SHARED_PLAYERUI_CHARACTERS_ANI[4*position+characterId].c_str());
cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile(SHARED_PLAYERUI_CHARACTERS_ANI_PLIST[4*position+characterId].c_str());
}
else
{
spritebatch = CCSpriteBatchNode::create(SHARED_PLAYERUI_CHARACTERS_ANI_OFF[4*position+characterId].c_str());
cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile(SHARED_PLAYERUI_CHARACTERS_ANI_OFF_PLIST[4*position+characterId].c_str());
}
CCArray* animFrames = CCArray::createWithCapacity(SHARED_PLAYERUI_CHARACTERS_ANI_FRAME[characterId]);
char str[100] = {0};
for(int i = 1; i <= SHARED_PLAYERUI_CHARACTERS_ANI_FRAME[characterId]; i++)
{
sprintf(str, "ani_player_character0%d_0%d_000%02d.png",(characterId+1),(position+1),i);
CCSpriteFrame* frame = cache->spriteFrameByName( str );
animFrames->addObject(frame);
}
sprintf(str,"ani_player_character0%d_0%d_00001.png",(characterId+1),(position+1));
CCSprite *pElement = CCSprite::createWithSpriteFrameName( str );
pElement->setPosition( CCPoint(m_UIposition[position]) );
pElement->setAnchorPoint(ccp(0,0));
spritebatch->addChild(pElement);
spritebatch->setTag(10);
addChild(spritebatch,3);
CCAnimation* animation = CCAnimation::createWithSpriteFrames(animFrames,0.1f);
CCRepeatForever* repeatAction = CCRepeatForever::create(CCAnimate::create(animation));
pElement->runAction(repeatAction);
}
void CPlayerLayer::SetWaitingCharacters()
{
//pause
for (int playerId = 0; playerId<MAX_PLAYER_NUM;++playerId)
{
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId)==-1)
continue;
int position = CGameManager::GetInstance()->GetPlayerTurn(playerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId);
//online
if(CGameManager::GetInstance()->IsOnlineMode())
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS[4*position+characterId].c_str());
}
//offline
else
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS_OFF[4*position+characterId].c_str());
}
}
}
<commit_msg>애니메이션 수정 중입니다 위치는 맞췄는데 얘들 방향이 뒤집혀있음<commit_after>#include "PlayerLayer.h"
#include "GameManager.h"
USING_NS_CC;
bool CPlayerLayer::init()
{
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
m_CurrentPlayerId = -1;
m_VisibleSize = CCDirector::sharedDirector()->getVisibleSize();
//int playerNumber = CGameManager::GetInstance()->GetPlayerNumberOfThisGame();
//Init setting
//1.prepare positions for UI.
//2.prepare wating background
//3.set name
m_UIposition[0] = CCPoint(SHARED_PLAYER_UI_BELOW_LEFT_POS);
m_UIposition[1] = CCPoint(SHARED_PLAYER_UI_BELOW_RIGHT_POS);
m_UIposition[2] = CCPoint(SHARED_PLAYER_UI_UPPER_LEFT_POS);
m_UIposition[3] = CCPoint(SHARED_PLAYER_UI_UPPER_RIGHT_POS);
for (int playerId = 0; playerId<MAX_PLAYER_NUM; ++playerId)
{
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId) == -1)
continue;
int position = CGameManager::GetInstance()->GetPlayerTurn(playerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId);
m_BackGround[playerId] = CCSprite::create(SHARED_PLAYERUI_BG_WAIT[position].c_str());
m_BackGround[playerId]->setAnchorPoint(ccp(0,0));
m_BackGround[playerId]->setPosition(m_UIposition[position]);
addChild(m_BackGround[playerId],0);
if(CGameManager::GetInstance()->IsOnlineMode())
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS[4*position+characterId].c_str());
//̸ Ѵ. config ߰ .
m_PlayerName[playerId] = CCLabelTTF::create(CGameManager::GetInstance()->GetPlayerName(playerId).c_str(), GAME_FONT, 50,
CCSizeMake(400, 100), kCCTextAlignmentLeft);
m_PlayerName[playerId]->setAnchorPoint(ccp(0,0));
switch (position)
{
case 0:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+300.0f,m_UIposition[position].y+100.0f));
break;
case 1:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+100.0f,m_UIposition[position].y+100.0f));
break;
case 2:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+300.0f,m_UIposition[position].y+100.0f));
break;
case 3:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+100.0f,m_UIposition[position].y+100.0f));
break;
default:
break;
}
addChild(m_PlayerName[playerId],3);
}
else
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS_OFF[4*position+characterId].c_str());
CCSprite* name = CCSprite::create(SHARED_PLAYERUI_NAME_OFF[4*position+characterId].c_str());
name->setAnchorPoint(ccp(0,0));
name->setPosition(m_UIposition[position]);
addChild(name,3);
}
m_Player[playerId]->setAnchorPoint(ccp(0,0));
m_Player[playerId]->setPosition(m_UIposition[position]);
addChild(m_Player[playerId],2);
}
// (ù° ) ִϸ̼ ֵ update() ش.
update(0);
return true;
}
void CPlayerLayer::update( float dt )
{
//before running the animation, pause all the animations of playerUi.
if (m_CurrentPlayerId != -1)
{
removeChildByTag(10);
//SetWaitingCharacters();
m_Player[m_CurrentPlayerId]->setVisible(true);
}
m_CurrentPlayerId = CGameManager::GetInstance()->GetCurrentPlayerId();
int position = CGameManager::GetInstance()->GetPlayerTurn(m_CurrentPlayerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(m_CurrentPlayerId);
m_Player[m_CurrentPlayerId]->setVisible(false);
removeChildByTag(0);
CCSprite* currentTurnUI = CCSprite::create(SHARED_PLAYERUI_BG_TURN[position].c_str());
currentTurnUI->setTag(0);
currentTurnUI->setAnchorPoint(ccp(0,0));
currentTurnUI->setPosition(m_UIposition[position]);
addChild(currentTurnUI,1);
/////////added////////////
CCSpriteBatchNode* spritebatch;
CCSpriteFrameCache *cache;
if(CGameManager::GetInstance()->IsOnlineMode())
{
spritebatch = CCSpriteBatchNode::create(SHARED_PLAYERUI_CHARACTERS_ANI[4*position+characterId].c_str());
cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile(SHARED_PLAYERUI_CHARACTERS_ANI_PLIST[4*position+characterId].c_str());
}
else
{
spritebatch = CCSpriteBatchNode::create(SHARED_PLAYERUI_CHARACTERS_ANI_OFF[4*position+characterId].c_str());
cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile(SHARED_PLAYERUI_CHARACTERS_ANI_OFF_PLIST[4*position+characterId].c_str());
}
CCArray* animFrames = CCArray::createWithCapacity(SHARED_PLAYERUI_CHARACTERS_ANI_FRAME[characterId]);
char str[100] = {0};
for(int i = 1; i <= SHARED_PLAYERUI_CHARACTERS_ANI_FRAME[characterId]; i++)
{
sprintf(str, "ani_player_character0%d_0%d_000%02d.png",(characterId+1),(position+1),i);
CCSpriteFrame* frame = cache->spriteFrameByName( str );
animFrames->addObject(frame);
}
sprintf(str,"ani_player_character0%d_0%d_00001.png",(characterId+1),(position+1));
CCSprite *pElement = CCSprite::createWithSpriteFrameName( str );
pElement->setPosition( CCPoint(m_UIposition[position]) );
pElement->setAnchorPoint(ccp(0,0));
spritebatch->addChild(pElement);
spritebatch->setTag(10);
addChild(spritebatch,3);
CCAnimation* animation = CCAnimation::createWithSpriteFrames(animFrames,0.1f);
CCRepeatForever* repeatAction = CCRepeatForever::create(CCAnimate::create(animation));
pElement->runAction(repeatAction);
}
void CPlayerLayer::SetWaitingCharacters()
{
//pause
for (int playerId = 0; playerId<MAX_PLAYER_NUM;++playerId)
{
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId)==-1)
continue;
int position = CGameManager::GetInstance()->GetPlayerTurn(playerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId);
//online
if(CGameManager::GetInstance()->IsOnlineMode())
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS[4*position+characterId].c_str());
}
//offline
else
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS_OFF[4*position+characterId].c_str());
}
}
}
<|endoftext|> |
<commit_before>#include "PlayerLayer.h"
#include "GameManager.h"
USING_NS_CC;
bool CPlayerLayer::init()
{
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
m_CurrentPlayerId = -1;
m_VisibleSize = CCDirector::sharedDirector()->getVisibleSize();
//ġ Ѵ. ġ ̴.
int playerNumber = CGameManager::GetInstance()->GetPlayerNumberOfThisGame();
m_UIposition[0] = CCPoint(SHARED_PLAYER_UI_UPPER_LEFT_POS);
m_UIposition[1] = CCPoint(SHARED_PLAYER_UI_UPPER_RIGHT_POS);
m_UIposition[2] = CCPoint(SHARED_PLAYER_UI_BELOW_LEFT_POS);
m_UIposition[3] = CCPoint(SHARED_PLAYER_UI_BELOW_RIGHT_POS);
for (int playerId = 0; playerId<MAX_PLAYER_NUM; ++playerId)
{
// ÷̾ ѱ.
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId) == -1)
continue;
//Ͽ ġ ˾Ƴ.
int position = CGameManager::GetInstance()->GetPlayerTurn(playerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId);
// ٸ
m_BackGround[playerId] = CCSprite::create(SHARED_PLAYERUI_BACKGROUND[position].c_str());
m_BackGround[playerId]->setAnchorPoint(ccp(0,0));
m_BackGround[playerId]->setPosition(m_UIposition[position]);
addChild(m_BackGround[playerId],0);
//ġ, ij Id ϸ ˾Ƴ
if(CGameManager::GetInstance()->IsOnlineMode())
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS[4*position+characterId].c_str());
}
else
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS_OFF[4*position+characterId].c_str());
}
m_Player[playerId]->setAnchorPoint(ccp(0,0));
m_Player[playerId]->setPosition(m_UIposition[position]);
addChild(m_Player[playerId],2);
//̸ ´.
// ʿ µ?
// m_PlayerName[playerId] = CCLabelTTF::create(CGameManager::GetInstance()->GetPlayerName(playerId).c_str(), "Arial", 12,
// CCSizeMake(245, 32), kCCTextAlignmentCenter);
// m_PlayerName[playerId]->setPosition(m_UIposition[position]);
}
// (ù° ) ִϸ̼ ֵ update() ش.
update(0);
return true;
}
void CPlayerLayer::update( float dt )
{
//ϴ ̴ ִϸ̼ ϰ, ij ù° ´.
//pause Ƿ, ݵ resume ̿ؾ Ѵ.
if (m_CurrentPlayerId != -1)
{
//SetWaitingCharacters();
m_Player[m_CurrentPlayerId]->pauseSchedulerAndActions();
}
m_CurrentPlayerId = CGameManager::GetInstance()->GetCurrentPlayerId();
int position = CGameManager::GetInstance()->GetPlayerTurn(m_CurrentPlayerId);
removeChildByTag(0);
CCSprite* currentTurnUI = CCSprite::create(SHARED_PLAYERUI_BACKGROUND[4+position].c_str());
currentTurnUI->setTag(0);
currentTurnUI->setAnchorPoint(ccp(0,0));
currentTurnUI->setPosition(m_UIposition[position]);
addChild(currentTurnUI,1);
// Ͽ شϴ ij ִϸ̼ Ѵ.
//ִϸ̼ Ʈ .
/*
CCSpriteFrameCache* cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile("image/CharacterPlayAnimation.plist");
m_CurrentPlayerId = CGameManager::GetInstance()->GetCurrentPlayerId();
CCLOG("currentId = %d, it's turn = %d",m_CurrentPlayerId,CGameManager::GetInstance()->GetPlayerTurn(m_CurrentPlayerId));
m_CharacterAni = CCAnimation::create();
m_CharacterAni->setDelayPerUnit(0.5f);
switch(CGameManager::GetInstance()->GetCharacterIdByPlayerId(m_CurrentPlayerId))
{
case 0:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_1_Ani0.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_1_Ani1.png"));
break;
case 1:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_2_Ani1.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_2_Ani2.png"));
break;
case 2:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_3_Ani1.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_3_Ani2.png"));
break;
case 3:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_4_Ani1.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_4_Ani2.png"));
break;
}
CCRepeatForever* repeatAction = CCRepeatForever::create(CCAnimate::create(m_CharacterAni));
m_Player[m_CurrentPlayerId]->runAction(repeatAction);
m_Player[m_CurrentPlayerId]->resumeSchedulerAndActions();
*/
}
void CPlayerLayer::SetWaitingCharacters()
{
//ó Լ
for (int playerId = 0; playerId<MAX_PLAYER_NUM;++playerId)
{
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId)==-1)
continue;
}
}
<commit_msg>PlayerUI _ online/offline<commit_after>#include "PlayerLayer.h"
#include "GameManager.h"
USING_NS_CC;
bool CPlayerLayer::init()
{
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
m_CurrentPlayerId = -1;
m_VisibleSize = CCDirector::sharedDirector()->getVisibleSize();
//ġ Ѵ. ġ ̴.
int playerNumber = CGameManager::GetInstance()->GetPlayerNumberOfThisGame();
m_UIposition[0] = CCPoint(SHARED_PLAYER_UI_UPPER_LEFT_POS);
m_UIposition[1] = CCPoint(SHARED_PLAYER_UI_UPPER_RIGHT_POS);
m_UIposition[2] = CCPoint(SHARED_PLAYER_UI_BELOW_LEFT_POS);
m_UIposition[3] = CCPoint(SHARED_PLAYER_UI_BELOW_RIGHT_POS);
for (int playerId = 0; playerId<MAX_PLAYER_NUM; ++playerId)
{
// ÷̾ ѱ.
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId) == -1)
continue;
//Ͽ ġ ˾Ƴ.
int position = CGameManager::GetInstance()->GetPlayerTurn(playerId);
int characterId = CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId);
// ٸ
m_BackGround[playerId] = CCSprite::create(SHARED_PLAYERUI_BACKGROUND[position].c_str());
m_BackGround[playerId]->setAnchorPoint(ccp(0,0));
m_BackGround[playerId]->setPosition(m_UIposition[position]);
addChild(m_BackGround[playerId],0);
//ġ, ij Id ϸ ˾Ƴ
if(CGameManager::GetInstance()->IsOnlineMode())
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS[4*position+characterId].c_str());
//̸ Ѵ. config ߰ .
m_PlayerName[playerId] = CCLabelTTF::create(CGameManager::GetInstance()->GetPlayerName(playerId).c_str(), "Arial", 50,
CCSizeMake(400, 100), kCCTextAlignmentLeft);
m_PlayerName[playerId]->setAnchorPoint(ccp(0,0));
switch (position)
{
case 0:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+600.0f,m_UIposition[position].y+300.0f));
m_PlayerName[playerId]->setRotation(180.0f);
break;
case 1:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+400.0f,m_UIposition[position].y+300.0f));
m_PlayerName[playerId]->setRotation(180.0f);
break;
case 2:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+300.0f,m_UIposition[position].y+100.0f));
break;
case 3:
m_PlayerName[playerId]->setPosition(ccp(m_UIposition[position].x+100.0f,m_UIposition[position].y+100.0f));
break;
default:
break;
}
addChild(m_PlayerName[playerId],3);
}
else
{
m_Player[playerId] = CCSprite::create(SHARED_PLAYERUI_CHARACTERS_OFF[4*position+characterId].c_str());
}
m_Player[playerId]->setAnchorPoint(ccp(0,0));
m_Player[playerId]->setPosition(m_UIposition[position]);
addChild(m_Player[playerId],2);
}
// (ù° ) ִϸ̼ ֵ update() ش.
update(0);
return true;
}
void CPlayerLayer::update( float dt )
{
//ϴ ̴ ִϸ̼ ϰ, ij ù° ´.
//pause Ƿ, ݵ resume ̿ؾ Ѵ.
if (m_CurrentPlayerId != -1)
{
//SetWaitingCharacters();
m_Player[m_CurrentPlayerId]->pauseSchedulerAndActions();
}
m_CurrentPlayerId = CGameManager::GetInstance()->GetCurrentPlayerId();
int position = CGameManager::GetInstance()->GetPlayerTurn(m_CurrentPlayerId);
removeChildByTag(0);
CCSprite* currentTurnUI = CCSprite::create(SHARED_PLAYERUI_BACKGROUND[4+position].c_str());
currentTurnUI->setTag(0);
currentTurnUI->setAnchorPoint(ccp(0,0));
currentTurnUI->setPosition(m_UIposition[position]);
addChild(currentTurnUI,1);
// Ͽ شϴ ij ִϸ̼ Ѵ.
//ִϸ̼ Ʈ .
/*
CCSpriteFrameCache* cache = CCSpriteFrameCache::sharedSpriteFrameCache();
cache->addSpriteFramesWithFile("image/CharacterPlayAnimation.plist");
m_CurrentPlayerId = CGameManager::GetInstance()->GetCurrentPlayerId();
CCLOG("currentId = %d, it's turn = %d",m_CurrentPlayerId,CGameManager::GetInstance()->GetPlayerTurn(m_CurrentPlayerId));
m_CharacterAni = CCAnimation::create();
m_CharacterAni->setDelayPerUnit(0.5f);
switch(CGameManager::GetInstance()->GetCharacterIdByPlayerId(m_CurrentPlayerId))
{
case 0:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_1_Ani0.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_1_Ani1.png"));
break;
case 1:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_2_Ani1.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_2_Ani2.png"));
break;
case 2:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_3_Ani1.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_3_Ani2.png"));
break;
case 3:
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_4_Ani1.png"));
m_CharacterAni->addSpriteFrame(cache->spriteFrameByName("CHARACTER_4_Ani2.png"));
break;
}
CCRepeatForever* repeatAction = CCRepeatForever::create(CCAnimate::create(m_CharacterAni));
m_Player[m_CurrentPlayerId]->runAction(repeatAction);
m_Player[m_CurrentPlayerId]->resumeSchedulerAndActions();
*/
}
void CPlayerLayer::SetWaitingCharacters()
{
//ó Լ
for (int playerId = 0; playerId<MAX_PLAYER_NUM;++playerId)
{
if (CGameManager::GetInstance()->GetCharacterIdByPlayerId(playerId)==-1)
continue;
}
}
<|endoftext|> |
<commit_before>#pragma once
#include <regex>
#include "acmacs-base/fmt.hh"
// ----------------------------------------------------------------------
// specialization below follows fmt lib description, but it does not work due to ambiguity with
// template <typename RangeT, typename Char> struct formatter<RangeT, Char, enable_if_t<fmt::is_range<RangeT, Char>::value>>
//
// template <typename Match> struct fmt::formatter<Match, std::enable_if_t<std::is_same_v<Match, std::smatch> || std::is_same_v<Match, std::cmatch>, char>> : fmt::formatter<acmacs::fmt_default_formatter>
// ----------------------------------------------------------------------
namespace acmacs
{
template <typename Match> struct fmt_regex_match_formatter {};
}
template <typename Match> struct fmt::formatter<acmacs::fmt_regex_match_formatter<Match>> : fmt::formatter<acmacs::fmt_default_formatter>
{
template <typename FormatCtx> auto format(const Match& mr, FormatCtx& ctx) {
format_to(ctx.out(), "\"{}\" -> ({})[", mr.str(0), mr.size());
for (size_t nr = 1; nr <= mr.size(); ++nr)
format_to(ctx.out(), " {}:\"{}\"", nr, mr.str(nr));
format_to(ctx.out(), " ]");
return ctx.out();
}
};
template <> struct fmt::formatter<std::smatch> : fmt::formatter<acmacs::fmt_regex_match_formatter<std::smatch>>
{
};
template <> struct fmt::formatter<std::cmatch> : fmt::formatter<acmacs::fmt_regex_match_formatter<std::cmatch>>
{
};
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
<commit_msg>helper functions to scan over mutiple regex<commit_after>#pragma once
#include <regex>
#include "acmacs-base/fmt.hh"
// ======================================================================
// Support for multiple regex and replacements, see acmacs-virus/cc/reassortant.cc
// ======================================================================
namespace acmacs::regex
{
struct look_replace_t
{
const std::regex look_for;
const char* replace_fmt; // syntax: http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.11
};
// returns empty string if no matches found
template <typename Container> std::string scan_replace(std::string_view source, const Container& scan_data)
{
for (const auto& entry : scan_data) {
if (std::cmatch match; std::regex_search(std::begin(source), std::end(source), match, entry.look_for))
return match.format(entry.replace_fmt);
}
return {};
}
// ----------------------------------------------------------------------
struct look_replace2_t
{
const std::regex look_for;
const char* replace_fmt1;
const char* replace_fmt2;
};
// returns pair of empty strings if no matches found
template <typename Container> std::pair<std::string, std::string> scan_replace2(std::string_view source, const Container& scan_data)
{
for (const auto& entry : scan_data) {
if (std::cmatch match; std::regex_search(std::begin(source), std::end(source), match, entry.look_for))
return {match.format(entry.replace_fmt1), match.format(entry.replace_fmt2)};
}
return {};
}
}
// ======================================================================
// fmt support for std::smatch and std::cmatch
// ======================================================================
// specialization below follows fmt lib description, but it does not work due to ambiguity with
// template <typename RangeT, typename Char> struct formatter<RangeT, Char, enable_if_t<fmt::is_range<RangeT, Char>::value>>
//
// template <typename Match> struct fmt::formatter<Match, std::enable_if_t<std::is_same_v<Match, std::smatch> || std::is_same_v<Match, std::cmatch>, char>> : fmt::formatter<acmacs::fmt_default_formatter>
// ----------------------------------------------------------------------
namespace acmacs
{
template <typename Match> struct fmt_regex_match_formatter {};
}
template <typename Match> struct fmt::formatter<acmacs::fmt_regex_match_formatter<Match>> : fmt::formatter<acmacs::fmt_default_formatter>
{
template <typename FormatCtx> auto format(const Match& mr, FormatCtx& ctx) {
format_to(ctx.out(), "\"{}\" -> ({})[", mr.str(0), mr.size());
for (size_t nr = 1; nr <= mr.size(); ++nr)
format_to(ctx.out(), " {}:\"{}\"", nr, mr.str(nr));
format_to(ctx.out(), " ]");
return ctx.out();
}
};
template <> struct fmt::formatter<std::smatch> : fmt::formatter<acmacs::fmt_regex_match_formatter<std::smatch>>
{
};
template <> struct fmt::formatter<std::cmatch> : fmt::formatter<acmacs::fmt_regex_match_formatter<std::cmatch>>
{
};
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
<|endoftext|> |
<commit_before>#include <Windows.h>
#include <CommCtrl.h>
#include "win.h"
#include "desktop.h"
HWND Desktop_FindSHELLDLLDefView(const char* sClass) {
HWND hView = NULL;
HWND hWnd = Win_FindChildByClass(GetDesktopWindow(), sClass);
while(NULL != hWnd) {
hView = Win_FindChildByClass(hWnd, "SHELLDLL_DefView");
if(NULL != hView) {
break;
}
do {
char buf[MAX_PATH] = {};
hWnd = GetWindow(hWnd, GW_HWNDNEXT);
GetClassName(hWnd, buf, sizeof(buf) - 1);
if(0 == _strcmpi(buf, "WorkerW")) {
break;
}
} while(hWnd != NULL);
}
return hView;
}
//
// 获取桌面SysListView窗口句柄
//
HWND Desktop_GetSysListView() {
HWND xView = Desktop_FindSHELLDLLDefView("WorkerW");
if(NULL == xView) {
xView = Desktop_FindSHELLDLLDefView("Progman");
}
if(NULL != xView) {
xView = Win_FindChildByClass(xView, "SysListView32");
}
return xView;
}
//
// 获取桌面图标矩形
//
bool Desktop_GetIconRect(const char* psCaption, RECT* pRect) {
HANDLE hProcess = NULL;
HWND hView = Desktop_GetSysListView();
{
DWORD PID;
GetWindowThreadProcessId(hView, &PID);
hProcess=OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, PID);
if(NULL == hProcess) {
return false;
}
}
LVITEM xItem, *pRemoteItem = NULL;
char sText[512], *pRemoteText = NULL;
pRemoteItem = (LVITEM*) VirtualAllocEx(hProcess, NULL, sizeof(xItem), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
pRemoteText = (char*) VirtualAllocEx(hProcess, NULL, sizeof(sText), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
bool bFound = false;
int nSum = ListView_GetItemCount(hView);
for(int i = 0; i < nSum; ++i) {
memset(&xItem, 0, sizeof(xItem));
xItem.mask = LVIF_TEXT;
xItem.iItem = i;
xItem.iSubItem = 0;
xItem.pszText = pRemoteText;
xItem.cchTextMax = sizeof(sText);
WriteProcessMemory(hProcess, pRemoteItem, &xItem, sizeof(xItem), NULL);
::SendMessage(hView, LVM_GETITEM, 0, (LPARAM)pRemoteItem);
ReadProcessMemory(hProcess, pRemoteText, sText, sizeof(sText), NULL);
if(0 == _strcmpi(sText, psCaption)) {
if(NULL != pRect) {
memset(pRect, 0, sizeof(RECT));
pRect->left = LVIR_SELECTBOUNDS;
WriteProcessMemory(hProcess, pRemoteText, pRect, sizeof(RECT), NULL);
::SendMessage(hView, LVM_GETITEMRECT, (WPARAM)i, (LPARAM)pRemoteText);
ReadProcessMemory(hProcess, pRemoteText, pRect, sizeof(RECT), NULL);
}
bFound = true;
break;
}
}
CloseHandle(hProcess);
VirtualFreeEx(hProcess, pRemoteItem, 0, MEM_RELEASE);
VirtualFreeEx(hProcess, pRemoteText, 0, MEM_RELEASE);
return bFound;
}
<commit_msg>fix Desktop_GetIconRect memory leaks.<commit_after>#include <Windows.h>
#include <CommCtrl.h>
#include "win.h"
#include "desktop.h"
HWND Desktop_FindSHELLDLLDefView(const char* sClass) {
HWND hView = NULL;
HWND hWnd = Win_FindChildByClass(GetDesktopWindow(), sClass);
while(NULL != hWnd) {
hView = Win_FindChildByClass(hWnd, "SHELLDLL_DefView");
if(NULL != hView) {
break;
}
do {
char buf[MAX_PATH] = {};
hWnd = GetWindow(hWnd, GW_HWNDNEXT);
GetClassName(hWnd, buf, sizeof(buf) - 1);
if(0 == _strcmpi(buf, "WorkerW")) {
break;
}
} while(hWnd != NULL);
}
return hView;
}
//
// 获取桌面SysListView窗口句柄
//
HWND Desktop_GetSysListView() {
HWND xView = Desktop_FindSHELLDLLDefView("WorkerW");
if(NULL == xView) {
xView = Desktop_FindSHELLDLLDefView("Progman");
}
if(NULL != xView) {
xView = Win_FindChildByClass(xView, "SysListView32");
}
return xView;
}
//
// 获取桌面图标矩形
//
bool Desktop_GetIconRect(const char* psCaption, RECT* pRect) {
HANDLE hProcess = NULL;
HWND hView = Desktop_GetSysListView();
{
DWORD PID;
GetWindowThreadProcessId(hView, &PID);
hProcess=OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, PID);
if(NULL == hProcess) {
return false;
}
}
LVITEM xItem, *pRemoteItem = NULL;
char sText[512], *pRemoteText = NULL;
pRemoteItem = (LVITEM*) VirtualAllocEx(hProcess, NULL, sizeof(xItem) + 1, MEM_COMMIT, PAGE_READWRITE);
pRemoteText = (char*) VirtualAllocEx(hProcess, NULL, sizeof(sText) + 1, MEM_COMMIT, PAGE_READWRITE);
bool bFound = false;
int nSum = ListView_GetItemCount(hView);
for(int i = 0; i < nSum; ++i) {
memset(&xItem, 0, sizeof(xItem));
xItem.mask = LVIF_TEXT;
xItem.iItem = i;
xItem.iSubItem = 0;
xItem.pszText = pRemoteText;
xItem.cchTextMax = sizeof(sText);
WriteProcessMemory(hProcess, pRemoteItem, &xItem, sizeof(xItem), NULL);
::SendMessage(hView, LVM_GETITEM, 0, (LPARAM)pRemoteItem);
ReadProcessMemory(hProcess, pRemoteText, sText, sizeof(sText), NULL);
if(0 == _strcmpi(sText, psCaption)) {
if(NULL != pRect) {
memset(pRect, 0, sizeof(RECT));
pRect->left = LVIR_SELECTBOUNDS;
WriteProcessMemory(hProcess, pRemoteText, pRect, sizeof(RECT), NULL);
::SendMessage(hView, LVM_GETITEMRECT, (WPARAM)i, (LPARAM)pRemoteText);
ReadProcessMemory(hProcess, pRemoteText, pRect, sizeof(RECT), NULL);
}
bFound = true;
break;
}
}
VirtualFreeEx(hProcess, pRemoteItem, 0, MEM_RELEASE);
VirtualFreeEx(hProcess, pRemoteText, 0, MEM_RELEASE);
CloseHandle(hProcess);
return bFound;
}
<|endoftext|> |
<commit_before>/*
RawSpeed - RAW file decoder.
Copyright (C) 2009-2014 Klaus Post
Copyright (C) 2017 Axel Waggershauser
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 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
*/
#include "decompressors/HasselbladDecompressor.h"
#include "common/Common.h" // for uint32, ushort16
#include "common/Point.h" // for iPoint2D
#include "common/RawImage.h" // for RawImage, RawImageData
#include "decoders/RawDecoderException.h" // for ThrowRDE
#include "decompressors/HuffmanTable.h" // for HuffmanTable
#include "io/BitPumpMSB32.h" // for BitPumpMSB32, BitStream<>::f...
#include "io/ByteStream.h" // for ByteStream
#include <array> // for array
#include <cassert> // for assert
namespace rawspeed {
// Returns len bits as a signed value.
// Highest bit is a sign bit
inline int HasselbladDecompressor::getBits(BitPumpMSB32* bs, int len) {
int diff = bs->getBits(len);
diff = len > 0 ? HuffmanTable::signExtended(diff, len) : diff;
if (diff == 65535)
return -32768;
return diff;
}
void HasselbladDecompressor::decodeScan() {
if (frame.w != static_cast<unsigned>(mRaw->dim.x) ||
frame.h != static_cast<unsigned>(mRaw->dim.y)) {
ThrowRDE("LJPEG frame does not match EXIF dimensions: (%u; %u) vs (%i; %i)",
frame.w, frame.h, mRaw->dim.x, mRaw->dim.y);
}
assert(frame.h > 0);
assert(frame.w > 0);
assert(frame.w % 2 == 0);
BitPumpMSB32 bitStream(input);
// Pixels are packed two at a time, not like LJPEG:
// [p1_length_as_huffman][p2_length_as_huffman][p0_diff_with_length][p1_diff_with_length]|NEXT PIXELS
for (uint32 y = 0; y < frame.h; y++) {
auto* dest = reinterpret_cast<ushort16*>(mRaw->getData(0, y));
int p1 = 0x8000 + pixelBaseOffset;
int p2 = 0x8000 + pixelBaseOffset;
for (uint32 x = 0; x < frame.w; x += 2) {
int len1 = huff[0]->decodeLength(bitStream);
int len2 = huff[0]->decodeLength(bitStream);
p1 += getBits(&bitStream, len1);
p2 += getBits(&bitStream, len2);
dest[x] = p1;
dest[x+1] = p2;
}
}
input.skipBytes(bitStream.getBufferPosition());
}
void HasselbladDecompressor::decode(int pixelBaseOffset_)
{
pixelBaseOffset = pixelBaseOffset_;
// We cannot use fully decoding huffman table,
// because values are packed two pixels at the time.
fullDecodeHT = false;
AbstractLJpegDecompressor::decode();
}
} // namespace rawspeed
<commit_msg>HasselbladDecompressor::decodeScan(): use getHuffmanTables<>().<commit_after>/*
RawSpeed - RAW file decoder.
Copyright (C) 2009-2014 Klaus Post
Copyright (C) 2017 Axel Waggershauser
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 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
*/
#include "decompressors/HasselbladDecompressor.h"
#include "common/Common.h" // for uint32, ushort16
#include "common/Point.h" // for iPoint2D
#include "common/RawImage.h" // for RawImage, RawImageData
#include "decoders/RawDecoderException.h" // for ThrowRDE
#include "decompressors/HuffmanTable.h" // for HuffmanTable
#include "io/BitPumpMSB32.h" // for BitPumpMSB32, BitStream<>::f...
#include "io/ByteStream.h" // for ByteStream
#include <array> // for array
#include <cassert> // for assert
namespace rawspeed {
// Returns len bits as a signed value.
// Highest bit is a sign bit
inline int HasselbladDecompressor::getBits(BitPumpMSB32* bs, int len) {
int diff = bs->getBits(len);
diff = len > 0 ? HuffmanTable::signExtended(diff, len) : diff;
if (diff == 65535)
return -32768;
return diff;
}
void HasselbladDecompressor::decodeScan() {
if (frame.w != static_cast<unsigned>(mRaw->dim.x) ||
frame.h != static_cast<unsigned>(mRaw->dim.y)) {
ThrowRDE("LJPEG frame does not match EXIF dimensions: (%u; %u) vs (%i; %i)",
frame.w, frame.h, mRaw->dim.x, mRaw->dim.y);
}
assert(frame.h > 0);
assert(frame.w > 0);
assert(frame.w % 2 == 0);
const auto ht = getHuffmanTables<1>();
BitPumpMSB32 bitStream(input);
// Pixels are packed two at a time, not like LJPEG:
// [p1_length_as_huffman][p2_length_as_huffman][p0_diff_with_length][p1_diff_with_length]|NEXT PIXELS
for (uint32 y = 0; y < frame.h; y++) {
auto* dest = reinterpret_cast<ushort16*>(mRaw->getData(0, y));
int p1 = 0x8000 + pixelBaseOffset;
int p2 = 0x8000 + pixelBaseOffset;
for (uint32 x = 0; x < frame.w; x += 2) {
int len1 = ht[0]->decodeLength(bitStream);
int len2 = ht[0]->decodeLength(bitStream);
p1 += getBits(&bitStream, len1);
p2 += getBits(&bitStream, len2);
dest[x] = p1;
dest[x+1] = p2;
}
}
input.skipBytes(bitStream.getBufferPosition());
}
void HasselbladDecompressor::decode(int pixelBaseOffset_)
{
pixelBaseOffset = pixelBaseOffset_;
// We cannot use fully decoding huffman table,
// because values are packed two pixels at the time.
fullDecodeHT = false;
AbstractLJpegDecompressor::decode();
}
} // namespace rawspeed
<|endoftext|> |
<commit_before>// Copyright 2011 Alessio Sclocco <[email protected]>
//
// 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.
#define __CL_ENABLE_EXCEPTIONS
#include <CL/cl.hpp>
#include <vector>
using std::vector;
#include <utils.hpp>
#include <Exceptions.hpp>
using isa::utils::toStringValue;
using isa::Exceptions::OpenCLError;
#ifndef INITIALIZE_OPENCL_HPP
#define INITIALIZE_OPENCL_HPP
namespace isa {
namespace OpenCL {
void initializeOpenCL(unsigned int platform, unsigned int nrQueues, vector< cl::Platform > *platforms, cl::Context *context, vector< cl::Device > *devices, vector< vector< cl::CommandQueue > > *queues) throw (OpenCLError) {
try {
unsigned int nrDevices = 0;
cl::Platform::get(platforms);
cl_context_properties properties[] = {CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms->at(platform))(), 0};
*context = cl::Context(CL_DEVICE_TYPE_ALL, properties);
*devices = context->getInfo<CL_CONTEXT_DEVICES>();
nrDevices = devices->size();
for ( unsigned int device = 0; device < nrDevices; device++ ) {
queues->push_back(vector< cl::CommandQueue >());
for ( unsigned int queue = 0; queue < nrQueues; queue++ ) {
(queues->at(device)).push_back(cl::CommandQueue(*context, devices->at(device)));;
}
}
}
catch ( cl::Error e ) {
string err_s = toStringValue< cl_int >(e.err());
throw OpenCLError("Impossible to initialize OpenCL: " + err_s + ".");
}
}
} // OpenCL
} // isa
#endif // INITIALIZE_OPENCL_HPP
<commit_msg>Standardized initializeOpenCL().<commit_after>// Copyright 2011 Alessio Sclocco <[email protected]>
//
// 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.
#define __CL_ENABLE_EXCEPTIONS
#include <CL/cl.hpp>
#include <vector>
#include <utils.hpp>
#include <Exceptions.hpp>
#ifndef INITIALIZE_OPENCL_HPP
#define INITIALIZE_OPENCL_HPP
namespace isa {
namespace OpenCL {
void initializeOpenCL(unsigned int platform, unsigned int nrQueues, std::vector< cl::Platform > * platforms, cl::Context * context, std::vector< cl::Device > * devices, std::vector< vector< cl::CommandQueue > > * queues) throw (OpenCLError) {
try {
unsigned int nrDevices = 0;
cl::Platform::get(platforms);
cl_context_properties properties[] = {CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms->at(platform))(), 0};
*context = cl::Context(CL_DEVICE_TYPE_ALL, properties);
*devices = context->getInfo<CL_CONTEXT_DEVICES>();
nrDevices = devices->size();
for ( unsigned int device = 0; device < nrDevices; device++ ) {
queues->push_back(vector< cl::CommandQueue >());
for ( unsigned int queue = 0; queue < nrQueues; queue++ ) {
(queues->at(device)).push_back(cl::CommandQueue(*context, devices->at(device)));;
}
}
}
catch ( cl::Error &e ) {
string err_s = isa::utils::toString< cl_int >(e.err());
throw isa::Exceptions::OpenCLError("Impossible to initialize OpenCL: " + err_s + ".");
}
}
} // OpenCL
} // isa
#endif // INITIALIZE_OPENCL_HPP
<|endoftext|> |
<commit_before>#include "Thread/Mutex.hh"
#ifndef SCOPEDLOCK_HH_
# define SCOPEDLOCK_HH_
namespace LilWrapper
{
class ScopedLock
{
private:
Mutex *_mutex;
public:
ScopedLock(Mutex *);
~ScopedLock();
};
}
#endif /* SCOPEDLOCK_HH_ */
<commit_msg>Make the Scoped Lock class non-copyable.<commit_after>#include "Thread/Mutex.hh"
#ifndef SCOPEDLOCK_HH_
# define SCOPEDLOCK_HH_
namespace LilWrapper
{
class ScopedLock
{
private:
Mutex *_mutex;
ScopedLock(const ScopedLock&);
const ScopedLock& operator=(const NonCopyable&);
public:
ScopedLock(Mutex *);
~ScopedLock();
};
}
#endif /* SCOPEDLOCK_HH_ */
<|endoftext|> |
<commit_before>/* -*- coding: utf-8; mode: c++; tab-width: 3 -*-
Copyright 2013
Raffaello D. Di Napoli
This file is part of Application-Building Components (henceforth referred to as ABC).
ABC is free software: you can redistribute it and/or modify it under the terms of the GNU General
Public License as published by the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
ABC 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 ABC. If not, see
<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------------------------------*/
#ifndef ABC_TESTING_UNIT_HXX
#define ABC_TESTING_UNIT_HXX
#include <abc/testing/core.hxx>
#ifdef ABC_CXX_PRAGMA_ONCE
#pragma once
#endif
#include <abc/testing/runner.hxx>
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::testing::unit
namespace abc {
namespace testing {
/** Base class for unit tests.
*/
class ABCTESTINGAPI unit {
public:
/** Constructor.
*/
unit();
/** Destructor.
*/
virtual ~unit();
/** Initializes the object. Split into a method separated from the constructor so that derived
classes don’t need to declare a constructor just to forward its arguments.
prunner
Pointer to the test runner.
*/
void init(runner * prunner);
/** Executes the unit test.
*/
virtual void run() = 0;
/** Returns a short description for the testing unit.
return
Unit title.
*/
virtual istr title() = 0;
protected:
/** Validates an assertion.
bExpr
Result of the assertion expression.
pszExpr
Failed assertion.
*/
void assert(bool bExpr, istr const & sExpr);
/** Validates an expectation.
bExpr
Result of the expectation expression.
pszExpr
Failed assertion.
*/
void expect(bool bExpr, istr const & sExpr);
protected:
/** Runner executing this test. */
runner * m_prunner;
};
} //namespace testing
} //namespace abc
/** Asserts that the specified expression evaluates as non-false (true); throws an exception if the
assertion fails.
expr
Expression that should evaulate to non-false (true).
*/
#define ABC_TESTING_ASSERT(expr) \
this->assert(!!(expr), SL(#expr))
/** Verifies that the specified expression evaluates as non-false (true).
expr
Expression that should evaulate to non-false (true).
*/
#define ABC_TESTING_EXPECT(expr) \
this->expect(!!(expr), SL(#expr))
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::testing::unit_factory_impl
namespace abc {
namespace testing {
/** Maintains a list of abc::testing::unit-derived classes that can be used by an
abc::testing::runner instance to instantiate and execute each unit.
*/
class ABCTESTINGAPI unit_factory_impl {
public:
/** Factory function, returning an abc::testing::unit instance. */
typedef std::unique_ptr<unit> (* factory_fn)(runner * prunner);
/** Linked list item. */
struct factory_list_item {
factory_list_item * pfliNext;
factory_fn pfnFactory;
};
public:
/** Constructor.
pfli
Pointer to the derived class’s factory list item.
*/
unit_factory_impl(factory_list_item * pfli);
/** Returns a pointer to the head of the list of factory functions, which the caller can then use
to walk the entire list (ending when an item’s next pointer is NULL).
return
Pointer to the head of the list.
*/
static factory_list_item * get_factory_list_head() {
return sm_pfliHead;
}
private:
/** Pointer to the head of the list of factory functions. */
static factory_list_item * sm_pfliHead;
/** Pointer to the “next” pointer of the tail of the list of factory functions. */
static factory_list_item ** sm_ppfliTailNext;
};
} //namespace testing
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::testing::unit_factory
namespace abc {
namespace testing {
/** Template version of abc::testing::unit_factory_impl, able to instantiate classes derived from
abc::testing::unit.
*/
template <class T>
class unit_factory :
public unit_factory_impl {
public:
/** Constructor.
*/
unit_factory() :
unit_factory_impl(&sm_fli) {
}
/** Class factory for T.
prunner
Runner to provide to the unit.
*/
static std::unique_ptr<unit> factory(runner * prunner) {
std::unique_ptr<T> pt(new T());
pt->init(prunner);
return std::move(pt);
}
private:
/** Entry in the list of factory functions for this class. */
static factory_list_item sm_fli;
};
} //namespace testing
} //namespace abc
/** Registers an abc::testing::unit-derived class for execution by an abc::testing::runner instance.
cls
Unit class.
*/
#define ABC_TESTING_UNIT_REGISTER(cls) \
namespace abc { \
namespace testing { \
\
unit_factory<cls> ABC_CPP_APPEND_UID(g__uf); \
template <> \
/*static*/ unit_factory_impl::factory_list_item unit_factory<cls>::sm_fli = { \
NULL, \
unit_factory<cls>::factory \
}; \
\
} /*namespace testing*/ \
} /*namespace abc*/
////////////////////////////////////////////////////////////////////////////////////////////////////
#endif //ifndef ABC_TESTING_UNIT_HXX
<commit_msg>Add ABC_TESTING_EXPECT_EXCEPTION() and ABC_TESTING_EXPECT_NO_EXCEPTIONS()<commit_after>/* -*- coding: utf-8; mode: c++; tab-width: 3 -*-
Copyright 2013
Raffaello D. Di Napoli
This file is part of Application-Building Components (henceforth referred to as ABC).
ABC is free software: you can redistribute it and/or modify it under the terms of the GNU General
Public License as published by the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
ABC 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 ABC. If not, see
<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------------------------------*/
#ifndef ABC_TESTING_UNIT_HXX
#define ABC_TESTING_UNIT_HXX
#include <abc/testing/core.hxx>
#ifdef ABC_CXX_PRAGMA_ONCE
#pragma once
#endif
#include <abc/testing/runner.hxx>
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::testing::unit
namespace abc {
namespace testing {
/** Base class for unit tests.
*/
class ABCTESTINGAPI unit {
public:
/** Constructor.
*/
unit();
/** Destructor.
*/
virtual ~unit();
/** Initializes the object. Split into a method separated from the constructor so that derived
classes don’t need to declare a constructor just to forward its arguments.
prunner
Pointer to the test runner.
*/
void init(runner * prunner);
/** Executes the unit test.
*/
virtual void run() = 0;
/** Returns a short description for the testing unit.
return
Unit title.
*/
virtual istr title() = 0;
protected:
/** Validates an assertion.
bExpr
Result of the assertion expression.
pszExpr
Failed assertion.
*/
void assert(bool bExpr, istr const & sExpr);
/** Validates an expectation.
bExpr
Result of the expectation expression.
pszExpr
Failed assertion.
*/
void expect(bool bExpr, istr const & sExpr);
protected:
/** Runner executing this test. */
runner * m_prunner;
};
} //namespace testing
} //namespace abc
/** Asserts that the specified expression evaluates as non-false (true); throws an exception if the
assertion fails.
expr
Expression that should evaulate to non-false (true).
*/
#define ABC_TESTING_ASSERT(expr) \
this->assert(!!(expr), SL(#expr))
/** Verifies that the specified expression evaluates as non-false (true).
expr
Expression that should evaulate to non-false (true).
*/
#define ABC_TESTING_EXPECT(expr) \
this->expect(!!(expr), SL(#expr))
/** Verifies that the specified expression does not throw.
expr
Expression that should not throw.
*/
#define ABC_TESTING_EXPECT_NO_EXCEPTIONS(expr) \
do { \
bool _bCaught(false); \
try { \
static_cast<void>(expr); \
} catch (...) { \
_bCaught = true; \
} \
this->expect(!_bCaught, SL(#expr)); \
} while (false)
/** Verifies that the specified expression throws an exception of the specified type.
type
Exception class that should be caught.
expr
Expression that should throw.
*/
#define ABC_TESTING_EXPECT_EXCEPTION(type, expr) \
do { \
bool _bCaught(false); \
try { \
static_cast<void>(expr); \
} catch (type const & x) { \
_bCaught = true; \
} \
this->expect(_bCaught, SL(#expr)); \
} while (false)
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::testing::unit_factory_impl
namespace abc {
namespace testing {
/** Maintains a list of abc::testing::unit-derived classes that can be used by an
abc::testing::runner instance to instantiate and execute each unit.
*/
class ABCTESTINGAPI unit_factory_impl {
public:
/** Factory function, returning an abc::testing::unit instance. */
typedef std::unique_ptr<unit> (* factory_fn)(runner * prunner);
/** Linked list item. */
struct factory_list_item {
factory_list_item * pfliNext;
factory_fn pfnFactory;
};
public:
/** Constructor.
pfli
Pointer to the derived class’s factory list item.
*/
unit_factory_impl(factory_list_item * pfli);
/** Returns a pointer to the head of the list of factory functions, which the caller can then use
to walk the entire list (ending when an item’s next pointer is NULL).
return
Pointer to the head of the list.
*/
static factory_list_item * get_factory_list_head() {
return sm_pfliHead;
}
private:
/** Pointer to the head of the list of factory functions. */
static factory_list_item * sm_pfliHead;
/** Pointer to the “next” pointer of the tail of the list of factory functions. */
static factory_list_item ** sm_ppfliTailNext;
};
} //namespace testing
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::testing::unit_factory
namespace abc {
namespace testing {
/** Template version of abc::testing::unit_factory_impl, able to instantiate classes derived from
abc::testing::unit.
*/
template <class T>
class unit_factory :
public unit_factory_impl {
public:
/** Constructor.
*/
unit_factory() :
unit_factory_impl(&sm_fli) {
}
/** Class factory for T.
prunner
Runner to provide to the unit.
*/
static std::unique_ptr<unit> factory(runner * prunner) {
std::unique_ptr<T> pt(new T());
pt->init(prunner);
return std::move(pt);
}
private:
/** Entry in the list of factory functions for this class. */
static factory_list_item sm_fli;
};
} //namespace testing
} //namespace abc
/** Registers an abc::testing::unit-derived class for execution by an abc::testing::runner instance.
cls
Unit class.
*/
#define ABC_TESTING_UNIT_REGISTER(cls) \
namespace abc { \
namespace testing { \
\
unit_factory<cls> ABC_CPP_APPEND_UID(g__uf); \
template <> \
/*static*/ unit_factory_impl::factory_list_item unit_factory<cls>::sm_fli = { \
NULL, \
unit_factory<cls>::factory \
}; \
\
} /*namespace testing*/ \
} /*namespace abc*/
////////////////////////////////////////////////////////////////////////////////////////////////////
#endif //ifndef ABC_TESTING_UNIT_HXX
<|endoftext|> |
<commit_before>/**
* Sets the physics list of the simulation
*
* The physics list are electromagnetic based, using the G4 Kernal defaults
*/
#include "PhysicsList.hh"
#include "PhysicsListMessenger.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmStandardPhysics_option1.hh"
#include "G4EmStandardPhysics_option2.hh"
#include "G4EmStandardPhysics_option3.hh"
#include "G4EmStandardPhysics_option4.hh"
#include "G4EmLivermorePhysics.hh"
#include "G4EmPenelopePhysics.hh"
#include "DetectorConstruction.hh"
#include "G4LossTableManager.hh"
#include "G4UnitsTable.hh"
#include "G4SystemOfUnits.hh"
/**
* Creates the default PhysicsList. The default list is the Livermore physics.
*
* @param p - the detector construction
*
*/
PhysicsList::PhysicsList(DetectorConstruction* p)
: G4VModularPhysicsList()
{
G4LossTableManager::Instance();
fDet = p;
fCurrentDefaultCut = 1.0*mm; /* The default range cut */
fCutForGamma = fCurrentDefaultCut; /* Default gamma cut */
fCutForElectron = fCurrentDefaultCut; /* Default electron cut */
fCutForPositron = fCurrentDefaultCut; /* Default positron cut */
fCutForAlpha = fCurrentDefaultCut; /* Default cut for alpha */
fCutForTriton = fCurrentDefaultCut; /* Default cut for triton */
fMessenger = new PhysicsListMessenger(this); /* Physics List Messenger */
SetVerboseLevel(1);
// EM physics
fEmName = G4String("emlivermore");
fEmPhysicsList = new G4EmLivermorePhysics();
}
/**
* Deconstructor
*/
PhysicsList::~PhysicsList()
{
delete fMessenger;
}
// Bosons
#include "G4ChargedGeantino.hh"
#include "G4Geantino.hh"
#include "G4Gamma.hh"
#include "G4OpticalPhoton.hh"
// leptons
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4NeutrinoMu.hh"
#include "G4AntiNeutrinoMu.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoE.hh"
// Mesons
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4PionZero.hh"
#include "G4Eta.hh"
#include "G4EtaPrime.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4KaonZero.hh"
#include "G4AntiKaonZero.hh"
#include "G4KaonZeroLong.hh"
#include "G4KaonZeroShort.hh"
// Baryons
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Neutron.hh"
#include "G4AntiNeutron.hh"
// Nuclei
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
/**
* Constructs the particles
*
* Particles are: bosons, leptons, mesons, bayrons, and nuclei. The bosons are
* for the gammas, the leptons for the electrons, the bayrons for protons and
* neturons, and the nuclei for the triton and alpha.
*/
void PhysicsList::ConstructParticle()
{
// pseudo-particles
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
// gamma
G4Gamma::GammaDefinition();
// optical photon
G4OpticalPhoton::OpticalPhotonDefinition();
// leptons
G4Electron::ElectronDefinition();
G4Positron::PositronDefinition();
G4MuonPlus::MuonPlusDefinition();
G4MuonMinus::MuonMinusDefinition();
G4NeutrinoE::NeutrinoEDefinition();
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
G4NeutrinoMu::NeutrinoMuDefinition();
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4PionZero::PionZeroDefinition();
G4Eta::EtaDefinition();
G4EtaPrime::EtaPrimeDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
G4KaonZero::KaonZeroDefinition();
G4AntiKaonZero::AntiKaonZeroDefinition();
G4KaonZeroLong::KaonZeroLongDefinition();
G4KaonZeroShort::KaonZeroShortDefinition();
// barions
G4Proton::ProtonDefinition();
G4AntiProton::AntiProtonDefinition();
G4Neutron::NeutronDefinition();
G4AntiNeutron::AntiNeutronDefinition();
// ions
G4Deuteron::DeuteronDefinition();
G4Triton::TritonDefinition();
G4Alpha::AlphaDefinition();
G4GenericIon::GenericIonDefinition();
}
/**
* Adds Processes to the particles
*/
#include "G4EmProcessOptions.hh"
void PhysicsList::ConstructProcess()
{
// Transportation
//
AddTransportation();
// Electromagnetic physics list
//
fEmPhysicsList->ConstructProcess();
// Em options
//
G4EmProcessOptions emOptions;
emOptions.SetBuildCSDARange(true);
emOptions.SetDEDXBinningForCSDARange(10*10);
// Decay Process
//
//AddDecay();
// Decay Process
//
//AddRadioactiveDecay();
}
/**
* Adds a physics list to the default
*
* @param name - name of the physics list
*/
void PhysicsList::AddPhysicsList(const G4String& name)
{
if (verboseLevel>1) {
G4cout << "PhysicsList::AddPhysicsList: <" << name << ">" << G4endl;
}
if (name == fEmName) return;
if (name == "emstandard_opt0") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics();
} else if (name == "emstandard_opt1") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option1();
} else if (name == "emstandard_opt2") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option2();
} else if (name == "emstandard_opt3") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option3();
} else if (name == "emstandard_opt4") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option4();
} else if (name == "emlivermore") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmLivermorePhysics();
} else if (name == "empenelope") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmPenelopePhysics();
} else {
G4cout << "PhysicsList::AddPhysicsList: <" << name << ">"
<< " is not defined"
<< G4endl;
}
}
/**
* Sets up the decay process
*/
#include "G4ProcessManager.hh"
#include "G4Decay.hh"
void PhysicsList::AddDecay()
{
// Decay Process
//
G4Decay* fDecayProcess = new G4Decay();
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (fDecayProcess->IsApplicable(*particle)) {
pmanager ->AddProcess(fDecayProcess);
// set ordering for PostStepDoIt and AtRestDoIt
pmanager ->SetProcessOrdering(fDecayProcess, idxPostStep);
pmanager ->SetProcessOrdering(fDecayProcess, idxAtRest);
}
}
}
/**
* Sets up the radioactive decay
*/
#include "G4PhysicsListHelper.hh"
#include "G4RadioactiveDecay.hh"
void PhysicsList::AddRadioactiveDecay()
{
G4RadioactiveDecay* radioactiveDecay = new G4RadioactiveDecay();
radioactiveDecay->SetHLThreshold(-1.*s);
radioactiveDecay->SetICM(true); //Internal Conversion
radioactiveDecay->SetARM(true); //Atomic Rearangement
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(radioactiveDecay, G4GenericIon::GenericIon());
}
/**
* Sets the default cuts for gamma, electrons, and positrons
*/
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
void PhysicsList::SetCuts()
{
if (verboseLevel >0) {
G4cout << "PhysicsList::SetCuts:";
G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;
}
// set cut values for gamma at first and for e- second and next for e+,
// because some processes for e+/e- need cut values for gamma
SetCutValue(fCutForGamma, "gamma");
SetCutValue(fCutForElectron, "e-");
SetCutValue(fCutForPositron, "e+");
SetCutValue(fCutForAlpha, "alpha");
SetCutValue(fCutForTriton, "triton");
if (verboseLevel>0) DumpCutValuesTable();
}
/**
* Sets the gamma cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForGamma(G4double cut)
{
fCutForGamma = cut;
SetParticleCuts(fCutForGamma, G4Gamma::Gamma());
}
/**
* Sets the triton cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForTriton(G4double cut)
{
fCutForTriton = cut;
SetParticleCuts(fCutForTriton, G4Triton::Triton());
}
/**
* Sets the alpha cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForAlpha(G4double cut)
{
fCutForAlpha = cut;
SetParticleCuts(fCutForAlpha, G4Alpha::Alpha());
}
/**
* Sets the electron cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForElectron(G4double cut)
{
fCutForElectron = cut;
SetParticleCuts(fCutForElectron, G4Electron::Electron());
}
/**
* Sets the positron cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForPositron(G4double cut)
{
fCutForPositron = cut;
SetParticleCuts(fCutForPositron, G4Positron::Positron());
}
/**
* Computes the CSDA range for electrons
*
* @param val - energy of the electron
*/
#include "G4Material.hh"
void PhysicsList::GetRange(G4double val)
{
G4LogicalVolume* lBox = fDet->GetWorld()->GetLogicalVolume();
G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
const G4MaterialCutsCouple* couple = lBox->GetMaterialCutsCouple();
const G4Material* currMat = lBox->GetMaterial();
G4ParticleDefinition* part;
G4double cut;
part = particleTable->FindParticle("e-");
cut = G4LossTableManager::Instance()->GetRange(part,val,couple);
G4cout << "material : " << currMat->GetName() << G4endl;
G4cout << "particle : " << part->GetParticleName() << G4endl;
G4cout << "energy : " << G4BestUnit(val,"Energy") << G4endl;
G4cout << "range : " << G4BestUnit(cut,"Length") << G4endl;
}
<commit_msg>Decreased default electorn cut<commit_after>/**
* Sets the physics list of the simulation
*
* The physics list are electromagnetic based, using the G4 Kernal defaults
*/
#include "PhysicsList.hh"
#include "PhysicsListMessenger.hh"
#include "G4EmStandardPhysics.hh"
#include "G4EmStandardPhysics_option1.hh"
#include "G4EmStandardPhysics_option2.hh"
#include "G4EmStandardPhysics_option3.hh"
#include "G4EmStandardPhysics_option4.hh"
#include "G4EmLivermorePhysics.hh"
#include "G4EmPenelopePhysics.hh"
#include "DetectorConstruction.hh"
#include "G4LossTableManager.hh"
#include "G4UnitsTable.hh"
#include "G4SystemOfUnits.hh"
/**
* Creates the default PhysicsList. The default list is the Livermore physics.
*
* @param p - the detector construction
*
*/
PhysicsList::PhysicsList(DetectorConstruction* p)
: G4VModularPhysicsList()
{
G4LossTableManager::Instance();
fDet = p;
fCurrentDefaultCut = 1.0*mm; /* The default range cut */
fCutForGamma = fCurrentDefaultCut; /* Default gamma cut */
fCutForElectron = 10*nm; /* Default electron cut */
fCutForPositron = fCutForElectron; /* Default positron cut */
fCutForAlpha = fCurrentDefaultCut; /* Default cut for alpha */
fCutForTriton = fCurrentDefaultCut; /* Default cut for triton */
fMessenger = new PhysicsListMessenger(this); /* Physics List Messenger */
SetVerboseLevel(1);
// EM physics
fEmName = G4String("emlivermore");
fEmPhysicsList = new G4EmLivermorePhysics();
}
/**
* Deconstructor
*/
PhysicsList::~PhysicsList()
{
delete fMessenger;
}
// Bosons
#include "G4ChargedGeantino.hh"
#include "G4Geantino.hh"
#include "G4Gamma.hh"
#include "G4OpticalPhoton.hh"
// leptons
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4NeutrinoMu.hh"
#include "G4AntiNeutrinoMu.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoE.hh"
// Mesons
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4PionZero.hh"
#include "G4Eta.hh"
#include "G4EtaPrime.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4KaonZero.hh"
#include "G4AntiKaonZero.hh"
#include "G4KaonZeroLong.hh"
#include "G4KaonZeroShort.hh"
// Baryons
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Neutron.hh"
#include "G4AntiNeutron.hh"
// Nuclei
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
/**
* Constructs the particles
*
* Particles are: bosons, leptons, mesons, bayrons, and nuclei. The bosons are
* for the gammas, the leptons for the electrons, the bayrons for protons and
* neturons, and the nuclei for the triton and alpha.
*/
void PhysicsList::ConstructParticle()
{
// pseudo-particles
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
// gamma
G4Gamma::GammaDefinition();
// optical photon
G4OpticalPhoton::OpticalPhotonDefinition();
// leptons
G4Electron::ElectronDefinition();
G4Positron::PositronDefinition();
G4MuonPlus::MuonPlusDefinition();
G4MuonMinus::MuonMinusDefinition();
G4NeutrinoE::NeutrinoEDefinition();
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
G4NeutrinoMu::NeutrinoMuDefinition();
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4PionZero::PionZeroDefinition();
G4Eta::EtaDefinition();
G4EtaPrime::EtaPrimeDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
G4KaonZero::KaonZeroDefinition();
G4AntiKaonZero::AntiKaonZeroDefinition();
G4KaonZeroLong::KaonZeroLongDefinition();
G4KaonZeroShort::KaonZeroShortDefinition();
// barions
G4Proton::ProtonDefinition();
G4AntiProton::AntiProtonDefinition();
G4Neutron::NeutronDefinition();
G4AntiNeutron::AntiNeutronDefinition();
// ions
G4Deuteron::DeuteronDefinition();
G4Triton::TritonDefinition();
G4Alpha::AlphaDefinition();
G4GenericIon::GenericIonDefinition();
}
/**
* Adds Processes to the particles
*/
#include "G4EmProcessOptions.hh"
void PhysicsList::ConstructProcess()
{
// Transportation
//
AddTransportation();
// Electromagnetic physics list
//
fEmPhysicsList->ConstructProcess();
// Em options
//
G4EmProcessOptions emOptions;
emOptions.SetBuildCSDARange(true);
emOptions.SetDEDXBinningForCSDARange(10*10);
// Decay Process
//
//AddDecay();
// Decay Process
//
//AddRadioactiveDecay();
}
/**
* Adds a physics list to the default
*
* @param name - name of the physics list
*/
void PhysicsList::AddPhysicsList(const G4String& name)
{
if (verboseLevel>1) {
G4cout << "PhysicsList::AddPhysicsList: <" << name << ">" << G4endl;
}
if (name == fEmName) return;
if (name == "emstandard_opt0") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics();
} else if (name == "emstandard_opt1") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option1();
} else if (name == "emstandard_opt2") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option2();
} else if (name == "emstandard_opt3") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option3();
} else if (name == "emstandard_opt4") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmStandardPhysics_option4();
} else if (name == "emlivermore") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmLivermorePhysics();
} else if (name == "empenelope") {
fEmName = name;
delete fEmPhysicsList;
fEmPhysicsList = new G4EmPenelopePhysics();
} else {
G4cout << "PhysicsList::AddPhysicsList: <" << name << ">"
<< " is not defined"
<< G4endl;
}
}
/**
* Sets up the decay process
*/
#include "G4ProcessManager.hh"
#include "G4Decay.hh"
void PhysicsList::AddDecay()
{
// Decay Process
//
G4Decay* fDecayProcess = new G4Decay();
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (fDecayProcess->IsApplicable(*particle)) {
pmanager ->AddProcess(fDecayProcess);
// set ordering for PostStepDoIt and AtRestDoIt
pmanager ->SetProcessOrdering(fDecayProcess, idxPostStep);
pmanager ->SetProcessOrdering(fDecayProcess, idxAtRest);
}
}
}
/**
* Sets up the radioactive decay
*/
#include "G4PhysicsListHelper.hh"
#include "G4RadioactiveDecay.hh"
void PhysicsList::AddRadioactiveDecay()
{
G4RadioactiveDecay* radioactiveDecay = new G4RadioactiveDecay();
radioactiveDecay->SetHLThreshold(-1.*s);
radioactiveDecay->SetICM(true); //Internal Conversion
radioactiveDecay->SetARM(true); //Atomic Rearangement
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(radioactiveDecay, G4GenericIon::GenericIon());
}
/**
* Sets the default cuts for gamma, electrons, and positrons
*/
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
void PhysicsList::SetCuts()
{
if (verboseLevel >0) {
G4cout << "PhysicsList::SetCuts:";
G4cout << "CutLength : " << G4BestUnit(defaultCutValue,"Length") << G4endl;
}
// set cut values for gamma at first and for e- second and next for e+,
// because some processes for e+/e- need cut values for gamma
SetCutValue(fCutForGamma, "gamma");
SetCutValue(fCutForElectron, "e-");
SetCutValue(fCutForPositron, "e+");
SetCutValue(fCutForAlpha, "alpha");
SetCutValue(fCutForTriton, "triton");
if (verboseLevel>0) DumpCutValuesTable();
}
/**
* Sets the gamma cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForGamma(G4double cut)
{
fCutForGamma = cut;
SetParticleCuts(fCutForGamma, G4Gamma::Gamma());
}
/**
* Sets the triton cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForTriton(G4double cut)
{
fCutForTriton = cut;
SetParticleCuts(fCutForTriton, G4Triton::Triton());
}
/**
* Sets the alpha cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForAlpha(G4double cut)
{
fCutForAlpha = cut;
SetParticleCuts(fCutForAlpha, G4Alpha::Alpha());
}
/**
* Sets the electron cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForElectron(G4double cut)
{
fCutForElectron = cut;
SetParticleCuts(fCutForElectron, G4Electron::Electron());
}
/**
* Sets the positron cuts
*
* @param cut - the range for the cut
*/
void PhysicsList::SetCutForPositron(G4double cut)
{
fCutForPositron = cut;
SetParticleCuts(fCutForPositron, G4Positron::Positron());
}
/**
* Computes the CSDA range for electrons
*
* @param val - energy of the electron
*/
#include "G4Material.hh"
void PhysicsList::GetRange(G4double val)
{
G4LogicalVolume* lBox = fDet->GetWorld()->GetLogicalVolume();
G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
const G4MaterialCutsCouple* couple = lBox->GetMaterialCutsCouple();
const G4Material* currMat = lBox->GetMaterial();
G4ParticleDefinition* part;
G4double cut;
part = particleTable->FindParticle("e-");
cut = G4LossTableManager::Instance()->GetRange(part,val,couple);
G4cout << "material : " << currMat->GetName() << G4endl;
G4cout << "particle : " << part->GetParticleName() << G4endl;
G4cout << "energy : " << G4BestUnit(val,"Energy") << G4endl;
G4cout << "range : " << G4BestUnit(cut,"Length") << G4endl;
}
<|endoftext|> |
<commit_before>// Copyright 2012 Alessio Sclocco <[email protected]>
//
// 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 <fstream>
#include <vector>
#include <string>
#include <cmath>
#include <exception>
#include <H5Cpp.h>
#include <dada_hdu.h>
#include <ascii_header.h>
#include <Observation.hpp>
#include <utils.hpp>
#ifndef READ_DATA_HPP
#define READ_DATA_HPP
namespace AstroData {
// Exception: the PSRDada ring buffer does not work
class RingBufferError : public std::exception {
public:
RingBufferError();
~RingBufferError() throw ();
const char * what() const throw ();
};
template< typename T > void readSIGPROC(const Observation & observation, const uint8_t inputBits, const unsigned int bytesToSkip, const std::string & inputFilename, std::vector< std::vector< T > * > & data, const unsigned int firstSecond = 0);
template< typename T > void readLOFAR(std::string headerFilename, std::string rawFilename, Observation & observation, std::vector< std::vector< T > * > & data, unsigned int nrSeconds = 0, unsigned int firstSecond = 0);
template< typename T > void readPSRDadaHeader(Observation & observation, dada_hdu_t & ringBuffer) throw(RingBufferError);
template< typename T > inline void readPSRDada(Observation & observation, dada_hdu_t & ringBuffer, std::vector< T > * data) throw(RingBufferError);
// Implementation
template< typename T > void readSIGPROC(const Observation & observation, const uint8_t inputBits, const unsigned int bytesToSkip, const std::string & inputFilename, std::vector< std::vector< T > * > & data, const unsigned int firstSecond = 0) {
std::ifstream inputFile;
const unsigned int BUFFER_DIM = sizeof(T);
char * buffer = new char [BUFFER_DIM];
inputFile.open(inputFilename.c_str(), std::ios::binary);
inputFile.sync_with_stdio(false);
inputFile.seekg(bytesToSkip, std::ios::beg);
for ( unsigned int second = 0; second < observation.getNrSeconds(); second++ ) {
if ( inputBits >= 8 ) {
data.at(second) = new std::vector< T >(observation.getNrChannels() * observation.getNrSamplesPerPaddedSecond());
for ( unsigned int sample = 0; sample < observation.getNrSamplesPerSecond(); sample++ ) {
for ( unsigned int channel = observation.getNrChannels(); channel > 0; channel-- ) {
inputFile.read(buffer, BUFFER_DIM);
data.at(second)->at((static_cast< uint64_t >(channel - 1) * observation.getNrSamplesPerPaddedSecond()) + sample) = *(reinterpret_cast< T * >(buffer));
}
}
} else {
data.at(second) = new std::vector< T >(observation.getNrChannels() * isa::utils::pad(observation.getNrSamplesPerSecond() / (8 / inputBits), observation.getPadding()));
for ( unsigned int sample = 0; sample < observation.getNrSamplesPerSecond() / (8 / inputBits); sample++ ) {
for ( unsigned int channel = observation.getNrChannels(); channel > 0; channel-- ) {
inputFile.read(buffer, BUFFER_DIM);
data.at(second)->at((static_cast< uint64_t >(channel - 1) * isa::utils::pad(observation.getNrSamplesPerSecond() / (8 / inputBits), observation.getPadding())) + sample) = *(reinterpret_cast< T * >(buffer));
}
}
}
}
inputFile.close();
delete [] buffer;
}
template< typename T > void readLOFAR(std::string headerFilename, std::string rawFilename, Observation & observation, std::vector< std::vector< T > * > & data, unsigned int nrSeconds, unsigned int firstSecond) {
unsigned int nrSubbands, nrChannels;
float minFreq, channelBandwidth;
// Read the HDF5 file with the metadata
H5::H5File headerFile = H5::H5File(headerFilename, H5F_ACC_RDONLY);
H5::FloatType typeDouble = H5::FloatType(H5::PredType::NATIVE_DOUBLE);
double valueDouble = 0.0;
H5::IntType typeUInt = H5::IntType(H5::PredType::NATIVE_UINT);
unsigned int valueUInt = 0;
H5::Group currentNode = headerFile.openGroup("/");
currentNode.openAttribute("OBSERVATION_FREQUENCY_MIN").read(typeDouble, reinterpret_cast< void * >(&valueDouble));
minFreq = valueDouble;
currentNode = currentNode.openGroup(currentNode.getObjnameByIdx(0));
currentNode.openAttribute("TOTAL_INTEGRATION_TIME").read(typeDouble, reinterpret_cast< void * >(&valueDouble));
double totalIntegrationTime = valueDouble;
currentNode.openAttribute("NOF_BEAMS").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
observation.setNrBeams(valueUInt);
currentNode = currentNode.openGroup(currentNode.getObjnameByIdx(0));
currentNode.openAttribute("NOF_SAMPLES").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
unsigned int totalSamples = valueUInt;
currentNode.openAttribute("NOF_STATIONS").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
observation.setNrStations(valueUInt);
currentNode.openAttribute("CHANNELS_PER_SUBBAND").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
nrChannels = valueUInt;
currentNode.openAttribute("CHANNEL_WIDTH").read(typeDouble, reinterpret_cast< void * >(&valueDouble));
channelBandwidth = valueDouble / 1000000;
H5::DataSet currentData = currentNode.openDataSet("STOKES_0");
currentData.openAttribute("NOF_SUBBANDS").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
nrSubbands = valueUInt;
headerFile.close();
observation.setNrSamplesPerSecond(static_cast< unsigned int >(totalSamples / totalIntegrationTime));
if ( nrSeconds == 0 ) {
observation.setNrSeconds(static_cast< unsigned int >(totalIntegrationTime));
} else {
if ( static_cast< unsigned int >(totalIntegrationTime) >= (firstSecond + nrSeconds) ) {
observation.setNrSeconds(nrSeconds);
} else {
observation.setNrSeconds(static_cast< unsigned int >(totalIntegrationTime) - firstSecond);
}
}
observation.setFrequencyRange(nrSubbands * nrChannels, minFreq, channelBandwidth);
// Read the raw file with the actual data
std::ifstream rawFile;
rawFile.open(rawFilename.c_str(), std::ios::binary);
rawFile.sync_with_stdio(false);
if ( firstSecond > 0 ) {
rawFile.seekg(firstSecond * observation.getNrSamplesPerSecond() * nrSubbands * nrChannels, std::ios::beg);
}
data.resize(observation.getNrSeconds());
char * word = new char [4];
for ( unsigned int second = 0; second < observation.getNrSeconds(); second++ ) {
data.at(second) = new std::vector< T >(observation.getNrChannels() * observation.getNrSamplesPerPaddedSecond());
for ( unsigned int sample = 0; sample < observation.getNrSamplesPerSecond(); sample++ ) {
for ( unsigned int subband = 0; subband < nrSubbands; subband++ ) {
for ( unsigned int channel = 0; channel < nrChannels; channel++ ) {
unsigned int globalChannel = (subband * nrChannels) + channel;
rawFile.read(word, 4);
isa::utils::bigEndianToLittleEndian(word);
data.at(second)->at((globalChannel * observation.getNrSamplesPerPaddedSecond()) + sample) = *(reinterpret_cast< T * >(word));
}
}
}
}
rawFile.close();
delete [] word;
}
template< typename T > void readPSRDadaHeader(Observation & observation, dada_hdu_t & ringBuffer) throw(RingBufferError) {
// Staging variables for the header elements
unsigned int uintValue = 0;
float floatValue[2] = {0.0f, 0.0f};
// Header string
uint64_t headerBytes = 0;
char * header = 0;
header = ipcbuf_get_next_read(ringBuffer.header_block, &headerBytes);
if ( (header == 0) || (headerBytes == 0 ) ) {
throw RingBufferError();
}
ascii_header_get(header, "SAMPLES_PER_SECOND", "%d", &uintValue);
observation.setNrSamplesPerSecond(uintValue);
ascii_header_get(header, "CHANNELS", "%d", &uintValue);
ascii_header_get(header, "MIN_FREQUENCY", "%f", &floatValue[0]);
ascii_header_get(header, "CHANNEL_BANDWIDTH", "%f", &floatValue[1]);
observation.setFrequencyRange(uintValue, floatValue[0], floatValue[1]);
ipcbuf_mark_cleared(ringBuffer.header_block);
delete header;
}
template< typename T > inline void readPSRDada(Observation & observation, dada_hdu_t & ringBuffer, std::vector< T > * data) throw(RingBufferError) {
if ( (ipcio_read(ringBuffer.data_block, reinterpret_cast< char * >(data->data()), observation.getNrChannels() * observation.getNrSamplesPerPaddedSecond() * sizeof(T))) < 0 ) {
throw RingBufferError();
}
}
} // AstroData
#endif // READ_DATA_HPP
<commit_msg>Reading < 8 bit values from SIGPROC data files was still wrong. Fixing it.<commit_after>// Copyright 2012 Alessio Sclocco <[email protected]>
//
// 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 <fstream>
#include <vector>
#include <string>
#include <cmath>
#include <exception>
#include <H5Cpp.h>
#include <dada_hdu.h>
#include <ascii_header.h>
#include <Observation.hpp>
#include <utils.hpp>
#ifndef READ_DATA_HPP
#define READ_DATA_HPP
namespace AstroData {
// Exception: the PSRDada ring buffer does not work
class RingBufferError : public std::exception {
public:
RingBufferError();
~RingBufferError() throw ();
const char * what() const throw ();
};
template< typename T > void readSIGPROC(const Observation & observation, const uint8_t inputBits, const unsigned int bytesToSkip, const std::string & inputFilename, std::vector< std::vector< T > * > & data, const unsigned int firstSecond = 0);
template< typename T > void readLOFAR(std::string headerFilename, std::string rawFilename, Observation & observation, std::vector< std::vector< T > * > & data, unsigned int nrSeconds = 0, unsigned int firstSecond = 0);
template< typename T > void readPSRDadaHeader(Observation & observation, dada_hdu_t & ringBuffer) throw(RingBufferError);
template< typename T > inline void readPSRDada(Observation & observation, dada_hdu_t & ringBuffer, std::vector< T > * data) throw(RingBufferError);
// Implementation
template< typename T > void readSIGPROC(const Observation & observation, const uint8_t inputBits, const unsigned int bytesToSkip, const std::string & inputFilename, std::vector< std::vector< T > * > & data, const unsigned int firstSecond = 0) {
std::ifstream inputFile;
const unsigned int BUFFER_DIM = sizeof(T);
char * buffer = new char [BUFFER_DIM];
inputFile.open(inputFilename.c_str(), std::ios::binary);
inputFile.sync_with_stdio(false);
inputFile.seekg(bytesToSkip, std::ios::beg);
for ( unsigned int second = 0; second < observation.getNrSeconds(); second++ ) {
if ( inputBits >= 8 ) {
data.at(second) = new std::vector< T >(observation.getNrChannels() * observation.getNrSamplesPerPaddedSecond());
for ( unsigned int sample = 0; sample < observation.getNrSamplesPerSecond(); sample++ ) {
for ( unsigned int channel = observation.getNrChannels(); channel > 0; channel-- ) {
inputFile.read(buffer, BUFFER_DIM);
data.at(second)->at((static_cast< uint64_t >(channel - 1) * observation.getNrSamplesPerPaddedSecond()) + sample) = *(reinterpret_cast< T * >(buffer));
}
}
} else {
data.at(second) = new std::vector< T >(observation.getNrChannels() * isa::utils::pad(observation.getNrSamplesPerSecond() / (8 / inputBits), observation.getPadding()));
for ( unsigned int sample = 0; sample < observation.getNrSamplesPerSecond(); sample++ ) {
unsigned int sampleByte = sample / (8 / inputBits);
uint8_t sampleFirstBit = (sample % (8 / inputBits)) * inputBits;
for ( int channel = observation.getNrChannels(); channel > 0; channel -= (8 / inputBits) ) {
inputFile.read(buffer, BUFFER_DIM);
for ( unsigned int item = 0; item < (8 / inputBits); item++ ) {
uint8_t channelFirstBit = item * inputBits;
uint8_t sampleBuffer = data.at(second)->at((static_cast< uint64_t >((channel - 1) - item) * isa::utils::pad(observation.getNrSamplesPerSecond() / (8 / inputBits), observation.getPadding())) + sampleByte);
for ( uint8_t bit = 0; bit < inputBits; bit++ ) {
isa::utils::setBit(sampleBuffer, isa::utils::getBit(buffer, channelFirstBit + bit), sampleFirstBit + bit);
}
data.at(second)->at((static_cast< uint64_t >((channel - 1) - item) * isa::utils::pad(observation.getNrSamplesPerSecond() / (8 / inputBits), observation.getPadding())) + sampleByte) = sampleBuffer;
}
}
}
}
}
inputFile.close();
delete [] buffer;
}
template< typename T > void readLOFAR(std::string headerFilename, std::string rawFilename, Observation & observation, std::vector< std::vector< T > * > & data, unsigned int nrSeconds, unsigned int firstSecond) {
unsigned int nrSubbands, nrChannels;
float minFreq, channelBandwidth;
// Read the HDF5 file with the metadata
H5::H5File headerFile = H5::H5File(headerFilename, H5F_ACC_RDONLY);
H5::FloatType typeDouble = H5::FloatType(H5::PredType::NATIVE_DOUBLE);
double valueDouble = 0.0;
H5::IntType typeUInt = H5::IntType(H5::PredType::NATIVE_UINT);
unsigned int valueUInt = 0;
H5::Group currentNode = headerFile.openGroup("/");
currentNode.openAttribute("OBSERVATION_FREQUENCY_MIN").read(typeDouble, reinterpret_cast< void * >(&valueDouble));
minFreq = valueDouble;
currentNode = currentNode.openGroup(currentNode.getObjnameByIdx(0));
currentNode.openAttribute("TOTAL_INTEGRATION_TIME").read(typeDouble, reinterpret_cast< void * >(&valueDouble));
double totalIntegrationTime = valueDouble;
currentNode.openAttribute("NOF_BEAMS").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
observation.setNrBeams(valueUInt);
currentNode = currentNode.openGroup(currentNode.getObjnameByIdx(0));
currentNode.openAttribute("NOF_SAMPLES").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
unsigned int totalSamples = valueUInt;
currentNode.openAttribute("NOF_STATIONS").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
observation.setNrStations(valueUInt);
currentNode.openAttribute("CHANNELS_PER_SUBBAND").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
nrChannels = valueUInt;
currentNode.openAttribute("CHANNEL_WIDTH").read(typeDouble, reinterpret_cast< void * >(&valueDouble));
channelBandwidth = valueDouble / 1000000;
H5::DataSet currentData = currentNode.openDataSet("STOKES_0");
currentData.openAttribute("NOF_SUBBANDS").read(typeUInt, reinterpret_cast< void * >(&valueUInt));
nrSubbands = valueUInt;
headerFile.close();
observation.setNrSamplesPerSecond(static_cast< unsigned int >(totalSamples / totalIntegrationTime));
if ( nrSeconds == 0 ) {
observation.setNrSeconds(static_cast< unsigned int >(totalIntegrationTime));
} else {
if ( static_cast< unsigned int >(totalIntegrationTime) >= (firstSecond + nrSeconds) ) {
observation.setNrSeconds(nrSeconds);
} else {
observation.setNrSeconds(static_cast< unsigned int >(totalIntegrationTime) - firstSecond);
}
}
observation.setFrequencyRange(nrSubbands * nrChannels, minFreq, channelBandwidth);
// Read the raw file with the actual data
std::ifstream rawFile;
rawFile.open(rawFilename.c_str(), std::ios::binary);
rawFile.sync_with_stdio(false);
if ( firstSecond > 0 ) {
rawFile.seekg(firstSecond * observation.getNrSamplesPerSecond() * nrSubbands * nrChannels, std::ios::beg);
}
data.resize(observation.getNrSeconds());
char * word = new char [4];
for ( unsigned int second = 0; second < observation.getNrSeconds(); second++ ) {
data.at(second) = new std::vector< T >(observation.getNrChannels() * observation.getNrSamplesPerPaddedSecond());
for ( unsigned int sample = 0; sample < observation.getNrSamplesPerSecond(); sample++ ) {
for ( unsigned int subband = 0; subband < nrSubbands; subband++ ) {
for ( unsigned int channel = 0; channel < nrChannels; channel++ ) {
unsigned int globalChannel = (subband * nrChannels) + channel;
rawFile.read(word, 4);
isa::utils::bigEndianToLittleEndian(word);
data.at(second)->at((globalChannel * observation.getNrSamplesPerPaddedSecond()) + sample) = *(reinterpret_cast< T * >(word));
}
}
}
}
rawFile.close();
delete [] word;
}
template< typename T > void readPSRDadaHeader(Observation & observation, dada_hdu_t & ringBuffer) throw(RingBufferError) {
// Staging variables for the header elements
unsigned int uintValue = 0;
float floatValue[2] = {0.0f, 0.0f};
// Header string
uint64_t headerBytes = 0;
char * header = 0;
header = ipcbuf_get_next_read(ringBuffer.header_block, &headerBytes);
if ( (header == 0) || (headerBytes == 0 ) ) {
throw RingBufferError();
}
ascii_header_get(header, "SAMPLES_PER_SECOND", "%d", &uintValue);
observation.setNrSamplesPerSecond(uintValue);
ascii_header_get(header, "CHANNELS", "%d", &uintValue);
ascii_header_get(header, "MIN_FREQUENCY", "%f", &floatValue[0]);
ascii_header_get(header, "CHANNEL_BANDWIDTH", "%f", &floatValue[1]);
observation.setFrequencyRange(uintValue, floatValue[0], floatValue[1]);
ipcbuf_mark_cleared(ringBuffer.header_block);
delete header;
}
template< typename T > inline void readPSRDada(Observation & observation, dada_hdu_t & ringBuffer, std::vector< T > * data) throw(RingBufferError) {
if ( (ipcio_read(ringBuffer.data_block, reinterpret_cast< char * >(data->data()), observation.getNrChannels() * observation.getNrSamplesPerPaddedSecond() * sizeof(T))) < 0 ) {
throw RingBufferError();
}
}
} // AstroData
#endif // READ_DATA_HPP
<|endoftext|> |
<commit_before>/*ckwg +5
* Copyright 2011 by Kitware, Inc. All Rights Reserved. Please refer to
* KITWARE_LICENSE.TXT for licensing information, or contact General Counsel,
* Kitware, Inc., 28 Corporate Drive, Clifton Park, NY 12065.
*/
#include <test_common.h>
#include <vistk/pipeline/config.h>
#include <vistk/pipeline/edge.h>
#include <vistk/pipeline/modules.h>
#include <vistk/pipeline/process.h>
#include <vistk/pipeline/process_exception.h>
#include <vistk/pipeline/process_registry.h>
#include <vistk/pipeline/process_registry_exception.h>
#include <vistk/pipeline/types.h>
#include <boost/foreach.hpp>
#include <boost/make_shared.hpp>
#include <exception>
#include <iostream>
static void test_process(vistk::process_registry::type_t const& type);
int
main()
{
try
{
vistk::load_known_modules();
}
catch (vistk::process_type_already_exists_exception& e)
{
TEST_ERROR("Duplicate process names: " << e.what());
}
catch (vistk::pipeline_exception& e)
{
TEST_ERROR("Failed to load modules: " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when loading modules: " << e.what());
return 1;
}
vistk::process_registry_t const reg = vistk::process_registry::self();
vistk::process_registry::types_t const types = reg->types();
BOOST_FOREACH (vistk::process_registry::type_t const& type, types)
{
try
{
test_process(type);
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when testing "
"type \'" << type << "\': " << e.what());
}
}
return 0;
}
static void test_process_constraints(vistk::process_t const process);
static void test_process_configuration(vistk::process_t const process);
static void test_process_input_ports(vistk::process_t const process);
static void test_process_output_ports(vistk::process_t const process);
static void test_process_invalid_configuration(vistk::process_t const process);
static void test_process_invalid_input_port(vistk::process_t const process);
static void test_process_invalid_output_port(vistk::process_t const process);
void
test_process(vistk::process_registry::type_t const& type)
{
static vistk::process::name_t const expected_name = vistk::process::name_t("expected_name");
vistk::config_t config = vistk::config::empty_config();
config->set_value(vistk::process::config_name, expected_name);
vistk::process_registry_t const reg = vistk::process_registry::self();
if (reg->description(type).empty())
{
TEST_ERROR("The description is empty");
}
vistk::process_t const process = reg->create_process(type, config);
if (!process)
{
TEST_ERROR("Received NULL process (" << type << ")");
return;
}
if (process->name() != expected_name)
{
TEST_ERROR("Name (" << process->name() << ") "
"does not match expected name: " << expected_name);
}
if (process->type() != type)
{
TEST_ERROR("The type does not match the registry type");
}
test_process_constraints(process);
test_process_configuration(process);
test_process_input_ports(process);
test_process_output_ports(process);
test_process_invalid_configuration(process);
test_process_invalid_input_port(process);
test_process_invalid_output_port(process);
}
void
test_process_constraints(vistk::process_t const process)
{
vistk::process::constraints_t const consts = process->constraints();
(void)consts;
/// \todo Test for conflicting constraints.
}
void
test_process_configuration(vistk::process_t const process)
{
vistk::config::keys_t const keys = process->available_config();
BOOST_FOREACH (vistk::config::key_t const& key, keys)
{
try
{
process->config_info(key);
}
catch (vistk::unknown_configuration_value_exception& e)
{
TEST_ERROR("Failed to get a default for "
<< process->type() << vistk::config::block_sep << key
<< ": " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when querying for default "
"(" << process->type() << vistk::config::block_sep
<< key << "): " << e.what());
}
}
}
void
test_process_input_ports(vistk::process_t const process)
{
static vistk::config_t const config = vistk::config::empty_config();
vistk::process::ports_t const ports = process->input_ports();
BOOST_FOREACH (vistk::process::port_t const& port, ports)
{
vistk::process::port_info_t info;
try
{
info = process->input_port_info(port);
}
catch (vistk::no_such_port_exception& e)
{
TEST_ERROR("Failed to get a info for input port "
<< process->type() << "." << port << ": " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when querying for input port info "
"(" << process->type() << "." << port << "): " << e.what());
}
vistk::process::port_flags_t const& flags = info->flags;
bool const is_const = (flags.find(vistk::process::flag_output_const) != flags.end());
if (is_const)
{
TEST_ERROR("Const flag on input port "
"(" << process->type() << "." << port << ")");
}
vistk::process::port_description_t const& description = info->description;
if (description.empty())
{
TEST_ERROR("Description empty on input port "
"(" << process->type() << "." << port << ")");
}
vistk::edge_t edge = boost::make_shared<vistk::edge>(config);
process->connect_input_port(port, edge);
EXPECT_EXCEPTION(vistk::port_reconnect_exception,
process->connect_input_port(port, edge),
"connecting to an input port a second time");
}
}
void
test_process_output_ports(vistk::process_t const process)
{
static vistk::config_t const config = vistk::config::empty_config();
vistk::process::ports_t const ports = process->output_ports();
BOOST_FOREACH (vistk::process::port_t const& port, ports)
{
vistk::process::port_info_t info;
try
{
info = process->output_port_info(port);
}
catch (vistk::no_such_port_exception& e)
{
TEST_ERROR("Failed to get a info for output port "
<< process->type() << "." << port << ": " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when querying for output port info "
"(" << process->type() << "." << port << "): " << e.what());
}
vistk::process::port_flags_t const& flags = info->flags;
bool const is_mutable = (flags.find(vistk::process::flag_input_mutable) != flags.end());
if (is_mutable)
{
TEST_ERROR("Mutable flag on output port "
"(" << process->type() << "." << port << ")");
}
vistk::process::port_description_t const& description = info->description;
if (description.empty())
{
TEST_ERROR("Description empty on output port "
"(" << process->type() << "." << port << ")");
}
vistk::edge_t edge1 = boost::make_shared<vistk::edge>(config);
vistk::edge_t edge2 = boost::make_shared<vistk::edge>(config);
process->connect_output_port(port, edge1);
process->connect_output_port(port, edge2);
}
}
void
test_process_invalid_configuration(vistk::process_t const process)
{
vistk::config::key_t const non_existent_config = vistk::config::key_t("does_not_exist");
EXPECT_EXCEPTION(vistk::unknown_configuration_value_exception,
process->config_info(non_existent_config),
"requesting the information for a non-existent config");
}
void
test_process_invalid_input_port(vistk::process_t const process)
{
static vistk::process::port_t const non_existent_port = vistk::process::port_t("does_not_exist");
static vistk::config_t const config = vistk::config::empty_config();
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->input_port_info(non_existent_port),
"requesting the info for a non-existent input port");
vistk::edge_t edge = boost::make_shared<vistk::edge>(config);
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->connect_input_port(non_existent_port, edge),
"requesting a connection to a non-existent input port");
}
void
test_process_invalid_output_port(vistk::process_t const process)
{
static vistk::process::port_t const non_existent_port = vistk::process::port_t("does_not_exist");
static vistk::config_t const config = vistk::config::empty_config();
// Output ports.
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->output_port_info(non_existent_port),
"requesting the info for a non-existent output port");
vistk::edge_t edge = boost::make_shared<vistk::edge>(config);
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->connect_output_port(non_existent_port, edge),
"requesting a connection to a non-existent output port");
}
<commit_msg>Add new introspection checks for types and flags<commit_after>/*ckwg +5
* Copyright 2011 by Kitware, Inc. All Rights Reserved. Please refer to
* KITWARE_LICENSE.TXT for licensing information, or contact General Counsel,
* Kitware, Inc., 28 Corporate Drive, Clifton Park, NY 12065.
*/
#include <test_common.h>
#include <vistk/pipeline/config.h>
#include <vistk/pipeline/edge.h>
#include <vistk/pipeline/modules.h>
#include <vistk/pipeline/process.h>
#include <vistk/pipeline/process_exception.h>
#include <vistk/pipeline/process_registry.h>
#include <vistk/pipeline/process_registry_exception.h>
#include <vistk/pipeline/types.h>
#include <boost/foreach.hpp>
#include <boost/make_shared.hpp>
#include <exception>
#include <iostream>
static void test_process(vistk::process_registry::type_t const& type);
int
main()
{
try
{
vistk::load_known_modules();
}
catch (vistk::process_type_already_exists_exception& e)
{
TEST_ERROR("Duplicate process names: " << e.what());
}
catch (vistk::pipeline_exception& e)
{
TEST_ERROR("Failed to load modules: " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when loading modules: " << e.what());
return 1;
}
vistk::process_registry_t const reg = vistk::process_registry::self();
vistk::process_registry::types_t const types = reg->types();
BOOST_FOREACH (vistk::process_registry::type_t const& type, types)
{
try
{
test_process(type);
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when testing "
"type \'" << type << "\': " << e.what());
}
}
return 0;
}
static void test_process_constraints(vistk::process_t const process);
static void test_process_configuration(vistk::process_t const process);
static void test_process_input_ports(vistk::process_t const process);
static void test_process_output_ports(vistk::process_t const process);
static void test_process_invalid_configuration(vistk::process_t const process);
static void test_process_invalid_input_port(vistk::process_t const process);
static void test_process_invalid_output_port(vistk::process_t const process);
void
test_process(vistk::process_registry::type_t const& type)
{
static vistk::process::name_t const expected_name = vistk::process::name_t("expected_name");
vistk::config_t config = vistk::config::empty_config();
config->set_value(vistk::process::config_name, expected_name);
vistk::process_registry_t const reg = vistk::process_registry::self();
if (reg->description(type).empty())
{
TEST_ERROR("The description is empty");
}
vistk::process_t const process = reg->create_process(type, config);
if (!process)
{
TEST_ERROR("Received NULL process (" << type << ")");
return;
}
if (process->name() != expected_name)
{
TEST_ERROR("Name (" << process->name() << ") "
"does not match expected name: " << expected_name);
}
if (process->type() != type)
{
TEST_ERROR("The type does not match the registry type");
}
test_process_constraints(process);
test_process_configuration(process);
test_process_input_ports(process);
test_process_output_ports(process);
test_process_invalid_configuration(process);
test_process_invalid_input_port(process);
test_process_invalid_output_port(process);
}
void
test_process_constraints(vistk::process_t const process)
{
vistk::process::constraints_t const consts = process->constraints();
(void)consts;
/// \todo Test for conflicting constraints.
}
void
test_process_configuration(vistk::process_t const process)
{
vistk::config::keys_t const keys = process->available_config();
BOOST_FOREACH (vistk::config::key_t const& key, keys)
{
try
{
process->config_info(key);
}
catch (vistk::unknown_configuration_value_exception& e)
{
TEST_ERROR("Failed to get a default for "
<< process->type() << vistk::config::block_sep << key
<< ": " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when querying for default "
"(" << process->type() << vistk::config::block_sep
<< key << "): " << e.what());
}
}
}
void
test_process_input_ports(vistk::process_t const process)
{
static vistk::config_t const config = vistk::config::empty_config();
vistk::process::ports_t const ports = process->input_ports();
BOOST_FOREACH (vistk::process::port_t const& port, ports)
{
vistk::process::port_info_t info;
try
{
info = process->input_port_info(port);
}
catch (vistk::no_such_port_exception& e)
{
TEST_ERROR("Failed to get a info for input port "
<< process->type() << "." << port << ": " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when querying for input port info "
"(" << process->type() << "." << port << "): " << e.what());
}
vistk::process::port_flags_t const& flags = info->flags;
bool const is_const = (flags.find(vistk::process::flag_output_const) != flags.end());
if (is_const)
{
TEST_ERROR("Const flag on input port "
"(" << process->type() << "." << port << ")");
}
vistk::process::port_type_t const& type = info->type;
bool const is_data_dependent = (type == vistk::process::type_data_dependent);
if (is_data_dependent)
{
TEST_ERROR("Data-dependent input port "
"(" << process->type() << "." << port << ")");
}
vistk::process::port_description_t const& description = info->description;
if (description.empty())
{
TEST_ERROR("Description empty on input port "
"(" << process->type() << "." << port << ")");
}
vistk::edge_t edge = boost::make_shared<vistk::edge>(config);
process->connect_input_port(port, edge);
EXPECT_EXCEPTION(vistk::port_reconnect_exception,
process->connect_input_port(port, edge),
"connecting to an input port a second time");
}
}
void
test_process_output_ports(vistk::process_t const process)
{
static vistk::config_t const config = vistk::config::empty_config();
vistk::process::ports_t const ports = process->output_ports();
BOOST_FOREACH (vistk::process::port_t const& port, ports)
{
vistk::process::port_info_t info;
try
{
info = process->output_port_info(port);
}
catch (vistk::no_such_port_exception& e)
{
TEST_ERROR("Failed to get a info for output port "
<< process->type() << "." << port << ": " << e.what());
}
catch (std::exception& e)
{
TEST_ERROR("Unexpected exception when querying for output port info "
"(" << process->type() << "." << port << "): " << e.what());
}
vistk::process::port_flags_t const& flags = info->flags;
bool const is_mutable = (flags.find(vistk::process::flag_input_mutable) != flags.end());
if (is_mutable)
{
TEST_ERROR("Mutable flag on output port "
"(" << process->type() << "." << port << ")");
}
bool const is_nodep = (flags.find(vistk::process::flag_input_nodep) != flags.end());
if (is_nodep)
{
TEST_ERROR("No dependency flag on output port "
"(" << process->type() << "." << port << ")");
}
vistk::process::port_description_t const& description = info->description;
if (description.empty())
{
TEST_ERROR("Description empty on output port "
"(" << process->type() << "." << port << ")");
}
vistk::edge_t edge1 = boost::make_shared<vistk::edge>(config);
vistk::edge_t edge2 = boost::make_shared<vistk::edge>(config);
process->connect_output_port(port, edge1);
process->connect_output_port(port, edge2);
}
}
void
test_process_invalid_configuration(vistk::process_t const process)
{
vistk::config::key_t const non_existent_config = vistk::config::key_t("does_not_exist");
EXPECT_EXCEPTION(vistk::unknown_configuration_value_exception,
process->config_info(non_existent_config),
"requesting the information for a non-existent config");
}
void
test_process_invalid_input_port(vistk::process_t const process)
{
static vistk::process::port_t const non_existent_port = vistk::process::port_t("does_not_exist");
static vistk::config_t const config = vistk::config::empty_config();
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->input_port_info(non_existent_port),
"requesting the info for a non-existent input port");
vistk::edge_t edge = boost::make_shared<vistk::edge>(config);
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->connect_input_port(non_existent_port, edge),
"requesting a connection to a non-existent input port");
}
void
test_process_invalid_output_port(vistk::process_t const process)
{
static vistk::process::port_t const non_existent_port = vistk::process::port_t("does_not_exist");
static vistk::config_t const config = vistk::config::empty_config();
// Output ports.
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->output_port_info(non_existent_port),
"requesting the info for a non-existent output port");
vistk::edge_t edge = boost::make_shared<vistk::edge>(config);
EXPECT_EXCEPTION(vistk::no_such_port_exception,
process->connect_output_port(non_existent_port, edge),
"requesting a connection to a non-existent output port");
}
<|endoftext|> |
<commit_before>/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of Qt Creator.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "maemodeviceconfigurations.h"
#include <coreplugin/icore.h>
#include <QtCore/QSettings>
#include <QtCore/QStringBuilder>
#include <QtGui/QDesktopServices>
#include <algorithm>
namespace Qt4ProjectManager {
namespace Internal {
QString homeDirOnDevice(const QString &uname)
{
const QString &dir = uname == QLatin1String("root")
? QLatin1String("/root")
: uname == QLatin1String("developer")
? QLatin1String("/var/local/mad-developer-home")
: QLatin1String("/home/") + uname;
qDebug("%s: user name %s is mapped to home dir %s",
Q_FUNC_INFO, qPrintable(uname), qPrintable(dir));
return dir;
}
namespace {
const QLatin1String SettingsGroup("MaemoDeviceConfigs");
const QLatin1String IdCounterKey("IdCounter");
const QLatin1String ConfigListKey("ConfigList");
const QLatin1String NameKey("Name");
const QLatin1String TypeKey("Type");
const QLatin1String HostKey("Host");
const QLatin1String SshPortKey("SshPort");
const QLatin1String GdbServerPortKey("GdbServerPort");
const QLatin1String UserNameKey("Uname");
const QLatin1String AuthKey("Authentication");
const QLatin1String KeyFileKey("KeyFile");
const QLatin1String PasswordKey("Password");
const QLatin1String TimeoutKey("Timeout");
const QLatin1String InternalIdKey("InternalId");
const QString DefaultKeyFile =
QDesktopServices::storageLocation(QDesktopServices::HomeLocation)
+ QLatin1String("/.ssh/id_rsa");
};
class DevConfIdMatcher
{
public:
DevConfIdMatcher(quint64 id) : m_id(id) {}
bool operator()(const MaemoDeviceConfig &devConfig)
{
return devConfig.internalId == m_id;
}
private:
const quint64 m_id;
};
MaemoDeviceConfig::MaemoDeviceConfig(const QString &name)
: name(name),
type(Physical),
sshPort(22),
gdbServerPort(10000),
authentication(Key),
keyFile(DefaultKeyFile),
timeout(30),
internalId(MaemoDeviceConfigurations::instance().m_nextId++)
{
}
MaemoDeviceConfig::MaemoDeviceConfig(const QSettings &settings,
quint64 &nextId)
: name(settings.value(NameKey).toString()),
type(static_cast<DeviceType>(settings.value(TypeKey, Physical).toInt())),
host(settings.value(HostKey).toString()),
sshPort(settings.value(SshPortKey, 22).toInt()),
gdbServerPort(settings.value(GdbServerPortKey, 10000).toInt()),
uname(settings.value(UserNameKey).toString()),
authentication(static_cast<AuthType>(settings.value(AuthKey).toInt())),
pwd(settings.value(PasswordKey).toString()),
keyFile(settings.value(KeyFileKey).toString()),
timeout(settings.value(TimeoutKey, 30).toInt()),
internalId(settings.value(InternalIdKey, nextId).toInt())
{
if (internalId == nextId)
++nextId;
}
MaemoDeviceConfig::MaemoDeviceConfig()
: internalId(InvalidId)
{
}
bool MaemoDeviceConfig::isValid() const
{
return internalId != InvalidId;
}
void MaemoDeviceConfig::save(QSettings &settings) const
{
settings.setValue(NameKey, name);
settings.setValue(TypeKey, type);
settings.setValue(HostKey, host);
settings.setValue(SshPortKey, sshPort);
settings.setValue(GdbServerPortKey, gdbServerPort);
settings.setValue(UserNameKey, uname);
settings.setValue(AuthKey, authentication);
settings.setValue(PasswordKey, pwd);
settings.setValue(KeyFileKey, keyFile);
settings.setValue(TimeoutKey, timeout);
settings.setValue(InternalIdKey, internalId);
}
void MaemoDeviceConfigurations::setDevConfigs(const QList<MaemoDeviceConfig> &devConfigs)
{
m_devConfigs = devConfigs;
save();
emit updated();
}
MaemoDeviceConfigurations &MaemoDeviceConfigurations::instance(QObject *parent)
{
if (m_instance == 0)
m_instance = new MaemoDeviceConfigurations(parent);
return *m_instance;
}
void MaemoDeviceConfigurations::save()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(SettingsGroup);
settings->setValue(IdCounterKey, m_nextId);
settings->beginWriteArray(ConfigListKey, m_devConfigs.count());
for (int i = 0; i < m_devConfigs.count(); ++i) {
settings->setArrayIndex(i);
m_devConfigs.at(i).save(*settings);
}
settings->endArray();
settings->endGroup();
}
MaemoDeviceConfigurations::MaemoDeviceConfigurations(QObject *parent)
: QObject(parent)
{
load();
}
void MaemoDeviceConfigurations::load()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(SettingsGroup);
m_nextId = settings->value(IdCounterKey, 1).toULongLong();
int count = settings->beginReadArray(ConfigListKey);
for (int i = 0; i < count; ++i) {
settings->setArrayIndex(i);
m_devConfigs.append(MaemoDeviceConfig(*settings, m_nextId));
}
settings->endArray();
settings->endGroup();
}
MaemoDeviceConfig MaemoDeviceConfigurations::find(const QString &name) const
{
QList<MaemoDeviceConfig>::ConstIterator resultIt =
std::find_if(m_devConfigs.constBegin(), m_devConfigs.constEnd(),
DevConfNameMatcher(name));
return resultIt == m_devConfigs.constEnd() ? MaemoDeviceConfig() : *resultIt;
}
MaemoDeviceConfig MaemoDeviceConfigurations::find(int id) const
{
QList<MaemoDeviceConfig>::ConstIterator resultIt =
std::find_if(m_devConfigs.constBegin(), m_devConfigs.constEnd(),
DevConfIdMatcher(id));
return resultIt == m_devConfigs.constEnd() ? MaemoDeviceConfig() : *resultIt;
}
MaemoDeviceConfigurations *MaemoDeviceConfigurations::m_instance = 0;
} // namespace Internal
} // namespace Qt4ProjectManager
<commit_msg>Maemo: Remove special case for "developer" user.<commit_after>/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of Qt Creator.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "maemodeviceconfigurations.h"
#include <coreplugin/icore.h>
#include <QtCore/QSettings>
#include <QtCore/QStringBuilder>
#include <QtGui/QDesktopServices>
#include <algorithm>
namespace Qt4ProjectManager {
namespace Internal {
QString homeDirOnDevice(const QString &uname)
{
const QString &dir = uname == QLatin1String("root")
? QLatin1String("/root")
: QLatin1String("/home/") + uname;
qDebug("%s: user name %s is mapped to home dir %s",
Q_FUNC_INFO, qPrintable(uname), qPrintable(dir));
return dir;
}
namespace {
const QLatin1String SettingsGroup("MaemoDeviceConfigs");
const QLatin1String IdCounterKey("IdCounter");
const QLatin1String ConfigListKey("ConfigList");
const QLatin1String NameKey("Name");
const QLatin1String TypeKey("Type");
const QLatin1String HostKey("Host");
const QLatin1String SshPortKey("SshPort");
const QLatin1String GdbServerPortKey("GdbServerPort");
const QLatin1String UserNameKey("Uname");
const QLatin1String AuthKey("Authentication");
const QLatin1String KeyFileKey("KeyFile");
const QLatin1String PasswordKey("Password");
const QLatin1String TimeoutKey("Timeout");
const QLatin1String InternalIdKey("InternalId");
const QString DefaultKeyFile =
QDesktopServices::storageLocation(QDesktopServices::HomeLocation)
+ QLatin1String("/.ssh/id_rsa");
};
class DevConfIdMatcher
{
public:
DevConfIdMatcher(quint64 id) : m_id(id) {}
bool operator()(const MaemoDeviceConfig &devConfig)
{
return devConfig.internalId == m_id;
}
private:
const quint64 m_id;
};
MaemoDeviceConfig::MaemoDeviceConfig(const QString &name)
: name(name),
type(Physical),
sshPort(22),
gdbServerPort(10000),
authentication(Key),
keyFile(DefaultKeyFile),
timeout(30),
internalId(MaemoDeviceConfigurations::instance().m_nextId++)
{
}
MaemoDeviceConfig::MaemoDeviceConfig(const QSettings &settings,
quint64 &nextId)
: name(settings.value(NameKey).toString()),
type(static_cast<DeviceType>(settings.value(TypeKey, Physical).toInt())),
host(settings.value(HostKey).toString()),
sshPort(settings.value(SshPortKey, 22).toInt()),
gdbServerPort(settings.value(GdbServerPortKey, 10000).toInt()),
uname(settings.value(UserNameKey).toString()),
authentication(static_cast<AuthType>(settings.value(AuthKey).toInt())),
pwd(settings.value(PasswordKey).toString()),
keyFile(settings.value(KeyFileKey).toString()),
timeout(settings.value(TimeoutKey, 30).toInt()),
internalId(settings.value(InternalIdKey, nextId).toInt())
{
if (internalId == nextId)
++nextId;
}
MaemoDeviceConfig::MaemoDeviceConfig()
: internalId(InvalidId)
{
}
bool MaemoDeviceConfig::isValid() const
{
return internalId != InvalidId;
}
void MaemoDeviceConfig::save(QSettings &settings) const
{
settings.setValue(NameKey, name);
settings.setValue(TypeKey, type);
settings.setValue(HostKey, host);
settings.setValue(SshPortKey, sshPort);
settings.setValue(GdbServerPortKey, gdbServerPort);
settings.setValue(UserNameKey, uname);
settings.setValue(AuthKey, authentication);
settings.setValue(PasswordKey, pwd);
settings.setValue(KeyFileKey, keyFile);
settings.setValue(TimeoutKey, timeout);
settings.setValue(InternalIdKey, internalId);
}
void MaemoDeviceConfigurations::setDevConfigs(const QList<MaemoDeviceConfig> &devConfigs)
{
m_devConfigs = devConfigs;
save();
emit updated();
}
MaemoDeviceConfigurations &MaemoDeviceConfigurations::instance(QObject *parent)
{
if (m_instance == 0)
m_instance = new MaemoDeviceConfigurations(parent);
return *m_instance;
}
void MaemoDeviceConfigurations::save()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(SettingsGroup);
settings->setValue(IdCounterKey, m_nextId);
settings->beginWriteArray(ConfigListKey, m_devConfigs.count());
for (int i = 0; i < m_devConfigs.count(); ++i) {
settings->setArrayIndex(i);
m_devConfigs.at(i).save(*settings);
}
settings->endArray();
settings->endGroup();
}
MaemoDeviceConfigurations::MaemoDeviceConfigurations(QObject *parent)
: QObject(parent)
{
load();
}
void MaemoDeviceConfigurations::load()
{
QSettings *settings = Core::ICore::instance()->settings();
settings->beginGroup(SettingsGroup);
m_nextId = settings->value(IdCounterKey, 1).toULongLong();
int count = settings->beginReadArray(ConfigListKey);
for (int i = 0; i < count; ++i) {
settings->setArrayIndex(i);
m_devConfigs.append(MaemoDeviceConfig(*settings, m_nextId));
}
settings->endArray();
settings->endGroup();
}
MaemoDeviceConfig MaemoDeviceConfigurations::find(const QString &name) const
{
QList<MaemoDeviceConfig>::ConstIterator resultIt =
std::find_if(m_devConfigs.constBegin(), m_devConfigs.constEnd(),
DevConfNameMatcher(name));
return resultIt == m_devConfigs.constEnd() ? MaemoDeviceConfig() : *resultIt;
}
MaemoDeviceConfig MaemoDeviceConfigurations::find(int id) const
{
QList<MaemoDeviceConfig>::ConstIterator resultIt =
std::find_if(m_devConfigs.constBegin(), m_devConfigs.constEnd(),
DevConfIdMatcher(id));
return resultIt == m_devConfigs.constEnd() ? MaemoDeviceConfig() : *resultIt;
}
MaemoDeviceConfigurations *MaemoDeviceConfigurations::m_instance = 0;
} // namespace Internal
} // namespace Qt4ProjectManager
<|endoftext|> |
<commit_before>#include "TestScene.h"
#include "Helpers/Helpers.h"
#include "SceneManaging/CollisionManager.h"
#include "SceneManaging\PathFindManager.h"
#include "Input\InputManager.h"
#include "GraphicsManager.h"
#include "SceneManaging/SceneManager.h"
#ifdef _WIN32
#include "libs/OpenGL/GLEW/include/GL/glew.h"
#else
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#endif
#define INPUT_MANAGER (InputManager::GetSingleton())
#define LOGGER (Logger::GetSingleton())
namespace star
{
TestScene::TestScene(const tstring & Name):
BaseScene(Name),
m_TotalFrames(0),
m_FPS(0),
m_Step(0),
m_PassedMiliseconds(0),
m_pObjectOne(nullptr),
m_pObjectTwo(nullptr),
m_pObjectThree(nullptr),
m_pObjectFour(nullptr),
m_pObjectFive(nullptr),
m_pObjectSix(nullptr),
m_pRectCompOne(nullptr),
m_pRectCompTwo(nullptr),
m_pPathFindComp(nullptr),
m_pPathFindCompTwo(nullptr),
m_pPathFindCompThree(nullptr),
m_pPathFindCompFour(nullptr),
m_pPathFindCompFive(nullptr),
m_pPathFindCompSix(nullptr)
{
}
status TestScene::Initialize( const Context& context)
{
m_pObjectOne = new Object();
m_pRectCompOne = new RectangleColliderComponent(10,10);
m_pPathFindComp = new PathFindNodeComponent();
m_pObjectOne->AddComponent(m_pRectCompOne);
m_pObjectOne->AddComponent(m_pPathFindComp);
m_pObjectTwo = new Object();
m_pRectCompTwo = new CircleColliderComponent(10);
m_pPathFindCompTwo = new PathFindNodeComponent();
m_pObjectTwo->AddComponent(m_pRectCompTwo);
m_pObjectTwo->AddComponent(m_pPathFindCompTwo);
m_pObjectTwo->GetComponent<TransformComponent>()->Translate(1,0,0);
m_pObjectThree = new Object();
m_pPathFindCompThree = new PathFindNodeComponent();
m_pObjectThree->AddComponent(m_pPathFindCompThree);
m_pObjectThree->GetComponent<TransformComponent>()->Translate(1,1,0);
m_pObjectFour = new Object();
m_pPathFindCompFour = new PathFindNodeComponent();
m_pObjectFour->AddComponent(m_pPathFindCompFour);
m_pObjectFour->GetComponent<TransformComponent>()->Translate(2,1,0);
m_pObjectFive = new Object();
m_pPathFindCompFive = new PathFindNodeComponent();
m_pObjectFive->AddComponent(m_pPathFindCompFive);
m_pObjectFive->GetComponent<TransformComponent>()->Translate(3,1,0);
m_pObjectSix = new Object();
m_pPathFindCompSix = new PathFindNodeComponent();
m_pObjectSix->AddComponent(m_pPathFindCompSix);
m_pObjectSix->GetComponent<TransformComponent>()->Translate(3,2,0);
CollisionManager::GetInstance()->AddObject(m_pObjectOne);
CollisionManager::GetInstance()->AddObject(m_pObjectTwo);
CollisionManager::GetInstance()->CheckCollision(_T("Default"));
if(TextureManager::GetInstance()->LoadTexture(_T("TestDaPng.png"),_T("TestPNG")))
{
LOGGER->Log(star::LogLevel::Info,_T("PNG : TestDaPng loaded succesfull"));
}
if(TextureManager::GetInstance()->LoadTexture(_T("Awesome.png"),_T("Awesome")))
{
LOGGER->Log(star::LogLevel::Info,_T("PNG : Awesome loaded succesfull"));
}
#ifndef _WIN32
LOGGER->Log(star::LogLevel::Info,_T("Started making shader"));
if(!mTextureShader.Init(_T("BaseTexShader.vert"),_T("BaseTexShader.frag")))
{
LOGGER->Log(star::LogLevel::Info,_T("Making Shader Failed"));
}
LOGGER->Log(star::LogLevel::Info,_T("Stopped making shader"));
#endif
return STATUS_OK;
}
status TestScene::Update(const Context& context)
{
auto pos = INPUT_MANAGER->GetCurrentFingerPosCP();
//tstringstream posBuffer;
//posBuffer << _T("Current Mouse Pos: ( ") << pos.x << _T(" , ") << pos.y << _T(" )");
//LOGGER->Log(LogLevel::Warning, posBuffer.str());
++m_TotalFrames;
m_PassedMiliseconds += float(context.mTimeManager->GetMicroSeconds());
if(m_PassedMiliseconds >= 1000000)
{
m_FPS = m_TotalFrames;
m_TotalFrames = 0;
m_PassedMiliseconds -= 1000000;
tstringstream str;
str << "FPS: " << m_FPS;
//LOGGER->Log(LogLevel::Info, str.str());
m_pObjectOne->GetComponent<TransformComponent>()->Translate(PathFindManager::GetInstance()->GetStep(m_Step));
vec3 pos = m_pObjectOne->GetComponent<TransformComponent>()->GetWorldPosition();
//tstringstream tstr;
//tstr << _T("PlayerPos : (") << pos.x << _T(", ") << pos.y << _T(")");
//LOGGER->Log(LogLevel::Info, tstr.str());
++m_Step;
}
PathFindManager::GetInstance()->FindPath(m_pObjectOne->GetComponent<TransformComponent>()->GetWorldPosition(), vec3(3,2,0));
if(pos.y>(GraphicsManager::GetInstance()->GetScreenHeight()/2) && pos.y< star::GraphicsManager::GetInstance()->GetScreenHeight())
{
SceneManager::GetInstance()->SetActiveScene(_T("TestScene2"));
}
return STATUS_OK;
}
status TestScene::Draw()
{
glClearColor(1.0f, 0.0f, 1.0f, 1.0f); // Clear the background of our window to red
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); //Clear the colour buffer (more buffers later on)
#ifdef _WIN32
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, star::TextureManager::GetInstance()->GetTextureID(_T("TestPNG")));
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex2f(-8.0f, -8.0f);
glTexCoord2f(1.0, 0.0); glVertex2f(0.0f, -8.0f);
glTexCoord2f(1.0, 1.0); glVertex2f(0.0f, 0.0f);
glTexCoord2f(0.0, 1.0); glVertex2f(-8.0f, 0.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, star::TextureManager::GetInstance()->GetTextureID(_T("Awesome")));
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0, 0.0); glVertex2f(8.0f, 0.0f);
glTexCoord2f(1.0, 1.0); glVertex2f(8.0f, 8.0f);
glTexCoord2f(0.0, 1.0); glVertex2f(0.0f, 8.0f);
glEnd();
glDisable(GL_TEXTURE_2D);
#else
//Simon - Do Not remove, I'm working on this but its a pain in the ass. commented for now
mTextureShader.Bind();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, star::TextureManager::GetInstance()->GetTextureID(_T("Awesome")));
GLint s_textureId = glGetUniformLocation(mTextureShader.id(), "textureSampler");
glUniform1i(s_textureId, 0);
static const GLfloat squareVertices[] = {
-0.5f, -0.5f,
0.5f, -0.5f,
-0.5f, 0.5f,
0.5f, 0.5f,
};
static const GLfloat textureVertices[] = {
1.0f, 1.0f,
1.0f, 0.0f,
0.0f, 1.0f,
0.0f, 0.0f,
};
glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT,0,0, squareVertices);
glEnableVertexAttribArray(ATTRIB_VERTEX);
glVertexAttribPointer(ATTRIB_TEXTUREPOSITON, 2, GL_FLOAT, 0, 0, textureVertices);
glEnableVertexAttribArray(ATTRIB_TEXTUREPOSITON);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glDisableVertexAttribArray(ATTRIB_VERTEX);
glDisableVertexAttribArray(ATTRIB_TEXTUREPOSITON);
mTextureShader.Unbind();
#endif
return STATUS_OK;
}
}
<commit_msg>Test Scene [EXAMPLE] for the Filepath.<commit_after>#include "TestScene.h"
#include "Helpers/Helpers.h"
#include "SceneManaging/CollisionManager.h"
#include "SceneManaging\PathFindManager.h"
#include "Input\InputManager.h"
#include "GraphicsManager.h"
#include "SceneManaging/SceneManager.h"
#include "Helpers/Filepath.h"
#ifdef _WIN32
#include "libs/OpenGL/GLEW/include/GL/glew.h"
#else
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#endif
#define INPUT_MANAGER (InputManager::GetSingleton())
#define LOGGER (Logger::GetSingleton())
namespace star
{
TestScene::TestScene(const tstring & Name):
BaseScene(Name),
m_TotalFrames(0),
m_FPS(0),
m_Step(0),
m_PassedMiliseconds(0),
m_pObjectOne(nullptr),
m_pObjectTwo(nullptr),
m_pObjectThree(nullptr),
m_pObjectFour(nullptr),
m_pObjectFive(nullptr),
m_pObjectSix(nullptr),
m_pRectCompOne(nullptr),
m_pRectCompTwo(nullptr),
m_pPathFindComp(nullptr),
m_pPathFindCompTwo(nullptr),
m_pPathFindCompThree(nullptr),
m_pPathFindCompFour(nullptr),
m_pPathFindCompFive(nullptr),
m_pPathFindCompSix(nullptr)
{
}
status TestScene::Initialize( const Context& context)
{
m_pObjectOne = new Object();
m_pRectCompOne = new RectangleColliderComponent(10,10);
m_pPathFindComp = new PathFindNodeComponent();
m_pObjectOne->AddComponent(m_pRectCompOne);
m_pObjectOne->AddComponent(m_pPathFindComp);
m_pObjectTwo = new Object();
m_pRectCompTwo = new CircleColliderComponent(10);
m_pPathFindCompTwo = new PathFindNodeComponent();
m_pObjectTwo->AddComponent(m_pRectCompTwo);
m_pObjectTwo->AddComponent(m_pPathFindCompTwo);
m_pObjectTwo->GetComponent<TransformComponent>()->Translate(1,0,0);
m_pObjectThree = new Object();
m_pPathFindCompThree = new PathFindNodeComponent();
m_pObjectThree->AddComponent(m_pPathFindCompThree);
m_pObjectThree->GetComponent<TransformComponent>()->Translate(1,1,0);
m_pObjectFour = new Object();
m_pPathFindCompFour = new PathFindNodeComponent();
m_pObjectFour->AddComponent(m_pPathFindCompFour);
m_pObjectFour->GetComponent<TransformComponent>()->Translate(2,1,0);
m_pObjectFive = new Object();
m_pPathFindCompFive = new PathFindNodeComponent();
m_pObjectFive->AddComponent(m_pPathFindCompFive);
m_pObjectFive->GetComponent<TransformComponent>()->Translate(3,1,0);
m_pObjectSix = new Object();
m_pPathFindCompSix = new PathFindNodeComponent();
m_pObjectSix->AddComponent(m_pPathFindCompSix);
m_pObjectSix->GetComponent<TransformComponent>()->Translate(3,2,0);
CollisionManager::GetInstance()->AddObject(m_pObjectOne);
CollisionManager::GetInstance()->AddObject(m_pObjectTwo);
CollisionManager::GetInstance()->CheckCollision(_T("Default"));
if(TextureManager::GetInstance()->LoadTexture(_T("TestDaPng.png"),_T("TestPNG")))
{
LOGGER->Log(star::LogLevel::Info,_T("PNG : TestDaPng loaded succesfull"));
}
if(TextureManager::GetInstance()->LoadTexture(_T("Awesome.png"),_T("Awesome")))
{
LOGGER->Log(star::LogLevel::Info,_T("PNG : Awesome loaded succesfull"));
}
#ifndef _WIN32
LOGGER->Log(star::LogLevel::Info,_T("Started making shader"));
if(!mTextureShader.Init(_T("BaseTexShader.vert"),_T("BaseTexShader.frag")))
{
LOGGER->Log(star::LogLevel::Info,_T("Making Shader Failed"));
}
LOGGER->Log(star::LogLevel::Info,_T("Stopped making shader"));
#endif
//=================================================================
// [EXAMPLE] Here you see that I have a file path.
// I used the easiest constructor,
// but it has also other constructors.
// For more information: check the header file.
// This constructor has 2 parameters
// 1) Directory of the file
// Notes:
// + use EMPTY_STRING or _T("") if the file is
// in the assets root dir.
// + always start the path defintion starting
// from the assets root dir.
Filepath example_path(_T("directory/"), _T("file.ext"));
// this is the function you use to get the complete path
// inclusive the file name and extension
// Notes:
// + for windows he automaticly prepends the
// predefined assets dir path to the returned full path.
// by default this is './assets/'. (dir android uses)
// this can be changed in the Win32Manifest.xml file.
LOGGER->Log(star::LogLevel::Info,example_path.GetFullPath());
// File path has also functions, which you in most cases probably
// don't really need.
//=================================================================
return STATUS_OK;
}
status TestScene::Update(const Context& context)
{
auto pos = INPUT_MANAGER->GetCurrentFingerPosCP();
//tstringstream posBuffer;
//posBuffer << _T("Current Mouse Pos: ( ") << pos.x << _T(" , ") << pos.y << _T(" )");
//LOGGER->Log(LogLevel::Warning, posBuffer.str());
++m_TotalFrames;
m_PassedMiliseconds += float(context.mTimeManager->GetMicroSeconds());
if(m_PassedMiliseconds >= 1000000)
{
m_FPS = m_TotalFrames;
m_TotalFrames = 0;
m_PassedMiliseconds -= 1000000;
tstringstream str;
str << "FPS: " << m_FPS;
//LOGGER->Log(LogLevel::Info, str.str());
m_pObjectOne->GetComponent<TransformComponent>()->Translate(PathFindManager::GetInstance()->GetStep(m_Step));
vec3 pos = m_pObjectOne->GetComponent<TransformComponent>()->GetWorldPosition();
//tstringstream tstr;
//tstr << _T("PlayerPos : (") << pos.x << _T(", ") << pos.y << _T(")");
//LOGGER->Log(LogLevel::Info, tstr.str());
++m_Step;
}
PathFindManager::GetInstance()->FindPath(m_pObjectOne->GetComponent<TransformComponent>()->GetWorldPosition(), vec3(3,2,0));
if(pos.y>(GraphicsManager::GetInstance()->GetScreenHeight()/2) && pos.y< star::GraphicsManager::GetInstance()->GetScreenHeight())
{
SceneManager::GetInstance()->SetActiveScene(_T("TestScene2"));
}
return STATUS_OK;
}
status TestScene::Draw()
{
glClearColor(1.0f, 0.0f, 1.0f, 1.0f); // Clear the background of our window to red
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); //Clear the colour buffer (more buffers later on)
#ifdef _WIN32
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, star::TextureManager::GetInstance()->GetTextureID(_T("TestPNG")));
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex2f(-8.0f, -8.0f);
glTexCoord2f(1.0, 0.0); glVertex2f(0.0f, -8.0f);
glTexCoord2f(1.0, 1.0); glVertex2f(0.0f, 0.0f);
glTexCoord2f(0.0, 1.0); glVertex2f(-8.0f, 0.0f);
glEnd();
glBindTexture(GL_TEXTURE_2D, star::TextureManager::GetInstance()->GetTextureID(_T("Awesome")));
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0, 0.0); glVertex2f(8.0f, 0.0f);
glTexCoord2f(1.0, 1.0); glVertex2f(8.0f, 8.0f);
glTexCoord2f(0.0, 1.0); glVertex2f(0.0f, 8.0f);
glEnd();
glDisable(GL_TEXTURE_2D);
#else
//Simon - Do Not remove, I'm working on this but its a pain in the ass. commented for now
mTextureShader.Bind();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, star::TextureManager::GetInstance()->GetTextureID(_T("Awesome")));
GLint s_textureId = glGetUniformLocation(mTextureShader.id(), "textureSampler");
glUniform1i(s_textureId, 0);
static const GLfloat squareVertices[] = {
-0.5f, -0.5f,
0.5f, -0.5f,
-0.5f, 0.5f,
0.5f, 0.5f,
};
static const GLfloat textureVertices[] = {
1.0f, 1.0f,
1.0f, 0.0f,
0.0f, 1.0f,
0.0f, 0.0f,
};
glVertexAttribPointer(ATTRIB_VERTEX, 2, GL_FLOAT,0,0, squareVertices);
glEnableVertexAttribArray(ATTRIB_VERTEX);
glVertexAttribPointer(ATTRIB_TEXTUREPOSITON, 2, GL_FLOAT, 0, 0, textureVertices);
glEnableVertexAttribArray(ATTRIB_TEXTUREPOSITON);
glDrawArrays(GL_TRIANGLE_STRIP,0,4);
glDisableVertexAttribArray(ATTRIB_VERTEX);
glDisableVertexAttribArray(ATTRIB_TEXTUREPOSITON);
mTextureShader.Unbind();
#endif
return STATUS_OK;
}
}
<|endoftext|> |
<commit_before>/* -*- coding: utf-8; mode: c++; tab-width: 3; indent-tabs-mode: nil -*-
Copyright 2010, 2011, 2012, 2013, 2014
Raffaello D. Di Napoli
This file is part of Application-Building Components (henceforth referred to as ABC).
ABC is free software: you can redistribute it and/or modify it under the terms of the GNU General
Public License as published by the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
ABC 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 ABC. If not, see
<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------------------------------*/
#ifndef _ABC_CORE_HXX
#error Please #include <abc/core.hxx> instead of this file
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text globals
namespace abc {
namespace text {
/** Recognized text encodings. Little endians should be listed before big endians; some code relies
on this.
*/
ABC_ENUM(encoding, \
/** Unknown/undetermined encoding. */ \
(unknown, 0), \
/** UTF-8 encoding. */ \
(utf8, 1), \
/** UTF-16 Little Endian encoding. */ \
(utf16le, 2), \
/** UTF-16 Big Endian encoding. */ \
(utf16be, 3), \
/** UTF-32 Little Endian encoding. */ \
(utf32le, 4), \
/** UTF-32 Big Endian encoding. */ \
(utf32be, 5), \
/** ISO-8859-1 encoding. Only supported in detection and handling, but not as internal string
* representation. */ \
(iso_8859_1, 6), \
/** Windows-1252 encoding. Only supported in detection and handling, but not as internal string
* representation. */ \
(windows_1252, 7), \
/** EBCDIC encoding. Only supported in detection and handling, but not as internal string
* representation. */ \
(ebcdic, 8), \
/** UTF-16 encoding (host endianness). */ \
(utf16_host, (ABC_HOST_LITTLE_ENDIAN ? utf16le : utf16be)), \
/** UTF-32 encoding (host endianness). */ \
(utf32_host, (ABC_HOST_LITTLE_ENDIAN ? utf32le : utf32be)), \
/** Default host encoding. */ \
(host, (ABC_HOST_UTF == 8 ? utf8 : (ABC_HOST_UTF == 16 ? utf16_host : utf32_host))) \
);
/** Recognized line terminators.
*/
ABC_ENUM(line_terminator, \
/** Unknown/undetermined line terminator. */ \
(unknown, 0), \
/** Old Mac style: Carriage Return, '\r'. */ \
(cr, 1), \
/** Unix/POSIX style: Line Feed, '\n'. */ \
(lf, 2), \
/** DOS/Windows style: Carriage Return + Line Feed, '\r', '\n'. */ \
(cr_lf, 3), \
/** EBCDIC style: Next Line, '\x15'. */ \
(nel, 4), \
/** Default host line terminator. */ \
(host, (ABC_HOST_API_WIN32 ? cr_lf : lf)) \
);
/** This can be used by any char32_t-returning function that needs to return a value that’s
obviously not a char32_t value. */
char32_t const invalid_char(~char32_t(0));
/** This must be used to replace any invalid char32_t value. */
char32_t const replacement_char(0x00fffd);
/** Maximum run length for the encoding of a code point, in any encoding.
Technically, 6 is an illegal UTF-8 run, but it’s possible due to the way bits are encoded, so it’s
here. */
size_t const max_codepoint_length(6);
/** Provides an estimate of the space, in bytes, necessary to store a string, transcoded in a
different encoding. For example, transcoding from UTF-32 to UTF-16 will yield half the source size,
although special cases such as surrogates might make the estimate too low.
encSrc
Source encoding.
pSrc
Pointer to the source string.
cbSrc
Length of the source string, in bytes.
encDst
Target encoding.
return
Estimated size necessary for the destination string, in bytes.
*/
ABCAPI size_t estimate_transcoded_size(
encoding encSrc, void const * pSrc, size_t cbSrc, encoding encDst
);
/** Returns the character size, in bytes, for the specified charset encoding, or 0 for non-charset
encodings (e.g. identity_encoding).
enc
Desired encoding.
return
Size of a character (not a code point, which can require more than one character) for the
specified encoding, in bytes.
*/
ABCAPI size_t get_encoding_size(encoding enc);
/** Tries to guess the encoding of a sequence of bytes, optionally also taking into account the
total number of bytes in the source of which the buffer is the beginning.
While this function can check for validity of some encodings, it does not guarantee that, for
example, for a return value of utf8_encoding utf8_traits::is_valid() will return true for the same
buffer.
TODO: why not guarantee validity? It would help weed out more encodings with fewer bytes.
pchBegin
Pointer to the beginning of the buffer to scan for encoding clues.
pchEnd
Pointer to beyond the end of the buffer.
cbSrcTotal
Total size, in bytes, of a larger string of which *pBuf is the beginning.
pcbBom
Pointer to a variable that will receive the size of the Byte Order Mark if found at the beginning
of the string, in bytes, or 0 otherwise.
return
Detected encoding of the string pointed to by pBuf.
*/
ABCAPI encoding guess_encoding(
void const * pBufBegin, void const * pBufEnd, size_t cbSrcTotal = 0, size_t * pcbBom = nullptr
);
/** Tries to guess the line terminators employed in a string.
pchBegin
Pointer to the first character of the string to scan for a line terminator sequence.
pchEnd
Pointer to beyond the last character of the string.
return
Detected line terminator sequence.
*/
ABCAPI line_terminator guess_line_terminator(char_t const * pchBegin, char_t const * pchEnd);
/** Converts from one character encoding to another. All pointed-by variables are updated to discard
the bytes used in the conversion; the number of bytes written is returned.
UTF validity: not necessary; invalid sequences are replaced with text::replacement_char.
encSrc
Encoding of the string pointed to by *ppSrc.
ppSrc
Pointer to a pointer to the source string; the pointed-to pointer will be incremented as
characters are transcoded.
pcbSrc
Pointer to a variable that holds the size of the string pointed to by *ppSrc, and that will be
decremented by the number of source characters transcoded.
encDst
Encoding of the string pointed to by *ppDst.
ppDst
Pointer to a pointer to the destination buffer; the pointed-to pointer will be incremented as
characters are stored in the buffer.
pcbDstMax
Pointer to a variable that holds the size of the buffer pointed to by *ppDst, and that will be
decremented by the number of characters stored in the buffer.
return
Count of bytes that were written to **ppDst.
*/
ABCAPI size_t transcode(
std::nothrow_t const &,
encoding encSrc, void const ** ppSrc, size_t * pcbSrc,
encoding encDst, void ** ppDst, size_t * pcbDstMax
);
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text::error
namespace abc {
namespace text {
/** A text encoding or decoding error occurred.
*/
class ABCAPI error :
public virtual generic_error {
public:
/** Constructor.
*/
error();
/** See abc::generic_error::init().
*/
void init(errint_t err = 0);
};
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text::decode_error
namespace abc {
namespace text {
/** A text decoding error occurred.
*/
class ABCAPI decode_error :
public virtual error {
public:
/** Constructor.
*/
decode_error();
/** See abc::text::error::init().
*/
void init(errint_t err = 0);
};
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text::encode_error
namespace abc {
namespace text {
/** A text encoding error occurred.
*/
class ABCAPI encode_error :
public virtual error {
public:
/** Constructor.
*/
encode_error();
/** See abc::text::error::init().
*/
void init(errint_t err = 0);
};
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
<commit_msg>Realign lists<commit_after>/* -*- coding: utf-8; mode: c++; tab-width: 3; indent-tabs-mode: nil -*-
Copyright 2010, 2011, 2012, 2013, 2014
Raffaello D. Di Napoli
This file is part of Application-Building Components (henceforth referred to as ABC).
ABC is free software: you can redistribute it and/or modify it under the terms of the GNU General
Public License as published by the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
ABC 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 ABC. If not, see
<http://www.gnu.org/licenses/>.
--------------------------------------------------------------------------------------------------*/
#ifndef _ABC_CORE_HXX
#error Please #include <abc/core.hxx> instead of this file
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text globals
namespace abc {
namespace text {
/** Recognized text encodings. Little endians should be listed before big endians; some code relies
on this.
*/
ABC_ENUM(encoding, \
/** Unknown/undetermined encoding. */ \
(unknown, 0), \
/** UTF-8 encoding. */ \
(utf8, 1), \
/** UTF-16 Little Endian encoding. */ \
(utf16le, 2), \
/** UTF-16 Big Endian encoding. */ \
(utf16be, 3), \
/** UTF-32 Little Endian encoding. */ \
(utf32le, 4), \
/** UTF-32 Big Endian encoding. */ \
(utf32be, 5), \
/** ISO-8859-1 encoding. Only supported in detection and handling, but not as internal string
* representation. */ \
(iso_8859_1, 6), \
/** Windows-1252 encoding. Only supported in detection and handling, but not as internal string
* representation. */ \
(windows_1252, 7), \
/** EBCDIC encoding. Only supported in detection and handling, but not as internal string
* representation. */ \
(ebcdic, 8), \
/** UTF-16 encoding (host endianness). */ \
(utf16_host, (ABC_HOST_LITTLE_ENDIAN ? utf16le : utf16be)), \
/** UTF-32 encoding (host endianness). */ \
(utf32_host, (ABC_HOST_LITTLE_ENDIAN ? utf32le : utf32be)), \
/** Default host encoding. */ \
(host, (ABC_HOST_UTF == 8 ? utf8 : (ABC_HOST_UTF == 16 ? utf16_host : utf32_host))) \
);
/** Recognized line terminators.
*/
ABC_ENUM(line_terminator, \
/** Unknown/undetermined line terminator. */ \
(unknown, 0), \
/** Old Mac style: Carriage Return, '\r'. */ \
(cr, 1), \
/** Unix/POSIX style: Line Feed, '\n'. */ \
(lf, 2), \
/** DOS/Windows style: Carriage Return + Line Feed, '\r', '\n'. */ \
(cr_lf, 3), \
/** EBCDIC style: Next Line, '\x15'. */ \
(nel, 4), \
/** Default host line terminator. */ \
(host, (ABC_HOST_API_WIN32 ? cr_lf : lf)) \
);
/** This can be used by any char32_t-returning function that needs to return a value that’s
obviously not a char32_t value. */
char32_t const invalid_char(~char32_t(0));
/** This must be used to replace any invalid char32_t value. */
char32_t const replacement_char(0x00fffd);
/** Maximum run length for the encoding of a code point, in any encoding.
Technically, 6 is an illegal UTF-8 run, but it’s possible due to the way bits are encoded, so it’s
here. */
size_t const max_codepoint_length(6);
/** Provides an estimate of the space, in bytes, necessary to store a string, transcoded in a
different encoding. For example, transcoding from UTF-32 to UTF-16 will yield half the source size,
although special cases such as surrogates might make the estimate too low.
encSrc
Source encoding.
pSrc
Pointer to the source string.
cbSrc
Length of the source string, in bytes.
encDst
Target encoding.
return
Estimated size necessary for the destination string, in bytes.
*/
ABCAPI size_t estimate_transcoded_size(
encoding encSrc, void const * pSrc, size_t cbSrc, encoding encDst
);
/** Returns the character size, in bytes, for the specified charset encoding, or 0 for non-charset
encodings (e.g. identity_encoding).
enc
Desired encoding.
return
Size of a character (not a code point, which can require more than one character) for the
specified encoding, in bytes.
*/
ABCAPI size_t get_encoding_size(encoding enc);
/** Tries to guess the encoding of a sequence of bytes, optionally also taking into account the
total number of bytes in the source of which the buffer is the beginning.
While this function can check for validity of some encodings, it does not guarantee that, for
example, for a return value of utf8_encoding utf8_traits::is_valid() will return true for the same
buffer.
TODO: why not guarantee validity? It would help weed out more encodings with fewer bytes.
pchBegin
Pointer to the beginning of the buffer to scan for encoding clues.
pchEnd
Pointer to beyond the end of the buffer.
cbSrcTotal
Total size, in bytes, of a larger string of which *pBuf is the beginning.
pcbBom
Pointer to a variable that will receive the size of the Byte Order Mark if found at the beginning
of the string, in bytes, or 0 otherwise.
return
Detected encoding of the string pointed to by pBuf.
*/
ABCAPI encoding guess_encoding(
void const * pBufBegin, void const * pBufEnd, size_t cbSrcTotal = 0, size_t * pcbBom = nullptr
);
/** Tries to guess the line terminators employed in a string.
pchBegin
Pointer to the first character of the string to scan for a line terminator sequence.
pchEnd
Pointer to beyond the last character of the string.
return
Detected line terminator sequence.
*/
ABCAPI line_terminator guess_line_terminator(char_t const * pchBegin, char_t const * pchEnd);
/** Converts from one character encoding to another. All pointed-by variables are updated to discard
the bytes used in the conversion; the number of bytes written is returned.
UTF validity: not necessary; invalid sequences are replaced with text::replacement_char.
encSrc
Encoding of the string pointed to by *ppSrc.
ppSrc
Pointer to a pointer to the source string; the pointed-to pointer will be incremented as
characters are transcoded.
pcbSrc
Pointer to a variable that holds the size of the string pointed to by *ppSrc, and that will be
decremented by the number of source characters transcoded.
encDst
Encoding of the string pointed to by *ppDst.
ppDst
Pointer to a pointer to the destination buffer; the pointed-to pointer will be incremented as
characters are stored in the buffer.
pcbDstMax
Pointer to a variable that holds the size of the buffer pointed to by *ppDst, and that will be
decremented by the number of characters stored in the buffer.
return
Count of bytes that were written to **ppDst.
*/
ABCAPI size_t transcode(
std::nothrow_t const &,
encoding encSrc, void const ** ppSrc, size_t * pcbSrc,
encoding encDst, void ** ppDst, size_t * pcbDstMax
);
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text::error
namespace abc {
namespace text {
/** A text encoding or decoding error occurred.
*/
class ABCAPI error :
public virtual generic_error {
public:
/** Constructor.
*/
error();
/** See abc::generic_error::init().
*/
void init(errint_t err = 0);
};
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text::decode_error
namespace abc {
namespace text {
/** A text decoding error occurred.
*/
class ABCAPI decode_error :
public virtual error {
public:
/** Constructor.
*/
decode_error();
/** See abc::text::error::init().
*/
void init(errint_t err = 0);
};
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
// abc::text::encode_error
namespace abc {
namespace text {
/** A text encoding error occurred.
*/
class ABCAPI encode_error :
public virtual error {
public:
/** Constructor.
*/
encode_error();
/** See abc::text::error::init().
*/
void init(errint_t err = 0);
};
} //namespace text
} //namespace abc
////////////////////////////////////////////////////////////////////////////////////////////////////
<|endoftext|> |
<commit_before>/*
Copyright (c) 2006 Till Adam <[email protected]>
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; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
*/
#include "localbookmarksresource.h"
#include <libakonadi/collectionlistjob.h>
#include <libakonadi/collectionmodifyjob.h>
#include <libakonadi/itemappendjob.h>
#include <libakonadi/itemfetchjob.h>
#include <libakonadi/itemstorejob.h>
#include <libakonadi/session.h>
#include <kdebug.h>
#include <kfiledialog.h>
#include <klocale.h>
#include <kbookmarkmanager.h>
#include <kbookmark.h>
#include <QtDBus/QDBusConnection>
using namespace Akonadi;
LocalBookmarksResource::LocalBookmarksResource( const QString &id )
:ResourceBase( id )
{
}
LocalBookmarksResource::~ LocalBookmarksResource()
{
}
bool LocalBookmarksResource::retrieveItem( const Akonadi::Item &item, const QStringList &parts )
{
Q_UNUSED( parts );
// TODO use remote id to retrieve the item in the file
return true;
}
void LocalBookmarksResource::aboutToQuit()
{
// TODO save to the backend
}
void LocalBookmarksResource::configure()
{
QString oldFile = settings()->value( "General/Path" ).toString();
KUrl url;
if ( !oldFile.isEmpty() )
url = KUrl::fromPath( oldFile );
else
url = KUrl::fromPath( QDir::homePath() );
QString newFile = KFileDialog::getOpenFileName( url, "*.xml |" + i18nc("Filedialog filter for *.xml", "XML Bookmark file"), 0, i18n("Select Bookmarks File") );
if ( newFile.isEmpty() )
return;
if ( oldFile == newFile )
return;
settings()->setValue( "General/Path", newFile );
mBookmarkManager = KBookmarkManager::managerForFile( newFile, name() );
synchronize();
}
void LocalBookmarksResource::itemAdded( const Akonadi::Item & item, const Akonadi::Collection& col )
{
if ( item.mimeType() != QLatin1String( "application/x-xbel" ) )
return;
KBookmark bk = item.payload<KBookmark>();
KBookmark bkg = mBookmarkManager->findByAddress( col.remoteId() );
if ( !bkg.isGroup() )
return;
KBookmarkGroup group = bkg.toGroup();
group.addBookmark( bk );
// saves the file
mBookmarkManager->emitChanged( group );
}
void LocalBookmarksResource::itemChanged( const Akonadi::Item& item, const QStringList& )
{
KBookmark bk = item.payload<KBookmark>();
// saves the file
mBookmarkManager->emitChanged( bk.parentGroup() );
}
void LocalBookmarksResource::itemRemoved(const Akonadi::DataReference & ref)
{
KBookmark bk = mBookmarkManager->findByAddress( ref.remoteId() );
KBookmarkGroup bkg = bk.parentGroup();
if ( !bk.isNull() )
return;
bkg.deleteBookmark( bk );
// saves the file
mBookmarkManager->emitChanged( bkg );
}
Collection::List listRecursive( const KBookmarkGroup& parent, const Collection& parentCol )
{
Collection::List list;
const QStringList mimeTypes = QStringList() << "message/rfc822" << Collection::collectionMimeType();
for ( KBookmark it = parent.first(); !it.isNull(); it = parent.next( it ) ) {
if ( !it.isGroup() )
continue;
KBookmarkGroup bkg = it.toGroup();
Collection col;
col.setName( bkg.fullText() + '(' + bkg.address() + ')' ); // has to be unique
col.setRemoteId( bkg.address() );
col.setParent( parentCol );
col.setContentTypes( mimeTypes ); // ###
list << col;
list << listRecursive( bkg, col );
}
return list;
}
void LocalBookmarksResource::retrieveCollections()
{
Collection root;
root.setParent( Collection::root() );
root.setRemoteId( settings()->value( "General/Path" ).toString() );
root.setName( name() );
QStringList mimeTypes;
mimeTypes << "application/x-xbel" << Collection::collectionMimeType(); // ###
root.setContentTypes( mimeTypes );
Collection::List list;
list << root;
list << listRecursive( mBookmarkManager->root(), root );
collectionsRetrieved( list );
}
void LocalBookmarksResource::retrieveItems(const Akonadi::Collection & col, const QStringList &parts)
{
Q_UNUSED( parts );
if ( !col.isValid() )
{
kDebug( 5253 ) << "Collection not valid";
return;
}
changeProgress( 0 );
KBookmarkGroup bkg;
if ( col.remoteId() == settings()->value( "General/Path" ).toString() ) {
bkg = mBookmarkManager->root();
} else {
KBookmark bk = mBookmarkManager->findByAddress( col.remoteId() );
if ( bk.isNull() || !bk.isGroup() )
return;
bkg = bk.toGroup();
}
for ( KBookmark it = bkg.first(); !it.isNull(); it = bkg.next( it ) ) {
if ( it.isGroup() || it.isSeparator() || it.isNull() )
continue;
Item item( DataReference( -1, it.address() ) );
item.setMimeType( "application/x-xbel" );
item.setPayload<KBookmark>( it );
ItemAppendJob *job = new ItemAppendJob( item, col, this );
if ( !job->exec() ) {
kDebug( 5253 ) << "Error while appending bookmark to storage: " << job->errorString();
continue;
}
}
changeProgress( 100 );
itemsRetrieved();
}
#include "localbookmarksresource.moc"
<commit_msg>Make use of the new API.<commit_after>/*
Copyright (c) 2006 Till Adam <[email protected]>
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; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
*/
#include "localbookmarksresource.h"
#include <libakonadi/collectionlistjob.h>
#include <libakonadi/collectionmodifyjob.h>
#include <libakonadi/itemappendjob.h>
#include <libakonadi/itemfetchjob.h>
#include <libakonadi/itemstorejob.h>
#include <libakonadi/session.h>
#include <kdebug.h>
#include <kfiledialog.h>
#include <klocale.h>
#include <kbookmarkmanager.h>
#include <kbookmark.h>
#include <QtDBus/QDBusConnection>
using namespace Akonadi;
LocalBookmarksResource::LocalBookmarksResource( const QString &id )
:ResourceBase( id )
{
}
LocalBookmarksResource::~ LocalBookmarksResource()
{
}
bool LocalBookmarksResource::retrieveItem( const Akonadi::Item &item, const QStringList &parts )
{
Q_UNUSED( parts );
// TODO use remote id to retrieve the item in the file
return true;
}
void LocalBookmarksResource::aboutToQuit()
{
// TODO save to the backend
}
void LocalBookmarksResource::configure()
{
QString oldFile = settings()->value( "General/Path" ).toString();
KUrl url;
if ( !oldFile.isEmpty() )
url = KUrl::fromPath( oldFile );
else
url = KUrl::fromPath( QDir::homePath() );
QString newFile = KFileDialog::getOpenFileName( url, "*.xml |" + i18nc("Filedialog filter for *.xml", "XML Bookmark file"), 0, i18n("Select Bookmarks File") );
if ( newFile.isEmpty() )
return;
if ( oldFile == newFile )
return;
settings()->setValue( "General/Path", newFile );
mBookmarkManager = KBookmarkManager::managerForFile( newFile, name() );
synchronize();
}
void LocalBookmarksResource::itemAdded( const Akonadi::Item & item, const Akonadi::Collection& col )
{
if ( item.mimeType() != QLatin1String( "application/x-xbel" ) )
return;
KBookmark bk = item.payload<KBookmark>();
KBookmark bkg = mBookmarkManager->findByAddress( col.remoteId() );
if ( !bkg.isGroup() )
return;
KBookmarkGroup group = bkg.toGroup();
group.addBookmark( bk );
// saves the file
mBookmarkManager->emitChanged( group );
}
void LocalBookmarksResource::itemChanged( const Akonadi::Item& item, const QStringList& )
{
KBookmark bk = item.payload<KBookmark>();
// saves the file
mBookmarkManager->emitChanged( bk.parentGroup() );
}
void LocalBookmarksResource::itemRemoved(const Akonadi::DataReference & ref)
{
KBookmark bk = mBookmarkManager->findByAddress( ref.remoteId() );
KBookmarkGroup bkg = bk.parentGroup();
if ( !bk.isNull() )
return;
bkg.deleteBookmark( bk );
// saves the file
mBookmarkManager->emitChanged( bkg );
}
Collection::List listRecursive( const KBookmarkGroup& parent, const Collection& parentCol )
{
Collection::List list;
const QStringList mimeTypes = QStringList() << "message/rfc822" << Collection::collectionMimeType();
for ( KBookmark it = parent.first(); !it.isNull(); it = parent.next( it ) ) {
if ( !it.isGroup() )
continue;
KBookmarkGroup bkg = it.toGroup();
Collection col;
col.setName( bkg.fullText() + '(' + bkg.address() + ')' ); // has to be unique
col.setRemoteId( bkg.address() );
col.setParent( parentCol );
col.setContentTypes( mimeTypes ); // ###
list << col;
list << listRecursive( bkg, col );
}
return list;
}
void LocalBookmarksResource::retrieveCollections()
{
Collection root;
root.setParent( Collection::root() );
root.setRemoteId( settings()->value( "General/Path" ).toString() );
root.setName( name() );
QStringList mimeTypes;
mimeTypes << "application/x-xbel" << Collection::collectionMimeType(); // ###
root.setContentTypes( mimeTypes );
Collection::List list;
list << root;
list << listRecursive( mBookmarkManager->root(), root );
collectionsRetrieved( list );
}
void LocalBookmarksResource::retrieveItems(const Akonadi::Collection & col, const QStringList &parts)
{
Q_UNUSED( parts );
if ( !col.isValid() )
{
kDebug( 5253 ) << "Collection not valid";
return;
}
KBookmarkGroup bkg;
if ( col.remoteId() == settings()->value( "General/Path" ).toString() ) {
bkg = mBookmarkManager->root();
} else {
KBookmark bk = mBookmarkManager->findByAddress( col.remoteId() );
if ( bk.isNull() || !bk.isGroup() )
return;
bkg = bk.toGroup();
}
Item::List itemList;
for ( KBookmark it = bkg.first(); !it.isNull(); it = bkg.next( it ) ) {
if ( it.isGroup() || it.isSeparator() || it.isNull() )
continue;
Item item( DataReference( -1, it.address() ) );
item.setMimeType( "application/x-xbel" );
item.setPayload<KBookmark>( it );
itemList.append( item );
}
itemsRetrieved( itemList );
}
#include "localbookmarksresource.moc"
<|endoftext|> |
<commit_before>/*
* fsm.hpp
*
* Created on: 25 мая 2016 г.
* Author: sergey.fedorov
*/
#ifndef AFSM_FSM_HPP_
#define AFSM_FSM_HPP_
#include <afsm/detail/base_states.hpp>
#include <afsm/detail/observer.hpp>
#include <deque>
namespace afsm {
//----------------------------------------------------------------------------
// State
//----------------------------------------------------------------------------
template < typename T, typename FSM >
class state : public detail::state_base< T > {
public:
using enclosing_fsm_type = FSM;
public:
state(enclosing_fsm_type& fsm)
: state::state_type{}, fsm_{&fsm}
{}
state(state const& rhs) = default;
state(state&& rhs) = default;
state(enclosing_fsm_type& fsm, state const& rhs)
: state::state_type{static_cast<typename state::state_type const&>(rhs)}, fsm_{&fsm}
{}
state(enclosing_fsm_type& fsm, state&& rhs)
: state::state_type{static_cast<typename state::state_type&&>(rhs)}, fsm_{&fsm}
{}
state&
operator = (state const& rhs)
{
state{rhs}.swap(*this);
return *this;
}
state&
operator = (state&& rhs)
{
swap(rhs);
return *this;
}
void
swap(state& rhs) noexcept
{
static_cast<typename state::state_type&>(*this).swap(rhs);
}
template < typename Event >
actions::event_process_result
process_event( Event&& evt )
{
return process_event_impl(::std::forward<Event>(evt),
detail::event_process_selector<
Event,
typename state::internal_events,
typename state::deferred_events>{} );
}
enclosing_fsm_type&
enclosing_fsm()
{ return *fsm_; }
enclosing_fsm_type const&
enclosing_fsm() const
{ return *fsm_; }
void
enclosing_fsm(enclosing_fsm_type& fsm)
{ fsm_ = &fsm; }
template < typename Event >
void
state_enter(Event&&) {}
template < typename Event >
void
state_exit(Event&&) {}
private:
template < typename Event >
actions::event_process_result
process_event_impl(Event&& evt,
detail::process_type<actions::event_process_result::process> const&)
{
return actions::handle_in_state_event(::std::forward<Event>(evt), *fsm_, *this);
}
template < typename Event >
constexpr actions::event_process_result
process_event_impl(Event&&,
detail::process_type<actions::event_process_result::defer> const&) const
{
return actions::event_process_result::defer;
}
template < typename Event >
constexpr actions::event_process_result
process_event_impl(Event&&,
detail::process_type<actions::event_process_result::refuse> const&) const
{
return actions::event_process_result::refuse;
}
private:
enclosing_fsm_type* fsm_;
};
//----------------------------------------------------------------------------
// Inner state machine
//----------------------------------------------------------------------------
template < typename T, typename FSM >
class inner_state_machine : public detail::state_machine_base< T, none, inner_state_machine<T, FSM> > {
public:
using enclosing_fsm_type = FSM;
using this_type = inner_state_machine<T, FSM>;
using base_machine_type = detail::state_machine_base< T, none, this_type >;
public:
inner_state_machine(enclosing_fsm_type& fsm)
: base_machine_type{this}, fsm_{&fsm} {}
inner_state_machine(inner_state_machine const& rhs)
: base_machine_type{this, rhs}, fsm_{rhs.fsm_} {}
inner_state_machine(inner_state_machine&& rhs)
: base_machine_type{this, ::std::move(rhs)},
fsm_{rhs.fsm_}
{
}
inner_state_machine(enclosing_fsm_type& fsm, inner_state_machine const& rhs)
: base_machine_type{static_cast<base_machine_type const&>(rhs)}, fsm_{&fsm} {}
inner_state_machine(enclosing_fsm_type& fsm, inner_state_machine&& rhs)
: base_machine_type{static_cast<base_machine_type&&>(rhs)}, fsm_{&fsm} {}
void
swap(inner_state_machine& rhs) noexcept
{
using ::std::swap;
static_cast<base_machine_type&>(*this).swap(rhs);
swap(fsm_, rhs.fsm_);
}
inner_state_machine&
operator = (inner_state_machine const& rhs)
{
inner_state_machine tmp{rhs};
swap(tmp);
return *this;
}
inner_state_machine&
operator = (inner_state_machine&& rhs)
{
swap(rhs);
return *this;
}
template < typename Event >
actions::event_process_result
process_event( Event&& event )
{
return process_event_impl(*fsm_, ::std::forward<Event>(event),
detail::event_process_selector<
Event,
typename inner_state_machine::handled_events,
typename inner_state_machine::deferred_events>{} );
}
enclosing_fsm_type&
enclosing_fsm()
{ return *fsm_; }
enclosing_fsm_type const&
enclosing_fsm() const
{ return *fsm_; }
void
enclosing_fsm(enclosing_fsm_type& fsm)
{ fsm_ = &fsm; }
private:
using base_machine_type::process_event_impl;
private:
enclosing_fsm_type* fsm_;
};
//----------------------------------------------------------------------------
// State machine
//----------------------------------------------------------------------------
template < typename T, typename Mutex, typename Observer,
template<typename> class ObserverWrapper >
class state_machine :
public detail::state_machine_base< T, Mutex,
state_machine<T, Mutex, Observer> >,
public ObserverWrapper<Observer> {
public:
static_assert( ::psst::meta::is_empty< typename T::deferred_events >::value,
"Outer state machine cannot defer events" );
using this_type = state_machine<T, Mutex, Observer>;
using base_machine_type = detail::state_machine_base< T, Mutex, this_type >;
using mutex_type = Mutex;
using lock_guard = typename detail::lock_guard_type<mutex_type>::type;
using observer_wrapper = ObserverWrapper<Observer>;
using event_invokation = ::std::function< actions::event_process_result() >;
using event_queue = ::std::deque< event_invokation >;
public:
state_machine()
: base_machine_type{this},
is_top_{},
mutex_{},
queued_events_{},
queue_size_{0},
deferred_mutex_{},
deferred_events_{}
{}
template<typename ... Args>
explicit
state_machine(Args&& ... args)
: base_machine_type(this, ::std::forward<Args>(args)...),
is_top_{},
mutex_{},
queued_events_{},
queue_size_{0},
deferred_mutex_{},
deferred_events_{}
{}
template < typename Event >
actions::event_process_result
process_event( Event&& event )
{
if (!is_top_.test_and_set()) {
auto res = process_event_dispatch(::std::forward<Event>(event));
is_top_.clear();
// Process enqueued events
process_event_queue();
return res;
} else {
// Enqueue event
enqueue_event(::std::forward<Event>(event));
return actions::event_process_result::defer;
}
}
private:
template < typename Event >
actions::event_process_result
process_event_dispatch( Event&& event )
{
return process_event_impl(::std::forward<Event>(event),
detail::event_process_selector<
Event,
typename state_machine::handled_events>{} );
}
template < typename Event >
actions::event_process_result
process_event_impl(Event&& event,
detail::process_type<actions::event_process_result::process> const& sel)
{
using actions::event_process_result;
observer_wrapper::start_process_event(*this, ::std::forward<Event>(event));
auto res = base_machine_type::process_event_impl(*this, ::std::forward<Event>(event), sel );
switch (res) {
case event_process_result::process:
observer_wrapper::state_changed(*this);
// Changed state. Process deferred events
process_deferred_queue();
break;
case event_process_result::process_in_state:
observer_wrapper::processed_in_state(*this, ::std::forward<Event>(event));
break;
case event_process_result::defer:
// Add event to deferred queue
defer_event(::std::forward<Event>(event));
break;
case event_process_result::refuse:
// The event cannot be processed in current state
observer_wrapper::reject_event(*this, ::std::forward<Event>(event));
break;
default:
break;
}
return res;
}
template < typename Event >
actions::event_process_result
process_event_impl(Event&&,
detail::process_type<actions::event_process_result::refuse> const&)
{
static_assert( detail::event_process_selector<
Event,
typename state_machine::handled_events,
typename state_machine::deferred_events>::value
!= actions::event_process_result::refuse,
"Event type is not handled by this state machine" );
return actions::event_process_result::refuse;
}
template < typename Event >
void
enqueue_event(Event&& event)
{
{
lock_guard lock{mutex_};
++queue_size_;
observer_wrapper::enqueue_event(*this, ::std::forward<Event>(event));
Event evt = event;
queued_events_.emplace_back([&, evt]() mutable {
return process_event_dispatch(::std::move(evt));
});
}
// Process enqueued events in case we've been waiting for queue
// mutex release
process_event_queue();
}
void
lock_and_swap_queue(event_queue& queue)
{
lock_guard lock{mutex_};
::std::swap(queued_events_, queue);
queue_size_ -= queue.size();
}
void
process_event_queue()
{
while (queue_size_ > 0 && !is_top_.test_and_set()) {
observer_wrapper::start_process_events_queue(*this);
while (queue_size_ > 0) {
event_queue postponed;
lock_and_swap_queue(postponed);
for (auto const& event : postponed) {
event();
}
}
observer_wrapper::end_process_events_queue(*this);
is_top_.clear();
}
}
template < typename Event >
void
defer_event(Event&& event)
{
lock_guard lock{deferred_mutex_};
observer_wrapper::defer_event(*this, ::std::forward<Event>(event));
Event evt = event;
deferred_events_.emplace_back([&, evt]() mutable {
return process_event_dispatch(::std::move(evt));
});
}
void
process_deferred_queue()
{
using actions::event_process_result;
event_queue deferred;
{
lock_guard lock{deferred_mutex_};
::std::swap(deferred_events_, deferred);
}
while (!deferred.empty()) {
observer_wrapper::start_process_deferred_queue(*this);
auto res = event_process_result::refuse;
while (!deferred.empty()) {
auto event = deferred.front();
deferred.pop_front();
res = event();
if (res == event_process_result::process)
break;
}
{
lock_guard lock{deferred_mutex_};
deferred_events_.insert(deferred_events_.end(), deferred.begin(), deferred.end());
deferred.clear();
}
if (res == event_process_result::process) {
::std::swap(deferred_events_, deferred);
}
observer_wrapper::end_process_deferred_queue(*this);
}
}
private:
using atomic_counter = ::std::atomic< ::std::size_t >;
::std::atomic_flag is_top_;
mutex_type mutex_;
event_queue queued_events_;
atomic_counter queue_size_;
mutex_type deferred_mutex_;
event_queue deferred_events_;
};
} /* namespace afsm */
#endif /* AFSM_FSM_HPP_ */
<commit_msg>Squashed 'lib/afsm/' changes from 2f27cb3..b6e629b<commit_after>/*
* fsm.hpp
*
* Created on: 25 мая 2016 г.
* Author: sergey.fedorov
*/
#ifndef AFSM_FSM_HPP_
#define AFSM_FSM_HPP_
#include <afsm/detail/base_states.hpp>
#include <afsm/detail/observer.hpp>
#include <deque>
namespace afsm {
//----------------------------------------------------------------------------
// State
//----------------------------------------------------------------------------
template < typename T, typename FSM >
class state : public detail::state_base< T > {
public:
using enclosing_fsm_type = FSM;
public:
state(enclosing_fsm_type& fsm)
: state::state_type{}, fsm_{&fsm}
{}
state(state const& rhs) = default;
state(state&& rhs) = default;
state(enclosing_fsm_type& fsm, state const& rhs)
: state::state_type{static_cast<typename state::state_type const&>(rhs)}, fsm_{&fsm}
{}
state(enclosing_fsm_type& fsm, state&& rhs)
: state::state_type{static_cast<typename state::state_type&&>(rhs)}, fsm_{&fsm}
{}
state&
operator = (state const& rhs)
{
state{rhs}.swap(*this);
return *this;
}
state&
operator = (state&& rhs)
{
swap(rhs);
return *this;
}
void
swap(state& rhs) noexcept
{
static_cast<typename state::state_type&>(*this).swap(rhs);
}
template < typename Event >
actions::event_process_result
process_event( Event&& evt )
{
return process_event_impl(::std::forward<Event>(evt),
detail::event_process_selector<
Event,
typename state::internal_events,
typename state::deferred_events>{} );
}
enclosing_fsm_type&
enclosing_fsm()
{ return *fsm_; }
enclosing_fsm_type const&
enclosing_fsm() const
{ return *fsm_; }
void
enclosing_fsm(enclosing_fsm_type& fsm)
{ fsm_ = &fsm; }
template < typename Event >
void
state_enter(Event&&) {}
template < typename Event >
void
state_exit(Event&&) {}
private:
template < typename Event >
actions::event_process_result
process_event_impl(Event&& evt,
detail::process_type<actions::event_process_result::process> const&)
{
return actions::handle_in_state_event(::std::forward<Event>(evt), *fsm_, *this);
}
template < typename Event >
constexpr actions::event_process_result
process_event_impl(Event&&,
detail::process_type<actions::event_process_result::defer> const&) const
{
return actions::event_process_result::defer;
}
template < typename Event >
constexpr actions::event_process_result
process_event_impl(Event&&,
detail::process_type<actions::event_process_result::refuse> const&) const
{
return actions::event_process_result::refuse;
}
private:
enclosing_fsm_type* fsm_;
};
//----------------------------------------------------------------------------
// Inner state machine
//----------------------------------------------------------------------------
template < typename T, typename FSM >
class inner_state_machine : public detail::state_machine_base< T, none, inner_state_machine<T, FSM> > {
public:
using enclosing_fsm_type = FSM;
using this_type = inner_state_machine<T, FSM>;
using base_machine_type = detail::state_machine_base< T, none, this_type >;
public:
inner_state_machine(enclosing_fsm_type& fsm)
: base_machine_type{this}, fsm_{&fsm} {}
inner_state_machine(inner_state_machine const& rhs)
: base_machine_type{this, rhs}, fsm_{rhs.fsm_} {}
inner_state_machine(inner_state_machine&& rhs)
: base_machine_type{this, ::std::move(rhs)},
fsm_{rhs.fsm_}
{
}
inner_state_machine(enclosing_fsm_type& fsm, inner_state_machine const& rhs)
: base_machine_type{static_cast<base_machine_type const&>(rhs)}, fsm_{&fsm} {}
inner_state_machine(enclosing_fsm_type& fsm, inner_state_machine&& rhs)
: base_machine_type{static_cast<base_machine_type&&>(rhs)}, fsm_{&fsm} {}
void
swap(inner_state_machine& rhs) noexcept
{
using ::std::swap;
static_cast<base_machine_type&>(*this).swap(rhs);
swap(fsm_, rhs.fsm_);
}
inner_state_machine&
operator = (inner_state_machine const& rhs)
{
inner_state_machine tmp{rhs};
swap(tmp);
return *this;
}
inner_state_machine&
operator = (inner_state_machine&& rhs)
{
swap(rhs);
return *this;
}
template < typename Event >
actions::event_process_result
process_event( Event&& event )
{
return process_event_impl(*fsm_, ::std::forward<Event>(event),
detail::event_process_selector<
Event,
typename inner_state_machine::handled_events,
typename inner_state_machine::deferred_events>{} );
}
enclosing_fsm_type&
enclosing_fsm()
{ return *fsm_; }
enclosing_fsm_type const&
enclosing_fsm() const
{ return *fsm_; }
void
enclosing_fsm(enclosing_fsm_type& fsm)
{ fsm_ = &fsm; }
private:
using base_machine_type::process_event_impl;
private:
enclosing_fsm_type* fsm_;
};
//----------------------------------------------------------------------------
// State machine
//----------------------------------------------------------------------------
template < typename T, typename Mutex, typename Observer,
template<typename> class ObserverWrapper >
class state_machine :
public detail::state_machine_base< T, Mutex,
state_machine<T, Mutex, Observer> >,
public ObserverWrapper<Observer> {
public:
static_assert( ::psst::meta::is_empty< typename T::deferred_events >::value,
"Outer state machine cannot defer events" );
using this_type = state_machine<T, Mutex, Observer>;
using base_machine_type = detail::state_machine_base< T, Mutex, this_type >;
using mutex_type = Mutex;
using lock_guard = typename detail::lock_guard_type<mutex_type>::type;
using observer_wrapper = ObserverWrapper<Observer>;
using event_invokation = ::std::function< actions::event_process_result() >;
using event_queue = ::std::deque< event_invokation >;
public:
state_machine()
: base_machine_type{this},
is_top_{},
mutex_{},
queued_events_{},
queue_size_{0},
deferred_mutex_{},
deferred_events_{}
{}
template<typename ... Args>
explicit
state_machine(Args&& ... args)
: base_machine_type(this, ::std::forward<Args>(args)...),
is_top_{},
mutex_{},
queued_events_{},
queue_size_{0},
deferred_mutex_{},
deferred_events_{}
{}
template < typename Event >
actions::event_process_result
process_event( Event&& event )
{
if (!queue_size_ && !is_top_.test_and_set()) {
auto res = process_event_dispatch(::std::forward<Event>(event));
is_top_.clear();
// Process enqueued events
process_event_queue();
return res;
} else {
// Enqueue event
enqueue_event(::std::forward<Event>(event));
return actions::event_process_result::defer;
}
}
private:
template < typename Event >
actions::event_process_result
process_event_dispatch( Event&& event )
{
return process_event_impl(::std::forward<Event>(event),
detail::event_process_selector<
Event,
typename state_machine::handled_events>{} );
}
template < typename Event >
actions::event_process_result
process_event_impl(Event&& event,
detail::process_type<actions::event_process_result::process> const& sel)
{
using actions::event_process_result;
observer_wrapper::start_process_event(*this, ::std::forward<Event>(event));
auto res = base_machine_type::process_event_impl(*this, ::std::forward<Event>(event), sel );
switch (res) {
case event_process_result::process:
observer_wrapper::state_changed(*this);
// Changed state. Process deferred events
process_deferred_queue();
break;
case event_process_result::process_in_state:
observer_wrapper::processed_in_state(*this, ::std::forward<Event>(event));
break;
case event_process_result::defer:
// Add event to deferred queue
defer_event(::std::forward<Event>(event));
break;
case event_process_result::refuse:
// The event cannot be processed in current state
observer_wrapper::reject_event(*this, ::std::forward<Event>(event));
break;
default:
break;
}
return res;
}
template < typename Event >
actions::event_process_result
process_event_impl(Event&&,
detail::process_type<actions::event_process_result::refuse> const&)
{
static_assert( detail::event_process_selector<
Event,
typename state_machine::handled_events,
typename state_machine::deferred_events>::value
!= actions::event_process_result::refuse,
"Event type is not handled by this state machine" );
return actions::event_process_result::refuse;
}
template < typename Event >
void
enqueue_event(Event&& event)
{
{
lock_guard lock{mutex_};
++queue_size_;
observer_wrapper::enqueue_event(*this, ::std::forward<Event>(event));
Event evt = event;
queued_events_.emplace_back([&, evt]() mutable {
return process_event_dispatch(::std::move(evt));
});
}
// Process enqueued events in case we've been waiting for queue
// mutex release
process_event_queue();
}
void
lock_and_swap_queue(event_queue& queue)
{
lock_guard lock{mutex_};
::std::swap(queued_events_, queue);
queue_size_ -= queue.size();
}
void
process_event_queue()
{
while (queue_size_ > 0 && !is_top_.test_and_set()) {
observer_wrapper::start_process_events_queue(*this);
while (queue_size_ > 0) {
event_queue postponed;
lock_and_swap_queue(postponed);
for (auto const& event : postponed) {
event();
}
}
observer_wrapper::end_process_events_queue(*this);
is_top_.clear();
}
}
template < typename Event >
void
defer_event(Event&& event)
{
lock_guard lock{deferred_mutex_};
observer_wrapper::defer_event(*this, ::std::forward<Event>(event));
Event evt = event;
deferred_events_.emplace_back([&, evt]() mutable {
return process_event_dispatch(::std::move(evt));
});
}
void
process_deferred_queue()
{
using actions::event_process_result;
event_queue deferred;
{
lock_guard lock{deferred_mutex_};
::std::swap(deferred_events_, deferred);
}
while (!deferred.empty()) {
observer_wrapper::start_process_deferred_queue(*this);
auto res = event_process_result::refuse;
while (!deferred.empty()) {
auto event = deferred.front();
deferred.pop_front();
res = event();
if (res == event_process_result::process)
break;
}
{
lock_guard lock{deferred_mutex_};
deferred_events_.insert(deferred_events_.end(), deferred.begin(), deferred.end());
deferred.clear();
}
if (res == event_process_result::process) {
::std::swap(deferred_events_, deferred);
}
observer_wrapper::end_process_deferred_queue(*this);
}
}
private:
using atomic_counter = ::std::atomic< ::std::size_t >;
::std::atomic_flag is_top_;
mutex_type mutex_;
event_queue queued_events_;
atomic_counter queue_size_;
mutex_type deferred_mutex_;
event_queue deferred_events_;
};
} /* namespace afsm */
#endif /* AFSM_FSM_HPP_ */
<|endoftext|> |
<commit_before>#ifndef EXPR_HXX_SPN8H6I7
#define EXPR_HXX_SPN8H6I7
#include "pos.hxx"
#include "dup.hxx"
#include "ppr.hxx"
#include "id.hxx"
#include "ptr.hxx"
#include "ast/type.hxx"
#include "visitor.hxx"
#include <unordered_set>
namespace miniml
{
/// Type of expression.
enum class ExprType
{
ID, ///< Identifier
APP, ///< Application
LAM, ///< Lambda term
INT, ///< Integer literal
BOOL, ///< Boolean literal
TYPE, ///< Typed expression
BINOP, ///< Binary operator expression
};
/// Abstract base class for expressions.
class Expr: public Pretty, public HasPos, public Dup<Expr>
{
public:
virtual ~Expr() {}
/// Get the (syntactic) type of the expression.
/// \see ExprType
virtual ExprType type() const = 0;
// Substitutes \a expr for all occurrences of \a var in \a this.
Ptr<Expr> subst(Id var, const Ptr<Expr> expr);
protected:
inline Expr(Pos start = Pos(), Pos end = Pos()): HasPos(start, end) {}
};
/// Identifier expression.
class IdExpr final: public Expr
{
public:
IdExpr(const IdExpr&) = default;
IdExpr(IdExpr&&) = default;
/// \param[in] id The identifier this expression represents.
IdExpr(const Id id, Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_id(id)
{}
/// \return ExprType::ID
inline ExprType type() const override { return ExprType::ID; }
/// \param prec Ignored, since variables are always atomic.
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The identifier value.
inline Id id() const { return m_id; }
inline Ptr<Expr> dup() const override
{ return ptr<IdExpr>(id(), start(), end()); }
private:
Id m_id; ///< Identifier value.
};
/// Integer literals.
class IntExpr final: public Expr
{
public:
IntExpr(const IntExpr&) = default;
IntExpr(IntExpr&&) = default;
/// \param[in] val The value of this literal.
IntExpr(long val, Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_val(val)
{}
/// \return ExprType::INT
inline ExprType type() const override { return ExprType::INT; }
/// \param prec Ignored, since literals are always atomic.
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The value of this literal.
inline long val() const { return m_val; }
inline Ptr<Expr> dup() const override
{ return ptr<IntExpr>(val(), start(), end()); }
private:
long m_val;
};
/// Boolean literals.
class BoolExpr final: public Expr
{
public:
BoolExpr(const BoolExpr&) = default;
BoolExpr(BoolExpr&&) = default;
/// \param[in] val The value of this literal.
BoolExpr(bool val, Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_val(val)
{}
/// \return ExprType::INT
inline ExprType type() const override { return ExprType::BOOL; }
/// \param prec Ignored, since literals are always atomic.
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The value of this literal.
inline bool val() const { return m_val; }
inline Ptr<Expr> dup() const override
{ return ptr<BoolExpr>(val(), start(), end()); }
private:
bool m_val;
};
/// Application expression.
class AppExpr final: public Expr
{
public:
AppExpr(const AppExpr&) = default;
AppExpr(AppExpr&&) = default;
AppExpr(const Ptr<Expr> left, const Ptr<Expr> right,
Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_left(left), m_right(right)
{}
/// \return ExprType::APP
inline ExprType type() const override { return ExprType::APP; }
virtual Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The left part (operator).
inline Ptr<Expr> left() const { return m_left; }
/// \return The right part (operand).
inline Ptr<Expr> right() const { return m_right; }
inline Ptr<Expr> dup() const override
{ return ptr<AppExpr>(left()->dup(), right()->dup(), start(), end()); }
private:
Ptr<Expr> m_left; ///< Operator.
Ptr<Expr> m_right; ///< Operand.
};
/// Lambda term (function) expression.
class LamExpr final: public Expr
{
public:
LamExpr(const LamExpr&) = default;
LamExpr(LamExpr&&) = default;
LamExpr(const Id var, const Ptr<Type> ty, const Ptr<Expr> body,
Pos start = Pos(), Pos end = Pos(),
const Ptr<Env<Expr>> env = nullptr):
Expr(start, end), m_var(var), m_ty(ty), m_body(body), m_env(env)
{}
/// \return ExprType::LAM
inline ExprType type() const override { return ExprType::LAM; }
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The bound variable.
inline Id var() const { return m_var; }
/// \return The argument type.
inline Ptr<Type> ty() const { return m_ty; }
/// \return The body of the term.
inline Ptr<Expr> body() const { return m_body; }
Ptr<Expr> apply(const Ptr<Expr>) const;
inline Ptr<Env<Expr>> env() { return m_env; }
inline void set_env(Ptr<Env<Expr>> env) { m_env = env; }
inline Ptr<Expr> dup() const override
{ return ptr<LamExpr>(var(), ty(), body()->dup(), start(), end()); }
private:
Id m_var; ///< Bound variable.
Ptr<Type> m_ty; ///< Argument type.
Ptr<Expr> m_body; ///< Body.
/// Captured environment, or null if we're not evaluating yet.
Ptr<Env<Expr>> m_env;
};
/// Expressions with type annotations.
class TypeExpr final: public Expr
{
public:
TypeExpr(const TypeExpr&) = default;
TypeExpr(TypeExpr&&) = default;
TypeExpr(const Ptr<Expr> expr, const Ptr<Type> ty,
Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_expr(expr), m_ty(ty)
{}
/// \return ExprType::TYPE
inline ExprType type() const override { return ExprType::TYPE; }
virtual Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The inner expression.
inline Ptr<Expr> expr() const { return m_expr; }
/// \return The assigned type.
inline Ptr<Type> ty() const { return m_ty; }
inline Ptr<Expr> dup() const override
{ return ptr<TypeExpr>(expr()->dup(), ty(), start(), end()); }
private:
Ptr<Expr> m_expr; ///< Expression.
Ptr<Type> m_ty; ///< Assigned type.
};
/// Operators. \see OpExpr
enum class BinOp
{
PLUS, MINUS, TIMES, DIVIDE,
LESS, LEQ, EQUAL, GEQ, GREATER, NEQ,
AND, OR, IFF,
};
enum class OpAssoc { LEFT, NONE, RIGHT };
inline unsigned prec(BinOp op)
{
switch (op) {
case BinOp::TIMES:
case BinOp::DIVIDE:
return 7;
case BinOp::PLUS:
case BinOp::MINUS:
return 6;
case BinOp::LESS:
case BinOp::LEQ:
case BinOp::EQUAL:
case BinOp::GEQ:
case BinOp::GREATER:
case BinOp::NEQ:
return 3;
case BinOp::AND:
return 2;
case BinOp::OR:
return 1;
case BinOp::IFF:
return 0;
}
}
inline Ptr<Ppr> name(BinOp op)
{
switch (op) {
case BinOp::PLUS: return '+'_p;
case BinOp::MINUS: return '-'_p;
case BinOp::TIMES: return '*'_p;
case BinOp::DIVIDE: return '/'_p;
case BinOp::LESS: return '<'_p;
case BinOp::LEQ: return "<="_p;
case BinOp::EQUAL: return "=="_p;
case BinOp::GEQ: return ">="_p;
case BinOp::GREATER: return '>'_p;
case BinOp::NEQ: return "!="_p;
case BinOp::AND: return "&&"_p;
case BinOp::OR: return "||"_p;
case BinOp::IFF: return "<->"_p;
}
}
inline OpAssoc assoc(BinOp op)
{
switch (op) {
case BinOp::PLUS:
case BinOp::MINUS:
case BinOp::TIMES:
case BinOp::DIVIDE:
return OpAssoc::LEFT;
case BinOp::AND:
case BinOp::OR:
case BinOp::IFF:
return OpAssoc::RIGHT;
default:
return OpAssoc::NONE;
}
}
/// Binary operator expressions. \see OpType
class BinOpExpr final: public Expr
{
public:
BinOpExpr(const BinOpExpr&) = default;
BinOpExpr(BinOpExpr&&) = default;
BinOpExpr(BinOp op, Ptr<Expr> left, Ptr<Expr> right,
Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_op(op), m_left(left), m_right(right)
{}
inline ExprType type() const override { return ExprType::BINOP; }
virtual Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
inline Ptr<Expr> dup() const override
{ return ptr<BinOpExpr>(op(), left(), right()); }
inline BinOp op() const { return m_op; }
inline Ptr<Expr> left() const { return m_left; }
inline Ptr<Expr> right() const { return m_right; }
private:
BinOp m_op;
Ptr<Expr> m_left, m_right;
};
template <typename T, typename... Args>
struct ExprVisitor
{
inline Ptr<T> operator()(Ptr<Expr> e, Args... args)
{ return v(e, args...); }
virtual Ptr<T> v(Ptr<Expr> e, Args... args)
{
switch (e->type()) {
#define CASE(x,t) \
case ExprType::x: \
return v(std::dynamic_pointer_cast<t>(e), args...);
CASE(ID, IdExpr)
CASE(APP, AppExpr)
CASE(LAM, LamExpr)
CASE(INT, IntExpr)
CASE(BOOL, BoolExpr)
CASE(TYPE, TypeExpr)
CASE(BINOP, BinOpExpr)
#undef CASE
}
}
virtual Ptr<T> v(Ptr<IdExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<AppExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<IntExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<BoolExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<LamExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<TypeExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<BinOpExpr>, Args...) = 0;
};
Ptr<std::unordered_set<Id>> fv(const Ptr<Expr> expr);
}
#endif /* end of include guard: EXPR_HXX_SPN8H6I7 */
<commit_msg>Stray useless ‘virtual’<commit_after>#ifndef EXPR_HXX_SPN8H6I7
#define EXPR_HXX_SPN8H6I7
#include "pos.hxx"
#include "dup.hxx"
#include "ppr.hxx"
#include "id.hxx"
#include "ptr.hxx"
#include "ast/type.hxx"
#include "visitor.hxx"
#include <unordered_set>
namespace miniml
{
/// Type of expression.
enum class ExprType
{
ID, ///< Identifier
APP, ///< Application
LAM, ///< Lambda term
INT, ///< Integer literal
BOOL, ///< Boolean literal
TYPE, ///< Typed expression
BINOP, ///< Binary operator expression
};
/// Abstract base class for expressions.
class Expr: public Pretty, public HasPos, public Dup<Expr>
{
public:
virtual ~Expr() {}
/// Get the (syntactic) type of the expression.
/// \see ExprType
virtual ExprType type() const = 0;
// Substitutes \a expr for all occurrences of \a var in \a this.
Ptr<Expr> subst(Id var, const Ptr<Expr> expr);
protected:
inline Expr(Pos start = Pos(), Pos end = Pos()): HasPos(start, end) {}
};
/// Identifier expression.
class IdExpr final: public Expr
{
public:
IdExpr(const IdExpr&) = default;
IdExpr(IdExpr&&) = default;
/// \param[in] id The identifier this expression represents.
IdExpr(const Id id, Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_id(id)
{}
/// \return ExprType::ID
inline ExprType type() const override { return ExprType::ID; }
/// \param prec Ignored, since variables are always atomic.
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The identifier value.
inline Id id() const { return m_id; }
inline Ptr<Expr> dup() const override
{ return ptr<IdExpr>(id(), start(), end()); }
private:
Id m_id; ///< Identifier value.
};
/// Integer literals.
class IntExpr final: public Expr
{
public:
IntExpr(const IntExpr&) = default;
IntExpr(IntExpr&&) = default;
/// \param[in] val The value of this literal.
IntExpr(long val, Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_val(val)
{}
/// \return ExprType::INT
inline ExprType type() const override { return ExprType::INT; }
/// \param prec Ignored, since literals are always atomic.
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The value of this literal.
inline long val() const { return m_val; }
inline Ptr<Expr> dup() const override
{ return ptr<IntExpr>(val(), start(), end()); }
private:
long m_val;
};
/// Boolean literals.
class BoolExpr final: public Expr
{
public:
BoolExpr(const BoolExpr&) = default;
BoolExpr(BoolExpr&&) = default;
/// \param[in] val The value of this literal.
BoolExpr(bool val, Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_val(val)
{}
/// \return ExprType::INT
inline ExprType type() const override { return ExprType::BOOL; }
/// \param prec Ignored, since literals are always atomic.
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The value of this literal.
inline bool val() const { return m_val; }
inline Ptr<Expr> dup() const override
{ return ptr<BoolExpr>(val(), start(), end()); }
private:
bool m_val;
};
/// Application expression.
class AppExpr final: public Expr
{
public:
AppExpr(const AppExpr&) = default;
AppExpr(AppExpr&&) = default;
AppExpr(const Ptr<Expr> left, const Ptr<Expr> right,
Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_left(left), m_right(right)
{}
/// \return ExprType::APP
inline ExprType type() const override { return ExprType::APP; }
virtual Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The left part (operator).
inline Ptr<Expr> left() const { return m_left; }
/// \return The right part (operand).
inline Ptr<Expr> right() const { return m_right; }
inline Ptr<Expr> dup() const override
{ return ptr<AppExpr>(left()->dup(), right()->dup(), start(), end()); }
private:
Ptr<Expr> m_left; ///< Operator.
Ptr<Expr> m_right; ///< Operand.
};
/// Lambda term (function) expression.
class LamExpr final: public Expr
{
public:
LamExpr(const LamExpr&) = default;
LamExpr(LamExpr&&) = default;
LamExpr(const Id var, const Ptr<Type> ty, const Ptr<Expr> body,
Pos start = Pos(), Pos end = Pos(),
const Ptr<Env<Expr>> env = nullptr):
Expr(start, end), m_var(var), m_ty(ty), m_body(body), m_env(env)
{}
/// \return ExprType::LAM
inline ExprType type() const override { return ExprType::LAM; }
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The bound variable.
inline Id var() const { return m_var; }
/// \return The argument type.
inline Ptr<Type> ty() const { return m_ty; }
/// \return The body of the term.
inline Ptr<Expr> body() const { return m_body; }
Ptr<Expr> apply(const Ptr<Expr>) const;
inline Ptr<Env<Expr>> env() { return m_env; }
inline void set_env(Ptr<Env<Expr>> env) { m_env = env; }
inline Ptr<Expr> dup() const override
{ return ptr<LamExpr>(var(), ty(), body()->dup(), start(), end()); }
private:
Id m_var; ///< Bound variable.
Ptr<Type> m_ty; ///< Argument type.
Ptr<Expr> m_body; ///< Body.
/// Captured environment, or null if we're not evaluating yet.
Ptr<Env<Expr>> m_env;
};
/// Expressions with type annotations.
class TypeExpr final: public Expr
{
public:
TypeExpr(const TypeExpr&) = default;
TypeExpr(TypeExpr&&) = default;
TypeExpr(const Ptr<Expr> expr, const Ptr<Type> ty,
Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_expr(expr), m_ty(ty)
{}
/// \return ExprType::TYPE
inline ExprType type() const override { return ExprType::TYPE; }
Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
/// \return The inner expression.
inline Ptr<Expr> expr() const { return m_expr; }
/// \return The assigned type.
inline Ptr<Type> ty() const { return m_ty; }
inline Ptr<Expr> dup() const override
{ return ptr<TypeExpr>(expr()->dup(), ty(), start(), end()); }
private:
Ptr<Expr> m_expr; ///< Expression.
Ptr<Type> m_ty; ///< Assigned type.
};
/// Operators. \see OpExpr
enum class BinOp
{
PLUS, MINUS, TIMES, DIVIDE,
LESS, LEQ, EQUAL, GEQ, GREATER, NEQ,
AND, OR, IFF,
};
enum class OpAssoc { LEFT, NONE, RIGHT };
inline unsigned prec(BinOp op)
{
switch (op) {
case BinOp::TIMES:
case BinOp::DIVIDE:
return 7;
case BinOp::PLUS:
case BinOp::MINUS:
return 6;
case BinOp::LESS:
case BinOp::LEQ:
case BinOp::EQUAL:
case BinOp::GEQ:
case BinOp::GREATER:
case BinOp::NEQ:
return 3;
case BinOp::AND:
return 2;
case BinOp::OR:
return 1;
case BinOp::IFF:
return 0;
}
}
inline Ptr<Ppr> name(BinOp op)
{
switch (op) {
case BinOp::PLUS: return '+'_p;
case BinOp::MINUS: return '-'_p;
case BinOp::TIMES: return '*'_p;
case BinOp::DIVIDE: return '/'_p;
case BinOp::LESS: return '<'_p;
case BinOp::LEQ: return "<="_p;
case BinOp::EQUAL: return "=="_p;
case BinOp::GEQ: return ">="_p;
case BinOp::GREATER: return '>'_p;
case BinOp::NEQ: return "!="_p;
case BinOp::AND: return "&&"_p;
case BinOp::OR: return "||"_p;
case BinOp::IFF: return "<->"_p;
}
}
inline OpAssoc assoc(BinOp op)
{
switch (op) {
case BinOp::PLUS:
case BinOp::MINUS:
case BinOp::TIMES:
case BinOp::DIVIDE:
return OpAssoc::LEFT;
case BinOp::AND:
case BinOp::OR:
case BinOp::IFF:
return OpAssoc::RIGHT;
default:
return OpAssoc::NONE;
}
}
/// Binary operator expressions. \see OpType
class BinOpExpr final: public Expr
{
public:
BinOpExpr(const BinOpExpr&) = default;
BinOpExpr(BinOpExpr&&) = default;
BinOpExpr(BinOp op, Ptr<Expr> left, Ptr<Expr> right,
Pos start = Pos(), Pos end = Pos()):
Expr(start, end), m_op(op), m_left(left), m_right(right)
{}
inline ExprType type() const override { return ExprType::BINOP; }
virtual Ptr<Ppr> ppr(unsigned prec = 0, bool pos = false) const override;
inline Ptr<Expr> dup() const override
{ return ptr<BinOpExpr>(op(), left(), right()); }
inline BinOp op() const { return m_op; }
inline Ptr<Expr> left() const { return m_left; }
inline Ptr<Expr> right() const { return m_right; }
private:
BinOp m_op;
Ptr<Expr> m_left, m_right;
};
template <typename T, typename... Args>
struct ExprVisitor
{
inline Ptr<T> operator()(Ptr<Expr> e, Args... args)
{ return v(e, args...); }
virtual Ptr<T> v(Ptr<Expr> e, Args... args)
{
switch (e->type()) {
#define CASE(x,t) \
case ExprType::x: \
return v(std::dynamic_pointer_cast<t>(e), args...);
CASE(ID, IdExpr)
CASE(APP, AppExpr)
CASE(LAM, LamExpr)
CASE(INT, IntExpr)
CASE(BOOL, BoolExpr)
CASE(TYPE, TypeExpr)
CASE(BINOP, BinOpExpr)
#undef CASE
}
}
virtual Ptr<T> v(Ptr<IdExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<AppExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<IntExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<BoolExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<LamExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<TypeExpr>, Args...) = 0;
virtual Ptr<T> v(Ptr<BinOpExpr>, Args...) = 0;
};
Ptr<std::unordered_set<Id>> fv(const Ptr<Expr> expr);
}
#endif /* end of include guard: EXPR_HXX_SPN8H6I7 */
<|endoftext|> |
<commit_before>#ifndef TREEGA_H_
#define TREEGA_H_
#include "cppEvolve/Genome/Tree/Tree.hpp"
#include "cppEvolve/Genome/Tree/Crossover.hpp"
#include "cppEvolve/Genome/Tree/Mutator.hpp"
#include <limits.h>
namespace evolve
{
/*!
* Defines a GA to use with Tree-like genomes (typically for growing algorithms.
* @param rType The type to be returned from the functions composing the tree
* @param PopSize The static size of the population
*/
template<typename rType, size_t PopSize=100>
class TreeGA
{
public:
/*!
* @param _generator A function which will return instances of Genome to be used in
* the initial population
*
* @param _evaluator A function which returns a double representing the fitness of a
* member of the population
*
* @param _crossover A function which returns a new member of the population by
* combining two parents
*
* @param _mutator A function which will alter a member of the population in some way
*
* @param _selector A function which removes the less fit members from the population
*/
TreeGA(tree::TreeFactory<rType> _generator,
function<float(const tree::Tree<rType>*)> _evaluator,
function<tree::Tree<rType>*(const tree::Tree<rType>*,
const tree::Tree<rType>*)> _crossover,
function<void(tree::Tree<rType>*,
const tree::TreeFactory<rType>&)> _mutator,
function<void(std::vector<tree::Tree<rType>*>&,
function<double(const tree::Tree<rType>*)>)> _selector) :
generator(_generator),
evaluator(_evaluator),
crossover(_crossover),
mutator(_mutator),
selector(_selector) {}
virtual ~TreeGA(){}
/*!
* Preform the evolution printing statistics a logFrequency intervals
*/
virtual void run(unsigned int generations, unsigned int logFrequency=100)
{
for(auto i=0U; i < PopSize; ++i)
{
population.push_back(generator.make());
}
for(auto generation=0U; generation < generations; ++generation)
{
selector(population, evaluator);
auto popSizePostSelection = population.size();
while(population.size() < PopSize) {
population.push_back(crossover(population[random_uint(popSizePostSelection)],
population[random_uint(popSizePostSelection)]));
}
for(size_t i=0; i < PopSize*mutationRate; ++i) {
auto index = random_uint(PopSize);
mutator(population[index], generator);
}
auto score = evaluator(population[0]);
if ( score > bestScore)
{
delete bestIndividual;
bestIndividual = population[0]->clone();
bestScore = score;
}
if (generation % logFrequency == 0)
{
std::cout << "Generation(" << generation << ") - Fitness:" << bestScore << std::endl;
}
}
std::cout << "Best: " << *bestIndividual << std::endl;
std::cout << "Fitness: " << bestScore << std::endl;
}
/*!
* Set the GA population to pre-created population.
*/
void setPopulation(const std::array<tree::Tree<rType>*, PopSize>& _population) {
population = _population;
}
/*!
* Set the mutation rate for the GA. Mutation guarantees that at least
* PopSize * rate individuals (not necessarily distinct) will be mutated
* each generation.
*/
void setMutationRate(float rate) {mutationRate = rate;}
const std::array<tree::Tree<rType>*, PopSize>& getPopulation() const {return population;}
const tree::Tree<rType>* getBest() const {return bestIndividual;}
protected:
std::vector<tree::Tree<rType>*> population;
tree::TreeFactory<rType> generator;
tree::Tree<rType>* bestIndividual = nullptr; //Historically best individual
double bestScore = std::numeric_limits<float>::lowest();
function<float(const tree::Tree<rType>*)> evaluator;
function<tree::Tree<rType>*(const tree::Tree<rType>*,
const tree::Tree<rType>*)> crossover;
function<void(tree::Tree<rType>*,
const tree::TreeFactory<rType>&)> mutator;
function<void(std::vector<tree::Tree<rType>*>&,
function<double(const tree::Tree<rType>*)>)> selector;
float mutationRate = 0.6f;
};
}
#endif
<commit_msg>Better name scheme for template parameter<commit_after>#ifndef TREEGA_H_
#define TREEGA_H_
#include "cppEvolve/Genome/Tree/Tree.hpp"
#include "cppEvolve/Genome/Tree/Crossover.hpp"
#include "cppEvolve/Genome/Tree/Mutator.hpp"
#include <limits.h>
namespace evolve
{
/*!
* Defines a GA to use with Tree-like genomes (typically for growing algorithms.
* @param rType The type to be returned from the functions composing the tree
* @param PopSize The static size of the population
*/
template<typename Rtype, size_t PopSize=100>
class TreeGA
{
public:
/*!
* @param _generator A function which will return instances of Genome to be used in
* the initial population
*
* @param _evaluator A function which returns a double representing the fitness of a
* member of the population
*
* @param _crossover A function which returns a new member of the population by
* combining two parents
*
* @param _mutator A function which will alter a member of the population in some way
*
* @param _selector A function which removes the less fit members from the population
*/
TreeGA(tree::TreeFactory<Rtype> _generator,
function<float(const tree::Tree<Rtype>*)> _evaluator,
function<tree::Tree<Rtype>*(const tree::Tree<Rtype>*,
const tree::Tree<Rtype>*)> _crossover,
function<void(tree::Tree<Rtype>*,
const tree::TreeFactory<Rtype>&)> _mutator,
function<void(std::vector<tree::Tree<Rtype>*>&,
function<double(const tree::Tree<Rtype>*)>)> _selector) :
generator(_generator),
evaluator(_evaluator),
crossover(_crossover),
mutator(_mutator),
selector(_selector) {}
virtual ~TreeGA(){}
/*!
* Preform the evolution printing statistics a logFrequency intervals
*/
virtual void run(unsigned int generations, unsigned int logFrequency=100)
{
for(auto i=0U; i < PopSize; ++i)
{
population.push_back(generator.make());
}
for(auto generation=0U; generation < generations; ++generation)
{
selector(population, evaluator);
auto popSizePostSelection = population.size();
while(population.size() < PopSize) {
population.push_back(crossover(population[random_uint(popSizePostSelection)],
population[random_uint(popSizePostSelection)]));
}
for(size_t i=0; i < PopSize*mutationRate; ++i) {
auto index = random_uint(PopSize);
mutator(population[index], generator);
}
auto score = evaluator(population[0]);
if ( score > bestScore)
{
delete bestIndividual;
bestIndividual = population[0]->clone();
bestScore = score;
}
if (generation % logFrequency == 0)
{
std::cout << "Generation(" << generation << ") - Fitness:" << bestScore << std::endl;
}
}
std::cout << "Best: " << *bestIndividual << std::endl;
std::cout << "Fitness: " << bestScore << std::endl;
}
/*!
* Set the GA population to pre-created population.
*/
void setPopulation(const std::array<tree::Tree<Rtype>*, PopSize>& _population) {
population = _population;
}
/*!
* Set the mutation rate for the GA. Mutation guarantees that at least
* PopSize * rate individuals (not necessarily distinct) will be mutated
* each generation.
*/
void setMutationRate(float rate) {mutationRate = rate;}
const std::array<tree::Tree<Rtype>*, PopSize>& getPopulation() const {return population;}
const tree::Tree<Rtype>* getBest() const {return bestIndividual;}
protected:
std::vector<tree::Tree<Rtype>*> population;
tree::TreeFactory<Rtype> generator;
tree::Tree<Rtype>* bestIndividual = nullptr; //Historically best individual
double bestScore = std::numeric_limits<float>::lowest();
function<float(const tree::Tree<Rtype>*)> evaluator;
function<tree::Tree<Rtype>*(const tree::Tree<Rtype>*,
const tree::Tree<Rtype>*)> crossover;
function<void(tree::Tree<Rtype>*,
const tree::TreeFactory<Rtype>&)> mutator;
function<void(std::vector<tree::Tree<Rtype>*>&,
function<double(const tree::Tree<Rtype>*)>)> selector;
float mutationRate = 0.6f;
};
}
#endif
<|endoftext|> |
<commit_before>#ifndef TYPE_HXX_PHQ9E7V1
#define TYPE_HXX_PHQ9E7V1
#include "ptr.hxx"
#include "id.hxx"
#include "ppr.hxx"
namespace miniml
{
enum class TypeType
{
ID,
ARROW,
};
class Type: public Pretty
{
public:
virtual ~Type() {}
virtual TypeType type() const = 0;
virtual bool operator==(const Type &other) const = 0;
};
class IdType final: public Type
{
public:
IdType(const IdType &other) = default;
IdType(IdType &&other) = default;
IdType(Ptr<Id> id): m_id(id) {}
virtual TypeType type() const override { return TypeType::ID; }
virtual bool operator==(const Type &other) const override;
virtual Ptr<Ppr> ppr(unsigned prec = 0) const override;
const Ptr<Id> id() const { return m_id; }
private:
Ptr<Id> m_id;
};
class ArrowType final: public Type
{
public:
ArrowType(const ArrowType &other) = default;
ArrowType(ArrowType &&other) = default;
ArrowType(Ptr<Type> left, Ptr<Type> right):
m_left(left), m_right(right)
{}
virtual TypeType type() const override { return TypeType::ARROW; }
virtual bool operator==(const Type &other) const override;
virtual Ptr<Ppr> ppr(unsigned prec = 0) const override;
Ptr<Type> left() const { return m_left; }
Ptr<Type> right() const { return m_right; }
private:
Ptr<Type> m_left, m_right;
};
}
#endif /* end of include guard: TYPE_HXX_PHQ9E7V1 */
<commit_msg>Int type<commit_after>#ifndef TYPE_HXX_PHQ9E7V1
#define TYPE_HXX_PHQ9E7V1
#include "ptr.hxx"
#include "id.hxx"
#include "ppr.hxx"
namespace miniml
{
enum class TypeType
{
ID,
INT,
ARROW,
};
class Type: public Pretty
{
public:
virtual ~Type() {}
virtual TypeType type() const = 0;
virtual bool operator==(const Type &other) const = 0;
};
class IdType final: public Type
{
public:
IdType(const IdType &other) = default;
IdType(IdType &&other) = default;
IdType(Ptr<Id> id): m_id(id) {}
virtual TypeType type() const override { return TypeType::ID; }
virtual bool operator==(const Type &other) const override;
virtual Ptr<Ppr> ppr(unsigned prec = 0) const override;
const Ptr<Id> id() const { return m_id; }
private:
Ptr<Id> m_id;
};
class IntType final: public Type
{
virtual TypeType type() const override { return TypeType::INT; }
virtual bool operator==(const Type &other) const override
{ return other.type() == type(); }
virtual Ptr<Ppr> ppr(unsigned prec = 0) const override
{ return "int"_p; }
};
class ArrowType final: public Type
{
public:
ArrowType(const ArrowType &other) = default;
ArrowType(ArrowType &&other) = default;
ArrowType(Ptr<Type> left, Ptr<Type> right):
m_left(left), m_right(right)
{}
virtual TypeType type() const override { return TypeType::ARROW; }
virtual bool operator==(const Type &other) const override;
virtual Ptr<Ppr> ppr(unsigned prec = 0) const override;
Ptr<Type> left() const { return m_left; }
Ptr<Type> right() const { return m_right; }
private:
Ptr<Type> m_left, m_right;
};
}
#endif /* end of include guard: TYPE_HXX_PHQ9E7V1 */
<|endoftext|> |
<commit_before>// Copyright (c) 2016 Thomas Johansen
// The use of this source code is governed by the MIT license, found in LICENSE.md.
#pragma once
#include <iostream>
#include <vector>
namespace cuda {
void check_error(const cudaError_t code)
{
if (code == cudaSuccess) return;
std::cerr << "CUDA error: " << cudaGetErrorString(code) << "\n";
}
template<typename T>
T* allocate(const size_t num)
{
T* dev_ptr = nullptr;
cuda::check_error(cudaMalloc(&dev_ptr, num * sizeof(T)));
return dev_ptr;
}
template<typename T>
void free(T* dev_ptr)
{
if (dev_ptr == nullptr) return;
cuda::check_error(cudaFree(dev_ptr));
}
template<typename T>
void copy_to_device(T* dev_ptr, const T* host_ptr, const size_t num)
{
cuda::check_error(cudaMemcpy(dev_ptr, host_ptr, num * sizeof(T), cudaMemcpyHostToDevice));
}
template<typename T>
T* copy_to_device(const T* host_ptr, const size_t num)
{
T* dev_ptr = cuda::allocate<T>(num);
copy_to_device(dev_ptr, host_ptr, num);
return dev_ptr;
}
template<typename T>
T* copy_to_device(const std::vector<T>& host_vec)
{
return copy_to_device(host_vec.data(), host_vec.size());
}
template<typename T>
void copy_to_host(T* host_ptr, const T* dev_ptr, const size_t num)
{
cuda::check_error(cudaMemcpy(host_ptr, dev_ptr, num * sizeof(T), cudaMemcpyDeviceToHost));
}
template<typename T>
void copy_to_host(std::vector<T>& host_vec, const T* dev_ptr)
{
copy_to_host(host_vec.data(), dev_ptr, host_vec.size());
}
template<typename T>
void copy_on_device(T* dst_ptr, const T* src_ptr, const size_t num)
{
cuda::check_error(cudaMemcpy(dst_ptr, src_ptr, num * sizeof(T), cudaMemcpyDeviceToDevice));
}
template<typename T>
T* copy_on_device(const T* src_ptr, const size_t num)
{
T* dst_ptr = cuda::allocate<T>(num);
cuda::copy_on_device(dst_ptr, src_ptr, num);
return dst_ptr;
}
void device_sync()
{
cuda::check_error(cudaDeviceSynchronize());
}
void device_reset()
{
cuda::check_error(cudaDeviceReset());
}
void peek_at_last_error()
{
cuda::check_error(cudaPeekAtLastError());
}
} // cuda
<commit_msg>:art: Reorder functions<commit_after>// Copyright (c) 2016 Thomas Johansen
// The use of this source code is governed by the MIT license, found in LICENSE.md.
#pragma once
#include <iostream>
#include <vector>
namespace cuda {
void check_error(const cudaError_t code)
{
if (code == cudaSuccess) return;
std::cerr << "CUDA error: " << cudaGetErrorString(code) << "\n";
}
void device_sync()
{
cuda::check_error(cudaDeviceSynchronize());
}
void device_reset()
{
cuda::check_error(cudaDeviceReset());
}
void peek_at_last_error()
{
cuda::check_error(cudaPeekAtLastError());
}
template<typename T>
T* allocate(const size_t num)
{
T* dev_ptr = nullptr;
cuda::check_error(cudaMalloc(&dev_ptr, num * sizeof(T)));
return dev_ptr;
}
template<typename T>
void free(T* dev_ptr)
{
if (dev_ptr == nullptr) return;
cuda::check_error(cudaFree(dev_ptr));
}
template<typename T>
void copy_to_device(T* dev_ptr, const T* host_ptr, const size_t num)
{
cuda::check_error(cudaMemcpy(dev_ptr, host_ptr, num * sizeof(T), cudaMemcpyHostToDevice));
}
template<typename T>
T* copy_to_device(const T* host_ptr, const size_t num)
{
T* dev_ptr = cuda::allocate<T>(num);
copy_to_device(dev_ptr, host_ptr, num);
return dev_ptr;
}
template<typename T>
T* copy_to_device(const std::vector<T>& host_vec)
{
return copy_to_device(host_vec.data(), host_vec.size());
}
template<typename T>
void copy_to_host(T* host_ptr, const T* dev_ptr, const size_t num)
{
cuda::check_error(cudaMemcpy(host_ptr, dev_ptr, num * sizeof(T), cudaMemcpyDeviceToHost));
}
template<typename T>
void copy_to_host(std::vector<T>& host_vec, const T* dev_ptr)
{
copy_to_host(host_vec.data(), dev_ptr, host_vec.size());
}
template<typename T>
void copy_on_device(T* dst_ptr, const T* src_ptr, const size_t num)
{
cuda::check_error(cudaMemcpy(dst_ptr, src_ptr, num * sizeof(T), cudaMemcpyDeviceToDevice));
}
template<typename T>
T* copy_on_device(const T* src_ptr, const size_t num)
{
T* dst_ptr = cuda::allocate<T>(num);
cuda::copy_on_device(dst_ptr, src_ptr, num);
return dst_ptr;
}
} // cuda
<|endoftext|> |
<commit_before>/* dlvhex -- Answer-Set Programming with external interfaces.
* Copyright (C) 2005, 2006, 2007 Roman Schindlauer
*
* This file is part of dlvhex.
*
* dlvhex 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.
*
* dlvhex 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 dlvhex; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA.
*/
/**
* @file ASPSolver.tcc
* @author Thomas Krennwallner
* @date Thu Feb 21 09:20:32 CET 2008
*
* @brief Definition of ASP solver class.
*
*/
#if !defined(_DLVHEX_ASPSOLVER_TCC)
#define _DLVHEX_ASPSOLVER_TCC
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif // HAVE_CONFIG_H
#include "dlvhex/Error.h"
#include "dlvhex/Program.h"
#include "dlvhex/AtomSet.h"
#include "dlvhex/globals.h"
#include <sstream>
DLVHEX_NAMESPACE_BEGIN
template<typename Builder, typename Parser>
ASPSolver<Builder,Parser>::ASPSolver(Process& p)
: proc(p)
{ }
template<typename Builder, typename Parser>
void
ASPSolver<Builder,Parser>::solve(const Program& prg,
const AtomSet& facts,
std::vector<AtomSet>& as)
throw (FatalError)
{
int retcode;
std::string error;
try
{
DEBUG_START_TIMER;
proc.spawn();
// send program and facts
try
{
Builder builder(proc.getOutput());
const_cast<Program&>(prg).accept(builder);
const_cast<AtomSet&>(facts).accept(builder);
}
catch (std::ios_base::failure&)
{
throw FatalError("Received an error while sending the program to the external LP solver.");
}
proc.endoffile(); // send EOF to process
// parse result
Parser parser;
parser.parse(proc.getInput(), as, error);
// get exit code of process
retcode = proc.close();
// 123456789-123456789-123456789-123456789-123456789-123456789-123456789-123456789-
DEBUG_STOP_TIMER("Calling LP solver + result parsing: ");
}
catch (FatalError& e)
{
throw FatalError(proc.path() + ": " + e.getErrorMsg());
}
catch (GeneralError& e)
{
throw FatalError(proc.path() + ": " + e.getErrorMsg());
}
catch (std::exception& e)
{
throw FatalError(proc.path() + ": " + e.what());
}
// check for errors
if (retcode == 127)
{
throw FatalError("LP solver command `" + proc.path() + "´ not found!");
}
else if (retcode != 0) // other problem
{
std::stringstream errstr;
errstr << "LP solver `" << proc.path()
<< "´ failure (" << retcode << "):"
<< std::endl
<< error;
throw FatalError(errstr.str());
}
}
DLVHEX_NAMESPACE_END
#endif // _DLVHEX_ASPSOLVER_TCC
// Local Variables:
// mode: C++
// End:
<commit_msg>Provide better debug output in case of solver errors.<commit_after>/* dlvhex -- Answer-Set Programming with external interfaces.
* Copyright (C) 2005, 2006, 2007 Roman Schindlauer
*
* This file is part of dlvhex.
*
* dlvhex 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.
*
* dlvhex 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 dlvhex; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA.
*/
/**
* @file ASPSolver.tcc
* @author Thomas Krennwallner
* @date Thu Feb 21 09:20:32 CET 2008
*
* @brief Definition of ASP solver class.
*
*/
#if !defined(_DLVHEX_ASPSOLVER_TCC)
#define _DLVHEX_ASPSOLVER_TCC
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif // HAVE_CONFIG_H
#include "dlvhex/Error.h"
#include "dlvhex/Program.h"
#include "dlvhex/AtomSet.h"
#include "dlvhex/globals.h"
#include <sstream>
DLVHEX_NAMESPACE_BEGIN
template<typename Builder, typename Parser>
ASPSolver<Builder,Parser>::ASPSolver(Process& p)
: proc(p)
{ }
template<typename Builder, typename Parser>
void
ASPSolver<Builder,Parser>::solve(const Program& prg,
const AtomSet& facts,
std::vector<AtomSet>& as)
throw (FatalError)
{
int retcode;
std::string error;
try
{
DEBUG_START_TIMER;
proc.spawn();
// send program and facts
try
{
Builder builder(proc.getOutput());
const_cast<Program&>(prg).accept(builder);
const_cast<AtomSet&>(facts).accept(builder);
}
catch (std::ios_base::failure& e)
{
std::stringstream errstr;
errstr << "Received an error while sending the program to the external LP solver."
<< std::endl
<< "LP solver `" << proc.path()
<< "´ failure: " << e.what()
<< std::endl;
throw FatalError(errstr.str());
}
proc.endoffile(); // send EOF to process
// parse result
Parser parser;
parser.parse(proc.getInput(), as, error);
// get exit code of process
retcode = proc.close();
// 123456789-123456789-123456789-123456789-123456789-123456789-123456789-123456789-
DEBUG_STOP_TIMER("Calling LP solver + result parsing: ");
}
catch (FatalError& e)
{
throw FatalError(proc.path() + ": " + e.getErrorMsg());
}
catch (GeneralError& e)
{
throw FatalError(proc.path() + ": " + e.getErrorMsg());
}
catch (std::exception& e)
{
throw FatalError(proc.path() + ": " + e.what());
}
// check for errors
if (retcode == 127)
{
throw FatalError("LP solver command `" + proc.path() + "´ not found!");
}
else if (retcode != 0) // other problem
{
std::stringstream errstr;
errstr << "LP solver `" << proc.path()
<< "´ failure (" << retcode << "):"
<< std::endl
<< error;
throw FatalError(errstr.str());
}
}
DLVHEX_NAMESPACE_END
#endif // _DLVHEX_ASPSOLVER_TCC
// Local Variables:
// mode: C++
// End:
<|endoftext|> |
<commit_before>/*
Copyright (c) 2014-2015, Scott Zuyderduyn
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.
*/
//----------------------------------------------------------------------------
// device_ptr.hpp
//
// Smart pointer to device memory.
//
// Author: Scott D. Zuyderduyn, Ph.D. ([email protected])
//----------------------------------------------------------------------------
#pragma once
#ifndef ECUDA_DEVICE_PTR_HPP
#define ECUDA_DEVICE_PTR_HPP
#include "global.hpp"
#include "algorithm.hpp"
#ifdef __CPP11_SUPPORTED__
#include <cstddef> // to get std::nullptr_t
#endif
namespace ecuda {
///
/// \brief A reference-counting smart pointer for device memory.
///
/// This class keeps a pointer to allocated device memory and automatically
/// deallocates it when all references to it go out of scope. The workings are
/// similar to a C++11 \c std\::shared_ptr. Since deallocation can only be
/// done from host code reference counting only occurs within host code. On the
/// device the pointer is passed around freely without regards to reference
/// counting and will never undergo deallocation.
///
/// Like a typical smart pointer, this class handles deallocation but allocation
/// is performed elsewhere and the pointer to the allocated memory location is
/// passed to the constructor.
///
template<typename T,typename PointerType=typename reference<T>::pointer_type>
class device_ptr {
public:
typedef T element_type; //!< data type represented in allocated memory
typedef PointerType pointer; //!< data type pointer
//typedef T* pointer; //!< data type pointer
typedef T& reference; //!< data type reference
typedef std::size_t size_type; //!< size type for pointer arithmetic and reference counting
typedef std::ptrdiff_t difference_type; //!< signed integer type of the result of subtracting two pointers
typedef T* naked_pointer;
private:
pointer ptr; //!< pointer to device memory
size_type* reference_count; //!< pointer to reference count
public:
///
/// \brief Default constructor.
///
/// \param ptr A pointer to the allocated block of device memory.
///
HOST DEVICE device_ptr( pointer ptr = pointer() ) : ptr(ptr) {
#ifndef __CUDA_ARCH__
reference_count = new size_type;
*reference_count = 1;
std::cerr << "device_ptr.ctor() " << reference_count << std::endl;
#else
reference_count = nullptr;
#endif
}
///
/// \brief Copy constructor.
///
/// If called from the host, the reference count is incremented. If called from the device,
/// the underlying pointer is copied but no change to the reference count occurs.
///
/// \param src Another device pointer to be used as source to initialize with.
///
HOST DEVICE device_ptr( const device_ptr<T>& src ) : ptr(src.ptr), reference_count(src.reference_count) {
#ifndef __CUDA_ARCH__
std::cerr << "copying " << src.ptr << " " << src.reference_count << std::endl;
++(*reference_count);
#endif
}
#ifdef __CPP11_SUPPORTED__
///
/// \brief Move constructor.
///
/// Constructs the device pointer using move semantics.
/// This constructor is only available if the compiler is configured to allow C++11.
///
/// \param src Another device pointer whose contents are to be moved.
///
HOST DEVICE device_ptr( device_ptr<T>&& src ) : ptr(std::move(src.ptr)), reference_count(src.reference_count) {
src.ptr = pointer(); //nullptr;
#ifndef __CUDA_ARCH__
src.reference_count = new size_type;
*(src.reference_count) = 1;
#else
src.reference_count = nullptr;
#endif
}
#endif
///
/// \brief Destructor.
///
/// Destructs the device pointer. If called from host code, the reference count is decremented.
/// If the reference count becomes zero, the device memory is freed. If called from the device
/// the object is destroyed but nothing happens to the underlying pointer or reference count.
///
HOST DEVICE ~device_ptr() {
#ifndef __CUDA_ARCH__
std::cerr << "reference_count=" << reference_count << std::endl;
std::cerr << "*reference_count=" << (*reference_count) << std::endl;
--(*reference_count);
if( !(*reference_count) ) {
if( ptr ) CUDA_CALL( cudaFree( ptr ) );
//deleter<T>()(ptr);
delete reference_count;
}
#endif
}
///
/// \brief Exchanges the contents of *this and other.
///
/// \param other device pointer to exchange the contents with
///
HOST DEVICE inline void swap( device_ptr& other ) __NOEXCEPT__ {
#ifdef __CUDA_ARCH__
ecuda::swap( ptr, other.ptr );
ecuda::swap( reference_count, other.reference_count );
#else
std::swap( ptr, other.ptr );
std::swap( reference_count, other.reference_count );
#endif
}
///
/// \brief Releases ownership of the managed pointer to device memory.
///
/// After this call, *this manages no object.
///
HOST DEVICE inline void reset() __NOEXCEPT__ { device_ptr().swap(*this); }
///
/// \brief Replaces the managed pointer to device memory with another.
///
/// U must be a complete type and implicitly convertible to T.
///
template<typename U> HOST DEVICE inline void reset( U* p ) __NOEXCEPT__ { device_ptr<T,PointerType>(p).swap(*this); }
///
/// \brief Returns the managed pointer to device memory.
///
/// If no pointer is being managed, this will return null.
///
/// \returns A pointer to device memory.
///
HOST DEVICE inline pointer get() const __NOEXCEPT__ { return ptr; }
///
/// \brief Dereferences the managed pointer to device memory.
///
/// \returns A reference to the object at the managed device memory location.
///
DEVICE inline reference operator*() const __NOEXCEPT__ { return *ptr; }
///
/// \brief Dereferences the managed pointer to device memory.
///
/// \returns A pointer to the object at the managed device memory location.
///
DEVICE inline pointer operator->() const __NOEXCEPT__ { return ptr; }
///
/// \brief Returns the number of different host-bound device_ptr instances managing the current pointer to device memory.
///
/// If there is no managed pointer 0 is returned.
///
/// \returns The number of host-bound device_ptr instances managing the current pointer to device memory. 0 if there is no managed pointer.
///
HOST inline size_type use_count() const __NOEXCEPT__ { return reference_count ? *reference_count : 0; }
///
/// \brief Checks if *this is the only device_ptr instance managing the current pointer to device memory.
///
/// \returns true if *this is the only device_ptr instance managing the current pointer to device memory, false otherwise.
///
HOST inline bool unique() const __NOEXCEPT__ { return use_count() == 1; }
///
/// \brief Checks if *this stores a non-null pointer, i.e. whether get() != nullptr.
///
/// \returns true if *this stores a pointer, false otherwise.
///
HOST DEVICE inline operator bool() const __NOEXCEPT__ { return get() != pointer(); } //nullptr; }
///
/// \brief Checks whether this device_ptr precedes other in implementation defined owner-based (as opposed to value-based) order.
///
/// This method is included to make device_ptr have as much as common with the STL C++11 shared_ptr specification, although
/// it is not currently used for any internal ecuda purposes and hasn't been extensively tested. At present, it returns false
/// if neither of the compared device_ptrs manage pointers, and true if this managed pointer's address is less than other
/// (if one or the other manages no pointers, i.e. is null, the address is considered to be 0 for the purposes of comparison).
///
/// \returns true if *this precedes other, false otherwise.
///
template<typename U>
bool owner_before( const device_ptr<U>& other ) const {
if( ptr == other.ptr ) return false;
if( !ptr ) return true;
if( !other.ptr ) return false;
return ptr < other.ptr;
}
template<typename U,typename PointerType2> HOST DEVICE inline bool operator==( const device_ptr<U,PointerType2>& other ) const { return ptr == other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator!=( const device_ptr<U,PointerType2>& other ) const { return ptr != other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator< ( const device_ptr<U,PointerType2>& other ) const { return ptr < other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator> ( const device_ptr<U,PointerType2>& other ) const { return ptr > other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator<=( const device_ptr<U,PointerType2>& other ) const { return ptr <= other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator>=( const device_ptr<U,PointerType2>& other ) const { return ptr >= other.get(); }
#ifdef __CPP11_SUPPORTED__
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator==( std::nullptr_t other ) const { return ptr == pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator!=( std::nullptr_t other ) const { return ptr != pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator< ( std::nullptr_t other ) const { return ptr < pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator> ( std::nullptr_t other ) const { return ptr > pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator<=( std::nullptr_t other ) const { return ptr <= pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator>=( std::nullptr_t other ) const { return ptr >= pointer(); } //other; }
#endif
template<typename U,typename V>
friend std::basic_ostream<U,V>& operator<<( std::basic_ostream<U,V>& out, const device_ptr& ptr ) {
out << ptr.reference_count << " " << ptr.get();
return out;
}
HOST device_ptr<T>& operator=( pointer p ) {
std::cerr << "device_ptr.operator=(pointer)" << std::endl;
~device_ptr();
ptr = p;
reference_count = new size_type;
*reference_count = 1;
return *this;
}
HOST DEVICE device_ptr& operator=( const device_ptr& other ) {
#ifndef __CUDA_ARCH__
std::cerr << "device_ptr.operator=(device_ptr)" << std::endl;
~device_ptr();
#endif
ptr = other.ptr;
#ifndef __CUDA_ARCH__
reference_count = other.reference_count;
++(*reference_count);
#endif
return *this;
}
/*
* These methods were included at one time, but in retrospect are not part of
* shared_ptr spec and don't actually have any use in ecuda implementation.
* Listed here for debugging purposes in case there was an unforseen dependency.
*/
//HOST DEVICE inline operator pointer() const { return ptr; }
//DEVICE inline reference operator[]( size_type index ) const { return *(ptr+index); }
//HOST DEVICE inline difference_type operator-( const device_ptr<T>& other ) const { return ptr - other.ptr; }
HOST DEVICE inline operator naked_pointer() const { return ptr; }
HOST DEVICE inline pointer operator+( int x ) { return ptr+x; }
HOST DEVICE inline pointer operator-( int x ) { return ptr-x; }
};
} // namespace ecuda
/// \cond DEVELOPER_DOCUMENTATION
#ifdef __CPP11_SUPPORTED__
//
// C++ hash support for device_ptr.
//
namespace std {
template<typename T>
struct hash< ecuda::device_ptr<T> > {
size_t operator()( const ecuda::device_ptr<T>& dp ) const { return hash<typename ecuda::device_ptr<T>::pointer>()( dp.get() ); }
};
} // namespace std
#endif
/// \endcond
#endif
<commit_msg>tweaking pointers<commit_after>/*
Copyright (c) 2014-2015, Scott Zuyderduyn
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.
*/
//----------------------------------------------------------------------------
// device_ptr.hpp
//
// Smart pointer to device memory.
//
// Author: Scott D. Zuyderduyn, Ph.D. ([email protected])
//----------------------------------------------------------------------------
#pragma once
#ifndef ECUDA_DEVICE_PTR_HPP
#define ECUDA_DEVICE_PTR_HPP
#include "global.hpp"
#include "algorithm.hpp"
#ifdef __CPP11_SUPPORTED__
#include <cstddef> // to get std::nullptr_t
#endif
namespace ecuda {
///
/// \brief A reference-counting smart pointer for device memory.
///
/// This class keeps a pointer to allocated device memory and automatically
/// deallocates it when all references to it go out of scope. The workings are
/// similar to a C++11 \c std\::shared_ptr. Since deallocation can only be
/// done from host code reference counting only occurs within host code. On the
/// device the pointer is passed around freely without regards to reference
/// counting and will never undergo deallocation.
///
/// Like a typical smart pointer, this class handles deallocation but allocation
/// is performed elsewhere and the pointer to the allocated memory location is
/// passed to the constructor.
///
template<typename T,typename PointerType=typename reference<T>::pointer_type>
class device_ptr {
public:
typedef T element_type; //!< data type represented in allocated memory
typedef PointerType pointer; //!< data type pointer
//typedef T* pointer; //!< data type pointer
typedef T& reference; //!< data type reference
typedef std::size_t size_type; //!< size type for pointer arithmetic and reference counting
typedef std::ptrdiff_t difference_type; //!< signed integer type of the result of subtracting two pointers
typedef T* naked_pointer;
private:
pointer ptr; //!< pointer to device memory
size_type* reference_count; //!< pointer to reference count
public:
///
/// \brief Default constructor.
///
/// \param ptr A pointer to the allocated block of device memory.
///
HOST DEVICE device_ptr( pointer ptr = pointer() ) : ptr(ptr) {
#ifndef __CUDA_ARCH__
reference_count = new size_type;
*reference_count = 1;
std::cerr << "device_ptr.ctor() " << reference_count << std::endl;
#else
reference_count = nullptr;
#endif
}
///
/// \brief Copy constructor.
///
/// If called from the host, the reference count is incremented. If called from the device,
/// the underlying pointer is copied but no change to the reference count occurs.
///
/// \param src Another device pointer to be used as source to initialize with.
///
HOST DEVICE device_ptr( const device_ptr<T>& src ) : ptr(src.ptr), reference_count(src.reference_count) {
#ifndef __CUDA_ARCH__
std::cerr << "copying " << src.ptr << " " << src.reference_count << std::endl;
++(*reference_count);
#endif
}
#ifdef __CPP11_SUPPORTED__
///
/// \brief Move constructor.
///
/// Constructs the device pointer using move semantics.
/// This constructor is only available if the compiler is configured to allow C++11.
///
/// \param src Another device pointer whose contents are to be moved.
///
HOST DEVICE device_ptr( device_ptr<T>&& src ) : ptr(std::move(src.ptr)), reference_count(src.reference_count) {
src.ptr = pointer(); //nullptr;
#ifndef __CUDA_ARCH__
src.reference_count = new size_type;
*(src.reference_count) = 1;
#else
src.reference_count = nullptr;
#endif
}
#endif
///
/// \brief Destructor.
///
/// Destructs the device pointer. If called from host code, the reference count is decremented.
/// If the reference count becomes zero, the device memory is freed. If called from the device
/// the object is destroyed but nothing happens to the underlying pointer or reference count.
///
HOST DEVICE ~device_ptr() {
#ifndef __CUDA_ARCH__
std::cerr << "reference_count=" << reference_count << std::endl;
std::cerr << "*reference_count=" << (*reference_count) << std::endl;
--(*reference_count);
if( !(*reference_count) ) {
if( ptr ) CUDA_CALL( cudaFree( ptr ) );
//deleter<T>()(ptr);
delete reference_count;
}
#endif
}
///
/// \brief Exchanges the contents of *this and other.
///
/// \param other device pointer to exchange the contents with
///
HOST DEVICE inline void swap( device_ptr& other ) __NOEXCEPT__ {
#ifdef __CUDA_ARCH__
ecuda::swap( ptr, other.ptr );
ecuda::swap( reference_count, other.reference_count );
#else
std::swap( ptr, other.ptr );
std::swap( reference_count, other.reference_count );
#endif
}
///
/// \brief Releases ownership of the managed pointer to device memory.
///
/// After this call, *this manages no object.
///
HOST DEVICE inline void reset() __NOEXCEPT__ { device_ptr().swap(*this); }
///
/// \brief Replaces the managed pointer to device memory with another.
///
/// U must be a complete type and implicitly convertible to T.
///
template<typename U> HOST DEVICE inline void reset( U* p ) __NOEXCEPT__ { device_ptr<T,PointerType>(p).swap(*this); }
///
/// \brief Returns the managed pointer to device memory.
///
/// If no pointer is being managed, this will return null.
///
/// \returns A pointer to device memory.
///
HOST DEVICE inline pointer get() const __NOEXCEPT__ { return ptr; }
///
/// \brief Dereferences the managed pointer to device memory.
///
/// \returns A reference to the object at the managed device memory location.
///
DEVICE inline reference operator*() const __NOEXCEPT__ { return *ptr; }
///
/// \brief Dereferences the managed pointer to device memory.
///
/// \returns A pointer to the object at the managed device memory location.
///
DEVICE inline pointer operator->() const __NOEXCEPT__ { return ptr; }
///
/// \brief Returns the number of different host-bound device_ptr instances managing the current pointer to device memory.
///
/// If there is no managed pointer 0 is returned.
///
/// \returns The number of host-bound device_ptr instances managing the current pointer to device memory. 0 if there is no managed pointer.
///
HOST inline size_type use_count() const __NOEXCEPT__ { return reference_count ? *reference_count : 0; }
///
/// \brief Checks if *this is the only device_ptr instance managing the current pointer to device memory.
///
/// \returns true if *this is the only device_ptr instance managing the current pointer to device memory, false otherwise.
///
HOST inline bool unique() const __NOEXCEPT__ { return use_count() == 1; }
///
/// \brief Checks if *this stores a non-null pointer, i.e. whether get() != nullptr.
///
/// \returns true if *this stores a pointer, false otherwise.
///
HOST DEVICE inline operator bool() const __NOEXCEPT__ { return get() != pointer(); } //nullptr; }
///
/// \brief Checks whether this device_ptr precedes other in implementation defined owner-based (as opposed to value-based) order.
///
/// This method is included to make device_ptr have as much as common with the STL C++11 shared_ptr specification, although
/// it is not currently used for any internal ecuda purposes and hasn't been extensively tested. At present, it returns false
/// if neither of the compared device_ptrs manage pointers, and true if this managed pointer's address is less than other
/// (if one or the other manages no pointers, i.e. is null, the address is considered to be 0 for the purposes of comparison).
///
/// \returns true if *this precedes other, false otherwise.
///
template<typename U>
bool owner_before( const device_ptr<U>& other ) const {
if( ptr == other.ptr ) return false;
if( !ptr ) return true;
if( !other.ptr ) return false;
return ptr < other.ptr;
}
template<typename U,typename PointerType2> HOST DEVICE inline bool operator==( const device_ptr<U,PointerType2>& other ) const { return ptr == other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator!=( const device_ptr<U,PointerType2>& other ) const { return ptr != other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator< ( const device_ptr<U,PointerType2>& other ) const { return ptr < other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator> ( const device_ptr<U,PointerType2>& other ) const { return ptr > other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator<=( const device_ptr<U,PointerType2>& other ) const { return ptr <= other.get(); }
template<typename U,typename PointerType2> HOST DEVICE inline bool operator>=( const device_ptr<U,PointerType2>& other ) const { return ptr >= other.get(); }
#ifdef __CPP11_SUPPORTED__
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator==( std::nullptr_t other ) const { return ptr == pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator!=( std::nullptr_t other ) const { return ptr != pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator< ( std::nullptr_t other ) const { return ptr < pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator> ( std::nullptr_t other ) const { return ptr > pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator<=( std::nullptr_t other ) const { return ptr <= pointer(); } //other; }
///
/// This operator is only available if the compiler is configured to allow C++11.
///
HOST DEVICE inline bool operator>=( std::nullptr_t other ) const { return ptr >= pointer(); } //other; }
#endif
template<typename U,typename V>
friend std::basic_ostream<U,V>& operator<<( std::basic_ostream<U,V>& out, const device_ptr& ptr ) {
out << ptr.reference_count << " " << "(" << *ptr.reference_count << ") " << ptr.get();
return out;
}
HOST device_ptr<T>& operator=( pointer p ) {
std::cerr << "device_ptr.operator=(pointer)" << std::endl;
~device_ptr();
ptr = p;
reference_count = new size_type;
*reference_count = 1;
return *this;
}
HOST DEVICE device_ptr& operator=( const device_ptr& other ) {
#ifndef __CUDA_ARCH__
std::cerr << "device_ptr.operator=(device_ptr)" << std::endl;
~device_ptr();
#endif
ptr = other.ptr;
#ifndef __CUDA_ARCH__
reference_count = other.reference_count;
++(*reference_count);
#endif
return *this;
}
/*
* These methods were included at one time, but in retrospect are not part of
* shared_ptr spec and don't actually have any use in ecuda implementation.
* Listed here for debugging purposes in case there was an unforseen dependency.
*/
//HOST DEVICE inline operator pointer() const { return ptr; }
//DEVICE inline reference operator[]( size_type index ) const { return *(ptr+index); }
//HOST DEVICE inline difference_type operator-( const device_ptr<T>& other ) const { return ptr - other.ptr; }
HOST DEVICE inline operator naked_pointer() const { return ptr; }
HOST DEVICE inline pointer operator+( int x ) { return ptr+x; }
HOST DEVICE inline pointer operator-( int x ) { return ptr-x; }
};
} // namespace ecuda
/// \cond DEVELOPER_DOCUMENTATION
#ifdef __CPP11_SUPPORTED__
//
// C++ hash support for device_ptr.
//
namespace std {
template<typename T>
struct hash< ecuda::device_ptr<T> > {
size_t operator()( const ecuda::device_ptr<T>& dp ) const { return hash<typename ecuda::device_ptr<T>::pointer>()( dp.get() ); }
};
} // namespace std
#endif
/// \endcond
#endif
<|endoftext|> |
<commit_before>/*
** Author(s):
** - Cedric GESTES <[email protected]>
** - Laurent LEC <[email protected]>
**
** Copyright (C) 2010, 2011 Aldebararan Robotics
*/
#include <qimessaging/message.h>
#include <qimessaging/datastream.hpp>
#include <qimessaging/message.hpp>
#include <cstring>
#include <cstdlib>
#include <cassert>
typedef struct
{
qi::DataStream *ds;
qi::Message *msg;
} qi_message_data_t;
/// Message
qi_message_t *qi_message_create()
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(malloc(sizeof(qi_message_data_t)));
m->ds = new qi::DataStream();
m->msg = new qi::Message();
return reinterpret_cast<qi_message_t*>(m);
}
void qi_message_destroy(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
delete m->ds;
delete m->msg;
free(m);
}
void qi_message_set_type(qi_message_t *msg, qi_message_type_t type)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
switch (type)
{
case call:
m->msg->setType(qi::Message::Call);
case answer:
m->msg->setType(qi::Message::Answer);
case event:
m->msg->setType(qi::Message::Event);
case error:
m->msg->setType(qi::Message::Error);
case none:
m->msg->setType(qi::Message::None);
default:
assert(false);
}
}
qi_message_type_t qi_message_get_type(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
switch (m->msg->type())
{
case qi::Message::Call:
return call;
case qi::Message::Answer:
return answer;
case qi::Message::Event:
return event;
case qi::Message::Error:
return error;
case qi::Message::None:
return none;
default:
assert(false);
}
}
void qi_message_set_id(qi_message_t *msg, unsigned int id)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setId(id);
}
unsigned int qi_message_get_id(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
return m->msg->id();
}
void qi_message_set_src(qi_message_t *msg, char *src)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setSource(src);
}
char *qi_message_get_src(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->source();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_set_dst(qi_message_t *msg, char *dst)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setDestination(dst);
}
char *qi_message_get_dst(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->destination();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_set_path(qi_message_t *msg, char *path)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setPath(path);
}
char *qi_message_get_path(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->path();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_set_data(qi_message_t *msg, char *data)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setData(data);
}
char *qi_message_get_data(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->data();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_write_bool(qi_message_t *msg, char b)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << b;
}
void qi_message_write_char(qi_message_t *msg, char c)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << c;
}
void qi_message_write_int(qi_message_t *msg, int i)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << i;
}
void qi_message_write_float(qi_message_t *msg, float f)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << f;
}
void qi_message_write_double(qi_message_t *msg, double d)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << d;
}
void qi_message_write_string(qi_message_t *msg, const char *s)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << std::string(s);
}
void qi_message_write_raw(qi_message_t *msg, const char *s, unsigned int size)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << std::string(s, size);
}
char qi_message_read_bool(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
bool b;
*m->ds >> b;
return b;
}
char qi_message_read_char(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
char c;
*m->ds >> c;
return c;
}
int qi_message_read_int(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
int i;
*m->ds >> i;
return i;
}
float qi_message_read_float(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
float f;
*m->ds >> f;
return f;
}
double qi_message_read_double(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
double d;
*m->ds >> d;
return d;
}
char *qi_message_read_string(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string s;
*m->ds >> s;
//TODO: buffer overflow
#ifdef _WIN32
return _strdup(s.c_str());
#else
return strdup(s.c_str());
#endif
}
char *qi_message_read_raw(qi_message_t *msg, unsigned int *size)
{
//TODO set size
return qi_message_read_string(msg);
}
<commit_msg>Always return a qi_message_type_t, even after an asert<commit_after>/*
** Author(s):
** - Cedric GESTES <[email protected]>
** - Laurent LEC <[email protected]>
**
** Copyright (C) 2010, 2011 Aldebararan Robotics
*/
#include <qimessaging/message.h>
#include <qimessaging/datastream.hpp>
#include <qimessaging/message.hpp>
#include <cstring>
#include <cstdlib>
#include <cassert>
typedef struct
{
qi::DataStream *ds;
qi::Message *msg;
} qi_message_data_t;
/// Message
qi_message_t *qi_message_create()
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(malloc(sizeof(qi_message_data_t)));
m->ds = new qi::DataStream();
m->msg = new qi::Message();
return reinterpret_cast<qi_message_t*>(m);
}
void qi_message_destroy(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
delete m->ds;
delete m->msg;
free(m);
}
void qi_message_set_type(qi_message_t *msg, qi_message_type_t type)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
switch (type)
{
case call:
m->msg->setType(qi::Message::Call);
case answer:
m->msg->setType(qi::Message::Answer);
case event:
m->msg->setType(qi::Message::Event);
case error:
m->msg->setType(qi::Message::Error);
case none:
m->msg->setType(qi::Message::None);
default:
assert(false);
}
}
qi_message_type_t qi_message_get_type(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
switch (m->msg->type())
{
case qi::Message::Call:
return call;
case qi::Message::Answer:
return answer;
case qi::Message::Event:
return event;
case qi::Message::Error:
return error;
case qi::Message::None:
return none;
default:
assert(false);
}
return none;
}
void qi_message_set_id(qi_message_t *msg, unsigned int id)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setId(id);
}
unsigned int qi_message_get_id(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
return m->msg->id();
}
void qi_message_set_src(qi_message_t *msg, char *src)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setSource(src);
}
char *qi_message_get_src(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->source();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_set_dst(qi_message_t *msg, char *dst)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setDestination(dst);
}
char *qi_message_get_dst(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->destination();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_set_path(qi_message_t *msg, char *path)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setPath(path);
}
char *qi_message_get_path(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->path();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_set_data(qi_message_t *msg, char *data)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
m->msg->setData(data);
}
char *qi_message_get_data(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string r = m->msg->data();
#ifdef _WIN32
return _strdup(r.c_str());
#else
return strdup(r.c_str());
#endif
}
void qi_message_write_bool(qi_message_t *msg, char b)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << b;
}
void qi_message_write_char(qi_message_t *msg, char c)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << c;
}
void qi_message_write_int(qi_message_t *msg, int i)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << i;
}
void qi_message_write_float(qi_message_t *msg, float f)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << f;
}
void qi_message_write_double(qi_message_t *msg, double d)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << d;
}
void qi_message_write_string(qi_message_t *msg, const char *s)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << std::string(s);
}
void qi_message_write_raw(qi_message_t *msg, const char *s, unsigned int size)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
*m->ds << std::string(s, size);
}
char qi_message_read_bool(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
bool b;
*m->ds >> b;
return b;
}
char qi_message_read_char(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
char c;
*m->ds >> c;
return c;
}
int qi_message_read_int(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
int i;
*m->ds >> i;
return i;
}
float qi_message_read_float(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
float f;
*m->ds >> f;
return f;
}
double qi_message_read_double(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
double d;
*m->ds >> d;
return d;
}
char *qi_message_read_string(qi_message_t *msg)
{
qi_message_data_t *m = reinterpret_cast<qi_message_data_t*>(msg);
std::string s;
*m->ds >> s;
//TODO: buffer overflow
#ifdef _WIN32
return _strdup(s.c_str());
#else
return strdup(s.c_str());
#endif
}
char *qi_message_read_raw(qi_message_t *msg, unsigned int *size)
{
//TODO set size
return qi_message_read_string(msg);
}
<|endoftext|> |
<commit_before>/*
Copyright (C) 2018 Draios inc.
This file is part of falco.
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 <stdio.h>
#include <string.h>
#include "falco_common.h"
#include "webserver.h"
#include "json_evt.h"
using json = nlohmann::json;
using namespace std;
k8s_audit_handler::k8s_audit_handler(falco_engine *engine, falco_outputs *outputs)
: m_engine(engine), m_outputs(outputs)
{
}
k8s_audit_handler::~k8s_audit_handler()
{
}
bool k8s_audit_handler::accept_data(falco_engine *engine,
falco_outputs *outputs,
std::string &data,
std::string &errstr)
{
std::list<json_event> jevts;
json j;
try {
j = json::parse(data);
}
catch (json::parse_error& e)
{
errstr = string("Could not parse data: ") + e.what();
return false;
}
if(!engine->parse_k8s_audit_json(j, jevts))
{
errstr = string("Data not recognized as a k8s audit event");
return false;
}
for(auto &jev : jevts)
{
std::unique_ptr<falco_engine::rule_result> res;
res = engine->process_k8s_audit_event(&jev);
if(res)
{
try {
outputs->handle_event(res->evt, res->rule,
res->source, res->priority_num,
res->format);
}
catch(falco_exception &e)
{
errstr = string("Internal error handling output: ") + e.what();
fprintf(stderr, "%s\n", errstr.c_str());
return false;
}
}
}
return true;
}
bool k8s_audit_handler::accept_uploaded_data(std::string &post_data, std::string &errstr)
{
return k8s_audit_handler::accept_data(m_engine, m_outputs, post_data, errstr);
}
bool k8s_audit_handler::handleGet(CivetServer *server, struct mg_connection *conn)
{
mg_send_http_error(conn, 405, "GET method not allowed");
return true;
}
// The version in CivetServer.cpp has valgrind compliants due to
// unguarded initialization of c++ string from buffer.
static void get_post_data(struct mg_connection *conn, std::string &postdata)
{
mg_lock_connection(conn);
char buf[2048];
int r = mg_read(conn, buf, sizeof(buf));
while (r > 0) {
postdata.append(buf, r);
r = mg_read(conn, buf, sizeof(buf));
}
mg_unlock_connection(conn);
}
bool k8s_audit_handler::handlePost(CivetServer *server, struct mg_connection *conn)
{
// Ensure that the content-type is application/json
const char *ct = server->getHeader(conn, string("Content-Type"));
if(ct == NULL || string(ct) != "application/json")
{
mg_send_http_error(conn, 400, "Wrong Content Type");
return true;
}
std::string post_data;
get_post_data(conn, post_data);
std::string errstr;
if(!accept_uploaded_data(post_data, errstr))
{
errstr = "Bad Request: " + errstr;
mg_send_http_error(conn, 400, "%s", errstr.c_str());
return true;
}
std::string ok_body = "<html><body>Ok</body></html>";
mg_send_http_ok(conn, "text/html", ok_body.size());
mg_printf(conn, "%s", ok_body.c_str());
return true;
}
falco_webserver::falco_webserver()
: m_config(NULL)
{
}
falco_webserver::~falco_webserver()
{
stop();
}
void falco_webserver::init(falco_configuration *config,
falco_engine *engine,
falco_outputs *outputs)
{
m_config = config;
m_engine = engine;
m_outputs = outputs;
}
template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
}
void falco_webserver::start()
{
if(m_server)
{
stop();
}
if(!m_config)
{
throw falco_exception("No config provided to webserver");
}
if(!m_engine)
{
throw falco_exception("No engine provided to webserver");
}
if(!m_outputs)
{
throw falco_exception("No outputs provided to webserver");
}
std::vector<std::string> cpp_options = {
"num_threads", to_string(1)
};
if (m_config->m_webserver_ssl_enabled)
{
cpp_options.push_back("listening_ports");
cpp_options.push_back(to_string(m_config->m_webserver_listen_port) + "s");
cpp_options.push_back("ssl_certificate");
cpp_options.push_back(m_config->m_webserver_ssl_certificate);
} else {
cpp_options.push_back("listening_ports");
cpp_options.push_back(to_string(m_config->m_webserver_listen_port));
}
try {
m_server = make_unique<CivetServer>(cpp_options);
}
catch (CivetException &e)
{
throw falco_exception(std::string("Could not create embedded webserver: ") + e.what());
}
if(!m_server->getContext())
{
throw falco_exception("Could not create embedded webserver");
}
m_k8s_audit_handler = make_unique<k8s_audit_handler>(m_engine, m_outputs);
m_server->addHandler(m_config->m_webserver_k8s_audit_endpoint, *m_k8s_audit_handler);
}
void falco_webserver::stop()
{
if(m_server)
{
m_server = NULL;
m_k8s_audit_handler = NULL;
}
}
<commit_msg>update(userspace): falco webserver must catch json type errors (exceptions)<commit_after>/*
Copyright (C) 2018 Draios inc.
This file is part of falco.
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 <stdio.h>
#include <string.h>
#include "falco_common.h"
#include "webserver.h"
#include "json_evt.h"
using json = nlohmann::json;
using namespace std;
k8s_audit_handler::k8s_audit_handler(falco_engine *engine, falco_outputs *outputs)
: m_engine(engine), m_outputs(outputs)
{
}
k8s_audit_handler::~k8s_audit_handler()
{
}
bool k8s_audit_handler::accept_data(falco_engine *engine,
falco_outputs *outputs,
std::string &data,
std::string &errstr)
{
std::list<json_event> jevts;
json j;
try {
j = json::parse(data);
}
catch (json::parse_error& e)
{
errstr = string("Could not parse data: ") + e.what();
return false;
}
bool ok;
try
{
ok = engine->parse_k8s_audit_json(j, jevts);
}
catch(json::type_error &e)
{
ok = false;
}
if(!ok)
{
errstr = string("Data not recognized as a k8s audit event");
return false;
}
for(auto &jev : jevts)
{
std::unique_ptr<falco_engine::rule_result> res;
res = engine->process_k8s_audit_event(&jev);
if(res)
{
try {
outputs->handle_event(res->evt, res->rule,
res->source, res->priority_num,
res->format);
}
catch(falco_exception &e)
{
errstr = string("Internal error handling output: ") + e.what();
fprintf(stderr, "%s\n", errstr.c_str());
return false;
}
}
}
return true;
}
bool k8s_audit_handler::accept_uploaded_data(std::string &post_data, std::string &errstr)
{
return k8s_audit_handler::accept_data(m_engine, m_outputs, post_data, errstr);
}
bool k8s_audit_handler::handleGet(CivetServer *server, struct mg_connection *conn)
{
mg_send_http_error(conn, 405, "GET method not allowed");
return true;
}
// The version in CivetServer.cpp has valgrind compliants due to
// unguarded initialization of c++ string from buffer.
static void get_post_data(struct mg_connection *conn, std::string &postdata)
{
mg_lock_connection(conn);
char buf[2048];
int r = mg_read(conn, buf, sizeof(buf));
while (r > 0) {
postdata.append(buf, r);
r = mg_read(conn, buf, sizeof(buf));
}
mg_unlock_connection(conn);
}
bool k8s_audit_handler::handlePost(CivetServer *server, struct mg_connection *conn)
{
// Ensure that the content-type is application/json
const char *ct = server->getHeader(conn, string("Content-Type"));
if(ct == NULL || string(ct) != "application/json")
{
mg_send_http_error(conn, 400, "Wrong Content Type");
return true;
}
std::string post_data;
get_post_data(conn, post_data);
std::string errstr;
if(!accept_uploaded_data(post_data, errstr))
{
errstr = "Bad Request: " + errstr;
mg_send_http_error(conn, 400, "%s", errstr.c_str());
return true;
}
std::string ok_body = "<html><body>Ok</body></html>";
mg_send_http_ok(conn, "text/html", ok_body.size());
mg_printf(conn, "%s", ok_body.c_str());
return true;
}
falco_webserver::falco_webserver()
: m_config(NULL)
{
}
falco_webserver::~falco_webserver()
{
stop();
}
void falco_webserver::init(falco_configuration *config,
falco_engine *engine,
falco_outputs *outputs)
{
m_config = config;
m_engine = engine;
m_outputs = outputs;
}
template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
}
void falco_webserver::start()
{
if(m_server)
{
stop();
}
if(!m_config)
{
throw falco_exception("No config provided to webserver");
}
if(!m_engine)
{
throw falco_exception("No engine provided to webserver");
}
if(!m_outputs)
{
throw falco_exception("No outputs provided to webserver");
}
std::vector<std::string> cpp_options = {
"num_threads", to_string(1)
};
if (m_config->m_webserver_ssl_enabled)
{
cpp_options.push_back("listening_ports");
cpp_options.push_back(to_string(m_config->m_webserver_listen_port) + "s");
cpp_options.push_back("ssl_certificate");
cpp_options.push_back(m_config->m_webserver_ssl_certificate);
} else {
cpp_options.push_back("listening_ports");
cpp_options.push_back(to_string(m_config->m_webserver_listen_port));
}
try {
m_server = make_unique<CivetServer>(cpp_options);
}
catch (CivetException &e)
{
throw falco_exception(std::string("Could not create embedded webserver: ") + e.what());
}
if(!m_server->getContext())
{
throw falco_exception("Could not create embedded webserver");
}
m_k8s_audit_handler = make_unique<k8s_audit_handler>(m_engine, m_outputs);
m_server->addHandler(m_config->m_webserver_k8s_audit_endpoint, *m_k8s_audit_handler);
}
void falco_webserver::stop()
{
if(m_server)
{
m_server = NULL;
m_k8s_audit_handler = NULL;
}
}
<|endoftext|> |
<commit_before>// vim:ts=2:sw=2:expandtab:autoindent:filetype=cpp:
/*
The MIT License
Copyright (c) 2008, 2009 Aristid Breitkreuz, Ash Berlin, Ruediger Sonderfeld
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 FLUSSPFERD_ARRAY_HPP
#define FLUSSPFERD_ARRAY_HPP
#include "object.hpp"
#include <boost/utility/in_place_factory.hpp>
namespace flusspferd {
/**
* A class for holding a Javascript Array.
*
* @see flusspferd::create_array()
*
* @ingroup value_types
* @ingroup property_types
*/
class array : public object {
public:
/// Construct an #array from a Javascript Array object.
array(object const &o);
/// Assign a Javascript Array object to an #array object.
array &operator=(object const &o);
public:
/// Get the length of the Array.
std::size_t length() const;
/// Set the length of the array, resizing it in the process.
void set_length(std::size_t);
/// Get the length of the Array.
std::size_t size() const { return length(); }
/// Get an array element.
value get_element(std::size_t n) const;
/// Set an array element.
void set_element(std::size_t n, value const &x);
private:
void check();
};
template<>
struct detail::convert<array> {
typedef to_value_helper<array> to_value;
struct from_value {
boost::optional<root_array> root;
array perform(value const &v) {
root = boost::in_place(array(v.to_object()));
return root.get();
}
};
};
}
#endif
<commit_msg>started implementing an array iterator<commit_after>// vim:ts=2:sw=2:expandtab:autoindent:filetype=cpp:
/*
The MIT License
Copyright (c) 2008, 2009 Aristid Breitkreuz, Ash Berlin, Ruediger Sonderfeld
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 FLUSSPFERD_ARRAY_HPP
#define FLUSSPFERD_ARRAY_HPP
#include "object.hpp"
#include <boost/utility/in_place_factory.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <cassert>
namespace flusspferd {
/**
* A class for holding a Javascript Array.
*
* @see flusspferd::create_array()
*
* @ingroup value_types
* @ingroup property_types
*/
class array : public object {
public:
/// Construct an #array from a Javascript Array object.
array(object const &o);
/// Assign a Javascript Array object to an #array object.
array &operator=(object const &o);
public:
/// Get the length of the Array.
std::size_t length() const;
/// Set the length of the array, resizing it in the process.
void set_length(std::size_t);
/// Get the length of the Array.
std::size_t size() const { return length(); }
/// Get an array element.
value get_element(std::size_t n) const;
/// Set an array element.
void set_element(std::size_t n, value const &x);
class iterator
: public boost::iterator_facade<
iterator, value, boost::random_access_traversal_tag, value
>
{
typedef boost::iterator_facade<
iterator, value, boost::random_access_traversal_tag, value
> parent_t;
array const *a;
std::size_t pos;
public:
explicit
iterator(array const &a, std::size_t pos = 0) : a(&a), pos(pos) { }
iterator(iterator const &i) : a(i.a), pos(i.pos) { }
iterator &operator=(iterator const &o) {
a = o.a;
pos = o.pos;
return *this;
}
private:
friend class boost::iterator_core_access;
void increment() {
assert(a);
++pos;
assert(pos <= a->size());
}
void decrement() {
assert(a && pos > 0);
--pos;
}
void advance(std::size_t n) {
assert(a);
pos += n;
assert(pos <= a->size());
}
bool equal(iterator const &i) const {
assert(a && i.a);
return a == i.a && pos == i.pos;
}
parent_t::reference dereference() const {
assert(a && pos < a->size());
return a->get_element(pos);
}
parent_t::difference_type distance_to(iterator const &i) const {
assert(a && a == i.a);
typedef parent_t::difference_type diff_t;
return static_cast<diff_t>(pos) - static_cast<diff_t>(i.pos);
}
};
iterator begin() const { return iterator(*this); }
iterator end() const { return iterator(*this, size()); }
private:
void check();
};
template<>
struct detail::convert<array> {
typedef to_value_helper<array> to_value;
struct from_value {
boost::optional<root_array> root;
array perform(value const &v) {
root = boost::in_place(array(v.to_object()));
return root.get();
}
};
};
}
#endif
<|endoftext|> |
<commit_before>#ifndef KGR_INCLUDE_KANGARU_OPERATOR_HPP
#define KGR_INCLUDE_KANGARU_OPERATOR_HPP
#include "container.hpp"
#include "detail/lazy_base.hpp"
namespace kgr {
namespace detail {
template<typename CRTP, template<typename> class Map>
struct InvokerBase {
template<typename F, typename... Args>
detail::function_result_t<typename std::decay<F>::type> operator()(F&& f, Args&&... args) {
return static_cast<CRTP*>(this)->_container.template invoke<Map>(std::forward<F>(f), std::forward<Args>(args)...);
}
};
template<typename CRTP, typename T>
struct GeneratorBase {
static_assert(!std::is_base_of<Single, T>::value, "Generator only work with non-single services.");
template<typename... Args>
ServiceType<T> operator()(Args&& ...args) {
return static_cast<CRTP*>(this)->_container.template service<T>(std::forward<Args>(args)...);
}
};
} // namespace detail
template<template<typename> class Map>
struct Invoker : detail::InvokerBase<Invoker<Map>, Map> {
explicit Invoker(Container& container) : _container{container} {}
private:
friend struct detail::InvokerBase<Invoker<Map>, Map>;
kgr::Container& _container;
};
template<template<typename> class Map>
struct ForkedInvoker : detail::InvokerBase<ForkedInvoker<Map>, Map> {
explicit ForkedInvoker(Container container) : _container{std::move(container)} {}
private:
friend struct detail::InvokerBase<ForkedInvoker<Map>, Map>;
kgr::Container _container;
};
template<typename T>
struct Generator : detail::GeneratorBase<Generator<T>, T> {
explicit Generator(Container& container) : _container{container} {}
private:
friend struct detail::GeneratorBase<Generator<T>, T>;
kgr::Container& _container;
};
template<typename T>
struct ForkedGenerator : detail::GeneratorBase<ForkedGenerator<T>, T> {
explicit ForkedGenerator(Container container) : _container{std::move(container)} {}
private:
friend struct detail::GeneratorBase<ForkedGenerator<T>, T>;
kgr::Container _container;
};
template<typename T>
struct Lazy : detail::LazyBase<Lazy<T>, T> {
explicit Lazy(kgr::Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::LazyBase<Lazy<T>, T>;
kgr::Container* _container;
};
template<typename T>
struct ForkedLazy : detail::LazyBase<ForkedLazy<T>, T> {
explicit ForkedLazy(kgr::Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::LazyBase<ForkedLazy<T>, T>;
kgr::Container _container;
};
} // namespace kgr
#endif // KGR_INCLUDE_KANGARU_OPERATOR_HPP
<commit_msg>added sfinae on invoker<commit_after>#ifndef KGR_INCLUDE_KANGARU_OPERATOR_HPP
#define KGR_INCLUDE_KANGARU_OPERATOR_HPP
#include "container.hpp"
#include "detail/lazy_base.hpp"
namespace kgr {
namespace detail {
template<typename CRTP, template<typename> class Map>
struct InvokerBase {
template<typename F, typename... Args>
auto operator()(F&& f, Args&&... args) -> decltype(std::declval<Container>().invoke<Map>(std::declval<F>(), std::declval<Args>()...)) {
return static_cast<CRTP*>(this)->_container.template invoke<Map>(std::forward<F>(f), std::forward<Args>(args)...);
}
};
template<typename CRTP, typename T>
struct GeneratorBase {
static_assert(!std::is_base_of<Single, T>::value, "Generator only work with non-single services.");
template<typename... Args>
ServiceType<T> operator()(Args&& ...args) {
return static_cast<CRTP*>(this)->_container.template service<T>(std::forward<Args>(args)...);
}
};
} // namespace detail
template<template<typename> class Map>
struct Invoker : detail::InvokerBase<Invoker<Map>, Map> {
explicit Invoker(Container& container) : _container{container} {}
private:
friend struct detail::InvokerBase<Invoker<Map>, Map>;
kgr::Container& _container;
};
template<template<typename> class Map>
struct ForkedInvoker : detail::InvokerBase<ForkedInvoker<Map>, Map> {
explicit ForkedInvoker(Container container) : _container{std::move(container)} {}
private:
friend struct detail::InvokerBase<ForkedInvoker<Map>, Map>;
kgr::Container _container;
};
template<typename T>
struct Generator : detail::GeneratorBase<Generator<T>, T> {
explicit Generator(Container& container) : _container{container} {}
private:
friend struct detail::GeneratorBase<Generator<T>, T>;
kgr::Container& _container;
};
template<typename T>
struct ForkedGenerator : detail::GeneratorBase<ForkedGenerator<T>, T> {
explicit ForkedGenerator(Container container) : _container{std::move(container)} {}
private:
friend struct detail::GeneratorBase<ForkedGenerator<T>, T>;
kgr::Container _container;
};
template<typename T>
struct Lazy : detail::LazyBase<Lazy<T>, T> {
explicit Lazy(kgr::Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::LazyBase<Lazy<T>, T>;
kgr::Container* _container;
};
template<typename T>
struct ForkedLazy : detail::LazyBase<ForkedLazy<T>, T> {
explicit ForkedLazy(kgr::Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::LazyBase<ForkedLazy<T>, T>;
kgr::Container _container;
};
} // namespace kgr
#endif // KGR_INCLUDE_KANGARU_OPERATOR_HPP
<|endoftext|> |
<commit_before>#ifndef KGR_KANGARU_INCLUDE_KANGARU_OPERATOR_HPP
#define KGR_KANGARU_INCLUDE_KANGARU_OPERATOR_HPP
#include "container.hpp"
#include "detail/lazy_base.hpp"
namespace kgr {
namespace detail {
template<typename CRTP, template<typename> class Map>
struct InvokerBase {
template<typename F, typename... Args, enable_if_t<is_invoke_valid<Map, decay_t<F>, Args...>::value, int> = 0>
function_result_t<typename std::decay<F>::type> operator()(F&& f, Args&&... args) {
return static_cast<CRTP*>(this)->container().template invoke<Map>(std::forward<F>(f), std::forward<Args>(args)...);
}
Sink operator()(detail::NotInvokableError = {}, ...) = delete;
};
template<typename CRTP, typename T>
struct GeneratorBase {
static_assert(!is_single<T>::value, "Generator only work with non-single services.");
template<typename... Args, enable_if_t<is_service_valid<T, Args...>::value, int> = 0>
ServiceType<T> operator()(Args&& ...args) {
return static_cast<CRTP*>(this)->container().template service<T>(std::forward<Args>(args)...);
}
template<typename U = T, enable_if_t<std::is_default_constructible<ServiceError<U>>::value, int> = 0>
Sink operator()(ServiceError<U> = {}) = delete;
template<typename... Args>
Sink operator()(ServiceError<T, identity_t<Args>...>, Args&&...) = delete;
};
} // namespace detail
template<template<typename> class Map>
struct Invoker : detail::InvokerBase<Invoker<Map>, Map> {
explicit Invoker(Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::InvokerBase<Invoker<Map>, Map>;
kgr::Container* _container;
};
using DefaultInvoker = Invoker<kgr::AdlMap>;
template<template<typename> class Map>
struct ForkedInvoker : detail::InvokerBase<ForkedInvoker<Map>, Map> {
explicit ForkedInvoker(Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::InvokerBase<ForkedInvoker<Map>, Map>;
kgr::Container _container;
};
using DefaultForkedInvoker = ForkedInvoker<kgr::AdlMap>;
template<typename T>
struct Generator : detail::GeneratorBase<Generator<T>, T> {
explicit Generator(Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::GeneratorBase<Generator<T>, T>;
kgr::Container* _container;
};
template<typename T>
struct ForkedGenerator : detail::GeneratorBase<ForkedGenerator<T>, T> {
explicit ForkedGenerator(Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::GeneratorBase<ForkedGenerator<T>, T>;
kgr::Container _container;
};
template<typename T>
struct Lazy : detail::LazyBase<Lazy<T>, T> {
explicit Lazy(kgr::Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::LazyBase<Lazy<T>, T>;
kgr::Container* _container;
};
template<typename T>
struct ForkedLazy : detail::LazyBase<ForkedLazy<T>, T> {
explicit ForkedLazy(kgr::Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::LazyBase<ForkedLazy<T>, T>;
kgr::Container _container;
};
} // namespace kgr
#endif // KGR_KANGARU_INCLUDE_KANGARU_OPERATOR_HPP
<commit_msg>Using alias for std::decay<commit_after>#ifndef KGR_KANGARU_INCLUDE_KANGARU_OPERATOR_HPP
#define KGR_KANGARU_INCLUDE_KANGARU_OPERATOR_HPP
#include "container.hpp"
#include "detail/lazy_base.hpp"
namespace kgr {
namespace detail {
template<typename CRTP, template<typename> class Map>
struct InvokerBase {
template<typename F, typename... Args, enable_if_t<is_invoke_valid<Map, decay_t<F>, Args...>::value, int> = 0>
function_result_t<decay_t<F>> operator()(F&& f, Args&&... args) {
return static_cast<CRTP*>(this)->container().template invoke<Map>(std::forward<F>(f), std::forward<Args>(args)...);
}
Sink operator()(detail::NotInvokableError = {}, ...) = delete;
};
template<typename CRTP, typename T>
struct GeneratorBase {
static_assert(!is_single<T>::value, "Generator only work with non-single services.");
template<typename... Args, enable_if_t<is_service_valid<T, Args...>::value, int> = 0>
ServiceType<T> operator()(Args&& ...args) {
return static_cast<CRTP*>(this)->container().template service<T>(std::forward<Args>(args)...);
}
template<typename U = T, enable_if_t<std::is_default_constructible<ServiceError<U>>::value, int> = 0>
Sink operator()(ServiceError<U> = {}) = delete;
template<typename... Args>
Sink operator()(ServiceError<T, identity_t<Args>...>, Args&&...) = delete;
};
} // namespace detail
template<template<typename> class Map>
struct Invoker : detail::InvokerBase<Invoker<Map>, Map> {
explicit Invoker(Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::InvokerBase<Invoker<Map>, Map>;
kgr::Container* _container;
};
using DefaultInvoker = Invoker<kgr::AdlMap>;
template<template<typename> class Map>
struct ForkedInvoker : detail::InvokerBase<ForkedInvoker<Map>, Map> {
explicit ForkedInvoker(Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::InvokerBase<ForkedInvoker<Map>, Map>;
kgr::Container _container;
};
using DefaultForkedInvoker = ForkedInvoker<kgr::AdlMap>;
template<typename T>
struct Generator : detail::GeneratorBase<Generator<T>, T> {
explicit Generator(Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::GeneratorBase<Generator<T>, T>;
kgr::Container* _container;
};
template<typename T>
struct ForkedGenerator : detail::GeneratorBase<ForkedGenerator<T>, T> {
explicit ForkedGenerator(Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::GeneratorBase<ForkedGenerator<T>, T>;
kgr::Container _container;
};
template<typename T>
struct Lazy : detail::LazyBase<Lazy<T>, T> {
explicit Lazy(kgr::Container& container) : _container{&container} {}
private:
kgr::Container& container() {
return *_container;
}
const kgr::Container& container() const {
return *_container;
}
friend struct detail::LazyBase<Lazy<T>, T>;
kgr::Container* _container;
};
template<typename T>
struct ForkedLazy : detail::LazyBase<ForkedLazy<T>, T> {
explicit ForkedLazy(kgr::Container container) : _container{std::move(container)} {}
private:
kgr::Container& container() {
return _container;
}
const kgr::Container& container() const {
return _container;
}
friend struct detail::LazyBase<ForkedLazy<T>, T>;
kgr::Container _container;
};
} // namespace kgr
#endif // KGR_KANGARU_INCLUDE_KANGARU_OPERATOR_HPP
<|endoftext|> |
<commit_before>/*
Copyright (c) 2003, Arvid Norberg, Daniel Wallin
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.
*/
#ifndef TORRENT_ALERT_HPP_INCLUDED
#define TORRENT_ALERT_HPP_INCLUDED
#include <memory>
#include <queue>
#include <string>
#include <typeinfo>
#ifdef _MSC_VER
#pragma warning(push, 1)
#endif
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include "libtorrent/time.hpp"
#include "libtorrent/config.hpp"
#include "libtorrent/assert.hpp"
#ifndef TORRENT_MAX_ALERT_TYPES
#define TORRENT_MAX_ALERT_TYPES 15
#endif
namespace libtorrent {
class TORRENT_EXPORT alert
{
public:
// only here for backwards compatibility
enum severity_t { debug, info, warning, critical, fatal, none };
enum category_t
{
error_notification = 0x1,
peer_notification = 0x2,
port_mapping_notification = 0x4,
storage_notification = 0x8,
tracker_notification = 0x10,
debug_notification = 0x20,
status_notification = 0x40,
progress_notification = 0x80,
ip_block_notification = 0x100,
all_categories = 0xffffffff
};
alert();
virtual ~alert();
// a timestamp is automatically created in the constructor
ptime timestamp() const;
virtual char const* what() const = 0;
virtual std::string message() const = 0;
virtual int category() const = 0;
severity_t severity() const TORRENT_DEPRECATED { return warning; }
virtual std::auto_ptr<alert> clone() const = 0;
private:
ptime m_timestamp;
};
class TORRENT_EXPORT alert_manager
{
public:
alert_manager();
~alert_manager();
void post_alert(const alert& alert_);
bool pending() const;
std::auto_ptr<alert> get();
template <class T>
bool should_post() const { return m_alert_mask & T::static_category; }
alert const* wait_for_alert(time_duration max_wait);
void set_alert_mask(int m) { m_alert_mask = m; }
private:
std::queue<alert*> m_alerts;
mutable boost::mutex m_mutex;
boost::condition m_condition;
int m_alert_mask;
};
struct TORRENT_EXPORT unhandled_alert : std::exception
{
unhandled_alert() {}
};
namespace detail {
struct void_;
template<class Handler
, BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, class T)>
void handle_alert_dispatch(
const std::auto_ptr<alert>& alert_, const Handler& handler
, const std::type_info& typeid_
, BOOST_PP_ENUM_BINARY_PARAMS(TORRENT_MAX_ALERT_TYPES, T, *p))
{
if (typeid_ == typeid(T0))
handler(*static_cast<T0*>(alert_.get()));
else
handle_alert_dispatch(alert_, handler, typeid_
, BOOST_PP_ENUM_SHIFTED_PARAMS(
TORRENT_MAX_ALERT_TYPES, p), (void_*)0);
}
template<class Handler>
void handle_alert_dispatch(
const std::auto_ptr<alert>& alert_
, const Handler& handler
, const std::type_info& typeid_
, BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, void_* BOOST_PP_INTERCEPT))
{
throw unhandled_alert();
}
} // namespace detail
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
TORRENT_MAX_ALERT_TYPES, class T, detail::void_)>
struct TORRENT_EXPORT handle_alert
{
template<class Handler>
handle_alert(const std::auto_ptr<alert>& alert_
, const Handler& handler)
{
#define ALERT_POINTER_TYPE(z, n, text) (BOOST_PP_CAT(T, n)*)0
detail::handle_alert_dispatch(alert_, handler, typeid(*alert_)
, BOOST_PP_ENUM(TORRENT_MAX_ALERT_TYPES, ALERT_POINTER_TYPE, _));
#undef ALERT_POINTER_TYPE
}
};
} // namespace libtorrent
#endif // TORRENT_ALERT_HPP_INCLUDED
<commit_msg>fixed msvc warning<commit_after>/*
Copyright (c) 2003, Arvid Norberg, Daniel Wallin
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.
*/
#ifndef TORRENT_ALERT_HPP_INCLUDED
#define TORRENT_ALERT_HPP_INCLUDED
#include <memory>
#include <queue>
#include <string>
#include <typeinfo>
#ifdef _MSC_VER
#pragma warning(push, 1)
#endif
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include "libtorrent/time.hpp"
#include "libtorrent/config.hpp"
#include "libtorrent/assert.hpp"
#ifndef TORRENT_MAX_ALERT_TYPES
#define TORRENT_MAX_ALERT_TYPES 15
#endif
namespace libtorrent {
class TORRENT_EXPORT alert
{
public:
// only here for backwards compatibility
enum severity_t { debug, info, warning, critical, fatal, none };
enum category_t
{
error_notification = 0x1,
peer_notification = 0x2,
port_mapping_notification = 0x4,
storage_notification = 0x8,
tracker_notification = 0x10,
debug_notification = 0x20,
status_notification = 0x40,
progress_notification = 0x80,
ip_block_notification = 0x100,
all_categories = 0xffffffff
};
alert();
virtual ~alert();
// a timestamp is automatically created in the constructor
ptime timestamp() const;
virtual char const* what() const = 0;
virtual std::string message() const = 0;
virtual int category() const = 0;
severity_t severity() const TORRENT_DEPRECATED { return warning; }
virtual std::auto_ptr<alert> clone() const = 0;
private:
ptime m_timestamp;
};
class TORRENT_EXPORT alert_manager
{
public:
alert_manager();
~alert_manager();
void post_alert(const alert& alert_);
bool pending() const;
std::auto_ptr<alert> get();
template <class T>
bool should_post() const { return (m_alert_mask & T::static_category) != 0; }
alert const* wait_for_alert(time_duration max_wait);
void set_alert_mask(int m) { m_alert_mask = m; }
private:
std::queue<alert*> m_alerts;
mutable boost::mutex m_mutex;
boost::condition m_condition;
int m_alert_mask;
};
struct TORRENT_EXPORT unhandled_alert : std::exception
{
unhandled_alert() {}
};
namespace detail {
struct void_;
template<class Handler
, BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, class T)>
void handle_alert_dispatch(
const std::auto_ptr<alert>& alert_, const Handler& handler
, const std::type_info& typeid_
, BOOST_PP_ENUM_BINARY_PARAMS(TORRENT_MAX_ALERT_TYPES, T, *p))
{
if (typeid_ == typeid(T0))
handler(*static_cast<T0*>(alert_.get()));
else
handle_alert_dispatch(alert_, handler, typeid_
, BOOST_PP_ENUM_SHIFTED_PARAMS(
TORRENT_MAX_ALERT_TYPES, p), (void_*)0);
}
template<class Handler>
void handle_alert_dispatch(
const std::auto_ptr<alert>& alert_
, const Handler& handler
, const std::type_info& typeid_
, BOOST_PP_ENUM_PARAMS(TORRENT_MAX_ALERT_TYPES, void_* BOOST_PP_INTERCEPT))
{
throw unhandled_alert();
}
} // namespace detail
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
TORRENT_MAX_ALERT_TYPES, class T, detail::void_)>
struct TORRENT_EXPORT handle_alert
{
template<class Handler>
handle_alert(const std::auto_ptr<alert>& alert_
, const Handler& handler)
{
#define ALERT_POINTER_TYPE(z, n, text) (BOOST_PP_CAT(T, n)*)0
detail::handle_alert_dispatch(alert_, handler, typeid(*alert_)
, BOOST_PP_ENUM(TORRENT_MAX_ALERT_TYPES, ALERT_POINTER_TYPE, _));
#undef ALERT_POINTER_TYPE
}
};
} // namespace libtorrent
#endif // TORRENT_ALERT_HPP_INCLUDED
<|endoftext|> |
<commit_before>// $Id$
// The libMesh Finite Element Library.
// Copyright (C) 2002-2008 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include "libmesh_common.h"
#ifdef LIBMESH_HAVE_PETSC
// C++ includes
// Local Includes
#include "nonlinear_implicit_system.h"
#include "petsc_nonlinear_solver.h"
#include "petsc_linear_solver.h"
#include "petsc_vector.h"
#include "petsc_matrix.h"
#include "system.h"
#include "dof_map.h"
#include "preconditioner.h"
//--------------------------------------------------------------------
// Functions with C linkage to pass to PETSc. PETSc will call these
// methods as needed.
//
// Since they must have C linkage they have no knowledge of a namespace.
// Give them an obscure name to avoid namespace pollution.
extern "C"
{
// Older versions of PETSc do not have the different int typedefs.
// On 64-bit machines, PetscInt may actually be a long long int.
// This change occurred in Petsc-2.2.1.
#if PETSC_VERSION_LESS_THAN(2,2,1)
typedef int PetscErrorCode;
typedef int PetscInt;
#endif
//-------------------------------------------------------------------
// this function is called by PETSc at the end of each nonlinear step
PetscErrorCode
__libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
{
//int ierr=0;
//if (its > 0)
std::cout << " NL step " << its
<< std::scientific
<< ", |residual|_2 = " << fnorm
<< std::endl;
//return ierr;
return 0;
}
//---------------------------------------------------------------
// this function is called by PETSc to evaluate the residual at X
PetscErrorCode
__libmesh_petsc_snes_residual (SNES, Vec x, Vec r, void *ctx)
{
int ierr=0;
libmesh_assert (x != NULL);
libmesh_assert (r != NULL);
libmesh_assert (ctx != NULL);
PetscNonlinearSolver<Number>* solver =
static_cast<PetscNonlinearSolver<Number>*> (ctx);
NonlinearImplicitSystem &sys = solver->system();
PetscVector<Number> X_global(x), R(r);
PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
PetscVector<Number>& R_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.rhs);
// Use the systems update() to get a good local version of the parallel solution
X_global.swap(X_sys);
R.swap(R_sys);
sys.get_dof_map().enforce_constraints_exactly(sys);
sys.update();
//Swap back
X_global.swap(X_sys);
R.swap(R_sys);
R.zero();
if (solver->residual != NULL) solver->residual (*sys.current_local_solution.get(), R);
else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), &R, NULL);
else libmesh_error();
R.close();
X_global.close();
return ierr;
}
//---------------------------------------------------------------
// this function is called by PETSc to evaluate the Jacobian at X
PetscErrorCode
__libmesh_petsc_snes_jacobian (SNES, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
{
int ierr=0;
libmesh_assert (ctx != NULL);
PetscNonlinearSolver<Number>* solver =
static_cast<PetscNonlinearSolver<Number>*> (ctx);
NonlinearImplicitSystem &sys = solver->system();
PetscMatrix<Number> PC(*pc);
PetscMatrix<Number> Jac(*jac);
PetscVector<Number> X_global(x);
PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
PetscMatrix<Number>& Jac_sys = *libmesh_cast_ptr<PetscMatrix<Number>*>(sys.matrix);
// Use the systems update() to get a good local version of the parallel solution
X_global.swap(X_sys);
Jac.swap(Jac_sys);
sys.get_dof_map().enforce_constraints_exactly(sys);
sys.update();
X_global.swap(X_sys);
Jac.swap(Jac_sys);
PC.zero();
if (solver->jacobian != NULL) solver->jacobian (*sys.current_local_solution.get(), PC);
else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), NULL, &PC);
else libmesh_error();
PC.close();
Jac.close();
X_global.close();
*msflag = SAME_NONZERO_PATTERN;
return ierr;
}
} // end extern "C"
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// PetscNonlinearSolver<> methods
template <typename T>
void PetscNonlinearSolver<T>::clear ()
{
if (this->initialized())
{
this->_is_initialized = false;
int ierr=0;
ierr = SNESDestroy(_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
}
}
template <typename T>
void PetscNonlinearSolver<T>::init ()
{
// Initialize the data structures if not done so already.
if (!this->initialized())
{
this->_is_initialized = true;
int ierr=0;
#if PETSC_VERSION_LESS_THAN(2,1,2)
// At least until Petsc 2.1.1, the SNESCreate had a different calling syntax.
// The second argument was of type SNESProblemType, and could have a value of
// either SNES_NONLINEAR_EQUATIONS or SNES_UNCONSTRAINED_MINIMIZATION.
ierr = SNESCreate(libMesh::COMM_WORLD, SNES_NONLINEAR_EQUATIONS, &_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
#else
ierr = SNESCreate(libMesh::COMM_WORLD,&_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
#endif
#if PETSC_VERSION_LESS_THAN(2,3,3)
ierr = SNESSetMonitor (_snes, __libmesh_petsc_snes_monitor,
this, PETSC_NULL);
#else
// API name change in PETSc 2.3.3
ierr = SNESMonitorSet (_snes, __libmesh_petsc_snes_monitor,
this, PETSC_NULL);
#endif
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESSetFromOptions(_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
if(this->_preconditioner)
{
KSP ksp;
ierr = SNESGetKSP (_snes, &ksp);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
PC pc;
ierr = KSPGetPC(ksp,&pc);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
PCSetType(pc, PCSHELL);
PCShellSetContext(pc,(void*)this->_preconditioner);
//Re-Use the shell functions from petsc_linear_solver
PCShellSetSetUp(pc,__libmesh_petsc_preconditioner_setup);
PCShellSetApply(pc,__libmesh_petsc_preconditioner_apply);
}
}
}
template <typename T>
std::pair<unsigned int, Real>
PetscNonlinearSolver<T>::solve (SparseMatrix<T>& jac_in, // System Jacobian Matrix
NumericVector<T>& x_in, // Solution vector
NumericVector<T>& r_in, // Residual vector
const double, // Stopping tolerance
const unsigned int)
{
this->init ();
// Make sure the data passed in are really of Petsc types
PetscMatrix<T>* jac = libmesh_cast_ptr<PetscMatrix<T>*>(&jac_in);
PetscVector<T>* x = libmesh_cast_ptr<PetscVector<T>*>(&x_in);
PetscVector<T>* r = libmesh_cast_ptr<PetscVector<T>*>(&r_in);
int ierr=0;
int n_iterations =0;
ierr = SNESSetFunction (_snes, r->vec(), __libmesh_petsc_snes_residual, this);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESSetJacobian (_snes, jac->mat(), jac->mat(), __libmesh_petsc_snes_jacobian, this);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Have the Krylov subspace method use our good initial guess rather than 0
KSP ksp;
ierr = SNESGetKSP (_snes, &ksp);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Set the tolerances for the iterative solver. Use the user-supplied
// tolerance for the relative residual & leave the others at default values
ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
PETSC_DEFAULT, this->max_linear_iterations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Set the tolerances for the non-linear solver.
ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
this->absolute_step_tolerance, this->max_nonlinear_iterations, this->max_function_evaluations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
//Pull in command-line options
KSPSetFromOptions(ksp);
SNESSetFromOptions(_snes);
//Set the preconditioning matrix
if(this->_preconditioner)
this->_preconditioner->set_matrix(jac_in);
// ierr = KSPSetInitialGuessNonzero (ksp, PETSC_TRUE);
// CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Older versions (at least up to 2.1.5) of SNESSolve took 3 arguments,
// the last one being a pointer to an int to hold the number of iterations required.
# if PETSC_VERSION_LESS_THAN(2,2,0)
ierr = SNESSolve (_snes, x->vec(), &n_iterations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// 2.2.x style
#elif PETSC_VERSION_LESS_THAN(2,3,0)
ierr = SNESSolve (_snes, x->vec());
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// 2.3.x & newer style
#else
ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
CHKERRABORT(libMesh::COMM_WORLD,ierr);
#endif
SNESConvergedReason reason;
SNESGetConvergedReason(_snes,&reason);
//Based on Petsc 2.3.3 documentation all diverged reasons are negative
this->converged = reason >= 0;
this->clear();
// return the # of its. and the final residual norm. Note that
// n_iterations may be zero for PETSc versions 2.2.x and greater.
return std::make_pair(n_iterations, 0.);
}
//------------------------------------------------------------------
// Explicit instantiations
template class PetscNonlinearSolver<Number>;
#endif // #ifdef LIBMESH_HAVE_PETSC
<commit_msg>print nonlinear iteration count as a fixed width for aesthetics<commit_after>// $Id$
// The libMesh Finite Element Library.
// Copyright (C) 2002-2008 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include "libmesh_common.h"
#ifdef LIBMESH_HAVE_PETSC
// C++ includes
// Local Includes
#include "nonlinear_implicit_system.h"
#include "petsc_nonlinear_solver.h"
#include "petsc_linear_solver.h"
#include "petsc_vector.h"
#include "petsc_matrix.h"
#include "system.h"
#include "dof_map.h"
#include "preconditioner.h"
//--------------------------------------------------------------------
// Functions with C linkage to pass to PETSc. PETSc will call these
// methods as needed.
//
// Since they must have C linkage they have no knowledge of a namespace.
// Give them an obscure name to avoid namespace pollution.
extern "C"
{
// Older versions of PETSc do not have the different int typedefs.
// On 64-bit machines, PetscInt may actually be a long long int.
// This change occurred in Petsc-2.2.1.
#if PETSC_VERSION_LESS_THAN(2,2,1)
typedef int PetscErrorCode;
typedef int PetscInt;
#endif
//-------------------------------------------------------------------
// this function is called by PETSc at the end of each nonlinear step
PetscErrorCode
__libmesh_petsc_snes_monitor (SNES, PetscInt its, PetscReal fnorm, void *)
{
//int ierr=0;
//if (its > 0)
std::cout << " NL step "
<< std::setw(2) << its
<< std::scientific
<< ", |residual|_2 = " << fnorm
<< std::endl;
//return ierr;
return 0;
}
//---------------------------------------------------------------
// this function is called by PETSc to evaluate the residual at X
PetscErrorCode
__libmesh_petsc_snes_residual (SNES, Vec x, Vec r, void *ctx)
{
int ierr=0;
libmesh_assert (x != NULL);
libmesh_assert (r != NULL);
libmesh_assert (ctx != NULL);
PetscNonlinearSolver<Number>* solver =
static_cast<PetscNonlinearSolver<Number>*> (ctx);
NonlinearImplicitSystem &sys = solver->system();
PetscVector<Number> X_global(x), R(r);
PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
PetscVector<Number>& R_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.rhs);
// Use the systems update() to get a good local version of the parallel solution
X_global.swap(X_sys);
R.swap(R_sys);
sys.get_dof_map().enforce_constraints_exactly(sys);
sys.update();
//Swap back
X_global.swap(X_sys);
R.swap(R_sys);
R.zero();
if (solver->residual != NULL) solver->residual (*sys.current_local_solution.get(), R);
else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), &R, NULL);
else libmesh_error();
R.close();
X_global.close();
return ierr;
}
//---------------------------------------------------------------
// this function is called by PETSc to evaluate the Jacobian at X
PetscErrorCode
__libmesh_petsc_snes_jacobian (SNES, Vec x, Mat *jac, Mat *pc, MatStructure *msflag, void *ctx)
{
int ierr=0;
libmesh_assert (ctx != NULL);
PetscNonlinearSolver<Number>* solver =
static_cast<PetscNonlinearSolver<Number>*> (ctx);
NonlinearImplicitSystem &sys = solver->system();
PetscMatrix<Number> PC(*pc);
PetscMatrix<Number> Jac(*jac);
PetscVector<Number> X_global(x);
PetscVector<Number>& X_sys = *libmesh_cast_ptr<PetscVector<Number>*>(sys.solution.get());
PetscMatrix<Number>& Jac_sys = *libmesh_cast_ptr<PetscMatrix<Number>*>(sys.matrix);
// Use the systems update() to get a good local version of the parallel solution
X_global.swap(X_sys);
Jac.swap(Jac_sys);
sys.get_dof_map().enforce_constraints_exactly(sys);
sys.update();
X_global.swap(X_sys);
Jac.swap(Jac_sys);
PC.zero();
if (solver->jacobian != NULL) solver->jacobian (*sys.current_local_solution.get(), PC);
else if (solver->matvec != NULL) solver->matvec (*sys.current_local_solution.get(), NULL, &PC);
else libmesh_error();
PC.close();
Jac.close();
X_global.close();
*msflag = SAME_NONZERO_PATTERN;
return ierr;
}
} // end extern "C"
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// PetscNonlinearSolver<> methods
template <typename T>
void PetscNonlinearSolver<T>::clear ()
{
if (this->initialized())
{
this->_is_initialized = false;
int ierr=0;
ierr = SNESDestroy(_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
}
}
template <typename T>
void PetscNonlinearSolver<T>::init ()
{
// Initialize the data structures if not done so already.
if (!this->initialized())
{
this->_is_initialized = true;
int ierr=0;
#if PETSC_VERSION_LESS_THAN(2,1,2)
// At least until Petsc 2.1.1, the SNESCreate had a different calling syntax.
// The second argument was of type SNESProblemType, and could have a value of
// either SNES_NONLINEAR_EQUATIONS or SNES_UNCONSTRAINED_MINIMIZATION.
ierr = SNESCreate(libMesh::COMM_WORLD, SNES_NONLINEAR_EQUATIONS, &_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
#else
ierr = SNESCreate(libMesh::COMM_WORLD,&_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
#endif
#if PETSC_VERSION_LESS_THAN(2,3,3)
ierr = SNESSetMonitor (_snes, __libmesh_petsc_snes_monitor,
this, PETSC_NULL);
#else
// API name change in PETSc 2.3.3
ierr = SNESMonitorSet (_snes, __libmesh_petsc_snes_monitor,
this, PETSC_NULL);
#endif
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESSetFromOptions(_snes);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
if(this->_preconditioner)
{
KSP ksp;
ierr = SNESGetKSP (_snes, &ksp);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
PC pc;
ierr = KSPGetPC(ksp,&pc);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
PCSetType(pc, PCSHELL);
PCShellSetContext(pc,(void*)this->_preconditioner);
//Re-Use the shell functions from petsc_linear_solver
PCShellSetSetUp(pc,__libmesh_petsc_preconditioner_setup);
PCShellSetApply(pc,__libmesh_petsc_preconditioner_apply);
}
}
}
template <typename T>
std::pair<unsigned int, Real>
PetscNonlinearSolver<T>::solve (SparseMatrix<T>& jac_in, // System Jacobian Matrix
NumericVector<T>& x_in, // Solution vector
NumericVector<T>& r_in, // Residual vector
const double, // Stopping tolerance
const unsigned int)
{
this->init ();
// Make sure the data passed in are really of Petsc types
PetscMatrix<T>* jac = libmesh_cast_ptr<PetscMatrix<T>*>(&jac_in);
PetscVector<T>* x = libmesh_cast_ptr<PetscVector<T>*>(&x_in);
PetscVector<T>* r = libmesh_cast_ptr<PetscVector<T>*>(&r_in);
int ierr=0;
int n_iterations =0;
ierr = SNESSetFunction (_snes, r->vec(), __libmesh_petsc_snes_residual, this);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
ierr = SNESSetJacobian (_snes, jac->mat(), jac->mat(), __libmesh_petsc_snes_jacobian, this);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Have the Krylov subspace method use our good initial guess rather than 0
KSP ksp;
ierr = SNESGetKSP (_snes, &ksp);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Set the tolerances for the iterative solver. Use the user-supplied
// tolerance for the relative residual & leave the others at default values
ierr = KSPSetTolerances (ksp, this->initial_linear_tolerance, PETSC_DEFAULT,
PETSC_DEFAULT, this->max_linear_iterations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Set the tolerances for the non-linear solver.
ierr = SNESSetTolerances(_snes, this->absolute_residual_tolerance, this->relative_residual_tolerance,
this->absolute_step_tolerance, this->max_nonlinear_iterations, this->max_function_evaluations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
//Pull in command-line options
KSPSetFromOptions(ksp);
SNESSetFromOptions(_snes);
//Set the preconditioning matrix
if(this->_preconditioner)
this->_preconditioner->set_matrix(jac_in);
// ierr = KSPSetInitialGuessNonzero (ksp, PETSC_TRUE);
// CHKERRABORT(libMesh::COMM_WORLD,ierr);
// Older versions (at least up to 2.1.5) of SNESSolve took 3 arguments,
// the last one being a pointer to an int to hold the number of iterations required.
# if PETSC_VERSION_LESS_THAN(2,2,0)
ierr = SNESSolve (_snes, x->vec(), &n_iterations);
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// 2.2.x style
#elif PETSC_VERSION_LESS_THAN(2,3,0)
ierr = SNESSolve (_snes, x->vec());
CHKERRABORT(libMesh::COMM_WORLD,ierr);
// 2.3.x & newer style
#else
ierr = SNESSolve (_snes, PETSC_NULL, x->vec());
CHKERRABORT(libMesh::COMM_WORLD,ierr);
#endif
SNESConvergedReason reason;
SNESGetConvergedReason(_snes,&reason);
//Based on Petsc 2.3.3 documentation all diverged reasons are negative
this->converged = reason >= 0;
this->clear();
// return the # of its. and the final residual norm. Note that
// n_iterations may be zero for PETSc versions 2.2.x and greater.
return std::make_pair(n_iterations, 0.);
}
//------------------------------------------------------------------
// Explicit instantiations
template class PetscNonlinearSolver<Number>;
#endif // #ifdef LIBMESH_HAVE_PETSC
<|endoftext|> |
<commit_before>/***************************************************************************
plugin_katetextfilter.cpp - description
-------------------
begin : FRE Feb 23 2001
copyright : (C) 2001 by Joseph Wenninger
email : [email protected]
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
#include "plugin_kateopenheader.h"
#include "plugin_kateopenheader.moc"
#include <kate/application.h>
#include <ktexteditor/view.h>
#include <ktexteditor/document.h>
#include <QFileInfo>
#include <kpluginfactory.h>
#include <kpluginloader.h>
#include <kaboutdata.h>
#include <kaction.h>
#include <klocale.h>
#include <kdebug.h>
#include <kurl.h>
#include <kio/netaccess.h>
#include <kactioncollection.h>
K_PLUGIN_FACTORY(KateOpenHeaderFactory, registerPlugin<PluginKateOpenHeader>();)
K_EXPORT_PLUGIN(KateOpenHeaderFactory(KAboutData("kateopenheader","kateopenheader",ki18n("Open Header"), "0.1", ki18n("Open header for a source file"), KAboutData::License_LGPL_V2)) )
PluginViewKateOpenHeader::PluginViewKateOpenHeader(PluginKateOpenHeader *plugin,Kate::MainWindow *mainwindow): Kate::PluginView(mainwindow),KXMLGUIClient()
{
setComponentData (KateOpenHeaderFactory::componentData());
setXMLFile( "plugins/kateopenheader/ui.rc" );
QAction *a = actionCollection()->addAction("file_openheader");
a->setText(i18n("Open .h/.cpp/.c"));
a->setShortcut( Qt::Key_F12 );
connect( a, SIGNAL( triggered(bool) ), plugin, SLOT( slotOpenHeader() ) );
mainwindow->guiFactory()->addClient (this);
}
PluginViewKateOpenHeader::~PluginViewKateOpenHeader()
{
mainWindow()->guiFactory()->removeClient (this);
}
PluginKateOpenHeader::PluginKateOpenHeader( QObject* parent, const QList<QVariant>& )
: Kate::Plugin ( (Kate::Application *)parent, "open-header-plugin" )
{
}
PluginKateOpenHeader::~PluginKateOpenHeader()
{
}
Kate::PluginView *PluginKateOpenHeader::createView (Kate::MainWindow *mainWindow)
{
return new PluginViewKateOpenHeader(this,mainWindow);
}
void PluginKateOpenHeader::slotOpenHeader ()
{
if (!application()->activeMainWindow())
return;
KTextEditor::View * kv (application()->activeMainWindow()->activeView());
if (!kv) return;
KUrl url=kv->document()->url();
if ((!url.isValid()) || (url.isEmpty())) return;
QFileInfo info( url.path() );
QString extension = info.suffix().toLower();
QStringList headers( QStringList() << "h" << "H" << "hh" << "hpp" );
QStringList sources( QStringList() << "c" << "cpp" << "cc" << "cp" << "cxx" );
if( sources.contains( extension ) ) {
tryOpen( url, headers );
} else if ( headers.contains( extension ) ) {
tryOpen( url, sources );
}
}
void PluginKateOpenHeader::tryOpen( const KUrl& url, const QStringList& extensions )
{
if (!application()->activeMainWindow())
return;
kDebug() << "Trying to open " << url.prettyUrl() << " with extensions " << extensions.join(" ");
QString basename = QFileInfo( url.path() ).baseName();
KUrl newURL( url );
for( QStringList::ConstIterator it = extensions.begin(); it != extensions.end(); ++it ) {
newURL.setFileName( basename + '.' + *it );
if( KIO::NetAccess::exists( newURL , KIO::NetAccess::SourceSide, application()->activeMainWindow()->window()) )
application()->activeMainWindow()->openUrl( newURL );
newURL.setFileName( basename + '.' + (*it).toUpper() );
if( KIO::NetAccess::exists( newURL , KIO::NetAccess::SourceSide, application()->activeMainWindow()->window()) )
application()->activeMainWindow()->openUrl( newURL );
}
}
<commit_msg>QAction -> KAction<commit_after>/***************************************************************************
plugin_katetextfilter.cpp - description
-------------------
begin : FRE Feb 23 2001
copyright : (C) 2001 by Joseph Wenninger
email : [email protected]
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
#include "plugin_kateopenheader.h"
#include "plugin_kateopenheader.moc"
#include <kate/application.h>
#include <ktexteditor/view.h>
#include <ktexteditor/document.h>
#include <QFileInfo>
#include <kpluginfactory.h>
#include <kpluginloader.h>
#include <kaboutdata.h>
#include <kaction.h>
#include <klocale.h>
#include <kdebug.h>
#include <kurl.h>
#include <kio/netaccess.h>
#include <kactioncollection.h>
K_PLUGIN_FACTORY(KateOpenHeaderFactory, registerPlugin<PluginKateOpenHeader>();)
K_EXPORT_PLUGIN(KateOpenHeaderFactory(KAboutData("kateopenheader","kateopenheader",ki18n("Open Header"), "0.1", ki18n("Open header for a source file"), KAboutData::License_LGPL_V2)) )
PluginViewKateOpenHeader::PluginViewKateOpenHeader(PluginKateOpenHeader *plugin,Kate::MainWindow *mainwindow): Kate::PluginView(mainwindow),KXMLGUIClient()
{
setComponentData (KateOpenHeaderFactory::componentData());
setXMLFile( "plugins/kateopenheader/ui.rc" );
KAction *a = actionCollection()->addAction("file_openheader");
a->setText(i18n("Open .h/.cpp/.c"));
a->setShortcut( Qt::Key_F12 );
connect( a, SIGNAL( triggered(bool) ), plugin, SLOT( slotOpenHeader() ) );
mainwindow->guiFactory()->addClient (this);
}
PluginViewKateOpenHeader::~PluginViewKateOpenHeader()
{
mainWindow()->guiFactory()->removeClient (this);
}
PluginKateOpenHeader::PluginKateOpenHeader( QObject* parent, const QList<QVariant>& )
: Kate::Plugin ( (Kate::Application *)parent, "open-header-plugin" )
{
}
PluginKateOpenHeader::~PluginKateOpenHeader()
{
}
Kate::PluginView *PluginKateOpenHeader::createView (Kate::MainWindow *mainWindow)
{
return new PluginViewKateOpenHeader(this,mainWindow);
}
void PluginKateOpenHeader::slotOpenHeader ()
{
if (!application()->activeMainWindow())
return;
KTextEditor::View * kv (application()->activeMainWindow()->activeView());
if (!kv) return;
KUrl url=kv->document()->url();
if ((!url.isValid()) || (url.isEmpty())) return;
QFileInfo info( url.path() );
QString extension = info.suffix().toLower();
QStringList headers( QStringList() << "h" << "H" << "hh" << "hpp" );
QStringList sources( QStringList() << "c" << "cpp" << "cc" << "cp" << "cxx" );
if( sources.contains( extension ) ) {
tryOpen( url, headers );
} else if ( headers.contains( extension ) ) {
tryOpen( url, sources );
}
}
void PluginKateOpenHeader::tryOpen( const KUrl& url, const QStringList& extensions )
{
if (!application()->activeMainWindow())
return;
kDebug() << "Trying to open " << url.prettyUrl() << " with extensions " << extensions.join(" ");
QString basename = QFileInfo( url.path() ).baseName();
KUrl newURL( url );
for( QStringList::ConstIterator it = extensions.begin(); it != extensions.end(); ++it ) {
newURL.setFileName( basename + '.' + *it );
if( KIO::NetAccess::exists( newURL , KIO::NetAccess::SourceSide, application()->activeMainWindow()->window()) )
application()->activeMainWindow()->openUrl( newURL );
newURL.setFileName( basename + '.' + (*it).toUpper() );
if( KIO::NetAccess::exists( newURL , KIO::NetAccess::SourceSide, application()->activeMainWindow()->window()) )
application()->activeMainWindow()->openUrl( newURL );
}
}
<|endoftext|> |
<commit_before>/***************************************************************************
main.cpp - description
-------------------
begin : Wed Dec 26 03:12:10 CLST 2001
copyright : (C) 2001 by Duncan Mac-Vicar Prett
email : [email protected]
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
#include <kcmdlineargs.h>
#include <kaboutdata.h>
#include <klocale.h>
#include "kopete.h"
#include <dcopclient.h>
#include "kopeteiface.h"
static const char *description =
I18N_NOOP("Kopete, the KDE Instant Messenger");
#define KOPETE_VERSION "0.4.1"
static KCmdLineOptions options[] =
{
{ 0, 0, 0 }
};
int main(int argc, char *argv[])
{
KAboutData aboutData( "kopete", I18N_NOOP("Kopete"),
KOPETE_VERSION, description, KAboutData::License_GPL,
"(c) 2001,2002, Duncan Mac-Vicar Prett\n(c) 2002, The Kopete Development Team", "[email protected]", "http://kopete.kde.org");
aboutData.addAuthor ( "Duncan Mac-Vicar Prett", I18N_NOOP("Original author, core developer"), "[email protected]", "http://www.mac-vicar.com" );
aboutData.addAuthor ( "Nick Betcher", I18N_NOOP("Core developer, fastest plugin developer on earth."), "[email protected]", "http://www.kdedevelopers.net" );
aboutData.addAuthor ( "Ryan Cumming", I18N_NOOP("Core developer"), "[email protected]" );
aboutData.addAuthor ( "Martijn Klingens", I18N_NOOP("Core developer"), "[email protected]" );
aboutData.addAuthor ( "Richard Stellingwerff", I18N_NOOP("Developer"), "[email protected]");
aboutData.addAuthor ( "Daniel Stone", I18N_NOOP("Core developer, Jabber plugin"), "[email protected]", "http://raging.dropbear.id.au/daniel/");
aboutData.addAuthor ( "Hendrik vom Lehn", I18N_NOOP("Developer"), "[email protected]", "http://www.hennevl.de");
aboutData.addAuthor ( "Stefan Gehn", I18N_NOOP("Developer"), "[email protected]", "http://metz81.mine.nu" );
aboutData.addAuthor ( "Andres Krapf", I18N_NOOP("Random hacks and bugfixes"), "[email protected]" );
aboutData.addCredit ( "Herwin Jan Steehouwer", I18N_NOOP("KxEngine ICQ code") );
aboutData.addCredit ( "Olaf Lueg", I18N_NOOP("Kmerlin MSN code") );
aboutData.addCredit ( "Neil Stevens", I18N_NOOP("TAim engine AIM code") );
aboutData.addCredit ( "Justin Karneges", I18N_NOOP("Psi Jabber code") );
KCmdLineArgs::init( argc, argv, &aboutData );
KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
KUniqueApplication::addCmdLineOptions();
Kopete kopete;
kapp->dcopClient()->setDefaultObject( (new KopeteIface())->objId() ); // Has to be called before exec
kopete.exec();
}
<commit_msg>Added Gav to credits<commit_after>/***************************************************************************
main.cpp - description
-------------------
begin : Wed Dec 26 03:12:10 CLST 2001
copyright : (C) 2001 by Duncan Mac-Vicar Prett
email : [email protected]
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
#include <kcmdlineargs.h>
#include <kaboutdata.h>
#include <klocale.h>
#include "kopete.h"
#include <dcopclient.h>
#include "kopeteiface.h"
static const char *description =
I18N_NOOP("Kopete, the KDE Instant Messenger");
#define KOPETE_VERSION "0.4.1"
static KCmdLineOptions options[] =
{
{ 0, 0, 0 }
};
int main(int argc, char *argv[])
{
KAboutData aboutData( "kopete", I18N_NOOP("Kopete"),
KOPETE_VERSION, description, KAboutData::License_GPL,
"(c) 2001,2002, Duncan Mac-Vicar Prett\n(c) 2002, The Kopete Development Team", "[email protected]", "http://kopete.kde.org");
aboutData.addAuthor ( "Duncan Mac-Vicar Prett", I18N_NOOP("Original author, core developer"), "[email protected]", "http://www.mac-vicar.com" );
aboutData.addAuthor ( "Nick Betcher", I18N_NOOP("Core developer, fastest plugin developer on earth."), "[email protected]", "http://www.kdedevelopers.net" );
aboutData.addAuthor ( "Ryan Cumming", I18N_NOOP("Core developer"), "[email protected]" );
aboutData.addAuthor ( "Martijn Klingens", I18N_NOOP("Core developer"), "[email protected]" );
aboutData.addAuthor ( "Richard Stellingwerff", I18N_NOOP("Developer"), "[email protected]");
aboutData.addAuthor ( "Daniel Stone", I18N_NOOP("Core developer, Jabber plugin"), "[email protected]", "http://raging.dropbear.id.au/daniel/");
aboutData.addAuthor ( "Hendrik vom Lehn", I18N_NOOP("Developer"), "[email protected]", "http://www.hennevl.de");
aboutData.addAuthor ( "Stefan Gehn", I18N_NOOP("Developer"), "[email protected]", "http://metz81.mine.nu" );
aboutData.addAuthor ( "Andres Krapf", I18N_NOOP("Random hacks and bugfixes"), "[email protected]" );
aboutData.addAuthor ( "Gav Wood", I18N_NOOP("Winpopup plugin"), "[email protected]" );
aboutData.addCredit ( "Herwin Jan Steehouwer", I18N_NOOP("KxEngine ICQ code") );
aboutData.addCredit ( "Olaf Lueg", I18N_NOOP("Kmerlin MSN code") );
aboutData.addCredit ( "Neil Stevens", I18N_NOOP("TAim engine AIM code") );
aboutData.addCredit ( "Justin Karneges", I18N_NOOP("Psi Jabber code") );
KCmdLineArgs::init( argc, argv, &aboutData );
KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
KUniqueApplication::addCmdLineOptions();
Kopete kopete;
kapp->dcopClient()->setDefaultObject( (new KopeteIface())->objId() ); // Has to be called before exec
kopete.exec();
}
<|endoftext|> |
<commit_before>/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "Test.h"
#include "SkAAClip.h"
#include "SkPath.h"
static void imoveTo(SkPath& path, int x, int y) {
path.moveTo(SkIntToScalar(x), SkIntToScalar(y));
}
static void icubicTo(SkPath& path, int x0, int y0, int x1, int y1, int x2, int y2) {
path.cubicTo(SkIntToScalar(x0), SkIntToScalar(y0),
SkIntToScalar(x1), SkIntToScalar(y1),
SkIntToScalar(x2), SkIntToScalar(y2));
}
static void test_trim_bounds(skiatest::Reporter* reporter) {
SkPath path;
SkAAClip clip;
const int height = 40;
const SkScalar sheight = SkIntToScalar(height);
path.addOval(SkRect::MakeWH(sheight, sheight));
REPORTER_ASSERT(reporter, sheight == path.getBounds().height());
clip.setPath(path, NULL, true);
REPORTER_ASSERT(reporter, height == clip.getBounds().height());
// this is the trimmed height of this cubic (with aa). The critical thing
// for this test is that it is less than height, which represents just
// the bounds of the path's control-points.
//
// This used to fail until we tracked the MinY in the BuilderBlitter.
//
const int teardrop_height = 12;
path.reset();
imoveTo(path, 0, 20);
icubicTo(path, 40, 40, 40, 0, 0, 20);
REPORTER_ASSERT(reporter, sheight == path.getBounds().height());
clip.setPath(path, NULL, true);
REPORTER_ASSERT(reporter, teardrop_height == clip.getBounds().height());
}
static void TestAAClip(skiatest::Reporter* reporter) {
test_trim_bounds(reporter);
}
#include "TestClassDef.h"
DEFINE_TESTCLASS("AAClip", AAClipTestClass, TestAAClip)
<commit_msg>add test for rgn-ops. some disable for now as they don't work (yet)<commit_after>/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "Test.h"
#include "SkAAClip.h"
#include "SkPath.h"
#include "SkRandom.h"
static const SkRegion::Op gRgnOps[] = {
// SkRegion::kDifference_Op,
SkRegion::kIntersect_Op,
SkRegion::kUnion_Op,
SkRegion::kXOR_Op,
// SkRegion::kReverseDifference_Op,
SkRegion::kReplace_Op
};
static const char* gRgnOpNames[] = {
// "DIFF",
"SECT", "UNION", "XOR",
// "RDIFF",
"REPLACE"
};
static void imoveTo(SkPath& path, int x, int y) {
path.moveTo(SkIntToScalar(x), SkIntToScalar(y));
}
static void icubicTo(SkPath& path, int x0, int y0, int x1, int y1, int x2, int y2) {
path.cubicTo(SkIntToScalar(x0), SkIntToScalar(y0),
SkIntToScalar(x1), SkIntToScalar(y1),
SkIntToScalar(x2), SkIntToScalar(y2));
}
static void test_path_bounds(skiatest::Reporter* reporter) {
SkPath path;
SkAAClip clip;
const int height = 40;
const SkScalar sheight = SkIntToScalar(height);
path.addOval(SkRect::MakeWH(sheight, sheight));
REPORTER_ASSERT(reporter, sheight == path.getBounds().height());
clip.setPath(path, NULL, true);
REPORTER_ASSERT(reporter, height == clip.getBounds().height());
// this is the trimmed height of this cubic (with aa). The critical thing
// for this test is that it is less than height, which represents just
// the bounds of the path's control-points.
//
// This used to fail until we tracked the MinY in the BuilderBlitter.
//
const int teardrop_height = 12;
path.reset();
imoveTo(path, 0, 20);
icubicTo(path, 40, 40, 40, 0, 0, 20);
REPORTER_ASSERT(reporter, sheight == path.getBounds().height());
clip.setPath(path, NULL, true);
REPORTER_ASSERT(reporter, teardrop_height == clip.getBounds().height());
}
static void test_empty(skiatest::Reporter* reporter) {
SkAAClip clip0, clip1;
REPORTER_ASSERT(reporter, clip0.isEmpty());
REPORTER_ASSERT(reporter, clip0.getBounds().isEmpty());
REPORTER_ASSERT(reporter, clip1 == clip0);
clip0.translate(10, 10); // should have no effect on empty
REPORTER_ASSERT(reporter, clip0.isEmpty());
REPORTER_ASSERT(reporter, clip0.getBounds().isEmpty());
REPORTER_ASSERT(reporter, clip1 == clip0);
SkIRect r = { 10, 10, 40, 50 };
clip0.setRect(r);
REPORTER_ASSERT(reporter, !clip0.isEmpty());
REPORTER_ASSERT(reporter, !clip0.getBounds().isEmpty());
REPORTER_ASSERT(reporter, clip0 != clip1);
REPORTER_ASSERT(reporter, clip0.getBounds() == r);
clip0.setEmpty();
REPORTER_ASSERT(reporter, clip0.isEmpty());
REPORTER_ASSERT(reporter, clip0.getBounds().isEmpty());
REPORTER_ASSERT(reporter, clip1 == clip0);
SkMask mask;
mask.fImage = NULL;
clip0.copyToMask(&mask);
REPORTER_ASSERT(reporter, NULL == mask.fImage);
REPORTER_ASSERT(reporter, mask.fBounds.isEmpty());
}
static void rand_irect(SkIRect* r, int N, SkRandom& rand) {
r->setXYWH(0, 0, rand.nextU() % N, rand.nextU() % N);
int dx = rand.nextU() % (2*N);
int dy = rand.nextU() % (2*N);
// use int dx,dy to make the subtract be signed
r->offset(N - dx, N - dy);
}
static void test_irect(skiatest::Reporter* reporter) {
SkRandom rand;
for (int i = 0; i < 100; i++) {
SkAAClip clip0, clip1;
SkRegion rgn0, rgn1;
SkIRect r0, r1;
rand_irect(&r0, 10, rand);
rand_irect(&r1, 10, rand);
clip0.setRect(r0);
clip1.setRect(r1);
rgn0.setRect(r0);
rgn1.setRect(r1);
for (size_t j = 0; j < SK_ARRAY_COUNT(gRgnOps); ++j) {
SkRegion::Op op = gRgnOps[j];
SkAAClip clip2;
SkRegion rgn2;
bool nonEmptyAA = clip2.op(clip0, clip1, op);
bool nonEmptyBW = rgn2.op(rgn0, rgn1, op);
if (nonEmptyAA != nonEmptyBW || clip2.getBounds() != rgn2.getBounds()) {
SkDebugf("[%d %d %d %d] %s [%d %d %d %d] = BW:[%d %d %d %d] AA:[%d %d %d %d]\n",
r0.fLeft, r0.fTop, r0.right(), r0.bottom(),
gRgnOpNames[j],
r1.fLeft, r1.fTop, r1.right(), r1.bottom(),
rgn2.getBounds().fLeft, rgn2.getBounds().fTop,
rgn2.getBounds().right(), rgn2.getBounds().bottom(),
clip2.getBounds().fLeft, clip2.getBounds().fTop,
clip2.getBounds().right(), clip2.getBounds().bottom());
}
REPORTER_ASSERT(reporter, nonEmptyAA == nonEmptyBW);
REPORTER_ASSERT(reporter, clip2.getBounds() == rgn2.getBounds());
}
}
}
static void TestAAClip(skiatest::Reporter* reporter) {
test_empty(reporter);
test_path_bounds(reporter);
test_irect(reporter);
}
#include "TestClassDef.h"
DEFINE_TESTCLASS("AAClip", AAClipTestClass, TestAAClip)
<|endoftext|> |
<commit_before> /* -*- mode: c++; c-basic-offset:4 -*-
decryptverifyfilescontroller.cpp
This file is part of Kleopatra, the KDE keymanager
Copyright (c) 2008 Klarälvdalens Datakonsult AB
Kleopatra 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.
Kleopatra is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
In addition, as a special exception, the copyright holders give
permission to link the code of this program with any edition of
the Qt library by Trolltech AS, Norway (or with modified versions
of Qt that use the same license as Qt), and distribute linked
combinations including the two. You must obey the GNU General
Public License in all respects for all of the code used other than
Qt. If you modify this file, you may extend this exception to
your version of the file, but you are not obligated to do so. If
you do not wish to do so, delete this exception statement from
your version.
*/
#include <config-kleopatra.h>
#include "decryptverifyfilescontroller.h"
#include <crypto/gui/decryptverifyoperationwidget.h>
#include <crypto/gui/decryptverifyfileswizard.h>
#include <crypto/decryptverifytask.h>
#include <crypto/taskcollection.h>
#include <utils/classify.h>
#include <utils/gnupg-helper.h>
#include <utils/input.h>
#include <utils/output.h>
#include <utils/kleo_assert.h>
#include <KDebug>
#include <KLocalizedString>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QPointer>
#include <QTimer>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <vector>
using namespace boost;
using namespace GpgME;
using namespace Kleo;
using namespace Kleo::Crypto;
using namespace Kleo::Crypto::Gui;
class DecryptVerifyFilesController::Private {
DecryptVerifyFilesController* const q;
public:
static QString heuristicBaseDirectory( const QStringList& fileNames );
static shared_ptr<AbstractDecryptVerifyTask> taskFromOperationWidget( const DecryptVerifyOperationWidget * w, const shared_ptr<QFile> & file, const QDir & outDir, const shared_ptr<OverwritePolicy> & overwritePolicy );
explicit Private( DecryptVerifyFilesController* qq );
void slotWizardOperationPrepared();
void slotWizardCanceled();
void schedule();
std::vector< shared_ptr<QFile> > prepareWizardFromPassedFiles();
std::vector<shared_ptr<Task> > buildTasks( const std::vector<shared_ptr<QFile> > &, const shared_ptr<OverwritePolicy> & );
QString heuristicBaseDirectory() const;
void ensureWizardCreated();
void ensureWizardVisible();
void reportError( int err, const QString & details ) {
emit q->error( err, details );
}
void cancelAllTasks();
std::vector<shared_ptr<QFile> > m_passedFiles, m_filesAfterPreparation;
QPointer<DecryptVerifyFilesWizard> m_wizard;
std::vector<shared_ptr<const DecryptVerifyResult> > m_results;
std::vector<shared_ptr<Task> > m_runnableTasks, m_completedTasks;
shared_ptr<Task> m_runningTask;
bool m_errorDetected;
DecryptVerifyOperation m_operation;
};
// static
shared_ptr<AbstractDecryptVerifyTask> DecryptVerifyFilesController::Private::taskFromOperationWidget( const DecryptVerifyOperationWidget * w, const shared_ptr<QFile> & file, const QDir & outDir, const shared_ptr<OverwritePolicy> & overwritePolicy ) {
kleo_assert( w );
shared_ptr<AbstractDecryptVerifyTask> task;
switch ( w->mode() ) {
case DecryptVerifyOperationWidget::VerifyDetachedWithSignature:
{
shared_ptr<VerifyDetachedTask> t( new VerifyDetachedTask );
t->setInput( Input::createFromFile( file ) );
t->setSignedData( Input::createFromFile( w->signedDataFileName() ) );
task = t;
kleo_assert( file->fileName() == w->inputFileName() );
}
break;
case DecryptVerifyOperationWidget::VerifyDetachedWithSignedData:
{
shared_ptr<VerifyDetachedTask> t( new VerifyDetachedTask );
t->setInput( Input::createFromFile( w->inputFileName() ) );
t->setSignedData( Input::createFromFile( file ) );
task = t;
kleo_assert( file->fileName() == w->signedDataFileName() );
}
break;
case DecryptVerifyOperationWidget::DecryptVerifyOpaque:
{
shared_ptr<DecryptVerifyTask> t( new DecryptVerifyTask );
t->setInput( Input::createFromFile( file ) );
t->setOutput( Output::createFromFile( outDir.absoluteFilePath( outputFileName( QFileInfo( file->fileName() ).fileName() ) ), overwritePolicy ) );
task = t;
kleo_assert( file->fileName() == w->inputFileName() );
}
break;
}
task->autodetectProtocolFromInput();
return task;
}
DecryptVerifyFilesController::Private::Private( DecryptVerifyFilesController* qq ) : q( qq ), m_errorDetected( false ), m_operation( DecryptVerify )
{
qRegisterMetaType<VerificationResult>();
}
void DecryptVerifyFilesController::Private::slotWizardOperationPrepared()
{
try {
ensureWizardCreated();
std::vector<shared_ptr<Task> > tasks = buildTasks( m_filesAfterPreparation, shared_ptr<OverwritePolicy>( new OverwritePolicy( m_wizard ) ) );
kleo_assert( m_runnableTasks.empty() );
m_runnableTasks.swap( tasks );
shared_ptr<TaskCollection> coll( new TaskCollection );
Q_FOREACH( const shared_ptr<Task> & i, m_runnableTasks )
q->connectTask( i );
coll->setTasks( m_runnableTasks );
m_wizard->setTaskCollection( coll );
QTimer::singleShot( 0, q, SLOT( schedule() ) );
} catch ( const Kleo::Exception & e ) {
reportError( e.error().encodedError(), e.message() );
} catch ( const std::exception & e ) {
reportError( gpg_error( GPG_ERR_UNEXPECTED ),
i18n("Caught unexpected exception in DecryptVerifyFilesController::Private::slotWizardOperationPrepared: %1",
QString::fromLocal8Bit( e.what() ) ) );
} catch ( ... ) {
reportError( gpg_error( GPG_ERR_UNEXPECTED ),
i18n("Caught unknown exception in DecryptVerifyFilesController::Private::slotWizardOperationPrepared") );
}
}
void DecryptVerifyFilesController::Private::slotWizardCanceled()
{
kDebug();
reportError( gpg_error( GPG_ERR_CANCELED ), i18n("User canceled") );
}
void DecryptVerifyFilesController::doTaskDone( const Task* task, const shared_ptr<const Task::Result> & result )
{
assert( task );
assert( task == d->m_runningTask.get() );
// We could just delete the tasks here, but we can't use
// Qt::QueuedConnection here (we need sender()) and other slots
// might not yet have executed. Therefore, we push completed tasks
// into a burial container
d->m_completedTasks.push_back( d->m_runningTask );
d->m_runningTask.reset();
if ( const shared_ptr<const DecryptVerifyResult> & dvr = boost::dynamic_pointer_cast<const DecryptVerifyResult>( result ) )
d->m_results.push_back( dvr );
QTimer::singleShot( 0, this, SLOT(schedule()) );
}
void DecryptVerifyFilesController::Private::schedule()
{
if ( !m_runningTask && !m_runnableTasks.empty() ) {
const shared_ptr<Task> t = m_runnableTasks.back();
m_runnableTasks.pop_back();
t->start();
m_runningTask = t;
}
if ( !m_runningTask ) {
kleo_assert( m_runnableTasks.empty() );
Q_FOREACH ( const shared_ptr<const DecryptVerifyResult> & i, m_results )
emit q->verificationResult( i->verificationResult() );
q->emitDoneOrError();
}
}
void DecryptVerifyFilesController::Private::ensureWizardCreated()
{
if ( m_wizard )
return;
std::auto_ptr<DecryptVerifyFilesWizard> w( new DecryptVerifyFilesWizard );
w->setWindowTitle( i18n( "Decrypt/Verify Files" ) );
w->setAttribute( Qt::WA_DeleteOnClose );
connect( w.get(), SIGNAL(operationPrepared()), q, SLOT(slotWizardOperationPrepared()), Qt::QueuedConnection );
connect( w.get(), SIGNAL(canceled()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection );
m_wizard = w.release();
}
std::vector<shared_ptr<QFile> > DecryptVerifyFilesController::Private::prepareWizardFromPassedFiles()
{
ensureWizardCreated();
std::vector< shared_ptr<QFile> > files;
unsigned int counter = 0;
Q_FOREACH( const shared_ptr<QFile> & file, m_passedFiles ) {
kleo_assert( file );
const QString fname = file->fileName();
kleo_assert( !fname.isEmpty() );
const unsigned int classification = classify( fname );
if ( mayBeOpaqueSignature( classification ) || mayBeCipherText( classification ) || mayBeDetachedSignature( classification ) ) {
DecryptVerifyOperationWidget * const op = m_wizard->operationWidget( counter++ );
kleo_assert( op != 0 );
if ( mayBeOpaqueSignature( classification ) || mayBeCipherText( classification ) )
op->setMode( DecryptVerifyOperationWidget::DecryptVerifyOpaque );
else
op->setMode( DecryptVerifyOperationWidget::VerifyDetachedWithSignature );
op->setInputFileName( fname );
op->setSignedDataFileName( findSignedData( fname ) );
files.push_back( file );
} else {
// probably the signed data file was selected:
QStringList signatures = findSignatures( fname );
if ( signatures.empty() ) {
// We are assuming this is a detached signature file, but
// there were no signature files for it. Let's guess it's encrypted after all.
// ### FIXME once we have a proper heuristic for this, this should move into
// classify() and/or classifyContent()
DecryptVerifyOperationWidget * const op = m_wizard->operationWidget( counter++ );
kleo_assert( op != 0 );
op->setMode( DecryptVerifyOperationWidget::DecryptVerifyOpaque );
op->setInputFileName( fname );
files.push_back( file );
}
Q_FOREACH( const QString s, signatures ) {
DecryptVerifyOperationWidget * op = m_wizard->operationWidget( counter++ );
kleo_assert( op != 0 );
op->setMode( DecryptVerifyOperationWidget::VerifyDetachedWithSignedData );
op->setInputFileName( s );
op->setSignedDataFileName( fname );
files.push_back( file );
}
}
}
kleo_assert( counter == files.size() );
if ( !counter )
throw Kleo::Exception( makeGnuPGError( GPG_ERR_ASS_NO_INPUT ), i18n("No usable inputs found") );
m_wizard->setOutputDirectory( heuristicBaseDirectory() );
return files;
}
std::vector< shared_ptr<Task> > DecryptVerifyFilesController::Private::buildTasks( const std::vector<shared_ptr<QFile> > & files, const shared_ptr<OverwritePolicy> & overwritePolicy )
{
const bool useOutDir = m_wizard->useOutputDirectory();
const QFileInfo outDirInfo( m_wizard->outputDirectory() );
kleo_assert( !useOutDir || outDirInfo.isDir() );
const QDir outDir( outDirInfo.absoluteFilePath() );
kleo_assert( !useOutDir || outDir.exists() );
std::vector<shared_ptr<Task> > tasks;
for ( unsigned int i = 0 ; i < files.size(); ++i )
try {
const QDir fileDir = QFileInfo( *files[i] ).absoluteDir();
kleo_assert( fileDir.exists() );
tasks.push_back( taskFromOperationWidget( m_wizard->operationWidget( i ), files[i], useOutDir ? outDir : fileDir, overwritePolicy ) );
} catch ( const GpgME::Exception & e ) {
tasks.push_back( Task::makeErrorTask( e.error().code(), QString::fromLocal8Bit( e.what() ), QFileInfo( *files[i] ).fileName() ) );
}
return tasks;
}
void DecryptVerifyFilesController::setFiles( const std::vector<boost::shared_ptr<QFile> >& files )
{
d->m_passedFiles = files;
}
void DecryptVerifyFilesController::Private::ensureWizardVisible()
{
ensureWizardCreated();
q->bringToForeground( m_wizard );
}
DecryptVerifyFilesController::DecryptVerifyFilesController( QObject* parent ) : Controller( parent ), d( new Private( this ) )
{
}
DecryptVerifyFilesController::DecryptVerifyFilesController( const shared_ptr<const ExecutionContext> & ctx, QObject* parent ) : Controller( ctx, parent ), d( new Private( this ) )
{
}
DecryptVerifyFilesController::~DecryptVerifyFilesController() { kDebug(); }
void DecryptVerifyFilesController::start()
{
d->m_filesAfterPreparation = d->prepareWizardFromPassedFiles();
d->ensureWizardVisible();
}
static QString commonPrefix( const QString & s1, const QString & s2 ) {
return QString( s1.data(), std::mismatch( s1.data(), s1.data() + std::min( s1.size(), s2.size() ), s2.data() ).first - s1.data() );
}
static QString longestCommonPrefix( const QStringList & sl ) {
if ( sl.empty() )
return QString();
QString result = sl.front();
Q_FOREACH( const QString & s, sl )
result = commonPrefix( s, result );
return result;
}
QString DecryptVerifyFilesController::Private::heuristicBaseDirectory() const {
QStringList fileNames;
Q_FOREACH ( const shared_ptr<QFile> & i, m_passedFiles )
fileNames.push_back( i->fileName() );
return heuristicBaseDirectory( fileNames );
}
QString DecryptVerifyFilesController::Private::heuristicBaseDirectory( const QStringList& fileNames ) {
const QString candidate = longestCommonPrefix( fileNames );
const QFileInfo fi( candidate );
if ( fi.isDir() )
return candidate;
else
return fi.absolutePath();
}
void DecryptVerifyFilesController::setOperation( DecryptVerifyOperation op )
{
d->m_operation = op;
}
DecryptVerifyOperation DecryptVerifyFilesController::operation() const
{
return d->m_operation;
}
void DecryptVerifyFilesController::Private::cancelAllTasks() {
// we just kill all runnable tasks - this will not result in
// signal emissions.
m_runnableTasks.clear();
// a cancel() will result in a call to
if ( m_runningTask )
m_runningTask->cancel();
}
void DecryptVerifyFilesController::cancel()
{
kDebug();
try {
d->m_errorDetected = true;
if ( d->m_wizard )
d->m_wizard->close();
d->cancelAllTasks();
} catch ( const std::exception & e ) {
qDebug( "Caught exception: %s", e.what() );
}
}
#include "decryptverifyfilescontroller.moc"
<commit_msg>Put loop into !empty() branch, as it's too subtle that it's not executed simply b/c the container is empty. Add some const.<commit_after>/* -*- mode: c++; c-basic-offset:4 -*-
decryptverifyfilescontroller.cpp
This file is part of Kleopatra, the KDE keymanager
Copyright (c) 2008 Klarälvdalens Datakonsult AB
Kleopatra 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.
Kleopatra is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
In addition, as a special exception, the copyright holders give
permission to link the code of this program with any edition of
the Qt library by Trolltech AS, Norway (or with modified versions
of Qt that use the same license as Qt), and distribute linked
combinations including the two. You must obey the GNU General
Public License in all respects for all of the code used other than
Qt. If you modify this file, you may extend this exception to
your version of the file, but you are not obligated to do so. If
you do not wish to do so, delete this exception statement from
your version.
*/
#include <config-kleopatra.h>
#include "decryptverifyfilescontroller.h"
#include <crypto/gui/decryptverifyoperationwidget.h>
#include <crypto/gui/decryptverifyfileswizard.h>
#include <crypto/decryptverifytask.h>
#include <crypto/taskcollection.h>
#include <utils/classify.h>
#include <utils/gnupg-helper.h>
#include <utils/input.h>
#include <utils/output.h>
#include <utils/kleo_assert.h>
#include <KDebug>
#include <KLocalizedString>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QPointer>
#include <QTimer>
#include <boost/shared_ptr.hpp>
#include <memory>
#include <vector>
using namespace boost;
using namespace GpgME;
using namespace Kleo;
using namespace Kleo::Crypto;
using namespace Kleo::Crypto::Gui;
class DecryptVerifyFilesController::Private {
DecryptVerifyFilesController* const q;
public:
static QString heuristicBaseDirectory( const QStringList& fileNames );
static shared_ptr<AbstractDecryptVerifyTask> taskFromOperationWidget( const DecryptVerifyOperationWidget * w, const shared_ptr<QFile> & file, const QDir & outDir, const shared_ptr<OverwritePolicy> & overwritePolicy );
explicit Private( DecryptVerifyFilesController* qq );
void slotWizardOperationPrepared();
void slotWizardCanceled();
void schedule();
std::vector< shared_ptr<QFile> > prepareWizardFromPassedFiles();
std::vector<shared_ptr<Task> > buildTasks( const std::vector<shared_ptr<QFile> > &, const shared_ptr<OverwritePolicy> & );
QString heuristicBaseDirectory() const;
void ensureWizardCreated();
void ensureWizardVisible();
void reportError( int err, const QString & details ) {
emit q->error( err, details );
}
void cancelAllTasks();
std::vector<shared_ptr<QFile> > m_passedFiles, m_filesAfterPreparation;
QPointer<DecryptVerifyFilesWizard> m_wizard;
std::vector<shared_ptr<const DecryptVerifyResult> > m_results;
std::vector<shared_ptr<Task> > m_runnableTasks, m_completedTasks;
shared_ptr<Task> m_runningTask;
bool m_errorDetected;
DecryptVerifyOperation m_operation;
};
// static
shared_ptr<AbstractDecryptVerifyTask> DecryptVerifyFilesController::Private::taskFromOperationWidget( const DecryptVerifyOperationWidget * w, const shared_ptr<QFile> & file, const QDir & outDir, const shared_ptr<OverwritePolicy> & overwritePolicy ) {
kleo_assert( w );
shared_ptr<AbstractDecryptVerifyTask> task;
switch ( w->mode() ) {
case DecryptVerifyOperationWidget::VerifyDetachedWithSignature:
{
shared_ptr<VerifyDetachedTask> t( new VerifyDetachedTask );
t->setInput( Input::createFromFile( file ) );
t->setSignedData( Input::createFromFile( w->signedDataFileName() ) );
task = t;
kleo_assert( file->fileName() == w->inputFileName() );
}
break;
case DecryptVerifyOperationWidget::VerifyDetachedWithSignedData:
{
shared_ptr<VerifyDetachedTask> t( new VerifyDetachedTask );
t->setInput( Input::createFromFile( w->inputFileName() ) );
t->setSignedData( Input::createFromFile( file ) );
task = t;
kleo_assert( file->fileName() == w->signedDataFileName() );
}
break;
case DecryptVerifyOperationWidget::DecryptVerifyOpaque:
{
shared_ptr<DecryptVerifyTask> t( new DecryptVerifyTask );
t->setInput( Input::createFromFile( file ) );
t->setOutput( Output::createFromFile( outDir.absoluteFilePath( outputFileName( QFileInfo( file->fileName() ).fileName() ) ), overwritePolicy ) );
task = t;
kleo_assert( file->fileName() == w->inputFileName() );
}
break;
}
task->autodetectProtocolFromInput();
return task;
}
DecryptVerifyFilesController::Private::Private( DecryptVerifyFilesController* qq ) : q( qq ), m_errorDetected( false ), m_operation( DecryptVerify )
{
qRegisterMetaType<VerificationResult>();
}
void DecryptVerifyFilesController::Private::slotWizardOperationPrepared()
{
try {
ensureWizardCreated();
std::vector<shared_ptr<Task> > tasks = buildTasks( m_filesAfterPreparation, shared_ptr<OverwritePolicy>( new OverwritePolicy( m_wizard ) ) );
kleo_assert( m_runnableTasks.empty() );
m_runnableTasks.swap( tasks );
shared_ptr<TaskCollection> coll( new TaskCollection );
Q_FOREACH( const shared_ptr<Task> & i, m_runnableTasks )
q->connectTask( i );
coll->setTasks( m_runnableTasks );
m_wizard->setTaskCollection( coll );
QTimer::singleShot( 0, q, SLOT( schedule() ) );
} catch ( const Kleo::Exception & e ) {
reportError( e.error().encodedError(), e.message() );
} catch ( const std::exception & e ) {
reportError( gpg_error( GPG_ERR_UNEXPECTED ),
i18n("Caught unexpected exception in DecryptVerifyFilesController::Private::slotWizardOperationPrepared: %1",
QString::fromLocal8Bit( e.what() ) ) );
} catch ( ... ) {
reportError( gpg_error( GPG_ERR_UNEXPECTED ),
i18n("Caught unknown exception in DecryptVerifyFilesController::Private::slotWizardOperationPrepared") );
}
}
void DecryptVerifyFilesController::Private::slotWizardCanceled()
{
kDebug();
reportError( gpg_error( GPG_ERR_CANCELED ), i18n("User canceled") );
}
void DecryptVerifyFilesController::doTaskDone( const Task* task, const shared_ptr<const Task::Result> & result )
{
assert( task );
assert( task == d->m_runningTask.get() );
// We could just delete the tasks here, but we can't use
// Qt::QueuedConnection here (we need sender()) and other slots
// might not yet have executed. Therefore, we push completed tasks
// into a burial container
d->m_completedTasks.push_back( d->m_runningTask );
d->m_runningTask.reset();
if ( const shared_ptr<const DecryptVerifyResult> & dvr = boost::dynamic_pointer_cast<const DecryptVerifyResult>( result ) )
d->m_results.push_back( dvr );
QTimer::singleShot( 0, this, SLOT(schedule()) );
}
void DecryptVerifyFilesController::Private::schedule()
{
if ( !m_runningTask && !m_runnableTasks.empty() ) {
const shared_ptr<Task> t = m_runnableTasks.back();
m_runnableTasks.pop_back();
t->start();
m_runningTask = t;
}
if ( !m_runningTask ) {
kleo_assert( m_runnableTasks.empty() );
Q_FOREACH ( const shared_ptr<const DecryptVerifyResult> & i, m_results )
emit q->verificationResult( i->verificationResult() );
q->emitDoneOrError();
}
}
void DecryptVerifyFilesController::Private::ensureWizardCreated()
{
if ( m_wizard )
return;
std::auto_ptr<DecryptVerifyFilesWizard> w( new DecryptVerifyFilesWizard );
w->setWindowTitle( i18n( "Decrypt/Verify Files" ) );
w->setAttribute( Qt::WA_DeleteOnClose );
connect( w.get(), SIGNAL(operationPrepared()), q, SLOT(slotWizardOperationPrepared()), Qt::QueuedConnection );
connect( w.get(), SIGNAL(canceled()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection );
m_wizard = w.release();
}
std::vector<shared_ptr<QFile> > DecryptVerifyFilesController::Private::prepareWizardFromPassedFiles()
{
ensureWizardCreated();
std::vector< shared_ptr<QFile> > files;
unsigned int counter = 0;
Q_FOREACH( const shared_ptr<QFile> & file, m_passedFiles ) {
kleo_assert( file );
const QString fname = file->fileName();
kleo_assert( !fname.isEmpty() );
const unsigned int classification = classify( fname );
if ( mayBeOpaqueSignature( classification ) || mayBeCipherText( classification ) || mayBeDetachedSignature( classification ) ) {
DecryptVerifyOperationWidget * const op = m_wizard->operationWidget( counter++ );
kleo_assert( op != 0 );
if ( mayBeOpaqueSignature( classification ) || mayBeCipherText( classification ) )
op->setMode( DecryptVerifyOperationWidget::DecryptVerifyOpaque );
else
op->setMode( DecryptVerifyOperationWidget::VerifyDetachedWithSignature );
op->setInputFileName( fname );
op->setSignedDataFileName( findSignedData( fname ) );
files.push_back( file );
} else {
// probably the signed data file was selected:
const QStringList signatures = findSignatures( fname );
if ( signatures.empty() ) {
// We are assuming this is a detached signature file, but
// there were no signature files for it. Let's guess it's encrypted after all.
// ### FIXME once we have a proper heuristic for this, this should move into
// classify() and/or classifyContent()
DecryptVerifyOperationWidget * const op = m_wizard->operationWidget( counter++ );
kleo_assert( op != 0 );
op->setMode( DecryptVerifyOperationWidget::DecryptVerifyOpaque );
op->setInputFileName( fname );
files.push_back( file );
} else {
Q_FOREACH( const QString & s, signatures ) {
DecryptVerifyOperationWidget * op = m_wizard->operationWidget( counter++ );
kleo_assert( op != 0 );
op->setMode( DecryptVerifyOperationWidget::VerifyDetachedWithSignedData );
op->setInputFileName( s );
op->setSignedDataFileName( fname );
files.push_back( file );
}
}
}
}
kleo_assert( counter == files.size() );
if ( !counter )
throw Kleo::Exception( makeGnuPGError( GPG_ERR_ASS_NO_INPUT ), i18n("No usable inputs found") );
m_wizard->setOutputDirectory( heuristicBaseDirectory() );
return files;
}
std::vector< shared_ptr<Task> > DecryptVerifyFilesController::Private::buildTasks( const std::vector<shared_ptr<QFile> > & files, const shared_ptr<OverwritePolicy> & overwritePolicy )
{
const bool useOutDir = m_wizard->useOutputDirectory();
const QFileInfo outDirInfo( m_wizard->outputDirectory() );
kleo_assert( !useOutDir || outDirInfo.isDir() );
const QDir outDir( outDirInfo.absoluteFilePath() );
kleo_assert( !useOutDir || outDir.exists() );
std::vector<shared_ptr<Task> > tasks;
for ( unsigned int i = 0 ; i < files.size(); ++i )
try {
const QDir fileDir = QFileInfo( *files[i] ).absoluteDir();
kleo_assert( fileDir.exists() );
tasks.push_back( taskFromOperationWidget( m_wizard->operationWidget( i ), files[i], useOutDir ? outDir : fileDir, overwritePolicy ) );
} catch ( const GpgME::Exception & e ) {
tasks.push_back( Task::makeErrorTask( e.error().code(), QString::fromLocal8Bit( e.what() ), QFileInfo( *files[i] ).fileName() ) );
}
return tasks;
}
void DecryptVerifyFilesController::setFiles( const std::vector<boost::shared_ptr<QFile> >& files )
{
d->m_passedFiles = files;
}
void DecryptVerifyFilesController::Private::ensureWizardVisible()
{
ensureWizardCreated();
q->bringToForeground( m_wizard );
}
DecryptVerifyFilesController::DecryptVerifyFilesController( QObject* parent ) : Controller( parent ), d( new Private( this ) )
{
}
DecryptVerifyFilesController::DecryptVerifyFilesController( const shared_ptr<const ExecutionContext> & ctx, QObject* parent ) : Controller( ctx, parent ), d( new Private( this ) )
{
}
DecryptVerifyFilesController::~DecryptVerifyFilesController() { kDebug(); }
void DecryptVerifyFilesController::start()
{
d->m_filesAfterPreparation = d->prepareWizardFromPassedFiles();
d->ensureWizardVisible();
}
static QString commonPrefix( const QString & s1, const QString & s2 ) {
return QString( s1.data(), std::mismatch( s1.data(), s1.data() + std::min( s1.size(), s2.size() ), s2.data() ).first - s1.data() );
}
static QString longestCommonPrefix( const QStringList & sl ) {
if ( sl.empty() )
return QString();
QString result = sl.front();
Q_FOREACH( const QString & s, sl )
result = commonPrefix( s, result );
return result;
}
QString DecryptVerifyFilesController::Private::heuristicBaseDirectory() const {
QStringList fileNames;
Q_FOREACH ( const shared_ptr<QFile> & i, m_passedFiles )
fileNames.push_back( i->fileName() );
return heuristicBaseDirectory( fileNames );
}
QString DecryptVerifyFilesController::Private::heuristicBaseDirectory( const QStringList& fileNames ) {
const QString candidate = longestCommonPrefix( fileNames );
const QFileInfo fi( candidate );
if ( fi.isDir() )
return candidate;
else
return fi.absolutePath();
}
void DecryptVerifyFilesController::setOperation( DecryptVerifyOperation op )
{
d->m_operation = op;
}
DecryptVerifyOperation DecryptVerifyFilesController::operation() const
{
return d->m_operation;
}
void DecryptVerifyFilesController::Private::cancelAllTasks() {
// we just kill all runnable tasks - this will not result in
// signal emissions.
m_runnableTasks.clear();
// a cancel() will result in a call to
if ( m_runningTask )
m_runningTask->cancel();
}
void DecryptVerifyFilesController::cancel()
{
kDebug();
try {
d->m_errorDetected = true;
if ( d->m_wizard )
d->m_wizard->close();
d->cancelAllTasks();
} catch ( const std::exception & e ) {
qDebug( "Caught exception: %s", e.what() );
}
}
#include "decryptverifyfilescontroller.moc"
<|endoftext|> |
<commit_before>
#include "config.h"
#include "event.h"
#include <algorithm>
#include <atomic>
#include <cstring>
#include <exception>
#include <memory>
#include <mutex>
#include <new>
#include <string>
#include <thread>
#include "AL/al.h"
#include "AL/alc.h"
#include "alError.h"
#include "albyte.h"
#include "alcontext.h"
#include "alexcpt.h"
#include "almalloc.h"
#include "effects/base.h"
#include "inprogext.h"
#include "logging.h"
#include "opthelpers.h"
#include "ringbuffer.h"
#include "threads.h"
static int EventThread(ALCcontext *context)
{
RingBuffer *ring{context->AsyncEvents.get()};
bool quitnow{false};
while(LIKELY(!quitnow))
{
auto evt_data = ring->getReadVector().first;
if(evt_data.len == 0)
{
context->EventSem.wait();
continue;
}
std::lock_guard<std::mutex> _{context->EventCbLock};
do {
auto &evt = *reinterpret_cast<AsyncEvent*>(evt_data.buf);
evt_data.buf += sizeof(AsyncEvent);
evt_data.len -= 1;
/* This automatically destructs the event object and advances the
* ringbuffer's read offset at the end of scope.
*/
const struct EventAutoDestructor {
AsyncEvent &evt_;
RingBuffer *ring_;
~EventAutoDestructor()
{
al::destroy_at(&evt_);
ring_->readAdvance(1);
}
} _{evt, ring};
quitnow = evt.EnumType == EventType_KillThread;
if(UNLIKELY(quitnow)) break;
if(evt.EnumType == EventType_ReleaseEffectState)
{
evt.u.mEffectState->DecRef();
continue;
}
ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_acquire)};
if(!context->EventCb) continue;
if(evt.EnumType == EventType_SourceStateChange)
{
if(!(enabledevts&EventType_SourceStateChange))
continue;
std::string msg{"Source ID " + std::to_string(evt.u.srcstate.id)};
msg += " state has changed to ";
msg += (evt.u.srcstate.state==AL_INITIAL) ? "AL_INITIAL" :
(evt.u.srcstate.state==AL_PLAYING) ? "AL_PLAYING" :
(evt.u.srcstate.state==AL_PAUSED) ? "AL_PAUSED" :
(evt.u.srcstate.state==AL_STOPPED) ? "AL_STOPPED" : "<unknown>";
context->EventCb(AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT, evt.u.srcstate.id,
evt.u.srcstate.state, static_cast<ALsizei>(msg.length()), msg.c_str(),
context->EventParam
);
}
else if(evt.EnumType == EventType_BufferCompleted)
{
if(!(enabledevts&EventType_BufferCompleted))
continue;
std::string msg{std::to_string(evt.u.bufcomp.count)};
if(evt.u.bufcomp.count == 1) msg += " buffer completed";
else msg += " buffers completed";
context->EventCb(AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT, evt.u.bufcomp.id,
evt.u.bufcomp.count, static_cast<ALsizei>(msg.length()), msg.c_str(),
context->EventParam
);
}
else if((enabledevts&evt.EnumType) == evt.EnumType)
context->EventCb(evt.u.user.type, evt.u.user.id, evt.u.user.param,
static_cast<ALsizei>(strlen(evt.u.user.msg)), evt.u.user.msg,
context->EventParam
);
} while(evt_data.len != 0);
}
return 0;
}
void StartEventThrd(ALCcontext *ctx)
{
try {
ctx->EventThread = std::thread{EventThread, ctx};
}
catch(std::exception& e) {
ERR("Failed to start event thread: %s\n", e.what());
}
catch(...) {
ERR("Failed to start event thread! Expect problems.\n");
}
}
void StopEventThrd(ALCcontext *ctx)
{
static constexpr AsyncEvent kill_evt{EventType_KillThread};
RingBuffer *ring{ctx->AsyncEvents.get()};
auto evt_data = ring->getWriteVector().first;
if(evt_data.len == 0)
{
do {
std::this_thread::yield();
evt_data = ring->getWriteVector().first;
} while(evt_data.len == 0);
}
new (evt_data.buf) AsyncEvent{kill_evt};
ring->writeAdvance(1);
ctx->EventSem.post();
if(ctx->EventThread.joinable())
ctx->EventThread.join();
}
AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable)
START_API_FUNC
{
ContextRef context{GetContextRef()};
if(UNLIKELY(!context)) return;
if(count < 0) SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Controlling %d events", count);
if(count == 0) return;
if(!types) SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "NULL pointer");
ALbitfieldSOFT flags{0};
const ALenum *types_end = types+count;
auto bad_type = std::find_if_not(types, types_end,
[&flags](ALenum type) noexcept -> bool
{
if(type == AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT)
flags |= EventType_BufferCompleted;
else if(type == AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT)
flags |= EventType_SourceStateChange;
else if(type == AL_EVENT_TYPE_ERROR_SOFT)
flags |= EventType_Error;
else if(type == AL_EVENT_TYPE_PERFORMANCE_SOFT)
flags |= EventType_Performance;
else if(type == AL_EVENT_TYPE_DEPRECATED_SOFT)
flags |= EventType_Deprecated;
else if(type == AL_EVENT_TYPE_DISCONNECTED_SOFT)
flags |= EventType_Disconnected;
else
return false;
return true;
}
);
if(bad_type != types_end)
SETERR_RETURN(context.get(), AL_INVALID_ENUM,, "Invalid event type 0x%04x", *bad_type);
if(enable)
{
ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
while(context->EnabledEvts.compare_exchange_weak(enabledevts, enabledevts|flags,
std::memory_order_acq_rel, std::memory_order_acquire) == 0)
{
/* enabledevts is (re-)filled with the current value on failure, so
* just try again.
*/
}
}
else
{
ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
while(context->EnabledEvts.compare_exchange_weak(enabledevts, enabledevts&~flags,
std::memory_order_acq_rel, std::memory_order_acquire) == 0)
{
}
/* Wait to ensure the event handler sees the changed flags before
* returning.
*/
std::lock_guard<std::mutex>{context->EventCbLock};
}
}
END_API_FUNC
AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam)
START_API_FUNC
{
ContextRef context{GetContextRef()};
if(UNLIKELY(!context)) return;
std::lock_guard<std::mutex> _{context->PropLock};
std::lock_guard<std::mutex> __{context->EventCbLock};
context->EventCb = callback;
context->EventParam = userParam;
}
END_API_FUNC
<commit_msg>Minor formatting fixes<commit_after>
#include "config.h"
#include "event.h"
#include <algorithm>
#include <atomic>
#include <cstring>
#include <exception>
#include <memory>
#include <mutex>
#include <new>
#include <string>
#include <thread>
#include "AL/al.h"
#include "AL/alc.h"
#include "alError.h"
#include "albyte.h"
#include "alcontext.h"
#include "alexcpt.h"
#include "almalloc.h"
#include "effects/base.h"
#include "inprogext.h"
#include "logging.h"
#include "opthelpers.h"
#include "ringbuffer.h"
#include "threads.h"
static int EventThread(ALCcontext *context)
{
RingBuffer *ring{context->AsyncEvents.get()};
bool quitnow{false};
while(LIKELY(!quitnow))
{
auto evt_data = ring->getReadVector().first;
if(evt_data.len == 0)
{
context->EventSem.wait();
continue;
}
std::lock_guard<std::mutex> _{context->EventCbLock};
do {
auto &evt = *reinterpret_cast<AsyncEvent*>(evt_data.buf);
evt_data.buf += sizeof(AsyncEvent);
evt_data.len -= 1;
/* This automatically destructs the event object and advances the
* ringbuffer's read offset at the end of scope.
*/
const struct EventAutoDestructor {
AsyncEvent &evt_;
RingBuffer *ring_;
~EventAutoDestructor()
{
al::destroy_at(std::addressof(evt_));
ring_->readAdvance(1);
}
} _{evt, ring};
quitnow = evt.EnumType == EventType_KillThread;
if(UNLIKELY(quitnow)) break;
if(evt.EnumType == EventType_ReleaseEffectState)
{
evt.u.mEffectState->DecRef();
continue;
}
ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_acquire)};
if(!context->EventCb) continue;
if(evt.EnumType == EventType_SourceStateChange)
{
if(!(enabledevts&EventType_SourceStateChange))
continue;
std::string msg{"Source ID " + std::to_string(evt.u.srcstate.id)};
msg += " state has changed to ";
msg += (evt.u.srcstate.state==AL_INITIAL) ? "AL_INITIAL" :
(evt.u.srcstate.state==AL_PLAYING) ? "AL_PLAYING" :
(evt.u.srcstate.state==AL_PAUSED) ? "AL_PAUSED" :
(evt.u.srcstate.state==AL_STOPPED) ? "AL_STOPPED" : "<unknown>";
context->EventCb(AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT, evt.u.srcstate.id,
evt.u.srcstate.state, static_cast<ALsizei>(msg.length()), msg.c_str(),
context->EventParam);
}
else if(evt.EnumType == EventType_BufferCompleted)
{
if(!(enabledevts&EventType_BufferCompleted))
continue;
std::string msg{std::to_string(evt.u.bufcomp.count)};
if(evt.u.bufcomp.count == 1) msg += " buffer completed";
else msg += " buffers completed";
context->EventCb(AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT, evt.u.bufcomp.id,
evt.u.bufcomp.count, static_cast<ALsizei>(msg.length()), msg.c_str(),
context->EventParam);
}
else if((enabledevts&evt.EnumType) == evt.EnumType)
context->EventCb(evt.u.user.type, evt.u.user.id, evt.u.user.param,
static_cast<ALsizei>(strlen(evt.u.user.msg)), evt.u.user.msg,
context->EventParam);
} while(evt_data.len != 0);
}
return 0;
}
void StartEventThrd(ALCcontext *ctx)
{
try {
ctx->EventThread = std::thread{EventThread, ctx};
}
catch(std::exception& e) {
ERR("Failed to start event thread: %s\n", e.what());
}
catch(...) {
ERR("Failed to start event thread! Expect problems.\n");
}
}
void StopEventThrd(ALCcontext *ctx)
{
static constexpr AsyncEvent kill_evt{EventType_KillThread};
RingBuffer *ring{ctx->AsyncEvents.get()};
auto evt_data = ring->getWriteVector().first;
if(evt_data.len == 0)
{
do {
std::this_thread::yield();
evt_data = ring->getWriteVector().first;
} while(evt_data.len == 0);
}
new (evt_data.buf) AsyncEvent{kill_evt};
ring->writeAdvance(1);
ctx->EventSem.post();
if(ctx->EventThread.joinable())
ctx->EventThread.join();
}
AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable)
START_API_FUNC
{
ContextRef context{GetContextRef()};
if(UNLIKELY(!context)) return;
if(count < 0) SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Controlling %d events", count);
if(count == 0) return;
if(!types) SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "NULL pointer");
ALbitfieldSOFT flags{0};
const ALenum *types_end = types+count;
auto bad_type = std::find_if_not(types, types_end,
[&flags](ALenum type) noexcept -> bool
{
if(type == AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT)
flags |= EventType_BufferCompleted;
else if(type == AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT)
flags |= EventType_SourceStateChange;
else if(type == AL_EVENT_TYPE_ERROR_SOFT)
flags |= EventType_Error;
else if(type == AL_EVENT_TYPE_PERFORMANCE_SOFT)
flags |= EventType_Performance;
else if(type == AL_EVENT_TYPE_DEPRECATED_SOFT)
flags |= EventType_Deprecated;
else if(type == AL_EVENT_TYPE_DISCONNECTED_SOFT)
flags |= EventType_Disconnected;
else
return false;
return true;
}
);
if(bad_type != types_end)
SETERR_RETURN(context.get(), AL_INVALID_ENUM,, "Invalid event type 0x%04x", *bad_type);
if(enable)
{
ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
while(context->EnabledEvts.compare_exchange_weak(enabledevts, enabledevts|flags,
std::memory_order_acq_rel, std::memory_order_acquire) == 0)
{
/* enabledevts is (re-)filled with the current value on failure, so
* just try again.
*/
}
}
else
{
ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
while(context->EnabledEvts.compare_exchange_weak(enabledevts, enabledevts&~flags,
std::memory_order_acq_rel, std::memory_order_acquire) == 0)
{
}
/* Wait to ensure the event handler sees the changed flags before
* returning.
*/
std::lock_guard<std::mutex>{context->EventCbLock};
}
}
END_API_FUNC
AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam)
START_API_FUNC
{
ContextRef context{GetContextRef()};
if(UNLIKELY(!context)) return;
std::lock_guard<std::mutex> _{context->PropLock};
std::lock_guard<std::mutex> __{context->EventCbLock};
context->EventCb = callback;
context->EventParam = userParam;
}
END_API_FUNC
<|endoftext|> |
<commit_before>/*
This file is part of KOrganizer.
Copyright (c) 2008 Bruno Virlet <[email protected]>
Copyright (c) 2008 Thomas Thrainer <[email protected]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
As a special exception, permission is given to link this program
with any edition of Qt, and distribute the resulting executable,
without including the source code for Qt in the source distribution.
*/
#include "monthgraphicsitems.h"
#include "monthitem.h"
#include "monthscene.h"
#include "koglobals.h"
#include "koprefs.h"
#include "kohelper.h"
#include <QPainter>
#include <QGraphicsScene>
using namespace KOrg;
ScrollIndicator::ScrollIndicator( ScrollIndicator::ArrowDirection dir )
: mDirection( dir )
{
setZValue( 200 ); // on top of everything
hide();
}
QRectF ScrollIndicator::boundingRect() const
{
return QRectF( - mWidth / 2, - mHeight / 2, mWidth, mHeight );
}
void ScrollIndicator::paint( QPainter *painter, const QStyleOptionGraphicsItem *option,
QWidget *widget )
{
Q_UNUSED( option );
Q_UNUSED( widget );
painter->setRenderHint( QPainter::Antialiasing );
QPolygon arrow( 3 );
if ( mDirection == ScrollIndicator::UpArrow ) {
arrow.setPoint( 0, 0, - mHeight / 2 );
arrow.setPoint( 1, mWidth / 2, mHeight / 2 );
arrow.setPoint( 2, - mWidth / 2, mHeight / 2 );
} else if ( mDirection == ScrollIndicator::DownArrow ) { // down
arrow.setPoint( 1, mWidth / 2, - mHeight / 2 );
arrow.setPoint( 2, - mWidth / 2, - mHeight / 2 );
arrow.setPoint( 0, 0, mHeight / 2 );
}
QColor color( Qt::black );
color.setAlpha( 155 );
painter->setBrush( color );
painter->setPen( color );
painter->drawPolygon( arrow );
}
//-------------------------------------------------------------
MonthCell::MonthCell( int id, QDate date, QGraphicsScene *scene )
: mId( id ), mDate( date ), mScene( scene )
{
mUpArrow = new ScrollIndicator( ScrollIndicator::UpArrow );
mDownArrow = new ScrollIndicator( ScrollIndicator::DownArrow );
mScene->addItem( mUpArrow );
mScene->addItem( mDownArrow );
}
MonthCell::~MonthCell()
{
mScene->removeItem( mUpArrow );
mScene->removeItem( mDownArrow );
delete mUpArrow; // we've taken ownership, so this is safe
delete mDownArrow;
}
bool MonthCell::hasEventBelow( int height )
{
if ( mHeightHash.isEmpty() ) {
return false;
}
for ( int i=0; i<height; i++ ) {
if ( mHeightHash.value( i ) != 0 ) {
return true;
}
}
return false;
}
int MonthCell::topMargin()
{
return 18;
}
void MonthCell::addMonthItem( MonthItem *manager, int height )
{
mHeightHash[ height ] = manager;
}
int MonthCell::firstFreeSpace()
{
MonthItem *manager = 0;
int i = 0;
while ( true ) {
manager = mHeightHash[ i ];
if ( manager == 0 ) {
return i;
}
i++;
}
}
//-------------------------------------------------------------
// MONTHGRAPHICSITEM
static const int ft = 2; // frame thickness
MonthGraphicsItem::MonthGraphicsItem( MonthItem *manager )
: QGraphicsItem( 0, manager->monthScene() ),
mMonthItem( manager )
{
QTransform transform;
transform = transform.translate( 0.5, 0.5 );
setTransform( transform );
setToolTip( mMonthItem->toolTipText() );
}
MonthGraphicsItem::~MonthGraphicsItem()
{
}
bool MonthGraphicsItem::isMoving() const
{
return mMonthItem->isMoving();
}
bool MonthGraphicsItem::isEndItem() const
{
return startDate().addDays( daySpan() ) == mMonthItem->endDate();
}
bool MonthGraphicsItem::isBeginItem() const
{
return startDate() == mMonthItem->startDate();
}
QPainterPath MonthGraphicsItem::shape() const
{
return widgetPath( true );
}
// TODO: remove this method.
QPainterPath MonthGraphicsItem::widgetPath( bool border ) const
{
// If border is set we won't draw all the path. Items spanning on multiple
// rows won't have borders on their boundaries.
// If this is the mask, we draw it one pixel bigger
int x0 = 0;
int y0 = 0;
int x1 = boundingRect().width();
int y1 = boundingRect().height();
int height = y1 - y0;
int beginRound = height / 3;
QPainterPath path( QPoint( x0 + beginRound, y0 ) );
if ( isBeginItem() ) {
path.arcTo( QRect( x0, y0, beginRound * 2, height ), +90, +180 );
} else {
path.lineTo( x0, y0 );
if ( !border ) {
path.lineTo( x0, y1 );
} else {
path.moveTo( x0, y1 );
}
path.lineTo( x0 + beginRound, y1 );
}
if ( isEndItem() ) {
path.lineTo( x1 - beginRound, y1 );
path.arcTo( QRect( x1 - 2 * beginRound, y0, beginRound * 2, height ), -90, +180 );
} else {
path.lineTo( x1, y1 );
if ( !border ) {
path.lineTo( x1, y0 );
} else {
path.moveTo( x1, y0 );
}
}
// close path
path.lineTo( x0 + beginRound, y0 );
return path;
}
QRectF MonthGraphicsItem::boundingRect() const
{
// width - 2 because of the cell-dividing line with width == 1 at beginning and end
return QRectF( 0, 0, ( daySpan() + 1 ) * mMonthItem->monthScene()->columnWidth() - 2,
mMonthItem->monthScene()->itemHeight() );
}
void MonthGraphicsItem::paint( QPainter *p, const QStyleOptionGraphicsItem *, QWidget * )
{
if ( !mMonthItem->monthScene()->initialized() ) {
return;
}
MonthScene *scene = mMonthItem->monthScene();
p->setRenderHint( QPainter::Antialiasing );
int textMargin = 10;
QColor bgColor = mMonthItem->bgColor();
// keep this (110) in sync with agendaview
bgColor = mMonthItem->selected() ? bgColor.lighter( 110 ) : bgColor;
QColor frameColor = mMonthItem->frameColor( bgColor );
frameColor = mMonthItem->selected() ? frameColor.lighter( 110 ) : frameColor;
QColor textColor = getTextColor(bgColor);
// make moving or resizing items translucent
if ( mMonthItem->isMoving() || mMonthItem->isResizing() ) {
bgColor.setAlphaF( 0.75f );
}
QLinearGradient gradient( 0, 0, 0, boundingRect().height() );
gradient.setColorAt( 0, bgColor );
gradient.setColorAt( 0.7, bgColor.dark( 110 ) );
gradient.setColorAt( 1, bgColor.dark( 150 ) );
QBrush brush( gradient );
p->setBrush( brush );
p->setPen( Qt::NoPen );
// Rounded rect without border
p->drawPath( widgetPath( false ) );
// Draw the border without fill
QPen pen( frameColor );
pen.setWidth( ft );
p->setPen( pen );
p->setBrush( Qt::NoBrush );
p->drawPath( widgetPath( true ) );
p->setPen( textColor );
int alignFlag = Qt::AlignVCenter;
if ( isBeginItem() ) {
alignFlag |= Qt::AlignLeft;
} else if ( isEndItem() ) {
alignFlag |= Qt::AlignRight;
} else {
alignFlag |= Qt::AlignHCenter;
}
// !isBeginItem() is not always isEndItem()
QString text = mMonthItem->text( !isBeginItem() );
p->setFont( KOPrefs::instance()->monthViewFont() );
QRect textRect = QRect( textMargin, 0,
boundingRect().width() - 2 * textMargin, scene->itemHeight() );
if ( KOPrefs::instance()->enableMonthItemIcons() ) {
QList<QPixmap *> icons = mMonthItem->icons();
int iconWidths = 0;
foreach ( QPixmap *icon, icons ) {
iconWidths += icon->width();
}
if ( !icons.isEmpty() ) {
// add some margin between the icons and the text
iconWidths += textMargin / 2;
}
int textWidth = p->fontMetrics().size( 0, text ).width();
if ( textWidth + iconWidths > textRect.width() ) {
textWidth = textRect.width() - iconWidths;
if ( KOGlobals::reverseLayout() ) {
text = p->fontMetrics().elidedText( text, Qt::ElideLeft, textWidth );
} else {
text = p->fontMetrics().elidedText( text, Qt::ElideRight, textWidth );
}
}
int curXPos = textRect.left();
if ( alignFlag & Qt::AlignRight ) {
curXPos += textRect.width() - textWidth - iconWidths ;
} else if ( alignFlag & Qt::AlignHCenter ) {
curXPos += ( textRect.width() - textWidth - iconWidths ) / 2;
}
alignFlag &= ~( Qt::AlignRight | Qt::AlignCenter );
alignFlag |= Qt::AlignLeft;
// update the rect, where the text will be displayed
textRect.setLeft( curXPos + iconWidths );
// assume that all pixmaps have the same height
int pixYPos = icons.isEmpty() ? 0 : ( textRect.height() - icons[0]->height() ) / 2;
foreach ( QPixmap *icon, icons ) {
p->drawPixmap( curXPos, pixYPos, *icon );
curXPos += icon->width();
}
p->drawText( textRect, alignFlag, text );
} else {
if ( KOGlobals::reverseLayout() ) {
text = p->fontMetrics().elidedText( text, Qt::ElideLeft, textRect.width() );
} else {
text = p->fontMetrics().elidedText( text, Qt::ElideRight, textRect.width() );
}
p->drawText( textRect, alignFlag, text );
}
}
void MonthGraphicsItem::setStartDate( const QDate &date )
{
mStartDate = date;
}
QDate MonthGraphicsItem::endDate() const
{
return startDate().addDays( daySpan() );
}
QDate MonthGraphicsItem::startDate() const
{
return mStartDate;
}
void MonthGraphicsItem::setDaySpan( int span )
{
mDaySpan = span;
}
int MonthGraphicsItem::daySpan() const
{
return mDaySpan;
}
void MonthGraphicsItem::updateGeometry()
{
MonthCell *cell = mMonthItem->monthScene()->mMonthCellMap.value( startDate() );
// If the item is moving and this one is moved outside the view,
// cell will be null
if ( mMonthItem->isMoving() && !cell ) {
hide();
return;
}
Q_ASSERT( cell );
prepareGeometryChange();
int beginX = 1 + mMonthItem->monthScene()->cellHorizontalPos( cell );
int beginY = 1 + cell->topMargin() + mMonthItem->monthScene()->cellVerticalPos( cell );
beginY += mMonthItem->position() *
mMonthItem->monthScene()->itemHeightIncludingSpacing() -
mMonthItem->monthScene()->startHeight() *
mMonthItem->monthScene()->itemHeightIncludingSpacing(); // scrolling
setPos( beginX, beginY );
if ( mMonthItem->position() < mMonthItem->monthScene()->startHeight() ||
mMonthItem->position() - mMonthItem->monthScene()->startHeight() >=
mMonthItem->monthScene()->maxRowCount() ) {
hide();
} else {
show();
update();
}
}
<commit_msg>revert SVN commit 831596 by winterz:<commit_after>/*
This file is part of KOrganizer.
Copyright (c) 2008 Bruno Virlet <[email protected]>
Copyright (c) 2008 Thomas Thrainer <[email protected]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
As a special exception, permission is given to link this program
with any edition of Qt, and distribute the resulting executable,
without including the source code for Qt in the source distribution.
*/
#include "monthgraphicsitems.h"
#include "monthitem.h"
#include "monthscene.h"
#include "koprefs.h"
#include "kohelper.h"
#include <QPainter>
#include <QGraphicsScene>
using namespace KOrg;
ScrollIndicator::ScrollIndicator( ScrollIndicator::ArrowDirection dir )
: mDirection( dir )
{
setZValue( 200 ); // on top of everything
hide();
}
QRectF ScrollIndicator::boundingRect() const
{
return QRectF( - mWidth / 2, - mHeight / 2, mWidth, mHeight );
}
void ScrollIndicator::paint( QPainter *painter, const QStyleOptionGraphicsItem *option,
QWidget *widget )
{
Q_UNUSED( option );
Q_UNUSED( widget );
painter->setRenderHint( QPainter::Antialiasing );
QPolygon arrow( 3 );
if ( mDirection == ScrollIndicator::UpArrow ) {
arrow.setPoint( 0, 0, - mHeight / 2 );
arrow.setPoint( 1, mWidth / 2, mHeight / 2 );
arrow.setPoint( 2, - mWidth / 2, mHeight / 2 );
} else if ( mDirection == ScrollIndicator::DownArrow ) { // down
arrow.setPoint( 1, mWidth / 2, - mHeight / 2 );
arrow.setPoint( 2, - mWidth / 2, - mHeight / 2 );
arrow.setPoint( 0, 0, mHeight / 2 );
}
QColor color( Qt::black );
color.setAlpha( 155 );
painter->setBrush( color );
painter->setPen( color );
painter->drawPolygon( arrow );
}
//-------------------------------------------------------------
MonthCell::MonthCell( int id, QDate date, QGraphicsScene *scene )
: mId( id ), mDate( date ), mScene( scene )
{
mUpArrow = new ScrollIndicator( ScrollIndicator::UpArrow );
mDownArrow = new ScrollIndicator( ScrollIndicator::DownArrow );
mScene->addItem( mUpArrow );
mScene->addItem( mDownArrow );
}
MonthCell::~MonthCell()
{
mScene->removeItem( mUpArrow );
mScene->removeItem( mDownArrow );
delete mUpArrow; // we've taken ownership, so this is safe
delete mDownArrow;
}
bool MonthCell::hasEventBelow( int height )
{
if ( mHeightHash.isEmpty() ) {
return false;
}
for ( int i=0; i<height; i++ ) {
if ( mHeightHash.value( i ) != 0 ) {
return true;
}
}
return false;
}
int MonthCell::topMargin()
{
return 18;
}
void MonthCell::addMonthItem( MonthItem *manager, int height )
{
mHeightHash[ height ] = manager;
}
int MonthCell::firstFreeSpace()
{
MonthItem *manager = 0;
int i = 0;
while ( true ) {
manager = mHeightHash[ i ];
if ( manager == 0 ) {
return i;
}
i++;
}
}
//-------------------------------------------------------------
// MONTHGRAPHICSITEM
static const int ft = 2; // frame thickness
MonthGraphicsItem::MonthGraphicsItem( MonthItem *manager )
: QGraphicsItem( 0, manager->monthScene() ),
mMonthItem( manager )
{
QTransform transform;
transform = transform.translate( 0.5, 0.5 );
setTransform( transform );
setToolTip( mMonthItem->toolTipText() );
}
MonthGraphicsItem::~MonthGraphicsItem()
{
}
bool MonthGraphicsItem::isMoving() const
{
return mMonthItem->isMoving();
}
bool MonthGraphicsItem::isEndItem() const
{
return startDate().addDays( daySpan() ) == mMonthItem->endDate();
}
bool MonthGraphicsItem::isBeginItem() const
{
return startDate() == mMonthItem->startDate();
}
QPainterPath MonthGraphicsItem::shape() const
{
return widgetPath( true );
}
// TODO: remove this method.
QPainterPath MonthGraphicsItem::widgetPath( bool border ) const
{
// If border is set we won't draw all the path. Items spanning on multiple
// rows won't have borders on their boundaries.
// If this is the mask, we draw it one pixel bigger
int x0 = 0;
int y0 = 0;
int x1 = boundingRect().width();
int y1 = boundingRect().height();
int height = y1 - y0;
int beginRound = height / 3;
QPainterPath path( QPoint( x0 + beginRound, y0 ) );
if ( isBeginItem() ) {
path.arcTo( QRect( x0, y0, beginRound * 2, height ), +90, +180 );
} else {
path.lineTo( x0, y0 );
if ( !border ) {
path.lineTo( x0, y1 );
} else {
path.moveTo( x0, y1 );
}
path.lineTo( x0 + beginRound, y1 );
}
if ( isEndItem() ) {
path.lineTo( x1 - beginRound, y1 );
path.arcTo( QRect( x1 - 2 * beginRound, y0, beginRound * 2, height ), -90, +180 );
} else {
path.lineTo( x1, y1 );
if ( !border ) {
path.lineTo( x1, y0 );
} else {
path.moveTo( x1, y0 );
}
}
// close path
path.lineTo( x0 + beginRound, y0 );
return path;
}
QRectF MonthGraphicsItem::boundingRect() const
{
// width - 2 because of the cell-dividing line with width == 1 at beginning and end
return QRectF( 0, 0, ( daySpan() + 1 ) * mMonthItem->monthScene()->columnWidth() - 2,
mMonthItem->monthScene()->itemHeight() );
}
void MonthGraphicsItem::paint( QPainter *p, const QStyleOptionGraphicsItem *, QWidget * )
{
if ( !mMonthItem->monthScene()->initialized() ) {
return;
}
MonthScene *scene = mMonthItem->monthScene();
p->setRenderHint( QPainter::Antialiasing );
int textMargin = 10;
QColor bgColor = mMonthItem->bgColor();
// keep this (110) in sync with agendaview
bgColor = mMonthItem->selected() ? bgColor.lighter( 110 ) : bgColor;
QColor frameColor = mMonthItem->frameColor( bgColor );
frameColor = mMonthItem->selected() ? frameColor.lighter( 110 ) : frameColor;
QColor textColor = getTextColor(bgColor);
// make moving or resizing items translucent
if ( mMonthItem->isMoving() || mMonthItem->isResizing() ) {
bgColor.setAlphaF( 0.75f );
}
QLinearGradient gradient( 0, 0, 0, boundingRect().height() );
gradient.setColorAt( 0, bgColor );
gradient.setColorAt( 0.7, bgColor.dark( 110 ) );
gradient.setColorAt( 1, bgColor.dark( 150 ) );
QBrush brush( gradient );
p->setBrush( brush );
p->setPen( Qt::NoPen );
// Rounded rect without border
p->drawPath( widgetPath( false ) );
// Draw the border without fill
QPen pen( frameColor );
pen.setWidth( ft );
p->setPen( pen );
p->setBrush( Qt::NoBrush );
p->drawPath( widgetPath( true ) );
p->setPen( textColor );
int alignFlag = Qt::AlignVCenter;
if ( isBeginItem() ) {
alignFlag |= Qt::AlignLeft;
} else if ( isEndItem() ) {
alignFlag |= Qt::AlignRight;
} else {
alignFlag |= Qt::AlignHCenter;
}
// !isBeginItem() is not always isEndItem()
QString text = mMonthItem->text( !isBeginItem() );
p->setFont( KOPrefs::instance()->monthViewFont() );
QRect textRect = QRect( textMargin, 0,
boundingRect().width() - 2 * textMargin, scene->itemHeight() );
if ( KOPrefs::instance()->enableMonthItemIcons() ) {
QList<QPixmap *> icons = mMonthItem->icons();
int iconWidths = 0;
foreach ( QPixmap *icon, icons ) {
iconWidths += icon->width();
}
if ( !icons.isEmpty() ) {
// add some margin between the icons and the text
iconWidths += textMargin / 2;
}
int textWidth = p->fontMetrics().size( 0, text ).width();
if ( textWidth + iconWidths > textRect.width() ) {
textWidth = textRect.width() - iconWidths;
text = p->fontMetrics().elidedText( text, Qt::ElideRight, textWidth );
}
int curXPos = textRect.left();
if ( alignFlag & Qt::AlignRight ) {
curXPos += textRect.width() - textWidth - iconWidths ;
} else if ( alignFlag & Qt::AlignHCenter ) {
curXPos += ( textRect.width() - textWidth - iconWidths ) / 2;
}
alignFlag &= ~( Qt::AlignRight | Qt::AlignCenter );
alignFlag |= Qt::AlignLeft;
// update the rect, where the text will be displayed
textRect.setLeft( curXPos + iconWidths );
// assume that all pixmaps have the same height
int pixYPos = icons.isEmpty() ? 0 : ( textRect.height() - icons[0]->height() ) / 2;
foreach ( QPixmap *icon, icons ) {
p->drawPixmap( curXPos, pixYPos, *icon );
curXPos += icon->width();
}
p->drawText( textRect, alignFlag, text );
} else {
text = p->fontMetrics().elidedText( text, Qt::ElideRight, textRect.width() );
p->drawText( textRect, alignFlag, text );
}
}
void MonthGraphicsItem::setStartDate( const QDate &date )
{
mStartDate = date;
}
QDate MonthGraphicsItem::endDate() const
{
return startDate().addDays( daySpan() );
}
QDate MonthGraphicsItem::startDate() const
{
return mStartDate;
}
void MonthGraphicsItem::setDaySpan( int span )
{
mDaySpan = span;
}
int MonthGraphicsItem::daySpan() const
{
return mDaySpan;
}
void MonthGraphicsItem::updateGeometry()
{
MonthCell *cell = mMonthItem->monthScene()->mMonthCellMap.value( startDate() );
// If the item is moving and this one is moved outside the view,
// cell will be null
if ( mMonthItem->isMoving() && !cell ) {
hide();
return;
}
Q_ASSERT( cell );
prepareGeometryChange();
int beginX = 1 + mMonthItem->monthScene()->cellHorizontalPos( cell );
int beginY = 1 + cell->topMargin() + mMonthItem->monthScene()->cellVerticalPos( cell );
beginY += mMonthItem->position() *
mMonthItem->monthScene()->itemHeightIncludingSpacing() -
mMonthItem->monthScene()->startHeight() *
mMonthItem->monthScene()->itemHeightIncludingSpacing(); // scrolling
setPos( beginX, beginY );
if ( mMonthItem->position() < mMonthItem->monthScene()->startHeight() ||
mMonthItem->position() - mMonthItem->monthScene()->startHeight() >=
mMonthItem->monthScene()->maxRowCount() ) {
hide();
} else {
show();
update();
}
}
<|endoftext|> |
<commit_before>#ifndef __STAN__PROB__DISTRIBUTIONS__MULTIVARIATE__CONTINUOUS__GAUSSIAN_DLM_HPP__
#define __STAN__PROB__DISTRIBUTIONS__MULTIVARIATE__CONTINUOUS__GAUSSIAN_DLM_HPP__
#include <boost/random/normal_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include <stan/math/matrix_error_handling.hpp>
#include <stan/math/error_handling.hpp>
#include <stan/math/error_handling/dom_err.hpp>
#include <stan/prob/constants.hpp>
#include <stan/prob/traits.hpp>
#include <stan/agrad/agrad.hpp>
#include <stan/meta/traits.hpp>
#include <stan/agrad/matrix.hpp>
#include <stan/math/matrix/log.hpp>
#include <stan/math/matrix/subtract.hpp>
#include <stan/math/matrix/add.hpp>
#include <stan/math/matrix/multiply.hpp>
#include <stan/math/matrix/transpose.hpp>
#include <stan/math/matrix/inverse.hpp>
#include <stan/math/matrix/col.hpp>
// TODO: y as vector of vectors or matrix?
namespace stan {
namespace prob {
/**
* The log of a multivariate Gaussian Process for the given y, Sigma, and
* w. y is a dxN matrix, where each column is a different observation and each
* row is a different output dimension. The Guassian Process is assumed to
* have a scaled kernel matrix with a different scale for each output dimension.
* This distribution is equivalent to, for \f$t = 1:N$,
* \f{eqnarray*}{
* y_t & \sim N(F' \theta_t, V) \\
* \theta_t & \sim N(G \theta_{t-1}, W) \\
* \theta_0 & \sim N(0, diag(10^{6}))
* }
*
* @param y A r x T matrix of observations.
* @param F A n x r matrix. The design matrix.
* @param G A n x n matrix. The transition matrix.
* @param V A r x r matrix. The observation covariance matrix.
* @param W A n x n matrix. The state covariance matrix.
* @return The log of the joint density of the GDLM.
* @throw std::domain_error if Sigma is not square, not symmetric,
* or not semi-positive definite.
* @tparam T_y Type of scalar.
* @tparam T_F Type of design matrix.
* @tparam T_G Type of transition matrix.
* @tparam T_V Type of observation covariance matrix.
* @tparam T_W Type of state covariance matrix.
*/
template <bool propto,
typename T_y,
typename T_F, typename T_G,
typename T_V, typename T_W
>
typename boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type
gaussian_dlm_log(const Eigen::Matrix<T_y,Eigen::Dynamic,Eigen::Dynamic>& y,
const Eigen::Matrix<T_F,Eigen::Dynamic,Eigen::Dynamic>& F,
const Eigen::Matrix<T_G,Eigen::Dynamic,Eigen::Dynamic>& G,
const Eigen::Matrix<T_V,Eigen::Dynamic,Eigen::Dynamic>& V,
const Eigen::Matrix<T_W,Eigen::Dynamic,Eigen::Dynamic>& W) {
static const char* function = "stan::prob::dlm_log(%1%)";
typedef typename boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type T_lp;
T_lp lp(0.0);
using stan::math::check_not_nan;
using stan::math::check_size_match;
using stan::math::check_finite;
using stan::math::check_cov_matrix;
using stan::math::add;
using stan::math::multiply;
using stan::math::transpose;
using stan::math::inverse;
using stan::math::subtract;
int r = y.rows(); // number of variables
int T = y.cols(); // number of observations
int n = G.rows(); // number of states
// check F
if (!check_size_match(function,
F.cols(), "columns of F",
y.rows(), "rows of y",
&lp))
return lp;
if (!check_size_match(function,
F.rows(), "rows of F",
G.rows(), "rows of G",
&lp))
return lp;
// check G
if (!check_size_match(function,
G.rows(), "rows of G",
G.cols(), "columns of G",
&lp))
return lp;
// check V
if (!check_cov_matrix(function, V, "V", &lp))
return lp;
if (!check_size_match(function,
V.rows(), "rows of V",
y.rows(), "rows of y",
&lp))
return lp;
// check W
if (!check_cov_matrix(function, W, "W", &lp))
return lp;
if (!check_size_match(function,
W.rows(), "rows of W",
G.rows(), "rows of G",
&lp))
return lp;
if (y.cols() == 0 || y.rows() == 0)
return lp;
if (include_summand<propto>::value) {
lp += 0.5 *NEG_LOG_SQRT_TWO_PI * r * T;
}
if (include_summand<propto,T_y,T_F,T_G,T_V,T_W>::value) {
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> m(n);
for (int i = 0; i < m.size(); i ++)
m(i) = 0;
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> C(n, n);
for (int i = 0; i < C.rows(); i ++) {
for (int j = 0; j < C.cols(); j ++) {
if (i == j) {
C(i, j) == 10e6;
} else {
C(i, j) == 0.0;
}
}
}
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> a(n);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> R(n, n);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> f(r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> Q(r, r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> Q_inv(r, r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> e(r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> A(n, r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y>::type,
Eigen::Dynamic, 1> yi(r);
for (int i = 0; i < T; ++i) {
yi = y.col(i);
std::cout << yi << std::endl;
// Predict
a = multiply(G, m);
R = quad_form_sym(C, transpose(G)) + W;
// filter
f = multiply(transpose(F), a);
Q = quad_form_sym(R, F) + V;
Q_inv = inverse(Q);
e = subtract(yi, f);
A = multiply(multiply(R, F), Q_inv);
// // // update log-likelihood
m = add(a, multiply(A, e));
C = subtract(R, quad_form_sym(Q, transpose(A)));
lp -= 0.5 * (log_determinant(Q) + trace_quad_form(Q_inv, e));
}
}
return lp;
}
template <typename T_y,
typename T_F, typename T_G,
typename T_V, typename T_W
>
inline
typename boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type
gaussian_dlm_log(const Eigen::Matrix<T_y,Eigen::Dynamic,Eigen::Dynamic>& y,
const Eigen::Matrix<T_F,Eigen::Dynamic,Eigen::Dynamic>& F,
const Eigen::Matrix<T_G,Eigen::Dynamic,Eigen::Dynamic>& G,
const Eigen::Matrix<T_V,Eigen::Dynamic,Eigen::Dynamic>& V,
const Eigen::Matrix<T_W,Eigen::Dynamic,Eigen::Dynamic>& W) {
return gaussian_dlm_log<false>(y, F, G, V, W);
}
}
}
#endif
<commit_msg>working implementation<commit_after>#ifndef __STAN__PROB__DISTRIBUTIONS__MULTIVARIATE__CONTINUOUS__GAUSSIAN_DLM_HPP__
#define __STAN__PROB__DISTRIBUTIONS__MULTIVARIATE__CONTINUOUS__GAUSSIAN_DLM_HPP__
#include <boost/random/normal_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include <stan/math/matrix_error_handling.hpp>
#include <stan/math/error_handling.hpp>
#include <stan/math/error_handling/dom_err.hpp>
#include <stan/prob/constants.hpp>
#include <stan/prob/traits.hpp>
#include <stan/agrad/agrad.hpp>
#include <stan/meta/traits.hpp>
#include <stan/agrad/matrix.hpp>
#include <stan/math/matrix/log.hpp>
#include <stan/math/matrix/subtract.hpp>
#include <stan/math/matrix/add.hpp>
#include <stan/math/matrix/multiply.hpp>
#include <stan/math/matrix/transpose.hpp>
#include <stan/math/matrix/inverse.hpp>
#include <stan/math/matrix/col.hpp>
// TODO: y as vector of vectors or matrix?
namespace stan {
namespace prob {
/**
* The log of a multivariate Gaussian Process for the given y, Sigma, and
* w. y is a dxN matrix, where each column is a different observation and each
* row is a different output dimension. The Guassian Process is assumed to
* have a scaled kernel matrix with a different scale for each output dimension.
* This distribution is equivalent to, for \f$t = 1:N$,
* \f{eqnarray*}{
* y_t & \sim N(F' \theta_t, V) \\
* \theta_t & \sim N(G \theta_{t-1}, W) \\
* \theta_0 & \sim N(0, diag(10^{6}))
* }
*
* @param y A r x T matrix of observations.
* @param F A n x r matrix. The design matrix.
* @param G A n x n matrix. The transition matrix.
* @param V A r x r matrix. The observation covariance matrix.
* @param W A n x n matrix. The state covariance matrix.
* @return The log of the joint density of the GDLM.
* @throw std::domain_error if Sigma is not square, not symmetric,
* or not semi-positive definite.
* @tparam T_y Type of scalar.
* @tparam T_F Type of design matrix.
* @tparam T_G Type of transition matrix.
* @tparam T_V Type of observation covariance matrix.
* @tparam T_W Type of state covariance matrix.
*/
template <bool propto,
typename T_y,
typename T_F, typename T_G,
typename T_V, typename T_W
>
typename boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type
gaussian_dlm_log(const Eigen::Matrix<T_y,Eigen::Dynamic,Eigen::Dynamic>& y,
const Eigen::Matrix<T_F,Eigen::Dynamic,Eigen::Dynamic>& F,
const Eigen::Matrix<T_G,Eigen::Dynamic,Eigen::Dynamic>& G,
const Eigen::Matrix<T_V,Eigen::Dynamic,Eigen::Dynamic>& V,
const Eigen::Matrix<T_W,Eigen::Dynamic,Eigen::Dynamic>& W) {
static const char* function = "stan::prob::dlm_log(%1%)";
typedef typename boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type T_lp;
T_lp lp(0.0);
using stan::math::check_not_nan;
using stan::math::check_size_match;
using stan::math::check_finite;
using stan::math::check_cov_matrix;
using stan::math::add;
using stan::math::multiply;
using stan::math::transpose;
using stan::math::inverse;
using stan::math::subtract;
int r = y.rows(); // number of variables
int T = y.cols(); // number of observations
int n = G.rows(); // number of states
// check F
if (!check_size_match(function,
F.cols(), "columns of F",
y.rows(), "rows of y",
&lp))
return lp;
if (!check_size_match(function,
F.rows(), "rows of F",
G.rows(), "rows of G",
&lp))
return lp;
// check G
if (!check_size_match(function,
G.rows(), "rows of G",
G.cols(), "columns of G",
&lp))
return lp;
// check V
if (!check_cov_matrix(function, V, "V", &lp))
return lp;
if (!check_size_match(function,
V.rows(), "rows of V",
y.rows(), "rows of y",
&lp))
return lp;
// check W
if (!check_cov_matrix(function, W, "W", &lp))
return lp;
if (!check_size_match(function,
W.rows(), "rows of W",
G.rows(), "rows of G",
&lp))
return lp;
if (y.cols() == 0 || y.rows() == 0)
return lp;
if (include_summand<propto>::value) {
lp += 0.5 *NEG_LOG_SQRT_TWO_PI * r * T;
}
if (include_summand<propto,T_y,T_F,T_G,T_V,T_W>::value) {
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> m(n);
for (int i = 0; i < m.size(); i ++)
m(i) = 0.0;
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> C(n, n);
for (int i = 0; i < C.rows(); i ++) {
for (int j = 0; j < C.cols(); j ++) {
if (i == j) {
C(i, j) = 10e6;
} else {
C(i, j) = 0.0;
}
}
}
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> a(n);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> R(n, n);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> f(r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> Q(r, r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> Q_inv(r, r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, 1> e(r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type,
Eigen::Dynamic, Eigen::Dynamic> A(n, r);
Eigen::Matrix<typename
boost::math::tools::promote_args<T_y>::type,
Eigen::Dynamic, 1> yi(r);
for (int i = 0; i < T; ++i) {
yi = y.col(i);
// Predict
a = multiply(G, m);
R = quad_form_sym(C, transpose(G)) + W;
// filter
f = multiply(transpose(F), a);
Q = quad_form_sym(R, F) + V;
Q_inv = inverse(Q);
e = subtract(yi, f);
A = multiply(multiply(R, F), Q_inv);
// // // update log-likelihood
m = add(a, multiply(A, e));
C = subtract(R, quad_form_sym(Q, transpose(A)));
lp -= 0.5 * (log_determinant(Q) + trace_quad_form(Q_inv, e));
}
}
return lp;
}
template <typename T_y,
typename T_F, typename T_G,
typename T_V, typename T_W
>
inline
typename boost::math::tools::promote_args<T_y,T_F,T_G,T_V,T_W>::type
gaussian_dlm_log(const Eigen::Matrix<T_y,Eigen::Dynamic,Eigen::Dynamic>& y,
const Eigen::Matrix<T_F,Eigen::Dynamic,Eigen::Dynamic>& F,
const Eigen::Matrix<T_G,Eigen::Dynamic,Eigen::Dynamic>& G,
const Eigen::Matrix<T_V,Eigen::Dynamic,Eigen::Dynamic>& V,
const Eigen::Matrix<T_W,Eigen::Dynamic,Eigen::Dynamic>& W) {
return gaussian_dlm_log<false>(y, F, G, V, W);
}
}
}
#endif
<|endoftext|> |
<commit_before>/*=========================================================================
Program: Visualization Toolkit
Module: vtkProbeFilter.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkProbeFilter.h"
#include "vtkCell.h"
#include "vtkIdTypeArray.h"
#include "vtkImageData.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkObjectFactory.h"
#include "vtkPointData.h"
#include "vtkStreamingDemandDrivenPipeline.h"
vtkCxxRevisionMacro(vtkProbeFilter, "1.80");
vtkStandardNewMacro(vtkProbeFilter);
//----------------------------------------------------------------------------
vtkProbeFilter::vtkProbeFilter()
{
this->SpatialMatch = 0;
this->ValidPoints = vtkIdTypeArray::New();
this->SetNumberOfInputPorts(2);
}
//----------------------------------------------------------------------------
vtkProbeFilter::~vtkProbeFilter()
{
this->ValidPoints->Delete();
this->ValidPoints = NULL;
}
//----------------------------------------------------------------------------
void vtkProbeFilter::SetSource(vtkDataSet *input)
{
this->SetInput(1, input);
}
//----------------------------------------------------------------------------
vtkDataSet *vtkProbeFilter::GetSource()
{
if (this->GetNumberOfInputConnections(1) < 1)
{
return NULL;
}
return vtkDataSet::SafeDownCast(
this->GetExecutive()->GetInputData(1, 0));
}
//----------------------------------------------------------------------------
int vtkProbeFilter::RequestData(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
// get the input and ouptut
vtkDataSet *input = vtkDataSet::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkDataSet *source = vtkDataSet::SafeDownCast(
sourceInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkDataSet *output = vtkDataSet::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkIdType ptId, numPts;
double x[3], tol2;
vtkCell *cell;
vtkPointData *pd, *outPD;
int subId;
double pcoords[3], *weights;
double fastweights[256];
vtkDebugMacro(<<"Probing data");
pd = source->GetPointData();
int size = input->GetNumberOfPoints();
// lets use a stack allocated array if possible for performance reasons
int mcs = source->GetMaxCellSize();
if (mcs<=256)
{
weights = fastweights;
}
else
{
weights = new double[mcs];
}
// First, copy the input to the output as a starting point
output->CopyStructure( input );
numPts = input->GetNumberOfPoints();
this->ValidPoints->Allocate(numPts);
// Allocate storage for output PointData
//
outPD = output->GetPointData();
outPD->InterpolateAllocate(pd, size, size);
// Use tolerance as a function of size of source data
//
tol2 = source->GetLength();
tol2 = tol2 ? tol2*tol2 / 1000.0 : 0.001;
// Loop over all input points, interpolating source data
//
int abort=0;
vtkIdType progressInterval=numPts/20 + 1;
for (ptId=0; ptId < numPts && !abort; ptId++)
{
if ( !(ptId % progressInterval) )
{
this->UpdateProgress((double)ptId/numPts);
abort = GetAbortExecute();
}
// Get the xyz coordinate of the point in the input dataset
input->GetPoint(ptId, x);
// Find the cell that contains xyz and get it
cell = source->FindAndGetCell(x,NULL,-1,tol2,subId,pcoords,weights);
if (cell)
{
// Interpolate the point data
outPD->InterpolatePoint(pd,ptId,cell->PointIds,weights);
this->ValidPoints->InsertNextValue(ptId);
}
else
{
outPD->NullPoint(ptId);
}
}
// BUG FIX: JB.
// Output gets setup from input, but when output is imagedata, scalartype
// depends on source scalartype not input scalartype
if (output->IsA("vtkImageData"))
{
vtkImageData *out = (vtkImageData*)output;
vtkDataArray *s = outPD->GetScalars();
out->SetScalarType(s->GetDataType());
out->SetNumberOfScalarComponents(s->GetNumberOfComponents());
}
if (mcs>256)
{
delete [] weights;
}
return 1;
}
//----------------------------------------------------------------------------
int vtkProbeFilter::RequestInformation(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
outInfo->Set(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(),
inInfo->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()),
6);
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
inInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES()));
// Special case for ParaView.
if (this->SpatialMatch == 2)
{
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
sourceInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES()));
}
if (this->SpatialMatch == 1)
{
int m1 = inInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES());
int m2 = sourceInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES());
if (m1 < 0 && m2 < 0)
{
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
-1);
}
else
{
if (m1 < -1)
{
m1 = VTK_LARGE_INTEGER;
}
if (m2 < -1)
{
m2 = VTK_LARGE_INTEGER;
}
if (m2 < m1)
{
m1 = m2;
}
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
m1);
}
}
return 1;
}
//----------------------------------------------------------------------------
int vtkProbeFilter::RequestUpdateExtent(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
int usePiece = 0;
// What ever happend to CopyUpdateExtent in vtkDataObject?
// Copying both piece and extent could be bad. Setting the piece
// of a structured data set will affect the extent.
if (!strcmp(outInfo->Get(vtkDataObject::DATA_TYPE_NAME()), "vtkUnstructuredGrid") ||
!strcmp(outInfo->Get(vtkDataObject::DATA_TYPE_NAME()), "vtkPolyData"))
{
usePiece = 1;
}
inInfo->Set(vtkStreamingDemandDrivenPipeline::EXACT_EXTENT(), 1);
if ( ! this->SpatialMatch)
{
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(), 0);
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
1);
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
0);
}
else if (this->SpatialMatch == 1)
{
if (usePiece)
{
// Request an extra ghost level because the probe
// gets external values with computation prescision problems.
// I think the probe should be changed to have an epsilon ...
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS())+1);
}
else
{
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT()),
6);
}
}
if (usePiece)
{
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS()));
}
else
{
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT()),
6);
}
// Use the whole input in all processes, and use the requested update
// extent of the output to divide up the source.
if (this->SpatialMatch == 2)
{
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(), 0);
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(), 1);
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(), 0);
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS()));
}
return 1;
}
//----------------------------------------------------------------------------
void vtkProbeFilter::PrintSelf(ostream& os, vtkIndent indent)
{
vtkDataSet *source = this->GetSource();
this->Superclass::PrintSelf(os,indent);
os << indent << "Source: " << source << "\n";
if (this->SpatialMatch)
{
os << indent << "SpatialMatchOn\n";
}
else
{
os << indent << "SpatialMatchOff\n";
}
os << indent << "ValidPoints: " << this->ValidPoints << "\n";
}
<commit_msg>BUG: test whether DATA_TYPE_NAME is non-NULL before doing a strcmp with it<commit_after>/*=========================================================================
Program: Visualization Toolkit
Module: vtkProbeFilter.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkProbeFilter.h"
#include "vtkCell.h"
#include "vtkIdTypeArray.h"
#include "vtkImageData.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkObjectFactory.h"
#include "vtkPointData.h"
#include "vtkStreamingDemandDrivenPipeline.h"
vtkCxxRevisionMacro(vtkProbeFilter, "1.81");
vtkStandardNewMacro(vtkProbeFilter);
//----------------------------------------------------------------------------
vtkProbeFilter::vtkProbeFilter()
{
this->SpatialMatch = 0;
this->ValidPoints = vtkIdTypeArray::New();
this->SetNumberOfInputPorts(2);
}
//----------------------------------------------------------------------------
vtkProbeFilter::~vtkProbeFilter()
{
this->ValidPoints->Delete();
this->ValidPoints = NULL;
}
//----------------------------------------------------------------------------
void vtkProbeFilter::SetSource(vtkDataSet *input)
{
this->SetInput(1, input);
}
//----------------------------------------------------------------------------
vtkDataSet *vtkProbeFilter::GetSource()
{
if (this->GetNumberOfInputConnections(1) < 1)
{
return NULL;
}
return vtkDataSet::SafeDownCast(
this->GetExecutive()->GetInputData(1, 0));
}
//----------------------------------------------------------------------------
int vtkProbeFilter::RequestData(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
// get the input and ouptut
vtkDataSet *input = vtkDataSet::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkDataSet *source = vtkDataSet::SafeDownCast(
sourceInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkDataSet *output = vtkDataSet::SafeDownCast(
outInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkIdType ptId, numPts;
double x[3], tol2;
vtkCell *cell;
vtkPointData *pd, *outPD;
int subId;
double pcoords[3], *weights;
double fastweights[256];
vtkDebugMacro(<<"Probing data");
pd = source->GetPointData();
int size = input->GetNumberOfPoints();
// lets use a stack allocated array if possible for performance reasons
int mcs = source->GetMaxCellSize();
if (mcs<=256)
{
weights = fastweights;
}
else
{
weights = new double[mcs];
}
// First, copy the input to the output as a starting point
output->CopyStructure( input );
numPts = input->GetNumberOfPoints();
this->ValidPoints->Allocate(numPts);
// Allocate storage for output PointData
//
outPD = output->GetPointData();
outPD->InterpolateAllocate(pd, size, size);
// Use tolerance as a function of size of source data
//
tol2 = source->GetLength();
tol2 = tol2 ? tol2*tol2 / 1000.0 : 0.001;
// Loop over all input points, interpolating source data
//
int abort=0;
vtkIdType progressInterval=numPts/20 + 1;
for (ptId=0; ptId < numPts && !abort; ptId++)
{
if ( !(ptId % progressInterval) )
{
this->UpdateProgress((double)ptId/numPts);
abort = GetAbortExecute();
}
// Get the xyz coordinate of the point in the input dataset
input->GetPoint(ptId, x);
// Find the cell that contains xyz and get it
cell = source->FindAndGetCell(x,NULL,-1,tol2,subId,pcoords,weights);
if (cell)
{
// Interpolate the point data
outPD->InterpolatePoint(pd,ptId,cell->PointIds,weights);
this->ValidPoints->InsertNextValue(ptId);
}
else
{
outPD->NullPoint(ptId);
}
}
// BUG FIX: JB.
// Output gets setup from input, but when output is imagedata, scalartype
// depends on source scalartype not input scalartype
if (output->IsA("vtkImageData"))
{
vtkImageData *out = (vtkImageData*)output;
vtkDataArray *s = outPD->GetScalars();
out->SetScalarType(s->GetDataType());
out->SetNumberOfScalarComponents(s->GetNumberOfComponents());
}
if (mcs>256)
{
delete [] weights;
}
return 1;
}
//----------------------------------------------------------------------------
int vtkProbeFilter::RequestInformation(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
outInfo->Set(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(),
inInfo->Get(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT()),
6);
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
inInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES()));
// Special case for ParaView.
if (this->SpatialMatch == 2)
{
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
sourceInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES()));
}
if (this->SpatialMatch == 1)
{
int m1 = inInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES());
int m2 = sourceInfo->Get(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES());
if (m1 < 0 && m2 < 0)
{
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
-1);
}
else
{
if (m1 < -1)
{
m1 = VTK_LARGE_INTEGER;
}
if (m2 < -1)
{
m2 = VTK_LARGE_INTEGER;
}
if (m2 < m1)
{
m1 = m2;
}
outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),
m1);
}
}
return 1;
}
//----------------------------------------------------------------------------
int vtkProbeFilter::RequestUpdateExtent(
vtkInformation *vtkNotUsed(request),
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
// get the info objects
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *sourceInfo = inputVector[1]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
int usePiece = 0;
// What ever happend to CopyUpdateExtent in vtkDataObject?
// Copying both piece and extent could be bad. Setting the piece
// of a structured data set will affect the extent.
if (outInfo->Get(vtkDataObject::DATA_TYPE_NAME()) &&
(!strcmp(outInfo->Get(vtkDataObject::DATA_TYPE_NAME()), "vtkUnstructuredGrid") ||
!strcmp(outInfo->Get(vtkDataObject::DATA_TYPE_NAME()), "vtkPolyData")))
{
usePiece = 1;
}
inInfo->Set(vtkStreamingDemandDrivenPipeline::EXACT_EXTENT(), 1);
if ( ! this->SpatialMatch)
{
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(), 0);
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
1);
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
0);
}
else if (this->SpatialMatch == 1)
{
if (usePiece)
{
// Request an extra ghost level because the probe
// gets external values with computation prescision problems.
// I think the probe should be changed to have an epsilon ...
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS())+1);
}
else
{
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT()),
6);
}
}
if (usePiece)
{
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS()));
}
else
{
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_EXTENT()),
6);
}
// Use the whole input in all processes, and use the requested update
// extent of the output to divide up the source.
if (this->SpatialMatch == 2)
{
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(), 0);
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(), 1);
inInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(), 0);
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_PIECES()));
sourceInfo->Set(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS(),
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_NUMBER_OF_GHOST_LEVELS()));
}
return 1;
}
//----------------------------------------------------------------------------
void vtkProbeFilter::PrintSelf(ostream& os, vtkIndent indent)
{
vtkDataSet *source = this->GetSource();
this->Superclass::PrintSelf(os,indent);
os << indent << "Source: " << source << "\n";
if (this->SpatialMatch)
{
os << indent << "SpatialMatchOn\n";
}
else
{
os << indent << "SpatialMatchOff\n";
}
os << indent << "ValidPoints: " << this->ValidPoints << "\n";
}
<|endoftext|> |
<commit_before>//
// Landscape.cpp
//
// Created by Soso Limited on 5/26/15.
//
//
#include "Landscape.h"
#include "cinder/Log.h"
#include "Constants.h"
#include "LandscapeGeometry.h"
#include "cinder/Json.h"
using namespace soso;
using namespace cinder;
namespace {
struct alignas(16) Vertex {
vec3 position;
vec3 normal;
vec2 tex_coord;
vec2 color_tex_coord;
float deform_scaling;
float frame_offset;
float color_weight;
};
const auto kVertexLayout = ([] {
auto layout = geom::BufferLayout();
layout.append( geom::Attrib::POSITION, 3, sizeof(Vertex), offsetof(Vertex, position) );
layout.append( geom::Attrib::NORMAL, 3, sizeof(Vertex), offsetof(Vertex, normal) );
layout.append( geom::Attrib::TEX_COORD_0, 2, sizeof(Vertex), offsetof(Vertex, tex_coord) );
layout.append( geom::Attrib::TEX_COORD_1, 2, sizeof(Vertex), offsetof(Vertex, color_tex_coord) );
layout.append( geom::Attrib::CUSTOM_0, 1, sizeof(Vertex), offsetof(Vertex, deform_scaling) );
layout.append( geom::Attrib::CUSTOM_1, 1, sizeof(Vertex), offsetof(Vertex, frame_offset) );
layout.append( geom::Attrib::CUSTOM_2, 1, sizeof(Vertex), offsetof(Vertex, color_weight) );
return layout;
} ());
const auto kVertexMapping = ([] {
return gl::Batch::AttributeMapping{ { geom::Attrib::CUSTOM_0, "DeformScaling" }, { geom::Attrib::CUSTOM_1, "FrameOffset" }, { geom::Attrib::CUSTOM_2, "ColorWeight" } };
} ());
// Load a shader and handle exceptions. Return nullptr on failure.
gl::GlslProgRef loadShader( const fs::path &iVertex, const fs::path &iFragment )
{
try {
auto shader_format = gl::GlslProg::Format()
.vertex( app::loadAsset( iVertex ) )
.fragment( app::loadAsset( iFragment ) );
return gl::GlslProg::create( shader_format );
}
catch( ci::Exception &exc ) {
CI_LOG_E( "Error loading shader: " << exc.what() );
}
return nullptr;
}
///
/// Create a quadrilateral with clockwise vertices abcd.
/// Maps to frame at time and a slice of the video frame.
///
void addQuad( std::vector<Vertex> &vertices, const vec3 &a, const vec3 &b, const vec3 &c, const vec3 &d, float time, const Rectf &slice )
{
auto normal = vec3( 0, 1, 0 );
auto deform_scaling = 0.0f;
vertices.insert( vertices.end(), {
Vertex{ a, normal, slice.getUpperLeft(), slice.getUpperLeft(), deform_scaling, time, 0.0f },
Vertex{ b, normal, slice.getUpperRight(), slice.getUpperRight(), deform_scaling, time, 0.0f },
Vertex{ c, normal, slice.getLowerRight(), slice.getLowerRight(), deform_scaling, time, 0.0f },
Vertex{ a, normal, slice.getUpperLeft(), slice.getUpperLeft(), deform_scaling, time, 0.0f },
Vertex{ c, normal, slice.getLowerRight(), slice.getLowerRight(), deform_scaling, time, 0.0f },
Vertex{ d, normal, slice.getLowerLeft(), slice.getLowerLeft(), deform_scaling, time, 0.0f }
} );
}
/// Add a ring of geometry containing a given number of time bands (slitscanning effect) and repeats around the donut.
void addRing( std::vector<Vertex> &vertices, const Bar &bar, const ci::vec2 ¢er_offset )
{
auto segments = 64;
auto texture_insets = vec2( 0.05, 0.0875f );
// Generate cartesian position.
const auto calc_pos = [=] (int r, int s) {
auto pos = mix( bar.begin, bar.end, (float)r ) + center_offset;
auto t = (float) s / segments;
auto rotation = glm::rotate<float>( t * Tau, vec3(0, 1, 0) );
return vec3( rotation * vec4( pos, 0.0f, 1.0f ) );
};
const auto calc_normal = [=] (int r, int s) {
auto ray = bar.end - bar.begin;
auto normal = normalize(vec3(- ray.y, ray.x, 0.0f));
auto t = (float) s / segments;
auto rotation = glm::rotate<float>( t * Tau, vec3(0, 1, 0) );
return vec3( rotation * vec4(normal, 0.0f) );
};
// Generate texture coordinate mirrored at halfway point.
const auto calc_tc = [=] (int r, int s) {
auto t = (float) s / segments;
if( t < 1 ) {
t = glm::fract( t * bar.repeats );
}
// mirror copies
t = std::abs( t - 0.5f ) * 2.0f;
auto tc = vec2(0);
// Repeat t with mirroring
// insetting the texture coordinates minimizes edge color flashing.
tc.y = mix( texture_insets.y, 1.0f - texture_insets.y, t );
tc.x = mix( 1.0f - texture_insets.x, texture_insets.x, (float)r );
return tc;
};
// Add a vertex to texture (color_tc parameter allows us to do flat shading in ES2)
const auto add_vert = [=,&vertices] (int r, int s, const ivec2 &provoking) {
auto deform_scaling = 0.0f;
auto pos = calc_pos(r, s);
auto tc = calc_tc(r, s);
auto normal = calc_normal(r, s);
auto color_tc = calc_tc( provoking.x, provoking.y );
vertices.push_back( Vertex{ pos, normal, tc, color_tc, deform_scaling, (float)bar.time, 0.0f } );
};
// Create triangles for flat shading
const auto r = 0;
for( auto s = 0; s < segments; s += 1 )
{
auto provoking = ivec2(r, s);
add_vert( r, s, provoking );
add_vert( r, s + 1, provoking );
add_vert( r + 1, s + 1, provoking );
add_vert( r, s, provoking );
add_vert( r + 1, s, provoking );
add_vert( r + 1, s + 1, provoking );
}
}
} // namespace
void Landscape::setup()
{
auto shader = loadShader( "landscape.vs", "landscape.fs" );
std::vector<Vertex> vertices;
auto offset = vec2( 0.05f, 0.0f );
auto json = JsonTree( app::loadAsset("profile.json") );
for( auto &child : json["bars"].getChildren() ) {
Bar bar( child );
addRing( vertices, bar, offset );
}
auto center = vec3( 0, -4.0f, 0 );
// Plug center
/*
auto h = vec3( 0.25f, 0.0f, 0.25f );
addQuad( vertices, (h * vec3(-1, 0, -1)), (h * vec3(1, 0, -1)), (h * vec3(1, 0, 1)), (h * vec3(-1, 0, 1)), 0.0f, Rectf( 1, 1, 0, 0 ) );
*/
// Flip up
auto xf = glm::rotate<float>( Tau * 0.25f, vec3( 0, 0, 1 ) ) * glm::translate( center ) * glm::scale( vec3( 4.0f ) );
for( auto &v : vertices ) {
v.position = vec3( xf * vec4(v.position, 1.0f) );
v.normal = vec3( xf * vec4(v.normal, 0.0f) );
}
// Mirror
auto copy = vertices;
auto mirror = glm::mat4( glm::angleAxis<float>( Tau * 0.5f, vec3( 0, 1, 0 ) ) );
for( auto &v : copy ) {
v.position = vec3( mirror * vec4(v.position, 1.0f) );
v.normal = vec3( mirror * vec4(v.normal, 0.0f) );
}
vertices.insert( vertices.end(), copy.begin(), copy.end() );
auto vbo = gl::Vbo::create( GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW );
auto mesh = gl::VboMesh::create( vertices.size(), GL_TRIANGLES, {{ kVertexLayout, vbo }} );
batch = gl::Batch::create( mesh, shader, kVertexMapping );
}
void Landscape::setTextureUnits( uint8_t iClearUnit, uint8_t iBlurredUnit )
{
auto &shader = batch->getGlslProg();
shader->uniform( "uClearTexture", iClearUnit );
shader->uniform( "uBlurredTexture", iBlurredUnit );
}
void Landscape::draw( float iFrameOffset )
{
auto &shader = batch->getGlslProg();
shader->uniform( "uCurrentFrame", iFrameOffset );
batch->draw();
}
<commit_msg>Plugging hole again.<commit_after>//
// Landscape.cpp
//
// Created by Soso Limited on 5/26/15.
//
//
#include "Landscape.h"
#include "cinder/Log.h"
#include "Constants.h"
#include "LandscapeGeometry.h"
#include "cinder/Json.h"
using namespace soso;
using namespace cinder;
namespace {
struct alignas(16) Vertex {
vec3 position;
vec3 normal;
vec2 tex_coord;
vec2 color_tex_coord;
float deform_scaling;
float frame_offset;
float color_weight;
};
const auto kVertexLayout = ([] {
auto layout = geom::BufferLayout();
layout.append( geom::Attrib::POSITION, 3, sizeof(Vertex), offsetof(Vertex, position) );
layout.append( geom::Attrib::NORMAL, 3, sizeof(Vertex), offsetof(Vertex, normal) );
layout.append( geom::Attrib::TEX_COORD_0, 2, sizeof(Vertex), offsetof(Vertex, tex_coord) );
layout.append( geom::Attrib::TEX_COORD_1, 2, sizeof(Vertex), offsetof(Vertex, color_tex_coord) );
layout.append( geom::Attrib::CUSTOM_0, 1, sizeof(Vertex), offsetof(Vertex, deform_scaling) );
layout.append( geom::Attrib::CUSTOM_1, 1, sizeof(Vertex), offsetof(Vertex, frame_offset) );
layout.append( geom::Attrib::CUSTOM_2, 1, sizeof(Vertex), offsetof(Vertex, color_weight) );
return layout;
} ());
const auto kVertexMapping = ([] {
return gl::Batch::AttributeMapping{ { geom::Attrib::CUSTOM_0, "DeformScaling" }, { geom::Attrib::CUSTOM_1, "FrameOffset" }, { geom::Attrib::CUSTOM_2, "ColorWeight" } };
} ());
// Load a shader and handle exceptions. Return nullptr on failure.
gl::GlslProgRef loadShader( const fs::path &iVertex, const fs::path &iFragment )
{
try {
auto shader_format = gl::GlslProg::Format()
.vertex( app::loadAsset( iVertex ) )
.fragment( app::loadAsset( iFragment ) );
return gl::GlslProg::create( shader_format );
}
catch( ci::Exception &exc ) {
CI_LOG_E( "Error loading shader: " << exc.what() );
}
return nullptr;
}
///
/// Create a quadrilateral with clockwise vertices abcd.
/// Maps to frame at time and a slice of the video frame.
///
void addQuad( std::vector<Vertex> &vertices, const vec3 &a, const vec3 &b, const vec3 &c, const vec3 &d, float time, const Rectf &slice )
{
auto normal = vec3( 0, 1, 0 );
auto deform_scaling = 0.0f;
vertices.insert( vertices.end(), {
Vertex{ a, normal, slice.getUpperLeft(), slice.getUpperLeft(), deform_scaling, time, 0.0f },
Vertex{ b, normal, slice.getUpperRight(), slice.getUpperRight(), deform_scaling, time, 0.0f },
Vertex{ c, normal, slice.getLowerRight(), slice.getLowerRight(), deform_scaling, time, 0.0f },
Vertex{ a, normal, slice.getUpperLeft(), slice.getUpperLeft(), deform_scaling, time, 0.0f },
Vertex{ c, normal, slice.getLowerRight(), slice.getLowerRight(), deform_scaling, time, 0.0f },
Vertex{ d, normal, slice.getLowerLeft(), slice.getLowerLeft(), deform_scaling, time, 0.0f }
} );
}
/// Add a ring of geometry containing a given number of time bands (slitscanning effect) and repeats around the donut.
void addRing( std::vector<Vertex> &vertices, const Bar &bar, const ci::vec2 ¢er_offset )
{
auto segments = 64;
auto texture_insets = vec2( 0.05, 0.0875f );
// Generate cartesian position.
const auto calc_pos = [=] (int r, int s) {
auto pos = mix( bar.begin, bar.end, (float)r ) + center_offset;
auto t = (float) s / segments;
auto rotation = glm::rotate<float>( t * Tau, vec3(0, 1, 0) );
return vec3( rotation * vec4( pos, 0.0f, 1.0f ) );
};
const auto calc_normal = [=] (int r, int s) {
auto ray = bar.end - bar.begin;
auto normal = normalize(vec3(- ray.y, ray.x, 0.0f));
auto t = (float) s / segments;
auto rotation = glm::rotate<float>( t * Tau, vec3(0, 1, 0) );
return vec3( rotation * vec4(normal, 0.0f) );
};
// Generate texture coordinate mirrored at halfway point.
const auto calc_tc = [=] (int r, int s) {
auto t = (float) s / segments;
if( t < 1 ) {
t = glm::fract( t * bar.repeats );
}
// mirror copies
t = std::abs( t - 0.5f ) * 2.0f;
auto tc = vec2(0);
// Repeat t with mirroring
// insetting the texture coordinates minimizes edge color flashing.
tc.y = mix( texture_insets.y, 1.0f - texture_insets.y, t );
tc.x = mix( 1.0f - texture_insets.x, texture_insets.x, (float)r );
return tc;
};
// Add a vertex to texture (color_tc parameter allows us to do flat shading in ES2)
const auto add_vert = [=,&vertices] (int r, int s, const ivec2 &provoking) {
auto deform_scaling = 0.0f;
auto pos = calc_pos(r, s);
auto tc = calc_tc(r, s);
auto normal = calc_normal(r, s);
auto color_tc = calc_tc( provoking.x, provoking.y );
vertices.push_back( Vertex{ pos, normal, tc, color_tc, deform_scaling, (float)bar.time, 0.0f } );
};
// Create triangles for flat shading
const auto r = 0;
for( auto s = 0; s < segments; s += 1 )
{
auto provoking = ivec2(r, s);
add_vert( r, s, provoking );
add_vert( r, s + 1, provoking );
add_vert( r + 1, s + 1, provoking );
add_vert( r, s, provoking );
add_vert( r + 1, s, provoking );
add_vert( r + 1, s + 1, provoking );
}
}
} // namespace
void Landscape::setup()
{
auto shader = loadShader( "landscape.vs", "landscape.fs" );
std::vector<Vertex> vertices;
auto offset = vec2( 0.05f, 0.0f );
auto json = JsonTree( app::loadAsset("profile.json") );
for( auto &child : json["bars"].getChildren() ) {
Bar bar( child );
addRing( vertices, bar, offset );
}
auto center = vec3( 0, -4.0f, 0 );
// Plug center
auto h = vec3( offset.x * 1.5f, 0.0f, offset.x * 1.5f );
addQuad( vertices, (h * vec3(-1, 0, -1)), (h * vec3(1, 0, -1)), (h * vec3(1, 0, 1)), (h * vec3(-1, 0, 1)), 0.0f, Rectf( 1, 1, 0, 0 ) );
// Flip up
auto xf = glm::rotate<float>( Tau * 0.25f, vec3( 0, 0, 1 ) ) * glm::translate( center ) * glm::scale( vec3( 4.0f ) );
for( auto &v : vertices ) {
v.position = vec3( xf * vec4(v.position, 1.0f) );
v.normal = vec3( xf * vec4(v.normal, 0.0f) );
}
// Mirror
auto copy = vertices;
auto mirror = glm::mat4( glm::angleAxis<float>( Tau * 0.5f, vec3( 0, 1, 0 ) ) );
for( auto &v : copy ) {
v.position = vec3( mirror * vec4(v.position, 1.0f) );
v.normal = vec3( mirror * vec4(v.normal, 0.0f) );
}
vertices.insert( vertices.end(), copy.begin(), copy.end() );
auto vbo = gl::Vbo::create( GL_ARRAY_BUFFER, vertices, GL_STATIC_DRAW );
auto mesh = gl::VboMesh::create( vertices.size(), GL_TRIANGLES, {{ kVertexLayout, vbo }} );
batch = gl::Batch::create( mesh, shader, kVertexMapping );
}
void Landscape::setTextureUnits( uint8_t iClearUnit, uint8_t iBlurredUnit )
{
auto &shader = batch->getGlslProg();
shader->uniform( "uClearTexture", iClearUnit );
shader->uniform( "uBlurredTexture", iBlurredUnit );
}
void Landscape::draw( float iFrameOffset )
{
auto &shader = batch->getGlslProg();
shader->uniform( "uCurrentFrame", iFrameOffset );
batch->draw();
}
<|endoftext|> |
<commit_before>#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <string>
#include <math.h>
using namespace std;
bool controllo(string x);
struct dato {
float valore;
float errore;
};
int main (int argc, char *argv[]) {
ifstream leggi(argv[1]);
ofstream scrivi("output.txt");
if(!leggi.is_open()) {
cout << "Impossibile aprire il file" << endl;
return -1;
}
vector<float> tempo;
vector<dato> veloc;
int i=0;
string temp;
getline(leggi, temp); // scarto la prima riga
while(getline(leggi, temp)) {
if (controllo(temp)) break;
i++;
istringstream iss(temp);
float a;
iss >> a;
tempo.push_back(a);
}
while(i>0) {
getline(leggi, temp); //scarto la seconda "riga titolo"
if (controllo(temp)) break;
istringstream iss(temp);
float a, c;
iss >> a >> c >> c;
veloc.push_back(dato{a, c});
i--;
}
if(leggi.bad()) {
cout << "Impossibile leggere il file" << endl;
return -1;
}
//Interpolo
float x1=0, y1=0, x2=0, xy=0, e=0;
for (int k = 0; k < tempo.size(); k++){
x1+=tempo[k]*tempo[k];
y1+=veloc[k].valore;
x2+=tempo[k];
xy+=tempo[k]*veloc[k].valore;
}
float delta=tempo.size()*x1-x2*x2;
float a=(x1*y1-x2*xy)/delta;
float b=(xy*tempo.size()-x2*y1)/delta;
for (int k = 0; k < tempo.size(); k++){
e+=((a+b*tempo[k])-veloc[k].valore)*((a+b*tempo[k])-veloc[k].valore);
}
e=sqrt(e/(tempo.size()-2));
float eA=e*sqrt(x1/delta);
float eB=e*sqrt(tempo.size()/delta);
scrivi << "Tempo (s)\tVelocità (m/s)\t Errore velocità (m/s)" << endl; //da controllare
for (int k = 0; k < tempo.size(); k++){
scrivi << tempo[k] << "\t" << veloc[k].valore << "\t" << veloc[k].errore << endl;
}
scrivi << "a è " << a << ", b è " << b << endl;
scrivi << "Dev y è " << e << endl;
scrivi << "Dev.std di a è " << eA << " e dev.std di b è " << eB;
return 0;
}
bool controllo(string x){
for(auto w:x) {
if(isalpha(w) || (isspace(w) && !isblank(w))) return 1; //da migliorare
else return 0;
}
}
//http://stackoverflow.com/questions/7868936/read-file-line-by-line
//http://en.cppreference.com/w/cpp/string/byte/isdigit http://www.cprogramming.com/tutorial/lesson2.html
<commit_msg>Risolto problema con i tab<commit_after>#include <iostream>
#include <fstream>
#include <vector>
#include <sstream>
#include <string>
#include <math.h>
using namespace std;
bool controllo(string x);
struct dato {
float valore;
float errore;
};
int main (int argc, char *argv[]) {
ifstream leggi(argv[1]);
ofstream scrivi("output.txt");
if(!leggi.is_open()) {
cout << "Impossibile aprire il file" << endl;
return -1;
}
vector<float> tempo;
vector<dato> veloc;
int i=0;
string temp;
getline(leggi, temp); // scarto la prima riga
while(getline(leggi, temp)) {
if (controllo(temp)) break;
i++;
istringstream iss(temp);
float a;
iss >> a;
tempo.push_back(a);
}
while(i>0) {
getline(leggi, temp); //scarto la seconda "riga titolo"
if (controllo(temp)) break;
istringstream iss(temp);
float a, c;
iss >> a >> c >> c;
veloc.push_back(dato{a, c});
i--;
}
if(leggi.bad()) {
cout << "Impossibile leggere il file" << endl;
return -1;
}
//Interpolo
float x1=0, y1=0, x2=0, xy=0, e=0;
for (int k = 0; k < tempo.size(); k++){
x1+=tempo[k]*tempo[k];
y1+=veloc[k].valore;
x2+=tempo[k];
xy+=tempo[k]*veloc[k].valore;
}
float delta=tempo.size()*x1-x2*x2;
float a=(x1*y1-x2*xy)/delta;
float b=(xy*tempo.size()-x2*y1)/delta;
for (int k = 0; k < tempo.size(); k++){
e+=((a+b*tempo[k])-veloc[k].valore)*((a+b*tempo[k])-veloc[k].valore);
}
e=sqrt(e/(tempo.size()-2));
float eA=e*sqrt(x1/delta);
float eB=e*sqrt(tempo.size()/delta);
scrivi << "Tempo (s) Velocità (m/s) Errore velocità (m/s)" << endl;
for (int k = 0; k < tempo.size(); k++){
scrivi << tempo[k] << " " << veloc[k].valore << " " << veloc[k].errore << endl;
}
scrivi << "a è " << a << ", b è " << b << endl;
scrivi << "Dev y è " << e << endl;
scrivi << "Dev.std di a è " << eA << " e dev.std di b è " << eB;
return 0;
}
bool controllo(string x){
for(auto w:x) {
if(isalpha(w) || (isspace(w) && !isblank(w))) return 1; //da migliorare
else return 0;
}
}
//http://stackoverflow.com/questions/7868936/read-file-line-by-line
//http://en.cppreference.com/w/cpp/string/byte/isdigit http://www.cprogramming.com/tutorial/lesson2.html
<|endoftext|> |
<commit_before>#include <Servo.h>
#include "Msg.h"
#include "Device.h"
#include "MrlServo.h"
MrlServo::MrlServo(int deviceId) : Device(deviceId, DEVICE_TYPE_SERVO) {
isMoving = false;
isSweeping = false;
// create the servo
servo = new Servo();
lastUpdate = 0;
currentPosUs = 0.0;
targetPosUs = 0;
velocity = -1;
acceleration = -1;
moveStart = 0;
}
MrlServo::~MrlServo() {
if (servo){
servo->detach();
delete servo;
}
}
// this method "may" be called with a pin or pin & pos depending on
// config size
bool MrlServo::attach(byte pin, int initPosUs, int initVelocity){
// msg->publishDebug("MrlServo.deviceAttach !");
servo->writeMicroseconds(initPosUs);
currentPosUs = initPosUs;
targetPosUs = initPosUs;
velocity = initVelocity;
this->pin = pin;
servo->attach(pin);
//publishServoEvent(SERVO_EVENT_STOPPED);
return true;
}
// This method is equivalent to Arduino's Servo.attach(pin) - (no pos)
void MrlServo::attachPin(int pin){
attach(pin, currentPosUs, velocity);
}
void MrlServo::detachPin(){
servo->detach();
}
// FIXME - what happened to events ?
void MrlServo::update() {
//it may have an imprecision of +- 1 due to the conversion of currentPosUs to int
if (isMoving) {
if ((int)currentPosUs != targetPosUs) {
long deltaTime = millis() - lastUpdate;
lastUpdate = millis();
float _velocity = velocity;
if (acceleration != -1) {
_velocity *= acceleration * pow(((float)(millis()- moveStart)) / 1000,2) / 10;
//msg->publishDebug(String(_velocity));
if (_velocity > velocity) {
_velocity = velocity;
}
}
if(targetPosUs > 500) {
_velocity = map(_velocity, 0, 180, 544, 2400) - 544;
}
float step = _velocity * deltaTime;
step /= 1000; //for deg/ms;
if (isSweeping) {
step = sweepStep;
}
if (velocity < 0) { // when velocity < 0, it mean full speed ahead
step = targetPosUs - (int)currentPosUs;
}
else if (currentPosUs > targetPosUs) {
step *=-1;
}
int previousCurrentPosUs = (int)currentPosUs;
currentPosUs += step;
if ((step > 0.0 && (int)currentPosUs > targetPosUs) || (step < 0.0 && (int)currentPosUs < targetPosUs)) {
currentPosUs = targetPosUs;
}
if (!(previousCurrentPosUs == (int)currentPosUs)) {
servo->writeMicroseconds((int)currentPosUs);
if ((int)currentPosUs == targetPosUs) {
publishServoEvent(SERVO_EVENT_STOPPED);
}
else {
publishServoEvent(SERVO_EVENT_POSITION_UPDATE);
}
}
}
else {
if (isSweeping) {
if (targetPosUs == minUs) {
targetPosUs = maxUs;
}
else {
targetPosUs = minUs;
}
sweepStep *= -1;
}
else {
isMoving = false;
publishServoEvent(SERVO_EVENT_STOPPED);
}
}
}
}
void MrlServo::moveToMicroseconds(int posUs) {
if (servo == NULL){
return;
}
targetPosUs = posUs;
isMoving = true;
lastUpdate = millis();
moveStart = lastUpdate;
publishServoEvent(SERVO_EVENT_POSITION_UPDATE);
}
void MrlServo::startSweep(int minUs, int maxUs, int step) {
this->minUs = minUs;
this->maxUs = maxUs;
sweepStep = step;
targetPosUs = maxUs;
isMoving = true;
isSweeping = true;
}
void MrlServo::stopSweep() {
isMoving = false;
isSweeping = false;
}
void MrlServo::setVelocity(int velocity) {
this->velocity = velocity;
}
void MrlServo::setAcceleration(int acceleration) {
this->acceleration = acceleration;
}
void MrlServo::publishServoEvent(int type) {
msg->publishServoEvent(id, type, (int)currentPosUs, targetPosUs);
}
<commit_msg>forgot one<commit_after>#include <Servo.h>
#include "Msg.h"
#include "Device.h"
#include "MrlServo.h"
MrlServo::MrlServo(int deviceId) : Device(deviceId, DEVICE_TYPE_SERVO) {
isMoving = false;
isSweeping = false;
// create the servo
servo = new Servo();
lastUpdate = 0;
currentPosUs = 0.0;
targetPosUs = 0;
velocity = -1;
acceleration = -1;
moveStart = 0;
}
MrlServo::~MrlServo() {
if (servo){
servo->detach();
delete servo;
}
}
// this method "may" be called with a pin or pin & pos depending on
// config size
bool MrlServo::attach(byte pin, int initPosUs, int initVelocity){
// msg->publishDebug("MrlServo.deviceAttach !");
servo->writeMicroseconds(initPosUs);
currentPosUs = initPosUs;
targetPosUs = initPosUs;
velocity = initVelocity;
this->pin = pin;
servo->attach(pin);
//publishServoEvent(SERVO_EVENT_STOPPED);
return true;
}
// This method is equivalent to Arduino's Servo.attach(pin) - (no pos)
void MrlServo::attachPin(int pin){
attach(pin, currentPosUs, velocity);
}
void MrlServo::detachPin(){
servo->detach();
}
// FIXME - what happened to events ?
void MrlServo::update() {
//it may have an imprecision of +- 1 due to the conversion of currentPosUs to int
if (isMoving) {
if ((int)currentPosUs != targetPosUs) {
long deltaTime = millis() - lastUpdate;
lastUpdate = millis();
float _velocity = velocity;
if (acceleration != -1) {
_velocity *= acceleration * pow(((float)(millis()- moveStart)) / 1000,2) / 10;
//msg->publishDebug(String(_velocity));
if (_velocity > velocity) {
_velocity = velocity;
}
}
if(targetPosUs > 500) {
_velocity = map(_velocity, 0, 180, 544, 2400) - 544;
}
float step = _velocity * deltaTime;
step /= 1000; //for deg/ms;
if (isSweeping) {
step = sweepStep;
}
if (velocity < 0) { // when velocity < 0, it mean full speed ahead
step = targetPosUs - (int)currentPosUs;
}
else if (currentPosUs > targetPosUs) {
step *=-1;
}
int previousCurrentPosUs = (int)currentPosUs;
currentPosUs += step;
if ((step > 0.0 && (int)currentPosUs > targetPosUs) || (step < 0.0 && (int)currentPosUs < targetPosUs)) {
currentPosUs = targetPosUs;
}
if (!(previousCurrentPosUs == (int)currentPosUs)) {
servo->writeMicroseconds((int)currentPosUs);
if ((int)currentPosUs == targetPosUs) {
publishServoEvent(SERVO_EVENT_STOPPED);
}
else {
publishServoEvent(SERVO_EVENT_POSITION_UPDATE);
}
}
}
else {
if (isSweeping) {
if (targetPosUs == minUs) {
targetPosUs = maxUs;
}
else {
targetPosUs = minUs;
}
sweepStep *= -1;
}
else {
isMoving = false;
publishServoEvent(SERVO_EVENT_STOPPED);
}
}
}
}
void MrlServo::moveToMicroseconds(int posUs) {
if (servo == NULL){
return;
}
targetPosUs = posUs;
isMoving = true;
lastUpdate = millis();
moveStart = lastUpdate;
publishServoEvent(SERVO_EVENT_POSITION_UPDATE);
}
void MrlServo::startSweep(int minUs, int maxUs, int step) {
this->minUs = minUs;
this->maxUs = maxUs;
sweepStep = step;
targetPosUs = maxUs;
isMoving = true;
isSweeping = true;
}
void MrlServo::stop() {
isMoving = false;
isSweeping = false;
}
void MrlServo::stopSweep() {
isMoving = false;
isSweeping = false;
}
void MrlServo::setVelocity(int velocity) {
this->velocity = velocity;
}
void MrlServo::setAcceleration(int acceleration) {
this->acceleration = acceleration;
}
void MrlServo::publishServoEvent(int type) {
msg->publishServoEvent(id, type, (int)currentPosUs, targetPosUs);
}
<|endoftext|> |
<commit_before><commit_msg>More robust randomness for seeding RNG<commit_after><|endoftext|> |
<commit_before>/** @mainpage C++11 Proton Library
*
* @authors <a href="http://lenx.100871.net">Lenx Tao Wei</a> (lenx.wei at gmail.com)
*
* @section intro Introduction
* Proton is a library to provide Python-like interfaces for C++11,
* which try to make porting from Python to C++11 easier,
* and make programming in C++11 more convenient :)
*
* The main git repository is at https://github.com/LenxWei/libproton.
*
* @section install Install
* Download site:
* - http://code.google.com/p/libproton/downloads/list
* - https://github.com/LenxWei/libproton/downloads
*
* Need a compiler supporting c++11, such as gcc 4.7.0 or higher.<br>
* Install <a href="http://www.boost.org/">Boost C++ Library</a> 1.48 or higher first.
*
* After that, just standard "./configure; make; make check; make install"
*
* @section modules Modules
* You can find documents about modules <a href="modules.html">here</a>.
* <hr>
* @todo 1.1.1 goal: vector_, deque_, map_, set_, str
* @todo 1.1.2 goal: list_, unordered_, getopt
* @todo add examples
* @todo add tutorial
* @todo 1.2 milestone
* @todo add os module
* @todo add socket module(?)
* @todo add server/client module
* @todo add regex module
* @todo add threading
* @todo 1.4 milestone
* @todo add gc support
* @todo 1.6 milestone
*
* @defgroup ref Smart reference
* Provide basic reference support for proton.
* @{
* @defgroup ref_ ref_
* Core reference template.
*
* @defgroup functor func_
* General functor interface template.
*
* @}
*
* @defgroup stl Containers
* Repack stl containers in new templates following python's habits.
* @{
* @defgroup seq common
* common container operations
*
* @defgroup str str
* like string in python
*
* @defgroup vector_ vector_
* like list in python, better for small sequences
*
* @defgroup deque_ deque_
* like list in python, better for long sequences.
*
* @}
*
* @defgroup util Utilities
* @{
*
* @defgroup debug Debug utilities
* Macros, global variables, classes for debug.
*
* @defgroup pool Smart allocator
* A high-performance and smart allocator.
*
* @}
*
*/
<commit_msg>fix ref_ description<commit_after>/** @mainpage C++11 Proton Library
*
* @authors <a href="http://lenx.100871.net">Lenx Tao Wei</a> (lenx.wei at gmail.com)
*
* @section intro Introduction
* Proton is a library to provide Python-like interfaces for C++11,
* which try to make porting from Python to C++11 easier,
* and make programming in C++11 more convenient :)
*
* The main git repository is at https://github.com/LenxWei/libproton.
*
* @section install Install
* Download site:
* - http://code.google.com/p/libproton/downloads/list
* - https://github.com/LenxWei/libproton/downloads
*
* Need a compiler supporting c++11, such as gcc 4.7.0 or higher.<br>
* Install <a href="http://www.boost.org/">Boost C++ Library</a> 1.48 or higher first.
*
* After that, just standard "./configure; make; make check; make install"
*
* @section modules Modules
* You can find documents about modules <a href="modules.html">here</a>.
* <hr>
* @todo 1.1.1 goal: vector_, deque_, map_, set_, str
* @todo 1.1.2 goal: list_, unordered_, getopt
* @todo add examples
* @todo add tutorial
* @todo 1.2 milestone
* @todo add os module
* @todo add socket module(?)
* @todo add server/client module
* @todo add regex module
* @todo add threading
* @todo 1.4 milestone
* @todo add gc support
* @todo 1.6 milestone
*
* @defgroup ref Smart reference
* Provide basic reference support for proton.
* @{
* @defgroup ref_ ref_
* Core reference template supporting interface through inheritance/multiple inheritance.
*
* @defgroup functor func_
* General functor interface template.
*
* @}
*
* @defgroup stl Containers
* Repack stl containers in new templates following python's habits.
* @{
* @defgroup seq common
* common container operations
*
* @defgroup str str
* like string in python
*
* @defgroup vector_ vector_
* like list in python, better for small sequences
*
* @defgroup deque_ deque_
* like list in python, better for long sequences.
*
* @}
*
* @defgroup util Utilities
* @{
*
* @defgroup debug Debug utilities
* Macros, global variables, classes for debug.
*
* @defgroup pool Smart allocator
* A high-performance and smart allocator.
*
* @}
*
*/
<|endoftext|> |
<commit_before><commit_msg>Make config instances local static variables so that initialization happens only when the configuration is selected.<commit_after><|endoftext|> |
<commit_before>#ifndef GNR_DISPATCH_HPP
# define GNR_DISPATCH_HPP
# pragma once
#include <type_traits>
#include <utility>
#include "invoke.hpp"
namespace gnr
{
namespace detail
{
template <typename A, typename ...B>
struct front
{
using type = A;
};
template <typename ...A>
using front_t = typename front<A...>::type;
template <typename R>
using result_t = std::conditional_t<
std::is_array_v<std::remove_reference_t<R>>,
std::remove_extent_t<std::remove_reference_t<R>>(*)[],
std::conditional_t<
std::is_reference_v<R>,
std::remove_reference_t<R>*,
R
>
>;
}
constexpr decltype(auto) dispatch(auto const i, auto&& ...f)
noexcept(noexcept((f(), ...)))
requires(
std::is_enum_v<std::remove_const_t<decltype(i)>> &&
std::conjunction_v<
std::is_same<
std::decay_t<
decltype(std::declval<detail::front_t<decltype(f)...>>()())
>,
std::decay_t<decltype(std::declval<decltype(f)>()())>
>...
>
)
{
using int_t = std::underlying_type_t<std::remove_const_t<decltype(i)>>;
using R = decltype(std::declval<detail::front_t<decltype(f)...>>()());
return [&]<auto ...I>(std::integer_sequence<int_t, I...>)
noexcept(noexcept((f(), ...))) -> decltype(auto)
{
if constexpr(std::is_void_v<R>)
{
((I == int_t(i) ? (f(), 0) : 0), ...);
}
else if constexpr(std::is_array_v<std::remove_reference_t<R>> ||
std::is_reference_v<R>)
{
detail::result_t<R> r;
(
(
I == int_t(i) ?
r = reinterpret_cast<decltype(r)>(&f()) :
nullptr
),
...
);
return *r;
}
else
{
R r;
((I == int_t(i) ? (r = f(), 0) : 0), ...);
return r;
}
}(std::make_integer_sequence<int_t, sizeof...(f)>());
}
constexpr decltype(auto) select(auto const i, auto&& ...v) noexcept
requires(
std::conjunction_v<
std::is_same<
std::decay_t<
decltype(std::declval<detail::front_t<decltype(v)...>>())
>,
std::decay_t<decltype(std::declval<decltype(v)>())>
>...
>
)
{
using R = detail::front_t<decltype(v)...>;
return [&]<auto ...I>(std::index_sequence<I...>) noexcept -> decltype(auto)
{
detail::result_t<R> r;
((I == i ? r = reinterpret_cast<decltype(r)>(&v) : nullptr), ...);
return *r;
}(std::make_index_sequence<sizeof...(v)>());
}
constexpr decltype(auto) dispatch2(auto const i, auto&& ...a)
#ifndef __clang__
noexcept(noexcept(
gnr::invoke_split<2>(
[](auto&& e, auto&& f)
{
if constexpr(std::is_void_v<decltype(f())> ||
std::is_reference_v<decltype(f())>)
{
f();
}
else
{
detail::result_t<decltype(f())> r;
r = reinterpret_cast<decltype(r)>(f());
}
},
std::forward<decltype(a)>(a)...
)
)
)
#endif // __clang__
{
using tuple_t = std::tuple<decltype(a)...>;
using R = decltype(std::declval<std::tuple_element_t<1, tuple_t>>()());
if constexpr(std::is_void_v<R>)
{
gnr::invoke_split<2>(
[&](auto&& e, auto&& f) noexcept(noexcept(f()))
{
if (e == i)
{
f();
}
},
std::forward<decltype(a)>(a)...
);
}
else if constexpr(std::is_array_v<std::remove_reference_t<R>> ||
std::is_reference_v<R>)
{
detail::result_t<R> r;
gnr::invoke_split<2>(
[&](auto&& e, auto&& f) noexcept(noexcept(f()))
{
if (e == i)
{
r = reinterpret_cast<decltype(r)>(&f());
}
},
std::forward<decltype(a)>(a)...
);
return *r;
}
else
{
R r;
gnr::invoke_split<2>(
[&](auto&& e, auto&& f)
#ifndef __clang__
noexcept(noexcept(
std::declval<R&>() = reinterpret_cast<decltype(r)>(f())
)
)
#endif // __clang__
{
if (e == i)
{
r = f();
}
},
std::forward<decltype(a)>(a)...
);
return r;
}
}
}
#endif // GNR_DISPATCH_HPP
<commit_msg>some fixes<commit_after>#ifndef GNR_DISPATCH_HPP
# define GNR_DISPATCH_HPP
# pragma once
#include <type_traits>
#include <utility>
#include "invoke.hpp"
namespace gnr
{
namespace detail
{
template <typename A, typename ...B>
struct front
{
using type = A;
};
template <typename ...A>
using front_t = typename front<A...>::type;
template <typename R>
using result_t = std::conditional_t<
std::is_array_v<std::remove_reference_t<R>>,
std::remove_extent_t<std::remove_reference_t<R>>(*)[],
std::conditional_t<
std::is_reference_v<R>,
std::remove_reference_t<R>*,
R
>
>;
}
constexpr decltype(auto) dispatch(auto const i, auto&& ...f)
noexcept(noexcept((f(), ...)))
requires(
std::is_enum_v<std::remove_const_t<decltype(i)>> &&
std::conjunction_v<
std::is_same<
std::decay_t<
decltype(std::declval<detail::front_t<decltype(f)...>>()())
>,
std::decay_t<decltype(std::declval<decltype(f)>()())>
>...
>
)
{
using int_t = std::underlying_type_t<std::remove_const_t<decltype(i)>>;
using R = decltype(std::declval<detail::front_t<decltype(f)...>>()());
return [&]<auto ...I>(std::integer_sequence<int_t, I...>)
noexcept(noexcept((f(), ...))) -> decltype(auto)
{
if constexpr(std::is_void_v<R>)
{
((I == int_t(i) ? (f(), 0) : 0), ...);
}
else if constexpr(std::is_array_v<std::remove_reference_t<R>> ||
std::is_reference_v<R>)
{
detail::result_t<R> r;
(
(
I == int_t(i) ?
r = reinterpret_cast<decltype(r)>(&f()) :
nullptr
),
...
);
return *r;
}
else
{
R r;
((I == int_t(i) ? (r = f(), 0) : 0), ...);
return r;
}
}(std::make_integer_sequence<int_t, sizeof...(f)>());
}
constexpr decltype(auto) select(auto const i, auto&& ...v) noexcept
requires(
std::conjunction_v<
std::is_same<
std::decay_t<
decltype(std::declval<detail::front_t<decltype(v)...>>())
>,
std::decay_t<decltype(std::declval<decltype(v)>())>
>...
>
)
{
using R = detail::front_t<decltype(v)...>;
return [&]<auto ...I>(std::index_sequence<I...>) noexcept -> decltype(auto)
{
detail::result_t<R> r;
((I == i ? r = reinterpret_cast<decltype(r)>(&v) : nullptr), ...);
return *r;
}(std::make_index_sequence<sizeof...(v)>());
}
constexpr decltype(auto) dispatch2(auto const i, auto&& ...a)
#ifndef __clang__
noexcept(noexcept(
gnr::invoke_split<2>(
[](auto&& e, auto&& f)
{
if constexpr(std::is_void_v<decltype(f())> ||
std::is_reference_v<decltype(f())>)
{
f();
}
else
{
detail::result_t<decltype(f())> r;
r = reinterpret_cast<decltype(r)>(f());
}
},
std::forward<decltype(a)>(a)...
)
)
)
#endif // __clang__
{
using tuple_t = std::tuple<decltype(a)...>;
using R = decltype(std::declval<std::tuple_element_t<1, tuple_t>>()());
if constexpr(std::is_void_v<R>)
{
gnr::invoke_split<2>(
[&](auto&& e, auto&& f) noexcept(noexcept(f()))
{
if (e == i)
{
f();
}
},
std::forward<decltype(a)>(a)...
);
}
else if constexpr(std::is_array_v<std::remove_reference_t<R>> ||
std::is_reference_v<R>)
{
detail::result_t<R> r;
gnr::invoke_split<2>(
[&](auto&& e, auto&& f) noexcept(noexcept(f()))
{
if (e == i)
{
r = reinterpret_cast<decltype(r)>(&f());
}
},
std::forward<decltype(a)>(a)...
);
return *r;
}
else
{
R r;
gnr::invoke_split<2>(
[&](auto&& e, auto&& f)
noexcept(noexcept(std::declval<R&>() = f()))
{
if (e == i)
{
r = f();
}
},
std::forward<decltype(a)>(a)...
);
return r;
}
}
}
#endif // GNR_DISPATCH_HPP
<|endoftext|> |
<commit_before>/***************************************************************
*
* Copyright (C) 1990-2007, Condor Team, Computer Sciences Department,
* University of Wisconsin-Madison, WI.
*
* 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 "condor_common.h"
#include "condor_classad.h"
#include "condor_debug.h"
#include "condor_daemon_core.h"
#include "condor_attributes.h"
#include "condor_syscall_mode.h"
#include "exit.h"
#include "vanilla_proc.h"
#include "starter.h"
#include "syscall_numbers.h"
#include "dynuser.h"
#include "condor_config.h"
#include "domain_tools.h"
#include "classad_helpers.h"
#ifdef WIN32
#include "executable_scripts.WINDOWS.h"
extern dynuser* myDynuser;
#endif
extern CStarter *Starter;
VanillaProc::VanillaProc(ClassAd* jobAd) : OsProc(jobAd)
{
#if !defined(WIN32)
m_escalation_tid = -1;
#endif
}
int
VanillaProc::StartJob()
{
dprintf(D_FULLDEBUG,"in VanillaProc::StartJob()\n");
// vanilla jobs, unlike standard jobs, are allowed to run
// shell scripts (or as is the case on NT, batch files). so
// edit the ad so we start up a shell, pass the executable as
// an argument to the shell, if we are asked to run a .bat file.
#ifdef WIN32
CHAR interpreter[MAX_PATH+1],
systemshell[MAX_PATH+1];
const char* jobtmp = Starter->jic->origJobName();
int joblen = strlen(jobtmp);
const char *extension = joblen > 0 ? &(jobtmp[joblen-4]) : NULL;
bool binary_executable = ( extension &&
( MATCH == strcasecmp ( ".exe", extension ) ||
MATCH == strcasecmp ( ".com", extension ) ) ),
java_universe = ( CONDOR_UNIVERSE_JAVA == job_universe );
ArgList arguments;
MyString filename,
jobname,
error;
if ( extension && !java_universe && !binary_executable ) {
/** since we do not actually know how long the extension of
the file is, we'll need to hunt down the '.' in the path,
if it exists */
extension = strrchr ( jobtmp, '.' );
if ( !extension ) {
dprintf (
D_ALWAYS,
"VanillaProc::StartJob(): Failed to extract "
"the file's extension.\n" );
/** don't fail here, since we want executables to run
as usual. That is, some condor jobs submit
executables that do not have the '.exe' extension,
but are, nonetheless, executable binaries. For
instance, a submit script may contain:
executable = executable$(OPSYS) */
} else {
/** pull out the path to the executable */
if ( !JobAd->LookupString (
ATTR_JOB_CMD,
jobname ) ) {
/** fall back on Starter->jic->origJobName() */
jobname = jobtmp;
}
/** If we transferred the job, it may have been
renamed to condor_exec.exe even though it is
not an executable. Here we rename it back to
a the correct extension before it will run. */
if ( MATCH == strcasecmp (
CONDOR_EXEC,
condor_basename ( jobname.Value () ) ) ) {
filename.sprintf ( "condor_exec%s", extension );
rename ( CONDOR_EXEC, filename.Value () );
} else {
filename = jobname;
}
/** Since we've renamed our executable, we need to
update the job ad to reflect this change. */
if ( !JobAd->Assign (
ATTR_JOB_CMD,
filename ) ) {
dprintf (
D_ALWAYS,
"VanillaProc::StartJob(): ERROR: failed to "
"set new executable name.\n" );
return FALSE;
}
/** We've moved the script to argv[1], so we need to
add the remaining arguments to positions argv[2]..
argv[/n/]. */
if ( !arguments.AppendArgsFromClassAd ( JobAd, &error ) ||
!arguments.InsertArgsIntoClassAd ( JobAd, NULL,
&error ) ) {
dprintf (
D_ALWAYS,
"VanillaProc::StartJob(): ERROR: failed to "
"get arguments from job ad: %s\n",
error.Value () );
return FALSE;
}
/** Since we know already we don't want this file returned
to us, we explicitly add it to an exception list which
will stop the file transfer mechanism from considering
it for transfer back to its submitter */
Starter->jic->removeFromOutputFiles (
filename.Value () );
}
}
#endif
// set up a FamilyInfo structure to tell OsProc to register a family
// with the ProcD in its call to DaemonCore::Create_Process
//
FamilyInfo fi;
// take snapshots at no more than 15 seconds in between, by default
//
fi.max_snapshot_interval = param_integer("PID_SNAPSHOT_INTERVAL", 15);
char const *dedicated_account = Starter->jic->getExecuteAccountIsDedicated();
if( ThisProcRunsAlongsideMainProc() ) {
// If we track a secondary proc's family tree (such as
// sshd) using the same dedicated account as the job's
// family tree, we could end up killing the job when we
// clean up the secondary family.
dedicated_account = NULL;
}
if (dedicated_account) {
// using login-based family tracking
fi.login = dedicated_account;
// The following message is documented in the manual as the
// way to tell whether the dedicated execution account
// configuration is being used.
dprintf(D_ALWAYS,
"Tracking process family by login \"%s\"\n",
fi.login);
}
#if defined(LINUX)
// on Linux, we also have the ability to track processes via
// a phony supplementary group ID
//
gid_t tracking_gid;
if (param_boolean("USE_GID_PROCESS_TRACKING", false)) {
if (!can_switch_ids() &&
(Starter->condorPrivSepHelper() == NULL))
{
EXCEPT("USE_GID_PROCESS_TRACKING enabled, but can't modify "
"the group list of our children unless running as "
"root or using PrivSep");
}
fi.group_ptr = &tracking_gid;
}
#endif
// have OsProc start the job
//
return OsProc::StartJob(&fi);
}
bool
VanillaProc::PublishUpdateAd( ClassAd* ad )
{
dprintf( D_FULLDEBUG, "In VanillaProc::PublishUpdateAd()\n" );
ProcFamilyUsage* usage;
ProcFamilyUsage cur_usage;
if (m_proc_exited) {
usage = &m_final_usage;
}
else {
if (daemonCore->Get_Family_Usage(JobPid, cur_usage) == FALSE) {
dprintf(D_ALWAYS, "error getting family usage in "
"VanillaProc::PublishUpdateAd() for pid %d\n", JobPid);
return false;
}
usage = &cur_usage;
}
// Publish the info we care about into the ad.
char buf[200];
sprintf( buf, "%s=%lu", ATTR_JOB_REMOTE_SYS_CPU, usage->sys_cpu_time );
ad->InsertOrUpdate( buf );
sprintf( buf, "%s=%lu", ATTR_JOB_REMOTE_USER_CPU, usage->user_cpu_time );
ad->InsertOrUpdate( buf );
sprintf( buf, "%s=%lu", ATTR_IMAGE_SIZE, usage->max_image_size );
ad->InsertOrUpdate( buf );
sprintf( buf, "%s=%lu", ATTR_RESIDENT_SET_SIZE, usage->total_resident_set_size );
ad->InsertOrUpdate( buf );
// Update our knowledge of how many processes the job has
num_pids = usage->num_procs;
// Now, call our parent class's version
return OsProc::PublishUpdateAd( ad );
}
bool
VanillaProc::JobReaper(int pid, int status)
{
dprintf(D_FULLDEBUG,"Inside VanillaProc::JobReaper()\n");
#if !defined(WIN32)
cancelEscalationTimer();
#endif
if (pid == JobPid) {
// Make sure that nothing was left behind.
daemonCore->Kill_Family(JobPid);
// Record final usage stats for this process family, since
// once the reaper returns, the family is no longer
// registered with DaemonCore and we'll never be able to
// get this information again.
if (daemonCore->Get_Family_Usage(JobPid, m_final_usage) == FALSE) {
dprintf(D_ALWAYS, "error getting family usage for pid %d in "
"VanillaProc::JobReaper()\n", JobPid);
}
}
// This will reset num_pids for us, too.
return OsProc::JobReaper( pid, status );
}
void
VanillaProc::Suspend()
{
dprintf(D_FULLDEBUG,"in VanillaProc::Suspend()\n");
// suspend the user job
if (JobPid != -1) {
if (daemonCore->Suspend_Family(JobPid) == FALSE) {
dprintf(D_ALWAYS,
"error suspending family in VanillaProc::Suspend()\n");
}
}
// set our flag
is_suspended = true;
}
void
VanillaProc::Continue()
{
dprintf(D_FULLDEBUG,"in VanillaProc::Continue()\n");
// resume user job
if (JobPid != -1) {
if (daemonCore->Continue_Family(JobPid) == FALSE) {
dprintf(D_ALWAYS,
"error continuing family in VanillaProc::Continue()\n");
}
}
// set our flag
is_suspended = false;
}
bool
VanillaProc::ShutdownGraceful()
{
dprintf(D_FULLDEBUG,"in VanillaProc::ShutdownGraceful()\n");
if ( JobPid == -1 ) {
// there is no process family yet, probably because we are still
// transferring files. just return true to say we're all done,
// and that way the starter class will simply delete us and the
// FileTransfer destructor will clean up.
return true;
}
// WE USED TO.....
//
// take a snapshot before we softkill the parent job process.
// this helps ensure that if the parent exits without killing
// the kids, our JobExit() handler will get em all.
//
// TODO: should we make an explicit call to the procd here to tell
// it to take a snapshot???
// now softkill the parent job process. this is exactly what
// OsProc::ShutdownGraceful does, so call it.
//
return OsProc::ShutdownGraceful();
}
bool
VanillaProc::ShutdownFast()
{
dprintf(D_FULLDEBUG,"in VanillaProc::ShutdownFast()\n");
if ( JobPid == -1 ) {
// there is no process family yet, probably because we are still
// transferring files. just return true to say we're all done,
// and that way the starter class will simply delete us and the
// FileTransfer destructor will clean up.
return true;
}
// We purposely do not do a SIGCONT here, since there is no sense
// in potentially swapping the job back into memory if our next
// step is to hard kill it.
requested_exit = true;
#if !defined(WIN32)
int kill_sig = -1;
// Determine if a custom kill signal is provided in the job
kill_sig = findRmKillSig( JobAd );
if ( kill_sig == -1 )
{
kill_sig = findSoftKillSig( JobAd );
}
// If a custom kill signal was given, send that signal to the
// job
if ( kill_sig != -1 ) {
if ( daemonCore->Signal_Process( JobPid, kill_sig ) == FALSE ) {
dprintf(D_ALWAYS,
"Error: Failed to send signal %d to "
"job with pid %u\n", kill_sig, JobPid);
}
else {
startEscalationTimer();
return false;
}
}
#endif
return finishShutdownFast();
}
bool
VanillaProc::finishShutdownFast()
{
// this used to be the only place where we would clean up the process
// family. this, however, wouldn't properly clean up local universe jobs
// so a call to Kill_Family has been added to JobReaper(). i'm not sure
// that this call is still needed, but am unwilling to remove it on the
// eve of Condor 7
// -gquinn, 2007-11-14
daemonCore->Kill_Family(JobPid);
return false; // shutdown is pending, so return false
}
#if !defined(WIN32)
bool
VanillaProc::startEscalationTimer()
{
int job_kill_time = 0;
int killing_timeout = param_integer( "KILLING_TIMEOUT", 30 );
int escalation_delay;
if ( m_escalation_tid >= 0 ) {
return true;
}
if ( !JobAd->LookupInteger(ATTR_KILL_SIG_TIMEOUT, job_kill_time) ) {
job_kill_time = killing_timeout;
}
escalation_delay = std::max(std::min(killing_timeout-1, job_kill_time), 0);
dprintf(D_FULLDEBUG, "Using escalation delay %d for Escalation Timer\n", escalation_delay);
m_escalation_tid = daemonCore->Register_Timer(escalation_delay,
escalation_delay,
(TimerHandlercpp)&VanillaProc::EscalateSignal,
"EscalateSignal", this);
if ( m_escalation_tid < 0 ) {
dprintf(D_ALWAYS, "Error: Unable to register signal esclation timer. timeout attmepted: %d\n", escalation_delay);
}
return true;
}
void
VanillaProc::cancelEscalationTimer()
{
int rval;
if ( m_escalation_tid != -1 ) {
rval = daemonCore->Cancel_Timer( m_escalation_tid );
if ( rval < 0 ) {
dprintf(D_ALWAYS, "Failed to cancel signal escalation "
"timer (%d): daemonCore error\n", m_escalation_tid);
}
else {
dprintf(D_FULLDEBUG, "Cancel signal escalation timer (%d)\n", m_escalation_tid);
}
m_escalation_tid = -1;
}
}
bool
VanillaProc::EscalateSignal()
{
dprintf(D_FULLDEBUG, "Esclation Timer fired. Killing job\n");
cancelEscalationTimer();
finishShutdownFast();
return true;
}
#endif
<commit_msg>Revert "startEscalationTimer is only in 7.5, 7.4 will have to live without this fix for #1392"<commit_after>/***************************************************************
*
* Copyright (C) 1990-2007, Condor Team, Computer Sciences Department,
* University of Wisconsin-Madison, WI.
*
* 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 "condor_common.h"
#include "condor_classad.h"
#include "condor_debug.h"
#include "condor_daemon_core.h"
#include "condor_attributes.h"
#include "condor_syscall_mode.h"
#include "exit.h"
#include "vanilla_proc.h"
#include "starter.h"
#include "syscall_numbers.h"
#include "dynuser.h"
#include "condor_config.h"
#include "domain_tools.h"
#include "classad_helpers.h"
#ifdef WIN32
#include "executable_scripts.WINDOWS.h"
extern dynuser* myDynuser;
#endif
extern CStarter *Starter;
VanillaProc::VanillaProc(ClassAd* jobAd) : OsProc(jobAd)
{
#if !defined(WIN32)
m_escalation_tid = -1;
#endif
}
int
VanillaProc::StartJob()
{
dprintf(D_FULLDEBUG,"in VanillaProc::StartJob()\n");
// vanilla jobs, unlike standard jobs, are allowed to run
// shell scripts (or as is the case on NT, batch files). so
// edit the ad so we start up a shell, pass the executable as
// an argument to the shell, if we are asked to run a .bat file.
#ifdef WIN32
CHAR interpreter[MAX_PATH+1],
systemshell[MAX_PATH+1];
const char* jobtmp = Starter->jic->origJobName();
int joblen = strlen(jobtmp);
const char *extension = joblen > 0 ? &(jobtmp[joblen-4]) : NULL;
bool binary_executable = ( extension &&
( MATCH == strcasecmp ( ".exe", extension ) ||
MATCH == strcasecmp ( ".com", extension ) ) ),
java_universe = ( CONDOR_UNIVERSE_JAVA == job_universe );
ArgList arguments;
MyString filename,
jobname,
error;
if ( extension && !java_universe && !binary_executable ) {
/** since we do not actually know how long the extension of
the file is, we'll need to hunt down the '.' in the path,
if it exists */
extension = strrchr ( jobtmp, '.' );
if ( !extension ) {
dprintf (
D_ALWAYS,
"VanillaProc::StartJob(): Failed to extract "
"the file's extension.\n" );
/** don't fail here, since we want executables to run
as usual. That is, some condor jobs submit
executables that do not have the '.exe' extension,
but are, nonetheless, executable binaries. For
instance, a submit script may contain:
executable = executable$(OPSYS) */
} else {
/** pull out the path to the executable */
if ( !JobAd->LookupString (
ATTR_JOB_CMD,
jobname ) ) {
/** fall back on Starter->jic->origJobName() */
jobname = jobtmp;
}
/** If we transferred the job, it may have been
renamed to condor_exec.exe even though it is
not an executable. Here we rename it back to
a the correct extension before it will run. */
if ( MATCH == strcasecmp (
CONDOR_EXEC,
condor_basename ( jobname.Value () ) ) ) {
filename.sprintf ( "condor_exec%s", extension );
rename ( CONDOR_EXEC, filename.Value () );
} else {
filename = jobname;
}
/** Since we've renamed our executable, we need to
update the job ad to reflect this change. */
if ( !JobAd->Assign (
ATTR_JOB_CMD,
filename ) ) {
dprintf (
D_ALWAYS,
"VanillaProc::StartJob(): ERROR: failed to "
"set new executable name.\n" );
return FALSE;
}
/** We've moved the script to argv[1], so we need to
add the remaining arguments to positions argv[2]..
argv[/n/]. */
if ( !arguments.AppendArgsFromClassAd ( JobAd, &error ) ||
!arguments.InsertArgsIntoClassAd ( JobAd, NULL,
&error ) ) {
dprintf (
D_ALWAYS,
"VanillaProc::StartJob(): ERROR: failed to "
"get arguments from job ad: %s\n",
error.Value () );
return FALSE;
}
/** Since we know already we don't want this file returned
to us, we explicitly add it to an exception list which
will stop the file transfer mechanism from considering
it for transfer back to its submitter */
Starter->jic->removeFromOutputFiles (
filename.Value () );
}
}
#endif
// set up a FamilyInfo structure to tell OsProc to register a family
// with the ProcD in its call to DaemonCore::Create_Process
//
FamilyInfo fi;
// take snapshots at no more than 15 seconds in between, by default
//
fi.max_snapshot_interval = param_integer("PID_SNAPSHOT_INTERVAL", 15);
char const *dedicated_account = Starter->jic->getExecuteAccountIsDedicated();
if( ThisProcRunsAlongsideMainProc() ) {
// If we track a secondary proc's family tree (such as
// sshd) using the same dedicated account as the job's
// family tree, we could end up killing the job when we
// clean up the secondary family.
dedicated_account = NULL;
}
if (dedicated_account) {
// using login-based family tracking
fi.login = dedicated_account;
// The following message is documented in the manual as the
// way to tell whether the dedicated execution account
// configuration is being used.
dprintf(D_ALWAYS,
"Tracking process family by login \"%s\"\n",
fi.login);
}
#if defined(LINUX)
// on Linux, we also have the ability to track processes via
// a phony supplementary group ID
//
gid_t tracking_gid;
if (param_boolean("USE_GID_PROCESS_TRACKING", false)) {
if (!can_switch_ids() &&
(Starter->condorPrivSepHelper() == NULL))
{
EXCEPT("USE_GID_PROCESS_TRACKING enabled, but can't modify "
"the group list of our children unless running as "
"root or using PrivSep");
}
fi.group_ptr = &tracking_gid;
}
#endif
// have OsProc start the job
//
return OsProc::StartJob(&fi);
}
bool
VanillaProc::PublishUpdateAd( ClassAd* ad )
{
dprintf( D_FULLDEBUG, "In VanillaProc::PublishUpdateAd()\n" );
ProcFamilyUsage* usage;
ProcFamilyUsage cur_usage;
if (m_proc_exited) {
usage = &m_final_usage;
}
else {
if (daemonCore->Get_Family_Usage(JobPid, cur_usage) == FALSE) {
dprintf(D_ALWAYS, "error getting family usage in "
"VanillaProc::PublishUpdateAd() for pid %d\n", JobPid);
return false;
}
usage = &cur_usage;
}
// Publish the info we care about into the ad.
char buf[200];
sprintf( buf, "%s=%lu", ATTR_JOB_REMOTE_SYS_CPU, usage->sys_cpu_time );
ad->InsertOrUpdate( buf );
sprintf( buf, "%s=%lu", ATTR_JOB_REMOTE_USER_CPU, usage->user_cpu_time );
ad->InsertOrUpdate( buf );
sprintf( buf, "%s=%lu", ATTR_IMAGE_SIZE, usage->max_image_size );
ad->InsertOrUpdate( buf );
sprintf( buf, "%s=%lu", ATTR_RESIDENT_SET_SIZE, usage->total_resident_set_size );
ad->InsertOrUpdate( buf );
// Update our knowledge of how many processes the job has
num_pids = usage->num_procs;
// Now, call our parent class's version
return OsProc::PublishUpdateAd( ad );
}
bool
VanillaProc::JobReaper(int pid, int status)
{
dprintf(D_FULLDEBUG,"Inside VanillaProc::JobReaper()\n");
#if !defined(WIN32)
cancelEscalationTimer();
#endif
if (pid == JobPid) {
// Make sure that nothing was left behind.
daemonCore->Kill_Family(JobPid);
// Record final usage stats for this process family, since
// once the reaper returns, the family is no longer
// registered with DaemonCore and we'll never be able to
// get this information again.
if (daemonCore->Get_Family_Usage(JobPid, m_final_usage) == FALSE) {
dprintf(D_ALWAYS, "error getting family usage for pid %d in "
"VanillaProc::JobReaper()\n", JobPid);
}
}
// This will reset num_pids for us, too.
return OsProc::JobReaper( pid, status );
}
void
VanillaProc::Suspend()
{
dprintf(D_FULLDEBUG,"in VanillaProc::Suspend()\n");
// suspend the user job
if (JobPid != -1) {
if (daemonCore->Suspend_Family(JobPid) == FALSE) {
dprintf(D_ALWAYS,
"error suspending family in VanillaProc::Suspend()\n");
}
}
// set our flag
is_suspended = true;
}
void
VanillaProc::Continue()
{
dprintf(D_FULLDEBUG,"in VanillaProc::Continue()\n");
// resume user job
if (JobPid != -1) {
if (daemonCore->Continue_Family(JobPid) == FALSE) {
dprintf(D_ALWAYS,
"error continuing family in VanillaProc::Continue()\n");
}
}
// set our flag
is_suspended = false;
}
bool
VanillaProc::ShutdownGraceful()
{
dprintf(D_FULLDEBUG,"in VanillaProc::ShutdownGraceful()\n");
if ( JobPid == -1 ) {
// there is no process family yet, probably because we are still
// transferring files. just return true to say we're all done,
// and that way the starter class will simply delete us and the
// FileTransfer destructor will clean up.
return true;
}
// WE USED TO.....
//
// take a snapshot before we softkill the parent job process.
// this helps ensure that if the parent exits without killing
// the kids, our JobExit() handler will get em all.
//
// TODO: should we make an explicit call to the procd here to tell
// it to take a snapshot???
// now softkill the parent job process. this is exactly what
// OsProc::ShutdownGraceful does, so call it.
//
OsProc::ShutdownGraceful();
startEscalationTimer();
return false; // shutdown is pending (same as OsProc::ShutdownGraceful()
}
bool
VanillaProc::ShutdownFast()
{
dprintf(D_FULLDEBUG,"in VanillaProc::ShutdownFast()\n");
if ( JobPid == -1 ) {
// there is no process family yet, probably because we are still
// transferring files. just return true to say we're all done,
// and that way the starter class will simply delete us and the
// FileTransfer destructor will clean up.
return true;
}
// We purposely do not do a SIGCONT here, since there is no sense
// in potentially swapping the job back into memory if our next
// step is to hard kill it.
requested_exit = true;
#if !defined(WIN32)
int kill_sig = -1;
// Determine if a custom kill signal is provided in the job
kill_sig = findRmKillSig( JobAd );
if ( kill_sig == -1 )
{
kill_sig = findSoftKillSig( JobAd );
}
// If a custom kill signal was given, send that signal to the
// job
if ( kill_sig != -1 ) {
if ( daemonCore->Signal_Process( JobPid, kill_sig ) == FALSE ) {
dprintf(D_ALWAYS,
"Error: Failed to send signal %d to "
"job with pid %u\n", kill_sig, JobPid);
}
else {
startEscalationTimer();
return false;
}
}
#endif
return finishShutdownFast();
}
bool
VanillaProc::finishShutdownFast()
{
// this used to be the only place where we would clean up the process
// family. this, however, wouldn't properly clean up local universe jobs
// so a call to Kill_Family has been added to JobReaper(). i'm not sure
// that this call is still needed, but am unwilling to remove it on the
// eve of Condor 7
// -gquinn, 2007-11-14
daemonCore->Kill_Family(JobPid);
return false; // shutdown is pending, so return false
}
#if !defined(WIN32)
bool
VanillaProc::startEscalationTimer()
{
int job_kill_time = 0;
int killing_timeout = param_integer( "KILLING_TIMEOUT", 30 );
int escalation_delay;
if ( m_escalation_tid >= 0 ) {
return true;
}
if ( !JobAd->LookupInteger(ATTR_KILL_SIG_TIMEOUT, job_kill_time) ) {
job_kill_time = killing_timeout;
}
escalation_delay = std::max(std::min(killing_timeout-1, job_kill_time), 0);
dprintf(D_FULLDEBUG, "Using escalation delay %d for Escalation Timer\n", escalation_delay);
m_escalation_tid = daemonCore->Register_Timer(escalation_delay,
escalation_delay,
(TimerHandlercpp)&VanillaProc::EscalateSignal,
"EscalateSignal", this);
if ( m_escalation_tid < 0 ) {
dprintf(D_ALWAYS, "Error: Unable to register signal esclation timer. timeout attmepted: %d\n", escalation_delay);
}
return true;
}
void
VanillaProc::cancelEscalationTimer()
{
int rval;
if ( m_escalation_tid != -1 ) {
rval = daemonCore->Cancel_Timer( m_escalation_tid );
if ( rval < 0 ) {
dprintf(D_ALWAYS, "Failed to cancel signal escalation "
"timer (%d): daemonCore error\n", m_escalation_tid);
}
else {
dprintf(D_FULLDEBUG, "Cancel signal escalation timer (%d)\n", m_escalation_tid);
}
m_escalation_tid = -1;
}
}
bool
VanillaProc::EscalateSignal()
{
dprintf(D_FULLDEBUG, "Esclation Timer fired. Killing job\n");
cancelEscalationTimer();
finishShutdownFast();
return true;
}
#endif
<|endoftext|> |
<commit_before>
#include <iostream>
#include <stdexcept>
#include <sys/mman.h>
#include <unistd.h>
#include "PINContextHandler.h"
#include "PINConverter.h"
PINContextHandler::PINContextHandler(CONTEXT *ctx, THREADID id):
_ctx(ctx),
_threadId(id)
{
}
// REG is a enum, so the cast is from a bigger type.
static inline REG safecast(uint64_t regID)
{
return static_cast<REG>(regID);
}
void *PINContextHandler::getCtx(void) const
{
return this->_ctx;
}
// There is no verification on the validity of the ID.
uint64_t PINContextHandler::getFlagValue(uint64_t TritFlagID) const
{
uint64_t rflags;
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(ID_RFLAGS));
if (reg == -1 || !REG_valid(reg))
throw std::runtime_error("Error: Invalid PIN register id.");
rflags = PIN_GetContextReg(this->_ctx, reg);
switch (TritFlagID){
case ID_AF:
return (rflags >> 4) & 1;
break;
case ID_CF:
return rflags & 1;
break;
case ID_DF:
return (rflags >> 10) & 1;
break;
case ID_IF:
return (rflags >> 9) & 1;
break;
case ID_OF:
return (rflags >> 11) & 1;
break;
case ID_PF:
return (rflags >> 2) & 1;
break;
case ID_SF:
return (rflags >> 7) & 1;
break;
case ID_TF:
return (rflags >> 8) & 1;
break;
case ID_ZF:
return (rflags >> 6) & 1;
break;
default:
throw std::runtime_error("Error: Invalid Flag id.");
}
return 0;
}
// There is no verification on the validity of the ID.
uint64_t PINContextHandler::getRegisterValue(uint64_t TritRegID) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
if (reg == -1 || !REG_valid(reg) || (TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
return PIN_GetContextReg(this->_ctx, reg);
}
// There is no verification on the validity of the ID.
__uint128_t PINContextHandler::getSSERegisterValue(uint64_t TritRegID) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
__uint128_t value = 0;
PIN_REGISTER tmp;
if (reg == -1 || !REG_valid(reg) || !(TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
PIN_GetContextRegval(this->_ctx, reg, reinterpret_cast<UINT8 *>(&tmp));
value = *reinterpret_cast<__uint128_t*>(&tmp);
return value;
}
// There is no verification on the validity of the ID.
void PINContextHandler::setRegisterValue(uint64_t TritRegID, uint64_t value) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
if (reg == -1 || !REG_valid(reg) || (TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
PIN_SetContextReg(this->_ctx, reg, value);
PIN_ExecuteAt(this->_ctx);
}
// There is no verification on the validity of the ID.
void PINContextHandler::setSSERegisterValue(uint64_t TritRegID, __uint128_t value) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
unsigned char *tmp = (unsigned char*)malloc(16);
if (tmp == nullptr)
throw std::runtime_error("Error: Not enough memory.");
if (reg == -1 || !REG_valid(reg) || !(TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
*(__uint128_t *)tmp = value;
PIN_SetContextRegval(this->_ctx, reg, tmp);
PIN_ExecuteAt(this->_ctx);
free(tmp);
}
/* Tricks to check if the address is mapped */
static bool isAddressMapped(ADDRINT addr) {
int pagesize = getpagesize();
void *foo = (void *)(addr / pagesize * pagesize);
if (munlock(foo, 1) == -1)
return false;
return true;
}
/* Used to deref a pointer address and returns the targeted byte by size of read */
__uint128_t PINContextHandler::getMemValue(uint64_t mem, uint32_t readSize) const
{
if (!isAddressMapped(mem)){
std::cout << "[Bugs] Invalid read at " << std::hex << mem << std::endl;
exit(0);
}
switch(readSize){
case 1: return static_cast<__uint128_t>(*(reinterpret_cast<UINT8 *>(mem)));
case 2: return static_cast<__uint128_t>(*(reinterpret_cast<UINT16 *>(mem)));
case 4: return static_cast<__uint128_t>(*(reinterpret_cast<UINT32 *>(mem)));
case 8: return static_cast<__uint128_t>(*(reinterpret_cast<UINT64 *>(mem)));
case 16: return static_cast<__uint128_t>(*(reinterpret_cast<__uint128_t *>(mem)));
}
throw std::runtime_error("Error: Invalid read size");
return 0; // Never go there
}
/* Returns the thread id */
uint32_t PINContextHandler::getThreadID(void) const
{
return this->_threadId;
}
<commit_msg>Facto code<commit_after>
#include <iostream>
#include <stdexcept>
#include <sys/mman.h>
#include <unistd.h>
#include "PINContextHandler.h"
#include "PINConverter.h"
PINContextHandler::PINContextHandler(CONTEXT *ctx, THREADID id):
_ctx(ctx),
_threadId(id)
{
}
// REG is a enum, so the cast is from a bigger type.
static inline REG safecast(uint64_t regID)
{
return static_cast<REG>(regID);
}
void *PINContextHandler::getCtx(void) const
{
return this->_ctx;
}
// There is no verification on the validity of the ID.
uint64_t PINContextHandler::getFlagValue(uint64_t TritFlagID) const
{
uint64_t rflags;
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(ID_RFLAGS));
if (reg == -1 || !REG_valid(reg))
throw std::runtime_error("Error: Invalid PIN register id.");
rflags = PIN_GetContextReg(this->_ctx, reg);
switch (TritFlagID){
case ID_AF: return (rflags >> 4) & 1;
case ID_CF: return rflags & 1;
case ID_DF: return (rflags >> 10) & 1;
case ID_IF: return (rflags >> 9) & 1;
case ID_OF: return (rflags >> 11) & 1;
case ID_PF: return (rflags >> 2) & 1;
case ID_SF: return (rflags >> 7) & 1;
case ID_TF: return (rflags >> 8) & 1;
case ID_ZF: return (rflags >> 6) & 1;
default:
throw std::runtime_error("Error: Invalid Flag id.");
}
return 0;
}
// There is no verification on the validity of the ID.
uint64_t PINContextHandler::getRegisterValue(uint64_t TritRegID) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
if (reg == -1 || !REG_valid(reg) || (TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
return PIN_GetContextReg(this->_ctx, reg);
}
// There is no verification on the validity of the ID.
__uint128_t PINContextHandler::getSSERegisterValue(uint64_t TritRegID) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
__uint128_t value = 0;
PIN_REGISTER tmp;
if (reg == -1 || !REG_valid(reg) || !(TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
PIN_GetContextRegval(this->_ctx, reg, reinterpret_cast<UINT8 *>(&tmp));
value = *reinterpret_cast<__uint128_t*>(&tmp);
return value;
}
// There is no verification on the validity of the ID.
void PINContextHandler::setRegisterValue(uint64_t TritRegID, uint64_t value) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
if (reg == -1 || !REG_valid(reg) || (TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
PIN_SetContextReg(this->_ctx, reg, value);
PIN_ExecuteAt(this->_ctx);
}
// There is no verification on the validity of the ID.
void PINContextHandler::setSSERegisterValue(uint64_t TritRegID, __uint128_t value) const
{
REG reg = safecast(PINConverter::convertTritonReg2DBIReg(TritRegID));
unsigned char *tmp = (unsigned char*)malloc(16);
if (tmp == nullptr)
throw std::runtime_error("Error: Not enough memory.");
if (reg == -1 || !REG_valid(reg) || !(TritRegID >= ID_XMM0 && TritRegID <= ID_XMM15))
throw std::runtime_error("Error: Invalid PIN register id.");
*(__uint128_t *)tmp = value;
PIN_SetContextRegval(this->_ctx, reg, tmp);
PIN_ExecuteAt(this->_ctx);
free(tmp);
}
/* Tricks to check if the address is mapped */
static bool isAddressMapped(ADDRINT addr) {
int pagesize = getpagesize();
void *foo = (void *)(addr / pagesize * pagesize);
if (munlock(foo, 1) == -1)
return false;
return true;
}
/* Used to deref a pointer address and returns the targeted byte by size of read */
__uint128_t PINContextHandler::getMemValue(uint64_t mem, uint32_t readSize) const
{
if (!isAddressMapped(mem)){
std::cout << "[Bugs] Invalid read at " << std::hex << mem << std::endl;
exit(0);
}
switch(readSize){
case 1: return static_cast<__uint128_t>(*(reinterpret_cast<UINT8 *>(mem)));
case 2: return static_cast<__uint128_t>(*(reinterpret_cast<UINT16 *>(mem)));
case 4: return static_cast<__uint128_t>(*(reinterpret_cast<UINT32 *>(mem)));
case 8: return static_cast<__uint128_t>(*(reinterpret_cast<UINT64 *>(mem)));
case 16: return static_cast<__uint128_t>(*(reinterpret_cast<__uint128_t *>(mem)));
}
throw std::runtime_error("Error: Invalid read size");
return 0; // Never go there
}
/* Returns the thread id */
uint32_t PINContextHandler::getThreadID(void) const
{
return this->_threadId;
}
<|endoftext|> |
<commit_before>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// http.cc - Low level routines to write HTTP messages.
#include <ts/ts.h>
#include <spdy/spdy.h>
#include <base/logging.h>
#include "io.h"
#include "http.h"
#include "protocol.h"
static void
populate_http_headers(
TSMBuffer buffer,
TSMLoc header,
spdy::protocol_version version,
spdy::key_value_block& kvblock)
{
char status[128];
char httpvers[sizeof("HTTP/xx.xx")];
int vers = TSHttpHdrVersionGet(buffer, header);
TSHttpStatus code = TSHttpHdrStatusGet(buffer, header);
snprintf(status, sizeof(status),
"%u %s", (unsigned)code, TSHttpHdrReasonLookup(code));
snprintf(httpvers, sizeof(httpvers),
"HTTP/%2u.%2u", TS_HTTP_MAJOR(vers), TS_HTTP_MINOR(vers));
if (version == spdy::PROTOCOL_VERSION_2) {
kvblock["status"] = status;
kvblock["version"] = httpvers;
} else {
kvblock[":status"] = status;
kvblock[":version"] = httpvers;
}
}
void
http_send_response(
spdy_io_stream * stream,
TSMBuffer buffer,
TSMLoc header)
{
TSMLoc field;
spdy::key_value_block kvblock;
debug_http_header(stream, buffer, header);
field = TSMimeHdrFieldGet(buffer, header, 0);
while (field) {
TSMLoc next;
std::pair<const char *, int> name;
std::pair<const char *, int> value;
name.first = TSMimeHdrFieldNameGet(buffer, header, field, &name.second);
// XXX zwoop says that pointer comparisons ought to be
// sufficient here. If we can test and confirm, we can
// remove all the strcmp()s.
//The Connection, Keep-Alive, Proxy-Connection, and
//Transfer-Encoding headers are not valid and MUST not be
//sent.
if (strcmp(name.first, TS_MIME_FIELD_CONNECTION) == 0 ||
strcmp(name.first, TS_MIME_FIELD_KEEP_ALIVE) == 0 ||
strcmp(name.first, TS_MIME_FIELD_PROXY_CONNECTION) == 0 ||
strcmp(name.first, TS_MIME_FIELD_TRANSFER_ENCODING) == 0) {
debug_http("[%p/%u] skipping %s header",
stream->io, stream->stream_id, name.first);
goto skip;
}
value.first = TSMimeHdrFieldValueStringGet(buffer, header,
field, 0, &value.second);
kvblock.insert(std::string(name.first, name.second),
std::string(value.first, value.second));
skip:
next = TSMimeHdrFieldNext(buffer, header, field);
TSHandleMLocRelease(buffer, header, field);
field = next;
}
populate_http_headers(buffer, header, stream->version, kvblock);
spdy_send_syn_reply(stream, kvblock);
}
void
http_send_error(
spdy_io_stream * stream,
TSHttpStatus status)
{
scoped_mbuffer buffer;
scoped_http_header header(buffer.get());
TSHttpHdrTypeSet(buffer.get(), header.get(), TS_HTTP_TYPE_RESPONSE);
TSHttpHdrVersionSet(buffer.get(), header.get(), TS_HTTP_VERSION(1, 1));
TSHttpHdrStatusSet(buffer.get(), header.get(), status);
debug_http("[%p/%u] sending a HTTP %d result for %s %s://%s%s",
stream->io, stream->stream_id, status,
stream->kvblock.url().method.c_str(),
stream->kvblock.url().scheme.c_str(),
stream->kvblock.url().hostport.c_str(),
stream->kvblock.url().path.c_str());
http_send_response(stream, buffer.get(), header.get());
spdy_send_data_frame(stream, spdy::FLAG_FIN, nullptr, 0);
}
void
http_send_content(
spdy_io_stream * stream,
TSIOBufferReader reader)
{
TSIOBufferBlock blk;
int64_t consumed = 0;
blk = TSIOBufferReaderStart(stream->input.reader);
while (blk) {
const char * ptr;
int64_t nbytes;
ptr = TSIOBufferBlockReadStart(blk, reader, &nbytes);
if (ptr && nbytes) {
spdy_send_data_frame(stream, 0 /* flags */, ptr, nbytes);
consumed += nbytes;
}
blk = TSIOBufferBlockNext(blk);
}
TSIOBufferReaderConsume(reader, consumed);
}
void
debug_http_header(
const spdy_io_stream * stream,
TSMBuffer buffer,
TSMLoc header)
{
if (unlikely(TSIsDebugTagSet("spdy.http"))) {
spdy_io_buffer iobuf;
int64_t nbytes;
int64_t avail;
const char * ptr;
TSIOBufferBlock blk;
TSHttpHdrPrint(buffer, header, iobuf.buffer);
blk = TSIOBufferStart(iobuf.buffer);
avail = TSIOBufferBlockReadAvail(blk, iobuf.reader);
ptr = (const char *)TSIOBufferBlockReadStart(blk, iobuf.reader, &nbytes);
debug_http(
"[%p/%u] http request (%" PRIu64 " of %" PRIu64 " bytes):\n%*.*s",
stream, stream->stream_id, nbytes, avail,
(int)nbytes, (int)nbytes, ptr);
}
}
http_parser::http_parser()
: parser(TSHttpParserCreate()), mbuffer(), header(mbuffer.get()), complete(false)
{
}
http_parser::~http_parser()
{
if (parser) {
TSHttpParserDestroy(parser);
}
}
ssize_t
http_parser::parse(TSIOBufferReader reader)
{
TSIOBufferBlock blk;
ssize_t consumed = 0;
for (blk = TSIOBufferReaderStart(reader); blk;
blk = TSIOBufferBlockNext(blk)) {
const char * ptr;
const char * end;
int64_t nbytes;
TSParseResult result;
ptr = TSIOBufferBlockReadStart(blk, reader, &nbytes);
if (ptr == nullptr || nbytes == 0) {
continue;
}
end = ptr + nbytes;
result = TSHttpHdrParseResp(parser, mbuffer.get(), header.get(), &ptr, end);
switch (result) {
case TS_PARSE_ERROR:
return (ssize_t)result;
case TS_PARSE_DONE:
case TS_PARSE_OK:
this->complete = true;
case TS_PARSE_CONT:
// We consumed the buffer we got minus the remainder.
consumed += (nbytes - std::distance(ptr, end));
}
if (this->complete) {
break;
}
}
TSIOBufferReaderConsume(reader, consumed);
return consumed;
}
static void
make_ts_http_url(
TSMBuffer buffer,
TSMLoc header,
const spdy::key_value_block& kvblock)
{
TSReturnCode tstatus;
TSMLoc url;
tstatus = TSHttpHdrUrlGet(buffer, header, &url);
if (tstatus == TS_ERROR) {
tstatus = TSUrlCreate(buffer, &url);
}
TSUrlSchemeSet(buffer, url,
kvblock.url().scheme.data(), kvblock.url().scheme.size());
TSUrlHostSet(buffer, url,
kvblock.url().hostport.data(), kvblock.url().hostport.size());
TSUrlPathSet(buffer, url,
kvblock.url().path.data(), kvblock.url().path.size());
TSHttpHdrMethodSet(buffer, header,
kvblock.url().method.data(), kvblock.url().method.size());
TSHttpHdrUrlSet(buffer, header, url);
TSAssert(tstatus == TS_SUCCESS);
}
static TSMLoc
make_ts_http_header(
TSMBuffer buffer,
const spdy::key_value_block& kvblock)
{
scoped_http_header header(buffer);
TSHttpHdrTypeSet(buffer, header, TS_HTTP_TYPE_REQUEST);
// XXX extract the real HTTP version header from kvblock.url()
TSHttpHdrVersionSet(buffer, header, TS_HTTP_VERSION(1, 1));
make_ts_http_url(buffer, header, kvblock);
// Duplicate the header fields into the MIME header for the HTTP request we
// are building.
for (auto ptr(kvblock.begin()); ptr != kvblock.end(); ++ptr) {
if (ptr->first[0] != ':') {
TSMLoc field;
// XXX Need special handling for duplicate headers; we should
// append them as a multi-value
TSMimeHdrFieldCreateNamed(buffer, header,
ptr->first.c_str(), -1, &field);
TSMimeHdrFieldValueStringInsert(buffer, header, field,
-1, ptr->second.c_str(), -1);
TSMimeHdrFieldAppend(buffer, header, field);
}
}
return header.release();
}
scoped_http_header::scoped_http_header(
TSMBuffer b,
const spdy::key_value_block& kvblock)
: buffer(b)
{
this->header = make_ts_http_header(buffer, kvblock);
}
scoped_http_header::scoped_http_header(TSMBuffer b)
: header(TS_NULL_MLOC), buffer(b)
{
header = TSHttpHdrCreate(buffer);
}
/* vim: set sw=4 ts=4 tw=79 et : */
<commit_msg>TS-1525: SPDY plugin sends malformed HTTP version string<commit_after>/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// http.cc - Low level routines to write HTTP messages.
#include <ts/ts.h>
#include <spdy/spdy.h>
#include <base/logging.h>
#include "io.h"
#include "http.h"
#include "protocol.h"
static void
populate_http_headers(
TSMBuffer buffer,
TSMLoc header,
spdy::protocol_version version,
spdy::key_value_block& kvblock)
{
char status[128];
char httpvers[sizeof("HTTP/xx.xx")];
int vers = TSHttpHdrVersionGet(buffer, header);
TSHttpStatus code = TSHttpHdrStatusGet(buffer, header);
snprintf(status, sizeof(status),
"%u %s", (unsigned)code, TSHttpHdrReasonLookup(code));
snprintf(httpvers, sizeof(httpvers),
"HTTP/%u.%u", TS_HTTP_MAJOR(vers), TS_HTTP_MINOR(vers));
if (version == spdy::PROTOCOL_VERSION_2) {
kvblock["status"] = status;
kvblock["version"] = httpvers;
} else {
kvblock[":status"] = status;
kvblock[":version"] = httpvers;
}
}
void
http_send_response(
spdy_io_stream * stream,
TSMBuffer buffer,
TSMLoc header)
{
TSMLoc field;
spdy::key_value_block kvblock;
debug_http_header(stream, buffer, header);
field = TSMimeHdrFieldGet(buffer, header, 0);
while (field) {
TSMLoc next;
std::pair<const char *, int> name;
std::pair<const char *, int> value;
name.first = TSMimeHdrFieldNameGet(buffer, header, field, &name.second);
// XXX zwoop says that pointer comparisons ought to be
// sufficient here. If we can test and confirm, we can
// remove all the strcmp()s.
//The Connection, Keep-Alive, Proxy-Connection, and
//Transfer-Encoding headers are not valid and MUST not be
//sent.
if (strcmp(name.first, TS_MIME_FIELD_CONNECTION) == 0 ||
strcmp(name.first, TS_MIME_FIELD_KEEP_ALIVE) == 0 ||
strcmp(name.first, TS_MIME_FIELD_PROXY_CONNECTION) == 0 ||
strcmp(name.first, TS_MIME_FIELD_TRANSFER_ENCODING) == 0) {
debug_http("[%p/%u] skipping %s header",
stream->io, stream->stream_id, name.first);
goto skip;
}
value.first = TSMimeHdrFieldValueStringGet(buffer, header,
field, 0, &value.second);
kvblock.insert(std::string(name.first, name.second),
std::string(value.first, value.second));
skip:
next = TSMimeHdrFieldNext(buffer, header, field);
TSHandleMLocRelease(buffer, header, field);
field = next;
}
populate_http_headers(buffer, header, stream->version, kvblock);
spdy_send_syn_reply(stream, kvblock);
}
void
http_send_error(
spdy_io_stream * stream,
TSHttpStatus status)
{
scoped_mbuffer buffer;
scoped_http_header header(buffer.get());
TSHttpHdrTypeSet(buffer.get(), header.get(), TS_HTTP_TYPE_RESPONSE);
TSHttpHdrVersionSet(buffer.get(), header.get(), TS_HTTP_VERSION(1, 1));
TSHttpHdrStatusSet(buffer.get(), header.get(), status);
debug_http("[%p/%u] sending a HTTP %d result for %s %s://%s%s",
stream->io, stream->stream_id, status,
stream->kvblock.url().method.c_str(),
stream->kvblock.url().scheme.c_str(),
stream->kvblock.url().hostport.c_str(),
stream->kvblock.url().path.c_str());
http_send_response(stream, buffer.get(), header.get());
spdy_send_data_frame(stream, spdy::FLAG_FIN, nullptr, 0);
}
void
http_send_content(
spdy_io_stream * stream,
TSIOBufferReader reader)
{
TSIOBufferBlock blk;
int64_t consumed = 0;
blk = TSIOBufferReaderStart(stream->input.reader);
while (blk) {
const char * ptr;
int64_t nbytes;
ptr = TSIOBufferBlockReadStart(blk, reader, &nbytes);
if (ptr && nbytes) {
spdy_send_data_frame(stream, 0 /* flags */, ptr, nbytes);
consumed += nbytes;
}
blk = TSIOBufferBlockNext(blk);
}
TSIOBufferReaderConsume(reader, consumed);
}
void
debug_http_header(
const spdy_io_stream * stream,
TSMBuffer buffer,
TSMLoc header)
{
if (unlikely(TSIsDebugTagSet("spdy.http"))) {
spdy_io_buffer iobuf;
int64_t nbytes;
int64_t avail;
const char * ptr;
TSIOBufferBlock blk;
TSHttpHdrPrint(buffer, header, iobuf.buffer);
blk = TSIOBufferStart(iobuf.buffer);
avail = TSIOBufferBlockReadAvail(blk, iobuf.reader);
ptr = (const char *)TSIOBufferBlockReadStart(blk, iobuf.reader, &nbytes);
debug_http(
"[%p/%u] http request (%" PRIu64 " of %" PRIu64 " bytes):\n%*.*s",
stream, stream->stream_id, nbytes, avail,
(int)nbytes, (int)nbytes, ptr);
}
}
http_parser::http_parser()
: parser(TSHttpParserCreate()), mbuffer(), header(mbuffer.get()), complete(false)
{
}
http_parser::~http_parser()
{
if (parser) {
TSHttpParserDestroy(parser);
}
}
ssize_t
http_parser::parse(TSIOBufferReader reader)
{
TSIOBufferBlock blk;
ssize_t consumed = 0;
for (blk = TSIOBufferReaderStart(reader); blk;
blk = TSIOBufferBlockNext(blk)) {
const char * ptr;
const char * end;
int64_t nbytes;
TSParseResult result;
ptr = TSIOBufferBlockReadStart(blk, reader, &nbytes);
if (ptr == nullptr || nbytes == 0) {
continue;
}
end = ptr + nbytes;
result = TSHttpHdrParseResp(parser, mbuffer.get(), header.get(), &ptr, end);
switch (result) {
case TS_PARSE_ERROR:
return (ssize_t)result;
case TS_PARSE_DONE:
case TS_PARSE_OK:
this->complete = true;
case TS_PARSE_CONT:
// We consumed the buffer we got minus the remainder.
consumed += (nbytes - std::distance(ptr, end));
}
if (this->complete) {
break;
}
}
TSIOBufferReaderConsume(reader, consumed);
return consumed;
}
static void
make_ts_http_url(
TSMBuffer buffer,
TSMLoc header,
const spdy::key_value_block& kvblock)
{
TSReturnCode tstatus;
TSMLoc url;
tstatus = TSHttpHdrUrlGet(buffer, header, &url);
if (tstatus == TS_ERROR) {
tstatus = TSUrlCreate(buffer, &url);
}
TSUrlSchemeSet(buffer, url,
kvblock.url().scheme.data(), kvblock.url().scheme.size());
TSUrlHostSet(buffer, url,
kvblock.url().hostport.data(), kvblock.url().hostport.size());
TSUrlPathSet(buffer, url,
kvblock.url().path.data(), kvblock.url().path.size());
TSHttpHdrMethodSet(buffer, header,
kvblock.url().method.data(), kvblock.url().method.size());
TSHttpHdrUrlSet(buffer, header, url);
TSAssert(tstatus == TS_SUCCESS);
}
static TSMLoc
make_ts_http_header(
TSMBuffer buffer,
const spdy::key_value_block& kvblock)
{
scoped_http_header header(buffer);
TSHttpHdrTypeSet(buffer, header, TS_HTTP_TYPE_REQUEST);
// XXX extract the real HTTP version header from kvblock.url()
TSHttpHdrVersionSet(buffer, header, TS_HTTP_VERSION(1, 1));
make_ts_http_url(buffer, header, kvblock);
// Duplicate the header fields into the MIME header for the HTTP request we
// are building.
for (auto ptr(kvblock.begin()); ptr != kvblock.end(); ++ptr) {
if (ptr->first[0] != ':') {
TSMLoc field;
// XXX Need special handling for duplicate headers; we should
// append them as a multi-value
TSMimeHdrFieldCreateNamed(buffer, header,
ptr->first.c_str(), -1, &field);
TSMimeHdrFieldValueStringInsert(buffer, header, field,
-1, ptr->second.c_str(), -1);
TSMimeHdrFieldAppend(buffer, header, field);
}
}
return header.release();
}
scoped_http_header::scoped_http_header(
TSMBuffer b,
const spdy::key_value_block& kvblock)
: buffer(b)
{
this->header = make_ts_http_header(buffer, kvblock);
}
scoped_http_header::scoped_http_header(TSMBuffer b)
: header(TS_NULL_MLOC), buffer(b)
{
header = TSHttpHdrCreate(buffer);
}
/* vim: set sw=4 ts=4 tw=79 et : */
<|endoftext|> |
<commit_before>//****************************************************************************//
// mixer.cpp //
// Copyright (C) 2001, 2002 Bruno 'Beosil' Heidelberger //
//****************************************************************************//
// This library is free software; you can redistribute it and/or modify it //
// under the terms of the GNU Lesser General Public License as published by //
// the Free Software Foundation; either version 2.1 of the License, or (at //
// your option) any later version. //
//****************************************************************************//
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cal3d/error.h"
#include "cal3d/mixer.h"
#include "cal3d/corebone.h"
#include "cal3d/coreanimation.h"
#include "cal3d/coretrack.h"
#include "cal3d/corekeyframe.h"
#include "cal3d/skeleton.h"
#include "cal3d/bone.h"
#include "cal3d/animation.h"
void CalMixer::addAnimation(const CalAnimationPtr& animation) {
AnimationList::iterator i = activeAnimations.begin();
while (i != activeAnimations.end() && animation->priority < (*i)->priority) {
++i;
}
activeAnimations.insert(i, animation);
}
void CalMixer::removeAnimation(const CalAnimationPtr& animation) {
activeAnimations.remove(animation);
}
void CalMixer::updateSkeleton(
CalSkeleton* skeleton,
const std::vector<BoneTransformAdjustment>& boneTransformAdjustments,
const std::vector<BoneScaleAdjustment>& boneScaleAdjustments,
RootTransformFlag includeRoot
) {
skeleton->resetPose();
CalSkeleton::BoneArray& bones = skeleton->bones;
// The bone adjustments are "replace" so they have to go first, giving them
// highest priority and full influence. Subsequent animations affecting the same bones,
// including subsequent replace animations, will have their incluence attenuated appropriately.
applyBoneAdjustments(skeleton, boneTransformAdjustments, boneScaleAdjustments);
// loop through all animation actions
for (
std::list<CalAnimationPtr>::const_iterator itaa = activeAnimations.begin();
itaa != activeAnimations.end();
++itaa
) {
const CalAnimation* animation = itaa->get();
const CalCoreAnimation::TrackList& tracks = animation->coreAnimation->tracks;
for (
CalCoreAnimation::TrackList::const_iterator track = tracks.begin();
track != tracks.end();
++track
) {
if (track->coreBoneId >= bones.size()) {
continue;
}
bones[track->coreBoneId].blendPose(
animation->weight * animation->rampValue,
track->getState(animation->time),
// higher priority animations replace 0-priority animations
animation->priority != 0 ? animation->rampValue : 0.0f);
}
}
skeleton->calculateAbsolutePose(includeRoot == IncludeRootTransform);
}
void CalMixer::applyBoneAdjustments(
CalSkeleton* skeleton,
const std::vector<BoneTransformAdjustment>& boneTransformAdjustments,
const std::vector<BoneScaleAdjustment>& boneScaleAdjustments
) {
CalSkeleton::BoneArray& bones = skeleton->bones;
for (size_t i = 0; i < boneTransformAdjustments.size(); ++i) {
const BoneTransformAdjustment& ba = boneTransformAdjustments[i];
CalBone& bo = bones[ba.boneId];
bo.blendPose(
ba.rampValue, /* weight */
cal3d::RotateTranslate(
ba.localOri,
bo.getOriginalTranslation() /* adjustedLocalPos */),
ba.rampValue /* subsequentAttenuation */);
}
for (size_t i = 0; i < boneScaleAdjustments.size(); i++) {
const BoneScaleAdjustment& ba = boneScaleAdjustments[i];
bones[ba.boneId].scale = ba.scale;
}
}
<commit_msg>Use a bit of auto<commit_after>//****************************************************************************//
// mixer.cpp //
// Copyright (C) 2001, 2002 Bruno 'Beosil' Heidelberger //
//****************************************************************************//
// This library is free software; you can redistribute it and/or modify it //
// under the terms of the GNU Lesser General Public License as published by //
// the Free Software Foundation; either version 2.1 of the License, or (at //
// your option) any later version. //
//****************************************************************************//
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cal3d/error.h"
#include "cal3d/mixer.h"
#include "cal3d/corebone.h"
#include "cal3d/coreanimation.h"
#include "cal3d/coretrack.h"
#include "cal3d/corekeyframe.h"
#include "cal3d/skeleton.h"
#include "cal3d/bone.h"
#include "cal3d/animation.h"
void CalMixer::addAnimation(const CalAnimationPtr& animation) {
AnimationList::iterator i = activeAnimations.begin();
while (i != activeAnimations.end() && animation->priority < (*i)->priority) {
++i;
}
activeAnimations.insert(i, animation);
}
void CalMixer::removeAnimation(const CalAnimationPtr& animation) {
activeAnimations.remove(animation);
}
void CalMixer::updateSkeleton(
CalSkeleton* skeleton,
const std::vector<BoneTransformAdjustment>& boneTransformAdjustments,
const std::vector<BoneScaleAdjustment>& boneScaleAdjustments,
RootTransformFlag includeRoot
) {
skeleton->resetPose();
auto& bones = skeleton->bones;
// The bone adjustments are "replace" so they have to go first, giving them
// highest priority and full influence. Subsequent animations affecting the same bones,
// including subsequent replace animations, will have their incluence attenuated appropriately.
applyBoneAdjustments(skeleton, boneTransformAdjustments, boneScaleAdjustments);
// loop through all animation actions
for (auto itaa = activeAnimations.begin(); itaa != activeAnimations.end(); ++itaa) {
const auto& animation = itaa->get();
const auto& tracks = animation->coreAnimation->tracks;
for (auto track = tracks.begin(); track != tracks.end(); ++track) {
if (track->coreBoneId >= bones.size()) {
continue;
}
bones[track->coreBoneId].blendPose(
animation->weight * animation->rampValue,
track->getState(animation->time),
// higher priority animations replace 0-priority animations
animation->priority != 0 ? animation->rampValue : 0.0f);
}
}
skeleton->calculateAbsolutePose(includeRoot == IncludeRootTransform);
}
void CalMixer::applyBoneAdjustments(
CalSkeleton* skeleton,
const std::vector<BoneTransformAdjustment>& boneTransformAdjustments,
const std::vector<BoneScaleAdjustment>& boneScaleAdjustments
) {
CalSkeleton::BoneArray& bones = skeleton->bones;
for (size_t i = 0; i < boneTransformAdjustments.size(); ++i) {
const BoneTransformAdjustment& ba = boneTransformAdjustments[i];
CalBone& bo = bones[ba.boneId];
bo.blendPose(
ba.rampValue, /* weight */
cal3d::RotateTranslate(
ba.localOri,
bo.getOriginalTranslation() /* adjustedLocalPos */),
ba.rampValue /* subsequentAttenuation */);
}
for (size_t i = 0; i < boneScaleAdjustments.size(); i++) {
const BoneScaleAdjustment& ba = boneScaleAdjustments[i];
bones[ba.boneId].scale = ba.scale;
}
}
<|endoftext|> |
<commit_before>//////////////////////////////////////////////////////////////////////////////
//
// License Agreement:
//
// The following are Copyright 2008, Daniel nnerby
//
// 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 other 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.
//
//////////////////////////////////////////////////////////////////////////////
#ifdef WIN32
#include "pch.hpp"
#else
#include <core/pch.hpp>
#endif
#include <core/filestreams/LocalFileStream.h>
#include <core/config.h>
#include <core/common.h>
#include <core/config_filesystem.h>
//////////////////////////////////////////////////////////////////////////////
#ifdef UTF_WIDECHAR
#define UTFFopen _wfopen
typedef fpos_t stdioPositionType;
#else
#define UTFFopen fopen
typedef fpos_t stdioPositionType;
#endif
//////////////////////////////////////////////////////////////////////////////
using namespace musik::core::filestreams;
//////////////////////////////////////////////////////////////////////////////
LocalFileStream::LocalFileStream()
:file(NULL)
,filesize(-1)
{
}
LocalFileStream::~LocalFileStream(){
this->Close();
}
bool LocalFileStream::Open(const utfchar *filename,unsigned int options){
#ifdef _DEBUG
std::cerr << "LocalFileStream::Open()" << std::endl;
#endif
if(filename==NULL){
return false;
}
try{
boost::filesystem::utfpath file(UTF(filename));
//#ifdef _DEBUG
// std::cerr << "file: " << file << std::endl;
//#endif
if (!boost::filesystem::exists(file)) {
std::cerr << "File not found" << std::endl;
}
if (!boost::filesystem::is_regular(file)) {
std::cerr << "File not a regular file" << std::endl;
}
this->filesize = (long)boost::filesystem::file_size(file);
//#ifdef _DEBUG
// std::cerr << "filesize: " << this->filesize << std::endl;
//#endif
this->extension = file.extension();
//#ifdef _DEBUG
// std::cerr << "extension: " << this->extension << std::endl;
//#endif
this->file = UTFFopen(filename,UTF("rb"));
//#ifdef _DEBUG
// std::cerr << "this->file: " << this->file << std::endl;
//#endif
this->fd = new boost::iostreams::file_descriptor(file);
//#ifdef _DEBUG
// std::cerr << "fd: " << this->fd << std::endl;
//#endif
this->fileStream = new boost::iostreams::stream<boost::iostreams::file_descriptor>(*this->fd);
//#ifdef _DEBUG
// std::cerr << "this->fileStream: " << this->fileStream << std::endl;
//#endif
this->fileStream->exceptions ( std::ios_base::eofbit | std::ios_base::failbit | std::ios_base::badbit );
return this->file!=NULL;
}
catch(...){
return false;
}
}
bool LocalFileStream::Close(){
if(this->file){
if(fclose(this->file)==0){
this->file = NULL;
delete this->fd;
delete this->fileStream;
return true;
}
}
return false;
}
void LocalFileStream::Destroy(){
delete this;
}
PositionType LocalFileStream::Read(void* buffer,PositionType readBytes){
//return (PositionType)fread(buffer,1,readBytes,this->file);
try {
this->fileStream->read((char*)buffer, readBytes);
}
catch (std::ios_base::failure) {
if(this->fileStream->eof()) {
//EOF reached
return sizeof(buffer);
}
else {
std::cerr << "Error reading from file" << std::endl;
}
return 0;
}
return readBytes;
}
bool LocalFileStream::SetPosition(PositionType position){
/*stdioPositionType newPosition = (stdioPositionType)position;
return fsetpos(this->file,&newPosition)==0;*/
try {
this->fileStream->seekp(position);
this->fileStream->seekg(position);
}
catch (std::ios_base::failure) {
return false;
}
return true;
}
PositionType LocalFileStream::Position(){
/*stdioPositionType currentPosition(0);
if(fgetpos(this->file,¤tPosition)==0){
return (PositionType)currentPosition;
}
return -1;*/
return this->fileStream->tellg();
}
bool LocalFileStream::Eof(){
//return feof(this->file)!=0;
return this->fileStream->eof();
}
long LocalFileStream::Filesize(){
return this->filesize;
}
const utfchar* LocalFileStream::Type(){
return this->extension.c_str();
}
<commit_msg>Wrong case in include statement<commit_after>//////////////////////////////////////////////////////////////////////////////
//
// License Agreement:
//
// The following are Copyright 2008, Daniel nnerby
//
// 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 other 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.
//
//////////////////////////////////////////////////////////////////////////////
#ifdef WIN32
#include "pch.hpp"
#else
#include <core/pch.hpp>
#endif
#include <core/filestreams/LocalFileStream.h>
#include <core/config.h>
#include <core/Common.h>
#include <core/config_filesystem.h>
//////////////////////////////////////////////////////////////////////////////
#ifdef UTF_WIDECHAR
#define UTFFopen _wfopen
typedef fpos_t stdioPositionType;
#else
#define UTFFopen fopen
typedef fpos_t stdioPositionType;
#endif
//////////////////////////////////////////////////////////////////////////////
using namespace musik::core::filestreams;
//////////////////////////////////////////////////////////////////////////////
LocalFileStream::LocalFileStream()
:file(NULL)
,filesize(-1)
{
}
LocalFileStream::~LocalFileStream(){
this->Close();
}
bool LocalFileStream::Open(const utfchar *filename,unsigned int options){
#ifdef _DEBUG
std::cerr << "LocalFileStream::Open()" << std::endl;
#endif
if(filename==NULL){
return false;
}
try{
boost::filesystem::utfpath file(UTF(filename));
//#ifdef _DEBUG
// std::cerr << "file: " << file << std::endl;
//#endif
if (!boost::filesystem::exists(file)) {
std::cerr << "File not found" << std::endl;
}
if (!boost::filesystem::is_regular(file)) {
std::cerr << "File not a regular file" << std::endl;
}
this->filesize = (long)boost::filesystem::file_size(file);
//#ifdef _DEBUG
// std::cerr << "filesize: " << this->filesize << std::endl;
//#endif
this->extension = file.extension();
//#ifdef _DEBUG
// std::cerr << "extension: " << this->extension << std::endl;
//#endif
this->file = UTFFopen(filename,UTF("rb"));
//#ifdef _DEBUG
// std::cerr << "this->file: " << this->file << std::endl;
//#endif
this->fd = new boost::iostreams::file_descriptor(file);
//#ifdef _DEBUG
// std::cerr << "fd: " << this->fd << std::endl;
//#endif
this->fileStream = new boost::iostreams::stream<boost::iostreams::file_descriptor>(*this->fd);
//#ifdef _DEBUG
// std::cerr << "this->fileStream: " << this->fileStream << std::endl;
//#endif
this->fileStream->exceptions ( std::ios_base::eofbit | std::ios_base::failbit | std::ios_base::badbit );
return this->file!=NULL;
}
catch(...){
return false;
}
}
bool LocalFileStream::Close(){
if(this->file){
if(fclose(this->file)==0){
this->file = NULL;
delete this->fd;
delete this->fileStream;
return true;
}
}
return false;
}
void LocalFileStream::Destroy(){
delete this;
}
PositionType LocalFileStream::Read(void* buffer,PositionType readBytes){
//return (PositionType)fread(buffer,1,readBytes,this->file);
try {
this->fileStream->read((char*)buffer, readBytes);
}
catch (std::ios_base::failure) {
if(this->fileStream->eof()) {
//EOF reached
return sizeof(buffer);
}
else {
std::cerr << "Error reading from file" << std::endl;
}
return 0;
}
return readBytes;
}
bool LocalFileStream::SetPosition(PositionType position){
/*stdioPositionType newPosition = (stdioPositionType)position;
return fsetpos(this->file,&newPosition)==0;*/
try {
this->fileStream->seekp(position);
this->fileStream->seekg(position);
}
catch (std::ios_base::failure) {
return false;
}
return true;
}
PositionType LocalFileStream::Position(){
/*stdioPositionType currentPosition(0);
if(fgetpos(this->file,¤tPosition)==0){
return (PositionType)currentPosition;
}
return -1;*/
return this->fileStream->tellg();
}
bool LocalFileStream::Eof(){
//return feof(this->file)!=0;
return this->fileStream->eof();
}
long LocalFileStream::Filesize(){
return this->filesize;
}
const utfchar* LocalFileStream::Type(){
return this->extension.c_str();
}
<|endoftext|> |
<commit_before>#ifndef VSMC_CORE_WEIGHT_HPP
#define VSMC_CORE_WEIGHT_HPP
#include <vsmc/internal/common.hpp>
#include <vsmc/utility/cxxblas.hpp>
namespace vsmc {
/// \brief Weight set class
/// \ingroup Core
template <typename T>
class WeightSet
{
public :
typedef typename traits::SizeTypeTrait<T>::type size_type;
typedef typename traits::DDotTypeTrait<T>::type ddot_type;
explicit WeightSet (size_type N) :
size_(N), ess_(static_cast<double>(N)), weight_(N), log_weight_(N) {}
size_type resample_size () const
{
return size_;
}
template <typename OutputIter>
OutputIter read_resample_weight (OutputIter first) const
{
return read_weight(first);
}
template <typename RandomIter>
RandomIter read_resample_weight (RandomIter first, int stride) const
{
return read_weight(first, stride);
}
/// \brief Read normalized weights through an output iterator
template <typename OutputIter>
OutputIter read_weight (OutputIter first) const
{
return std::copy(weight_.begin(), weight_.end(), first);
}
/// \brief Read normalized weights through a random access iterator with
/// (possible non-uniform stride)
template <typename RandomIter>
RandomIter read_weight (RandomIter first, int stride) const
{
for (size_type i = 0; i != size_; ++i, first += stride)
*first = weight_[i];
return first;
}
/// \brief Read normalized weights through a pointer
double *read_weight (double *first) const
{
const double *const wptr = &weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - wptr) > static_cast<std::ptrdiff_t>(size_)),
"The destination of **WeightSet::read_weight** is "
"overlapping with the source.\n"
"How did you get this address?");
std::memcpy(first, wptr, sizeof(double) * size_);
return first + size_;
}
/// \brief Read unnormalized logarithm weights through an output iterator
template <typename OutputIter>
OutputIter read_log_weight (OutputIter first) const
{
return std::copy(log_weight_.begin(), log_weight_.end(), first);
}
/// \brief Read unnormalized logarithm weights through a random access
/// iterator with (possible non-uniform stride)
template <typename RandomIter>
RandomIter read_log_weight (RandomIter first, int stride) const
{
for (size_type i = 0; i != size_; ++i, first += stride)
*first = log_weight_[i];
return first;
}
/// \brief Read unnormalized logarithm weights through a pointer
double *read_log_weight (double *first) const
{
const double *const lwptr = &log_weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - lwptr) > static_cast<std::ptrdiff_t>(size_)),
"The destination of **WeightSet::read_weight** is "
"overlapping with the source.\n"
"How did you get this address?");
std::memcpy(first, lwptr, sizeof(double) * size_);
return first + size_;
}
/// \brief Get the normalized weight of the id'th particle
double weight (size_type id) const
{
return weight_[id];
}
/// \brief Get the unnormalized logarithm weight of the id'th particle
double log_weight (size_type id) const
{
return log_weight_[id];
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS
/// such that each particle has a equal weight
void set_equal_weight ()
{
ess_ = static_cast<double>(size_);
std::fill(weight_.begin(), weight_.end(), 1.0 / size_);
std::fill(log_weight_.begin(), log_weight_.end(), 0);
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) weights directly through an input
/// iterator
template <typename InputIter>
void set_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
weight_[i] = *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) weights directly through a random
/// access iterator with (possible non-uniform) stride
template <typename RandomIter>
void set_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
weight_[i] = *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) weights directly through a pointer
void set_weight (const double *first)
{
double *const wptr = &weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - wptr) > static_cast<std::ptrdiff_t>(size_)),
"The source of **WeightSet::set_weight** is "
"overlapping with the destination.\n"
"How did you get this address?");
std::memcpy(wptr, first, sizeof(double) * size_);
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// multiply the normalized weight with (possible unnormalized) incremental
/// weights through an input iterator
template <typename InputIter>
void mul_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
weight_[i] *= *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// multiply the normalized weight with (possible unnormalized) incremental
/// weights through a random access iterator with (possible non-uniform)
/// stride
template <typename RandomIter>
void mul_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
weight_[i] *= *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) logarithm weights directly through
/// an input iterator
template <typename InputIter>
void set_log_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
log_weight_[i] = *first;
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) logarithm weights directly through
/// a random access iterator with (possible non-uniform) stride
template <typename RandomIter>
void set_log_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
log_weight_[i] = *first;
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) logarithm weights directly through
/// a pointer
void set_log_weight (const double *first)
{
double *const lwptr = &log_weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - lwptr) > static_cast<std::ptrdiff_t>(size_)),
"The source of **WeightSet::set_log_weight** is "
"overlapping with the destination.\n"
"How did you get this address?");
std::memcpy(lwptr, first, sizeof(double) * size_);
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// adding to the unnormalized logarithm weights with (possible
/// unormalized) logarithm incremental weights through an input iterator
template <typename InputIter>
void add_log_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
log_weight_[i] += *first;
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// adding to the unnormalized logarithm weights with (possible
/// unormalized) logarithm incremental weights through a ranodm access
/// iterator with (possible non-uniform) stride
template <typename RandomIter>
void add_log_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
log_weight_[i] += *first;
log_weight2weight();
}
/// \brief Get the ESS of the particle collection based on the current
/// weights
double ess () const
{
return ess_;
}
protected :
void set_ess (double new_ess) {ess_ = new_ess;}
double *weight_ptr () {return &weight_[0];}
double *log_weight_ptr () {return &log_weight_[0];}
const double *weight_ptr () const {return &weight_[0];}
const double *log_weight_ptr () const {return &log_weight_[0];}
private :
size_type size_;
double ess_;
std::vector<double> weight_;
std::vector<double> log_weight_;
ddot_type ddot_;
void log_weight2weight ()
{
using std::exp;
std::vector<double>::const_iterator id_max = std::max_element(
log_weight_.begin(), log_weight_.end());
double max_weight = *id_max;
for (size_type i = 0; i != size_; ++i)
log_weight_[i] -= max_weight;
for (size_type i = 0; i != size_; ++i)
weight_[i] = exp(log_weight_[i]);
double coeff = std::accumulate(weight_.begin(), weight_.end(),
static_cast<double>(0));
coeff = 1 / coeff;
for (size_type i = 0; i != size_; ++i)
weight_[i] *= coeff;
ess_ = 1 / ddot_(static_cast<
typename traits::BlasSizeTypeTrait<ddot_type>::type>(size_),
&weight_[0], 1, &weight_[0], 1);
}
void weight2log_weight ()
{
using std::log;
double coeff = std::accumulate(weight_.begin(), weight_.end(),
static_cast<double>(0));
coeff = 1 / coeff;
for (size_type i = 0; i != size_; ++i)
weight_[i] *= coeff;
for (size_type i = 0; i != size_; ++i)
log_weight_[i] = log(weight_[i]);
ess_ = 1 / ddot_(static_cast<ddot_size_type>(size_),
&weight_[0], 1, &weight_[0], 1);
}
}; // class WeightSet
} // namespace vsmc
VSMC_DEFINE_TYPE_DISPATCH_TRAIT(WeightSetType, weight_set_type, WeightSet<T>);
#endif // VSMC_CORE_WEIGHT_HPP
<commit_msg>fix a trait<commit_after>#ifndef VSMC_CORE_WEIGHT_HPP
#define VSMC_CORE_WEIGHT_HPP
#include <vsmc/internal/common.hpp>
#include <vsmc/utility/cxxblas.hpp>
namespace vsmc {
/// \brief Weight set class
/// \ingroup Core
template <typename T>
class WeightSet
{
public :
typedef typename traits::SizeTypeTrait<T>::type size_type;
typedef typename traits::DDotTypeTrait<T>::type ddot_type;
explicit WeightSet (size_type N) :
size_(N), ess_(static_cast<double>(N)), weight_(N), log_weight_(N) {}
size_type resample_size () const
{
return size_;
}
template <typename OutputIter>
OutputIter read_resample_weight (OutputIter first) const
{
return read_weight(first);
}
template <typename RandomIter>
RandomIter read_resample_weight (RandomIter first, int stride) const
{
return read_weight(first, stride);
}
/// \brief Read normalized weights through an output iterator
template <typename OutputIter>
OutputIter read_weight (OutputIter first) const
{
return std::copy(weight_.begin(), weight_.end(), first);
}
/// \brief Read normalized weights through a random access iterator with
/// (possible non-uniform stride)
template <typename RandomIter>
RandomIter read_weight (RandomIter first, int stride) const
{
for (size_type i = 0; i != size_; ++i, first += stride)
*first = weight_[i];
return first;
}
/// \brief Read normalized weights through a pointer
double *read_weight (double *first) const
{
const double *const wptr = &weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - wptr) > static_cast<std::ptrdiff_t>(size_)),
"The destination of **WeightSet::read_weight** is "
"overlapping with the source.\n"
"How did you get this address?");
std::memcpy(first, wptr, sizeof(double) * size_);
return first + size_;
}
/// \brief Read unnormalized logarithm weights through an output iterator
template <typename OutputIter>
OutputIter read_log_weight (OutputIter first) const
{
return std::copy(log_weight_.begin(), log_weight_.end(), first);
}
/// \brief Read unnormalized logarithm weights through a random access
/// iterator with (possible non-uniform stride)
template <typename RandomIter>
RandomIter read_log_weight (RandomIter first, int stride) const
{
for (size_type i = 0; i != size_; ++i, first += stride)
*first = log_weight_[i];
return first;
}
/// \brief Read unnormalized logarithm weights through a pointer
double *read_log_weight (double *first) const
{
const double *const lwptr = &log_weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - lwptr) > static_cast<std::ptrdiff_t>(size_)),
"The destination of **WeightSet::read_weight** is "
"overlapping with the source.\n"
"How did you get this address?");
std::memcpy(first, lwptr, sizeof(double) * size_);
return first + size_;
}
/// \brief Get the normalized weight of the id'th particle
double weight (size_type id) const
{
return weight_[id];
}
/// \brief Get the unnormalized logarithm weight of the id'th particle
double log_weight (size_type id) const
{
return log_weight_[id];
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS
/// such that each particle has a equal weight
void set_equal_weight ()
{
ess_ = static_cast<double>(size_);
std::fill(weight_.begin(), weight_.end(), 1.0 / size_);
std::fill(log_weight_.begin(), log_weight_.end(), 0);
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) weights directly through an input
/// iterator
template <typename InputIter>
void set_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
weight_[i] = *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) weights directly through a random
/// access iterator with (possible non-uniform) stride
template <typename RandomIter>
void set_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
weight_[i] = *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) weights directly through a pointer
void set_weight (const double *first)
{
double *const wptr = &weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - wptr) > static_cast<std::ptrdiff_t>(size_)),
"The source of **WeightSet::set_weight** is "
"overlapping with the destination.\n"
"How did you get this address?");
std::memcpy(wptr, first, sizeof(double) * size_);
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// multiply the normalized weight with (possible unnormalized) incremental
/// weights through an input iterator
template <typename InputIter>
void mul_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
weight_[i] *= *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// multiply the normalized weight with (possible unnormalized) incremental
/// weights through a random access iterator with (possible non-uniform)
/// stride
template <typename RandomIter>
void mul_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
weight_[i] *= *first;
weight2log_weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) logarithm weights directly through
/// an input iterator
template <typename InputIter>
void set_log_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
log_weight_[i] = *first;
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) logarithm weights directly through
/// a random access iterator with (possible non-uniform) stride
template <typename RandomIter>
void set_log_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
log_weight_[i] = *first;
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// changing the (possible unnormalized) logarithm weights directly through
/// a pointer
void set_log_weight (const double *first)
{
double *const lwptr = &log_weight_[0];
VSMC_RUNTIME_ASSERT(
(std::abs(first - lwptr) > static_cast<std::ptrdiff_t>(size_)),
"The source of **WeightSet::set_log_weight** is "
"overlapping with the destination.\n"
"How did you get this address?");
std::memcpy(lwptr, first, sizeof(double) * size_);
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// adding to the unnormalized logarithm weights with (possible
/// unormalized) logarithm incremental weights through an input iterator
template <typename InputIter>
void add_log_weight (InputIter first)
{
for (size_type i = 0; i != size_; ++i, ++first)
log_weight_[i] += *first;
log_weight2weight();
}
/// \brief Set normalized weight, unnormalized logarithm weight and ESS by
/// adding to the unnormalized logarithm weights with (possible
/// unormalized) logarithm incremental weights through a ranodm access
/// iterator with (possible non-uniform) stride
template <typename RandomIter>
void add_log_weight (RandomIter first, int stride)
{
for (size_type i = 0; i != size_; ++i, first += stride)
log_weight_[i] += *first;
log_weight2weight();
}
/// \brief Get the ESS of the particle collection based on the current
/// weights
double ess () const
{
return ess_;
}
protected :
void set_ess (double new_ess) {ess_ = new_ess;}
double *weight_ptr () {return &weight_[0];}
double *log_weight_ptr () {return &log_weight_[0];}
const double *weight_ptr () const {return &weight_[0];}
const double *log_weight_ptr () const {return &log_weight_[0];}
private :
size_type size_;
double ess_;
std::vector<double> weight_;
std::vector<double> log_weight_;
ddot_type ddot_;
void log_weight2weight ()
{
using std::exp;
std::vector<double>::const_iterator id_max = std::max_element(
log_weight_.begin(), log_weight_.end());
double max_weight = *id_max;
for (size_type i = 0; i != size_; ++i)
log_weight_[i] -= max_weight;
for (size_type i = 0; i != size_; ++i)
weight_[i] = exp(log_weight_[i]);
double coeff = std::accumulate(weight_.begin(), weight_.end(),
static_cast<double>(0));
coeff = 1 / coeff;
for (size_type i = 0; i != size_; ++i)
weight_[i] *= coeff;
ess_ = 1 / ddot_(static_cast<
typename traits::BlasSizeTypeTrait<ddot_type>::type>(size_),
&weight_[0], 1, &weight_[0], 1);
}
void weight2log_weight ()
{
using std::log;
double coeff = std::accumulate(weight_.begin(), weight_.end(),
static_cast<double>(0));
coeff = 1 / coeff;
for (size_type i = 0; i != size_; ++i)
weight_[i] *= coeff;
for (size_type i = 0; i != size_; ++i)
log_weight_[i] = log(weight_[i]);
ess_ = 1 / ddot_(static_cast<
typename traits::BlasSizeTypeTrait<ddot_type>::type>(size_),
&weight_[0], 1, &weight_[0], 1);
}
}; // class WeightSet
} // namespace vsmc
VSMC_DEFINE_TYPE_DISPATCH_TRAIT(WeightSetType, weight_set_type, WeightSet<T>);
#endif // VSMC_CORE_WEIGHT_HPP
<|endoftext|> |
<commit_before>/***************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of libmeegotouch.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation
** and appearing in the file LICENSE.LGPL included in the packaging
** of this file.
**
****************************************************************************/
#include "mthemedaemonclient.h"
#include "mimagedirectory.h"
#include "mthemedaemon.h"
#include <QIODevice>
#include <QDir>
#include <QPixmap>
MThemeDaemonClient::MThemeDaemonClient(QIODevice *socket, const QString &clientName, const QStringList &themes):
dataStream(socket)
{
reinit(clientName, themes);
}
MThemeDaemonClient::~MThemeDaemonClient()
{
qDeleteAll(themeImageDirs);
themeImageDirs.clear();
qDeleteAll(customImageDirs);
customImageDirs.clear();
}
QString MThemeDaemonClient::name() const
{
return clientName;
}
bool MThemeDaemonClient::reinit(const QString &clientName, const QStringList &themes)
{
if (this->clientName == clientName && this->themes == themes) {
return false;
}
this->clientName = clientName;
this->themes = themes;
reloadImagePaths(themes);
return true;
}
QDataStream &MThemeDaemonClient::stream()
{
return dataStream;
}
ImageResource *MThemeDaemonClient::findImageResource(const QString &imageId)
{
ImageResource *resource = NULL;
// search the image first from manualy added image directories
foreach(MImageDirectory * imdir, customImageDirs) {
resource = imdir->findImage(imageId);
if (resource)
return resource;
}
// not found, so search from all theme directory
foreach(MThemeImagesDirectory * imdir, themeImageDirs) {
resource = imdir->findImage(imageId);
if (resource)
return resource;
}
return NULL;
}
void MThemeDaemonClient::reloadImagePaths(const QStringList &themes)
{
toBeDeletedThemeImageDirs.append(themeImageDirs);
qDeleteAll(themeImageDirs);
themeImageDirs.clear();
foreach(const QString & theme, themes) {
themeImageDirs.append(new MThemeImagesDirectory(theme + "meegotouch" + QDir::separator() + clientName));
}
}
void MThemeDaemonClient::addCustomImageDirectory(const QString &path, M::RecursionMode recursionMode)
{
customImageDirs.insert(0, new MImageDirectory(path, recursionMode));
}
QStringList MThemeDaemonClient::removeAddedImageDirectories()
{
QStringList stillActiveIds;
foreach(MImageDirectory * imdir, customImageDirs) {
stillActiveIds.append(imdir->activeImageIds());
}
if(stillActiveIds.isEmpty()) {
qDeleteAll(customImageDirs);
customImageDirs.clear();
}
return stillActiveIds;
}
void MThemeDaemonClient::themeChangeApplied()
{
qDeleteAll(toBeDeletedThemeImageDirs);
toBeDeletedThemeImageDirs.clear();
}
<commit_msg>Changes: Fix crash in MThemeDaemonClient<commit_after>/***************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of libmeegotouch.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation
** and appearing in the file LICENSE.LGPL included in the packaging
** of this file.
**
****************************************************************************/
#include "mthemedaemonclient.h"
#include "mimagedirectory.h"
#include "mthemedaemon.h"
#include <QIODevice>
#include <QDir>
#include <QPixmap>
MThemeDaemonClient::MThemeDaemonClient(QIODevice *socket, const QString &clientName, const QStringList &themes):
dataStream(socket)
{
reinit(clientName, themes);
}
MThemeDaemonClient::~MThemeDaemonClient()
{
qDeleteAll(themeImageDirs);
themeImageDirs.clear();
qDeleteAll(customImageDirs);
customImageDirs.clear();
}
QString MThemeDaemonClient::name() const
{
return clientName;
}
bool MThemeDaemonClient::reinit(const QString &clientName, const QStringList &themes)
{
if (this->clientName == clientName && this->themes == themes) {
return false;
}
this->clientName = clientName;
this->themes = themes;
reloadImagePaths(themes);
return true;
}
QDataStream &MThemeDaemonClient::stream()
{
return dataStream;
}
ImageResource *MThemeDaemonClient::findImageResource(const QString &imageId)
{
ImageResource *resource = NULL;
// search the image first from manualy added image directories
foreach(MImageDirectory * imdir, customImageDirs) {
resource = imdir->findImage(imageId);
if (resource)
return resource;
}
// not found, so search from all theme directory
foreach(MThemeImagesDirectory * imdir, themeImageDirs) {
resource = imdir->findImage(imageId);
if (resource)
return resource;
}
return NULL;
}
void MThemeDaemonClient::reloadImagePaths(const QStringList &themes)
{
toBeDeletedThemeImageDirs.append(themeImageDirs);
themeImageDirs.clear();
foreach(const QString & theme, themes) {
themeImageDirs.append(new MThemeImagesDirectory(theme + "meegotouch" + QDir::separator() + clientName));
}
}
void MThemeDaemonClient::addCustomImageDirectory(const QString &path, M::RecursionMode recursionMode)
{
customImageDirs.insert(0, new MImageDirectory(path, recursionMode));
}
QStringList MThemeDaemonClient::removeAddedImageDirectories()
{
QStringList stillActiveIds;
foreach(MImageDirectory * imdir, customImageDirs) {
stillActiveIds.append(imdir->activeImageIds());
}
if(stillActiveIds.isEmpty()) {
qDeleteAll(customImageDirs);
customImageDirs.clear();
}
return stillActiveIds;
}
void MThemeDaemonClient::themeChangeApplied()
{
qDeleteAll(toBeDeletedThemeImageDirs);
toBeDeletedThemeImageDirs.clear();
}
<|endoftext|> |
<commit_before>/*
* this file is part of the oxygen gtk engine
* Copyright (c) 2010 Hugo Pereira Da Costa <[email protected]>
* Copyright (c) 2010 Ruslan Kabatsayev <[email protected]>
*
* MenuBarState prelight effect is based on
* Redmond95 - a cairo based GTK+ engine
* Copyright (C) 2001 Red Hat, Inc. <@redhat.com>
* Copyright (C) 2006 Andrew Johnson <[email protected]>
* Copyright (C) 2006-2007 Benjamin Berg <[email protected]>
*
* the menushell data code is largely inspired from the gtk redmond engine
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 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 St, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#include "oxygenmenubarstatedata.h"
#include "../oxygengtkutils.h"
#include <gtk/gtk.h>
namespace Oxygen
{
//________________________________________________________________________________
void MenuBarStateData::connect( GtkWidget* widget )
{
_target = widget;
_motionId.connect( G_OBJECT(widget), "motion-notify-event", G_CALLBACK( motionNotifyEvent ), this );
_leaveId.connect( G_OBJECT(widget), "leave-notify-event", G_CALLBACK( leaveNotifyEvent ), this );
// connect timeLines
_current._timeLine.connect( (GSourceFunc)delayedUpdate, this );
_previous._timeLine.connect( (GSourceFunc)delayedUpdate, this );
// set directions
_current._timeLine.setDirection( TimeLine::Forward );
_previous._timeLine.setDirection( TimeLine::Backward );
}
//________________________________________________________________________________
void MenuBarStateData::disconnect( GtkWidget* widget )
{
_target = 0L;
// stop timer
_timer.stop();
// disconnect signal
_motionId.disconnect();
_leaveId.disconnect();
// disconnect timelines
_current._timeLine.disconnect();
_previous._timeLine.disconnect();
}
//________________________________________________________________________________
bool MenuBarStateData::updateState( GtkWidget* widget, const GdkRectangle& rect, bool state )
{
// do nothing if animations are disabled
if( !_animationsEnabled ) return true;
if( state && widget != _current._widget )
{
// stop timer. This blocks fade-out animation
const bool locked( _timer.isRunning() );
if( _timer.isRunning() ) _timer.stop();
// stop current animation if running
if( _current._timeLine.isRunning() ) _current._timeLine.stop();
// stop previous animation if running
if( _current._widget )
{
if( _previous._timeLine.isRunning() ) _previous._timeLine.stop();
// move current to previous
_previous._widget = _current._widget;
_previous._rect = _current._rect;
if( !locked ) _previous._timeLine.start();
}
// assign new widget to current and start animation
_current._widget = widget;
_current._rect = rect;
if( _current._widget )
{
if( !locked ) _current._timeLine.start();
else delayedUpdate( this );
}
return true;
} else if( (!state) && widget == _current._widget ) {
// stop current animation if running
if( _current._timeLine.isRunning() ) _current._timeLine.stop();
// stop previous animation if running
if( _previous._timeLine.isRunning() ) _previous._timeLine.stop();
// move current to previous
_previous._widget = _current._widget;
_previous._rect = _current._rect;
if( _previous._widget )
{
//_previous._timeLine.start();
if( _timer.isRunning() ) _timer.stop();
_timer.start( 100, (GSourceFunc)delayedAnimate, this );
}
// assign invalid widget to current
_current._widget = 0L;
_current._rect = Gtk::gdk_rectangle();
return true;
} else return false;
}
//________________________________________________________________________________
gboolean MenuBarStateData::motionNotifyEvent(GtkWidget* widget, GdkEventMotion*, gpointer pointer )
{
if( !GTK_IS_MENU_SHELL( widget ) ) return FALSE;
// cast pointer
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
// get pointer position
gint xPointer, yPointer;
gdk_window_get_pointer( gtk_widget_get_window( widget ), &xPointer, &yPointer, 0L );
GList *children( gtk_container_get_children( GTK_CONTAINER(widget) ) );
for( GList* child = g_list_first(children); child; child = g_list_next(child) )
{
if( !( child->data && GTK_IS_MENU_ITEM( child->data ) ) ) continue;
GtkWidget* childWidget( GTK_WIDGET( child->data ) );
if( gtk_widget_get_state( childWidget ) == GTK_STATE_INSENSITIVE ) continue;
//const GtkAllocation& allocation( childWidget->allocation );
GtkAllocation allocation( childWidget->allocation );
if( Gtk::gdk_rectangle_contains( &allocation, xPointer, yPointer ) )
{
// this triggers widget update
data.updateState( childWidget, allocation, true );
gtk_widget_set_state( childWidget, GTK_STATE_PRELIGHT );
} else {
// this triggers widget update
data.updateState( childWidget, allocation, false );
gtk_widget_set_state( childWidget, GTK_STATE_NORMAL );
}
}
if( children ) g_list_free( children );
return FALSE;
}
//________________________________________________________________________________
gboolean MenuBarStateData::leaveNotifyEvent( GtkWidget* widget, GdkEventCrossing*, gpointer pointer )
{
if( !GTK_IS_MENU_SHELL( widget ) ) return FALSE;
GList* children( gtk_container_get_children( GTK_CONTAINER( widget ) ) );
for( GList* child = g_list_first(children); child; child = g_list_next(child) )
{
if( !( child->data && GTK_IS_MENU_ITEM( child->data ) ) ) continue;
if( gtk_widget_get_state( GTK_WIDGET( child->data ) ) == GTK_STATE_INSENSITIVE ) continue;
// this is terrible code. I hate gtk. (hugo)
if( (!GTK_IS_MENU(GTK_MENU_ITEM(child->data)->submenu)) ||
(!(GTK_WIDGET_REALIZED(GTK_MENU_ITEM(child->data)->submenu) &&
GTK_WIDGET_VISIBLE(GTK_MENU_ITEM(child->data)->submenu) &&
GTK_WIDGET_REALIZED(GTK_MENU(GTK_MENU_ITEM(child->data)->submenu)->toplevel) &&
GTK_WIDGET_VISIBLE(GTK_MENU(GTK_MENU_ITEM(child->data)->submenu)->toplevel))))
{ gtk_widget_set_state( GTK_WIDGET(child->data), GTK_STATE_NORMAL ); }
}
if( children ) g_list_free( children );
// also triggers animation of current widget
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
if( data._current._widget )
{ data.updateState( data._current._widget, data._current._widget->allocation, false ); }
return FALSE;
}
//_____________________________________________
gboolean MenuBarStateData::delayedUpdate( gpointer pointer )
{
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
if( data._target )
{ Gtk::gtk_widget_queue_draw( data._target ); }
return FALSE;
}
//________________________________________________________________________________
gboolean MenuBarStateData::delayedAnimate( gpointer pointer )
{
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
if( data._previous._widget )
{
assert( !data._previous._timeLine.isRunning() );
data._previous._timeLine.start();
}
return FALSE;
}
}
<commit_msg>use const ref to widget allocation.<commit_after>/*
* this file is part of the oxygen gtk engine
* Copyright (c) 2010 Hugo Pereira Da Costa <[email protected]>
* Copyright (c) 2010 Ruslan Kabatsayev <[email protected]>
*
* MenuBarState prelight effect is based on
* Redmond95 - a cairo based GTK+ engine
* Copyright (C) 2001 Red Hat, Inc. <@redhat.com>
* Copyright (C) 2006 Andrew Johnson <[email protected]>
* Copyright (C) 2006-2007 Benjamin Berg <[email protected]>
*
* the menushell data code is largely inspired from the gtk redmond engine
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 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 St, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#include "oxygenmenubarstatedata.h"
#include "../oxygengtkutils.h"
#include <gtk/gtk.h>
namespace Oxygen
{
//________________________________________________________________________________
void MenuBarStateData::connect( GtkWidget* widget )
{
_target = widget;
_motionId.connect( G_OBJECT(widget), "motion-notify-event", G_CALLBACK( motionNotifyEvent ), this );
_leaveId.connect( G_OBJECT(widget), "leave-notify-event", G_CALLBACK( leaveNotifyEvent ), this );
// connect timeLines
_current._timeLine.connect( (GSourceFunc)delayedUpdate, this );
_previous._timeLine.connect( (GSourceFunc)delayedUpdate, this );
// set directions
_current._timeLine.setDirection( TimeLine::Forward );
_previous._timeLine.setDirection( TimeLine::Backward );
}
//________________________________________________________________________________
void MenuBarStateData::disconnect( GtkWidget* widget )
{
_target = 0L;
// stop timer
_timer.stop();
// disconnect signal
_motionId.disconnect();
_leaveId.disconnect();
// disconnect timelines
_current._timeLine.disconnect();
_previous._timeLine.disconnect();
}
//________________________________________________________________________________
bool MenuBarStateData::updateState( GtkWidget* widget, const GdkRectangle& rect, bool state )
{
// do nothing if animations are disabled
if( !_animationsEnabled ) return true;
if( state && widget != _current._widget )
{
// stop timer. This blocks fade-out animation
const bool locked( _timer.isRunning() );
if( _timer.isRunning() ) _timer.stop();
// stop current animation if running
if( _current._timeLine.isRunning() ) _current._timeLine.stop();
// stop previous animation if running
if( _current._widget )
{
if( _previous._timeLine.isRunning() ) _previous._timeLine.stop();
// move current to previous
_previous._widget = _current._widget;
_previous._rect = _current._rect;
if( !locked ) _previous._timeLine.start();
}
// assign new widget to current and start animation
_current._widget = widget;
_current._rect = rect;
if( _current._widget )
{
if( !locked ) _current._timeLine.start();
else delayedUpdate( this );
}
return true;
} else if( (!state) && widget == _current._widget ) {
// stop current animation if running
if( _current._timeLine.isRunning() ) _current._timeLine.stop();
// stop previous animation if running
if( _previous._timeLine.isRunning() ) _previous._timeLine.stop();
// move current to previous
_previous._widget = _current._widget;
_previous._rect = _current._rect;
if( _previous._widget )
{
//_previous._timeLine.start();
if( _timer.isRunning() ) _timer.stop();
_timer.start( 100, (GSourceFunc)delayedAnimate, this );
}
// assign invalid widget to current
_current._widget = 0L;
_current._rect = Gtk::gdk_rectangle();
return true;
} else return false;
}
//________________________________________________________________________________
gboolean MenuBarStateData::motionNotifyEvent(GtkWidget* widget, GdkEventMotion*, gpointer pointer )
{
if( !GTK_IS_MENU_SHELL( widget ) ) return FALSE;
// cast pointer
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
// get pointer position
gint xPointer, yPointer;
gdk_window_get_pointer( gtk_widget_get_window( widget ), &xPointer, &yPointer, 0L );
GList *children( gtk_container_get_children( GTK_CONTAINER(widget) ) );
for( GList* child = g_list_first(children); child; child = g_list_next(child) )
{
if( !( child->data && GTK_IS_MENU_ITEM( child->data ) ) ) continue;
GtkWidget* childWidget( GTK_WIDGET( child->data ) );
if( gtk_widget_get_state( childWidget ) == GTK_STATE_INSENSITIVE ) continue;
const GtkAllocation& allocation( childWidget->allocation );
if( Gtk::gdk_rectangle_contains( &allocation, xPointer, yPointer ) )
{
// this triggers widget update
data.updateState( childWidget, allocation, true );
gtk_widget_set_state( childWidget, GTK_STATE_PRELIGHT );
} else {
// this triggers widget update
data.updateState( childWidget, allocation, false );
gtk_widget_set_state( childWidget, GTK_STATE_NORMAL );
}
}
if( children ) g_list_free( children );
return FALSE;
}
//________________________________________________________________________________
gboolean MenuBarStateData::leaveNotifyEvent( GtkWidget* widget, GdkEventCrossing*, gpointer pointer )
{
if( !GTK_IS_MENU_SHELL( widget ) ) return FALSE;
GList* children( gtk_container_get_children( GTK_CONTAINER( widget ) ) );
for( GList* child = g_list_first(children); child; child = g_list_next(child) )
{
if( !( child->data && GTK_IS_MENU_ITEM( child->data ) ) ) continue;
if( gtk_widget_get_state( GTK_WIDGET( child->data ) ) == GTK_STATE_INSENSITIVE ) continue;
// this is terrible code. I hate gtk. (hugo)
if( (!GTK_IS_MENU(GTK_MENU_ITEM(child->data)->submenu)) ||
(!(GTK_WIDGET_REALIZED(GTK_MENU_ITEM(child->data)->submenu) &&
GTK_WIDGET_VISIBLE(GTK_MENU_ITEM(child->data)->submenu) &&
GTK_WIDGET_REALIZED(GTK_MENU(GTK_MENU_ITEM(child->data)->submenu)->toplevel) &&
GTK_WIDGET_VISIBLE(GTK_MENU(GTK_MENU_ITEM(child->data)->submenu)->toplevel))))
{ gtk_widget_set_state( GTK_WIDGET(child->data), GTK_STATE_NORMAL ); }
}
if( children ) g_list_free( children );
// also triggers animation of current widget
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
if( data._current._widget )
{ data.updateState( data._current._widget, data._current._widget->allocation, false ); }
return FALSE;
}
//_____________________________________________
gboolean MenuBarStateData::delayedUpdate( gpointer pointer )
{
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
if( data._target )
{ Gtk::gtk_widget_queue_draw( data._target ); }
return FALSE;
}
//________________________________________________________________________________
gboolean MenuBarStateData::delayedAnimate( gpointer pointer )
{
MenuBarStateData& data( *static_cast<MenuBarStateData*>( pointer ) );
if( data._previous._widget )
{
assert( !data._previous._timeLine.isRunning() );
data._previous._timeLine.start();
}
return FALSE;
}
}
<|endoftext|> |
<commit_before>/***************************************************************************
* Copyright (c) 2016, Johan Mabille and Sylvain Corlay *
* *
* Distributed under the terms of the BSD 3-Clause License. *
* *
* The full license is in the file LICENSE, distributed with this software. *
****************************************************************************/
/**
* @brief standard mathematical functions for xexpressions
*/
#ifndef XBUILDER_HPP
#define XBUILDER_HPP
#include <utility>
#include <functional>
#include <cmath>
#include "xfunction.hpp"
#include "xbroadcast.hpp"
#include "xgenerator.hpp"
#ifdef X_OLD_CLANG
#include <initializer_list>
#include <vector>
#else
#include <array>
#endif
namespace xt
{
/********
* ones *
********/
/**
* @brief Returns an \ref xexpression containing ones of the specified shape.
*
* @tparam shape the shape of the returned expression.
*/
template <class T, class S>
inline auto ones(S shape) noexcept
{
return broadcast(T(1), std::forward<S>(shape));
}
#ifdef X_OLD_CLANG
template <class T, class I>
inline auto ones(std::initializer_list<I> shape) noexcept
{
return broadcast(T(1), shape);
}
#else
template <class T, class I, std::size_t L>
inline auto ones(const I(&shape)[L]) noexcept
{
return broadcast(T(1), shape);
}
#endif
/*********
* zeros *
*********/
/**
* @brief Returns an \ref xexpression containing zeros of the specified shape.
*
* @tparam shape the shape of the returned expression.
*/
template <class T, class S>
inline auto zeros(S shape) noexcept
{
return broadcast(T(0), std::forward<S>(shape));
}
#ifdef X_OLD_CLANG
template <class T, class I>
inline auto zeros(std::initializer_list<I> shape) noexcept
{
return broadcast(T(0), shape);
}
#else
template <class T, class I, std::size_t L>
inline auto zeros(const I(&shape)[L]) noexcept
{
return broadcast(T(0), shape);
}
#endif
namespace detail
{
template <class T>
struct arange_impl
{
using value_type = T;
arange_impl(T start, T stop, T step) :
m_start(start), m_stop(stop), m_step(step)
{
}
template <class... Args>
inline T operator()(Args... args) const
{
return access_impl(args...);
}
inline T operator[](const xindex& idx) const
{
return T(m_start + m_step * idx[0]);
}
template <class It>
inline T element(It first, It /*last*/) const
{
return T(m_start + m_step * (*first));
}
private:
value_type m_start;
value_type m_stop;
value_type m_step;
template <class T1, class... Args>
inline T access_impl(T1 t, Args... /*args*/) const
{
return m_start + m_step * t;
}
inline T access_impl() const
{
return m_start;
}
};
template <class T, template<class, class> class F>
struct fn_impl
{
using value_type = T;
using size_type = std::size_t;
inline T operator()() const
{
// special case when called without args (happens when printing)
return T();
}
template <class... Args>
inline T operator()(Args... args) const
{
size_type idx [sizeof...(Args)] = {static_cast<size_type>(args)...};
return access_impl(std::begin(idx), std::end(idx));
}
inline T operator[](const xindex& idx) const
{
return access_impl(idx.begin(), idx.end());
}
template <class It>
inline T element(It first, It last) const
{
return access_impl(first, last);
}
private:
template <class It>
inline T access_impl(const It& begin, const It& end) const
{
return F<T, It>()(begin, end);
}
};
template <class T, class It>
struct eye_fn
{
T operator()(const It& /*begin*/, const It& end)
{
return *(end - 1) == *(end - 2) ? 1 : 0;
}
};
}
template <class T = bool>
inline auto eye(const std::vector<size_t>& shape)
{
return detail::make_xgenerator(detail::fn_impl<T, detail::eye_fn>(), shape);
}
template <class T = bool>
inline auto eye(std::size_t n)
{
return eye<T>({n, n});
}
/**
* @function arange(T start, T stop, T step = 1)
* @brief generate numbers evenly spaced within given half-open interval [start, stop).
*
* @param start start of the interval
* @param stop stop of the interval
* @param step stepsize
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto arange(T start, T stop, T step = 1) noexcept
{
std::size_t shape = static_cast<std::size_t>(std::ceil((stop - start) / step));
return detail::make_xgenerator(detail::arange_impl<T>(start, stop, step), {shape});
}
/**
* @function arange(T stop)
* @brief generate numbers evenly spaced within given half-open interval [0, stop)
* with a step size of 1.
*
* @param stop stop of the interval
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto arange(T stop) noexcept
{
return arange<T>(T(0), stop, T(1));
}
/**
* @function linspace
* @brief generate @a num_samples evenly spaced numbers over given interval
*
* @param start start of interval
* @param stop stop of interval
* @param num_samples number of samples (defaults to 50)
* @param endpoint if true, include endpoint (defaults to true)
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto linspace(T start, T stop, std::size_t num_samples = 50, bool endpoint = true) noexcept
{
T step = (stop - start) / T(num_samples - (endpoint ? 1 : 0));
return detail::make_xgenerator(detail::arange_impl<T>(start, stop, step), {num_samples});
}
/**
* @function logspace
* @brief generate @num_samples numbers evenly spaced on a log scale over given interval
*
* @param start start of interval (pow(base, start) is the first value).
* @param stop stop of interval (pow(base, stop) is the final value, except if endpoint = false)
* @param num_samples number of samples (defaults to 50)
* @param base the base of the log space.
* @param endpoint if true, include endpoint (defaults to true)
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto logspace(T start, T stop, std::size_t num_samples, T base = 10, bool endpoint = true) noexcept
{
return pow(base, linspace(start, stop, num_samples, endpoint));
}
}
#endif
<commit_msg>mark as inline and add cast to eye<commit_after>/***************************************************************************
* Copyright (c) 2016, Johan Mabille and Sylvain Corlay *
* *
* Distributed under the terms of the BSD 3-Clause License. *
* *
* The full license is in the file LICENSE, distributed with this software. *
****************************************************************************/
/**
* @brief standard mathematical functions for xexpressions
*/
#ifndef XBUILDER_HPP
#define XBUILDER_HPP
#include <utility>
#include <functional>
#include <cmath>
#include "xfunction.hpp"
#include "xbroadcast.hpp"
#include "xgenerator.hpp"
#ifdef X_OLD_CLANG
#include <initializer_list>
#include <vector>
#else
#include <array>
#endif
namespace xt
{
/********
* ones *
********/
/**
* @brief Returns an \ref xexpression containing ones of the specified shape.
*
* @tparam shape the shape of the returned expression.
*/
template <class T, class S>
inline auto ones(S shape) noexcept
{
return broadcast(T(1), std::forward<S>(shape));
}
#ifdef X_OLD_CLANG
template <class T, class I>
inline auto ones(std::initializer_list<I> shape) noexcept
{
return broadcast(T(1), shape);
}
#else
template <class T, class I, std::size_t L>
inline auto ones(const I(&shape)[L]) noexcept
{
return broadcast(T(1), shape);
}
#endif
/*********
* zeros *
*********/
/**
* @brief Returns an \ref xexpression containing zeros of the specified shape.
*
* @tparam shape the shape of the returned expression.
*/
template <class T, class S>
inline auto zeros(S shape) noexcept
{
return broadcast(T(0), std::forward<S>(shape));
}
#ifdef X_OLD_CLANG
template <class T, class I>
inline auto zeros(std::initializer_list<I> shape) noexcept
{
return broadcast(T(0), shape);
}
#else
template <class T, class I, std::size_t L>
inline auto zeros(const I(&shape)[L]) noexcept
{
return broadcast(T(0), shape);
}
#endif
namespace detail
{
template <class T>
struct arange_impl
{
using value_type = T;
arange_impl(T start, T stop, T step) :
m_start(start), m_stop(stop), m_step(step)
{
}
template <class... Args>
inline T operator()(Args... args) const
{
return access_impl(args...);
}
inline T operator[](const xindex& idx) const
{
return T(m_start + m_step * idx[0]);
}
template <class It>
inline T element(It first, It /*last*/) const
{
return T(m_start + m_step * (*first));
}
private:
value_type m_start;
value_type m_stop;
value_type m_step;
template <class T1, class... Args>
inline T access_impl(T1 t, Args... /*args*/) const
{
return m_start + m_step * t;
}
inline T access_impl() const
{
return m_start;
}
};
template <class T, template<class, class> class F>
struct fn_impl
{
using value_type = T;
using size_type = std::size_t;
inline T operator()() const
{
// special case when called without args (happens when printing)
return T();
}
template <class... Args>
inline T operator()(Args... args) const
{
size_type idx [sizeof...(Args)] = {static_cast<size_type>(args)...};
return access_impl(std::begin(idx), std::end(idx));
}
inline T operator[](const xindex& idx) const
{
return access_impl(idx.begin(), idx.end());
}
template <class It>
inline T element(It first, It last) const
{
return access_impl(first, last);
}
private:
template <class It>
inline T access_impl(const It& begin, const It& end) const
{
return F<T, It>()(begin, end);
}
};
template <class T, class It>
struct eye_fn
{
inline T operator()(const It& /*begin*/, const It& end) const
{
return *(end - 1) == *(end - 2) ? T(1) : T(0);
}
};
}
template <class T = bool>
inline auto eye(const std::vector<size_t>& shape)
{
return detail::make_xgenerator(detail::fn_impl<T, detail::eye_fn>(), shape);
}
template <class T = bool>
inline auto eye(std::size_t n)
{
return eye<T>({n, n});
}
/**
* @function arange(T start, T stop, T step = 1)
* @brief generate numbers evenly spaced within given half-open interval [start, stop).
*
* @param start start of the interval
* @param stop stop of the interval
* @param step stepsize
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto arange(T start, T stop, T step = 1) noexcept
{
std::size_t shape = static_cast<std::size_t>(std::ceil((stop - start) / step));
return detail::make_xgenerator(detail::arange_impl<T>(start, stop, step), {shape});
}
/**
* @function arange(T stop)
* @brief generate numbers evenly spaced within given half-open interval [0, stop)
* with a step size of 1.
*
* @param stop stop of the interval
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto arange(T stop) noexcept
{
return arange<T>(T(0), stop, T(1));
}
/**
* @function linspace
* @brief generate @a num_samples evenly spaced numbers over given interval
*
* @param start start of interval
* @param stop stop of interval
* @param num_samples number of samples (defaults to 50)
* @param endpoint if true, include endpoint (defaults to true)
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto linspace(T start, T stop, std::size_t num_samples = 50, bool endpoint = true) noexcept
{
T step = (stop - start) / T(num_samples - (endpoint ? 1 : 0));
return detail::make_xgenerator(detail::arange_impl<T>(start, stop, step), {num_samples});
}
/**
* @function logspace
* @brief generate @num_samples numbers evenly spaced on a log scale over given interval
*
* @param start start of interval (pow(base, start) is the first value).
* @param stop stop of interval (pow(base, stop) is the final value, except if endpoint = false)
* @param num_samples number of samples (defaults to 50)
* @param base the base of the log space.
* @param endpoint if true, include endpoint (defaults to true)
*
* @tparam T value_type of xexpression
*
* @return xgenerator that generates the values on access
*/
template <class T>
inline auto logspace(T start, T stop, std::size_t num_samples, T base = 10, bool endpoint = true) noexcept
{
return pow(base, linspace(start, stop, num_samples, endpoint));
}
}
#endif
<|endoftext|> |
<commit_before>#include <boost/intrusive/list.hpp>
// create policies
//Create empty container
template<class Container>
struct Empty {
inline static Container make(std::size_t) {
return Container();
}
inline static void clean(){}
};
//Prepare data for fill back
template<class Container>
struct EmptyPrepareBackup {
static std::vector<typename Container::value_type> v;
inline static Container make(std::size_t size) {
if(v.size() != size){
v.clear();
v.resize(size);
for(std::size_t i = 0; i < size; ++i){
v.push_back({i});
}
}
return Container();
}
inline static void clean(){
v.clear();
v.shrink_to_fit();
}
};
template<class Container>
std::vector<typename Container::value_type> EmptyPrepareBackup<Container>::v;
template<class Container>
struct Filled {
inline static Container make(std::size_t size) {
return Container(size);
}
inline static void clean(){}
};
template<class Container>
struct FilledRandom {
static std::vector<typename Container::value_type> v;
inline static Container make(std::size_t size){
// prepare randomized data that will have all the integers from the range
if(v.size() != size){
v.clear();
v.resize(size);
for(std::size_t i = 0; i < size; ++i){
v.push_back({i});
}
std::shuffle(begin(v), end(v), std::mt19937());
}
// fill with randomized data
Container container;
for(std::size_t i = 0; i < size; ++i){
container.push_back(v[i]);
}
return container;
}
inline static void clean(){
v.clear();
v.shrink_to_fit();
}
};
template<class Container>
std::vector<typename Container::value_type> FilledRandom<Container>::v;
template<class Container>
struct SmartFilled {
inline static std::unique_ptr<Container> make(std::size_t size){
return std::unique_ptr<Container>(new Container(size));
}
inline static void clean(){}
};
template<class Container>
struct BackupSmartFilled {
static std::vector<typename Container::value_type> v;
inline static std::unique_ptr<Container> make(std::size_t size){
if(v.size() != size){
v.clear();
v.resize(size);
for(std::size_t i = 0; i < size; ++i){
v.push_back({i});
}
}
std::unique_ptr<Container> container(new Container());
for(std::size_t i = 0; i < size; ++i){
container->push_back(v[i]);
}
return container;
}
inline static void clean(){
v.clear();
v.shrink_to_fit();
}
};
template<class Container>
std::vector<typename Container::value_type> BackupSmartFilled<Container>::v;
// testing policies
template<class Container>
struct NoOp {
inline static void run(Container &, std::size_t) {
//Nothing
}
};
template<class Container>
struct ReserveSize {
inline static void run(Container &c, std::size_t size){
c.reserve(size);
}
};
template<class Container>
struct FillBack {
static const typename Container::value_type value;
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.push_back(value);
}
}
};
template<class Container> const typename Container::value_type FillBack<Container>::value{};
template<class Container>
struct FillBackBackup {
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.push_back(EmptyPrepareBackup<Container>::v[i]);
}
}
};
template<class Container>
struct FillBackInserter {
static const typename Container::value_type value;
inline static void run(Container &c, std::size_t size){
std::fill_n(std::back_inserter(c), size, value);
}
};
template<class Container> const typename Container::value_type FillBackInserter<Container>::value{};
template<class Container>
struct EmplaceBack {
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.emplace_back();
}
}
};
template<class Container>
struct FillFront {
static const typename Container::value_type value;
inline static void run(Container &c, std::size_t size){
std::fill_n(std::front_inserter(c), size, value);
}
};
template<class Container> const typename Container::value_type FillFront<Container>::value{};
template<class T>
struct FillFront<std::vector<T> > {
static const T value;
inline static void run(std::vector<T> &c, std::size_t size){
for(std::size_t i=0; i<size; ++i){
c.insert(begin(c), value);
}
}
};
template<class T> const T FillFront<std::vector<T> >::value{};
template<class Container>
struct EmplaceFront {
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.emplace_front();
}
}
};
template<class T>
struct EmplaceFront<std::vector<T> > {
inline static void run(std::vector<T> &c, std::size_t size){
for(std::size_t i=0; i<size; ++i){
c.emplace(begin(c));
}
}
};
template<class Container>
struct Find {
inline static void run(Container &c, std::size_t size){
for(std::size_t i=0; i<size; ++i) {
// hand written comparison to eliminate temporary object creation
std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; });
}
}
};
template<class Container>
struct Insert {
static std::array<typename Container::value_type, 1000> values;
inline static void run(Container &c, std::size_t){
for(std::size_t i=0; i<1000; ++i) {
// hand written comparison to eliminate temporary object creation
auto it = std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; });
c.insert(it, values[i]);
}
}
};
template<class Container>
std::array<typename Container::value_type, 1000> Insert<Container>::values {};
template<class Container>
struct Write {
inline static void run(Container &c, std::size_t){
auto it = std::begin(c);
auto end = std::end(c);
for(; it != end; ++it){
++(it->a);
}
}
};
template<class Container>
struct Iterate {
inline static void run(Container &c, std::size_t){
auto it = std::begin(c);
auto end = std::end(c);
while(it != end){
++it;
}
}
};
template<class Container>
struct Erase {
inline static void run(Container &c, std::size_t){
for(std::size_t i=0; i<1000; ++i) {
// hand written comparison to eliminate temporary object creation
c.erase(std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; }));
}
}
};
template<class Container>
struct RemoveErase {
inline static void run(Container &c, std::size_t){
for(std::size_t i=0; i<1000; ++i) {
// hand written comparison to eliminate temporary object creation
c.erase(std::remove_if(begin(c), end(c), [&](decltype(*begin(c)) v){ return v.a == i; }), end(c));
}
}
};
//Sort the container
template<class Container>
struct Sort {
inline static void run(Container &c, std::size_t){
std::sort(c.begin(), c.end());
}
};
template<class T>
struct Sort<std::list<T> > {
inline static void run(std::list<T> &c, std::size_t){
c.sort();
}
};
template<class T>
struct Sort<boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>> {
inline static void run(boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>& c, std::size_t){
c.sort();
}
};
//Reverse the container
template<class Container>
struct Reverse {
inline static void run(Container &c, std::size_t){
std::reverse(c.begin(), c.end());
}
};
template<class T>
struct Reverse<std::list<T> > {
inline static void run(std::list<T> &c, std::size_t){
c.reverse();
}
};
template<class T>
struct Reverse<boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>> {
inline static void run(boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>& c, std::size_t){
c.reverse();
}
};
//Destroy the container
template<class Container>
struct SmartDelete {
inline static void run(Container &c, std::size_t) { c.reset(); }
};
template<class Container>
struct RandomSortedInsert {
static std::mt19937 generator;
static std::uniform_int_distribution<std::size_t> distribution;
inline static void run(Container &c, std::size_t size){
for(std::size_t i=0; i<size; ++i){
auto val = distribution(generator);
// hand written comparison to eliminate temporary object creation
c.insert(std::find_if(begin(c), end(c), [&](decltype(*begin(c)) v){ return v.a >= val; }), {val});
}
}
};
template<class Container> std::mt19937 RandomSortedInsert<Container>::generator;
template<class Container> std::uniform_int_distribution<std::size_t> RandomSortedInsert<Container>::distribution(0, std::numeric_limits<std::size_t>::max() - 1);
<commit_msg>Replace resize with reserve<commit_after>#include <boost/intrusive/list.hpp>
// create policies
//Create empty container
template<class Container>
struct Empty {
inline static Container make(std::size_t) {
return Container();
}
inline static void clean(){}
};
//Prepare data for fill back
template<class Container>
struct EmptyPrepareBackup {
static std::vector<typename Container::value_type> v;
inline static Container make(std::size_t size) {
if(v.size() != size){
v.clear();
v.reserve(size);
for(std::size_t i = 0; i < size; ++i){
v.push_back({i});
}
}
return Container();
}
inline static void clean(){
v.clear();
v.shrink_to_fit();
}
};
template<class Container>
std::vector<typename Container::value_type> EmptyPrepareBackup<Container>::v;
template<class Container>
struct Filled {
inline static Container make(std::size_t size) {
return Container(size);
}
inline static void clean(){}
};
template<class Container>
struct FilledRandom {
static std::vector<typename Container::value_type> v;
inline static Container make(std::size_t size){
// prepare randomized data that will have all the integers from the range
if(v.size() != size){
v.clear();
v.reserve(size);
for(std::size_t i = 0; i < size; ++i){
v.push_back({i});
}
std::shuffle(begin(v), end(v), std::mt19937());
}
// fill with randomized data
Container container;
for(std::size_t i = 0; i < size; ++i){
container.push_back(v[i]);
}
return container;
}
inline static void clean(){
v.clear();
v.shrink_to_fit();
}
};
template<class Container>
std::vector<typename Container::value_type> FilledRandom<Container>::v;
template<class Container>
struct SmartFilled {
inline static std::unique_ptr<Container> make(std::size_t size){
return std::unique_ptr<Container>(new Container(size));
}
inline static void clean(){}
};
template<class Container>
struct BackupSmartFilled {
static std::vector<typename Container::value_type> v;
inline static std::unique_ptr<Container> make(std::size_t size){
if(v.size() != size){
v.clear();
v.reserve(size);
for(std::size_t i = 0; i < size; ++i){
v.push_back({i});
}
}
std::unique_ptr<Container> container(new Container());
for(std::size_t i = 0; i < size; ++i){
container->push_back(v[i]);
}
return container;
}
inline static void clean(){
v.clear();
v.shrink_to_fit();
}
};
template<class Container>
std::vector<typename Container::value_type> BackupSmartFilled<Container>::v;
// testing policies
template<class Container>
struct NoOp {
inline static void run(Container &, std::size_t) {
//Nothing
}
};
template<class Container>
struct ReserveSize {
inline static void run(Container &c, std::size_t size){
c.reserve(size);
}
};
template<class Container>
struct FillBack {
static const typename Container::value_type value;
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.push_back(value);
}
}
};
template<class Container> const typename Container::value_type FillBack<Container>::value{};
template<class Container>
struct FillBackBackup {
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.push_back(EmptyPrepareBackup<Container>::v[i]);
}
}
};
template<class Container>
struct FillBackInserter {
static const typename Container::value_type value;
inline static void run(Container &c, std::size_t size){
std::fill_n(std::back_inserter(c), size, value);
}
};
template<class Container> const typename Container::value_type FillBackInserter<Container>::value{};
template<class Container>
struct EmplaceBack {
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.emplace_back();
}
}
};
template<class Container>
struct FillFront {
static const typename Container::value_type value;
inline static void run(Container &c, std::size_t size){
std::fill_n(std::front_inserter(c), size, value);
}
};
template<class Container> const typename Container::value_type FillFront<Container>::value{};
template<class T>
struct FillFront<std::vector<T> > {
static const T value;
inline static void run(std::vector<T> &c, std::size_t size){
for(std::size_t i=0; i<size; ++i){
c.insert(begin(c), value);
}
}
};
template<class T> const T FillFront<std::vector<T> >::value{};
template<class Container>
struct EmplaceFront {
inline static void run(Container &c, std::size_t size){
for(size_t i=0; i<size; ++i){
c.emplace_front();
}
}
};
template<class T>
struct EmplaceFront<std::vector<T> > {
inline static void run(std::vector<T> &c, std::size_t size){
for(std::size_t i=0; i<size; ++i){
c.emplace(begin(c));
}
}
};
template<class Container>
struct Find {
inline static void run(Container &c, std::size_t size){
for(std::size_t i=0; i<size; ++i) {
// hand written comparison to eliminate temporary object creation
std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; });
}
}
};
template<class Container>
struct Insert {
static std::array<typename Container::value_type, 1000> values;
inline static void run(Container &c, std::size_t){
for(std::size_t i=0; i<1000; ++i) {
// hand written comparison to eliminate temporary object creation
auto it = std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; });
c.insert(it, values[i]);
}
}
};
template<class Container>
std::array<typename Container::value_type, 1000> Insert<Container>::values {};
template<class Container>
struct Write {
inline static void run(Container &c, std::size_t){
auto it = std::begin(c);
auto end = std::end(c);
for(; it != end; ++it){
++(it->a);
}
}
};
template<class Container>
struct Iterate {
inline static void run(Container &c, std::size_t){
auto it = std::begin(c);
auto end = std::end(c);
while(it != end){
++it;
}
}
};
template<class Container>
struct Erase {
inline static void run(Container &c, std::size_t){
for(std::size_t i=0; i<1000; ++i) {
// hand written comparison to eliminate temporary object creation
c.erase(std::find_if(std::begin(c), std::end(c), [&](decltype(*std::begin(c)) v){ return v.a == i; }));
}
}
};
template<class Container>
struct RemoveErase {
inline static void run(Container &c, std::size_t){
for(std::size_t i=0; i<1000; ++i) {
// hand written comparison to eliminate temporary object creation
c.erase(std::remove_if(begin(c), end(c), [&](decltype(*begin(c)) v){ return v.a == i; }), end(c));
}
}
};
//Sort the container
template<class Container>
struct Sort {
inline static void run(Container &c, std::size_t){
std::sort(c.begin(), c.end());
}
};
template<class T>
struct Sort<std::list<T> > {
inline static void run(std::list<T> &c, std::size_t){
c.sort();
}
};
template<class T>
struct Sort<boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>> {
inline static void run(boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>& c, std::size_t){
c.sort();
}
};
//Reverse the container
template<class Container>
struct Reverse {
inline static void run(Container &c, std::size_t){
std::reverse(c.begin(), c.end());
}
};
template<class T>
struct Reverse<std::list<T> > {
inline static void run(std::list<T> &c, std::size_t){
c.reverse();
}
};
template<class T>
struct Reverse<boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>> {
inline static void run(boost::intrusive::list<T, boost::intrusive::constant_time_size<false>>& c, std::size_t){
c.reverse();
}
};
//Destroy the container
template<class Container>
struct SmartDelete {
inline static void run(Container &c, std::size_t) { c.reset(); }
};
template<class Container>
struct RandomSortedInsert {
static std::mt19937 generator;
static std::uniform_int_distribution<std::size_t> distribution;
inline static void run(Container &c, std::size_t size){
for(std::size_t i=0; i<size; ++i){
auto val = distribution(generator);
// hand written comparison to eliminate temporary object creation
c.insert(std::find_if(begin(c), end(c), [&](decltype(*begin(c)) v){ return v.a >= val; }), {val});
}
}
};
template<class Container> std::mt19937 RandomSortedInsert<Container>::generator;
template<class Container> std::uniform_int_distribution<std::size_t> RandomSortedInsert<Container>::distribution(0, std::numeric_limits<std::size_t>::max() - 1);
<|endoftext|> |
<commit_before>//Copyright (c) 2019 Ultimaker B.V.
//CuraEngine is released under the terms of the AGPLv3 or higher.
#include <gtest/gtest.h>
#include "../src/infill.h"
#include "ReadTestPolygons.h"
//#define TEST_INFILL_SVG_OUTPUT
#ifdef TEST_INFILL_SVG_OUTPUT
#include <cstdlib>
#include "../src/utils/SVG.h"
#endif //TEST_INFILL_SVG_OUTPUT
namespace cura
{
template<typename ... Ts>
std::string makeName(const std::string& format_string, Ts ... args)
{
constexpr int buff_size = 1024;
char buff[buff_size];
std::snprintf(buff, buff_size, format_string.c_str(), args...);
return std::string(buff);
}
coord_t getPatternMultiplier(const EFillMethod& pattern)
{
switch (pattern)
{
case EFillMethod::GRID: // fallthrough
case EFillMethod::TETRAHEDRAL: // fallthrough
case EFillMethod::QUARTER_CUBIC:
return 2;
case EFillMethod::TRIANGLES: // fallthrough
case EFillMethod::TRIHEXAGON: // fallthrough
case EFillMethod::CUBIC: // fallthrough
case EFillMethod::CUBICSUBDIV:
return 3;
default:
return 1;
}
}
struct InfillParameters
{
public:
// Actual infill parameters:
EFillMethod pattern;
bool zig_zagify;
bool connect_polygons;
coord_t line_distance;
std::string name;
InfillParameters(const EFillMethod& pattern, const bool& zig_zagify, const bool& connect_polygons, const coord_t& line_distance) :
pattern(pattern),
zig_zagify(zig_zagify),
connect_polygons(connect_polygons),
line_distance(line_distance)
{
name = makeName("InfillParameters_%d_%d_%d_%lld", (int)pattern, (int)zig_zagify, (int)connect_polygons, line_distance);
}
};
class InfillTestParameters
{
public:
bool valid; // <-- if the file isn't read (or anything else goes wrong with the setup) we can communicate it to the tests
std::string fail_reason;
size_t test_polygon_id;
// Parameters used to generate the infill:
InfillParameters params;
Polygons outline_polygons;
// Resulting infill:
Polygons result_lines;
Polygons result_polygons;
std::string name;
InfillTestParameters() :
valid(false),
fail_reason("Read of file with test polygons failed (see generateInfillTests), can't continue tests."),
test_polygon_id(-1),
params(InfillParameters(EFillMethod::NONE, false, false, 0)),
outline_polygons(Polygons()),
result_lines(Polygons()),
result_polygons(Polygons()),
name("UNNAMED")
{
}
InfillTestParameters(const InfillParameters& params, const size_t& test_polygon_id, const Polygons& outline_polygons, const Polygons& result_lines, const Polygons& result_polygons) :
valid(true),
fail_reason("__"),
test_polygon_id(test_polygon_id),
params(params),
outline_polygons(outline_polygons),
result_lines(result_lines),
result_polygons(result_polygons)
{
name = makeName("InfillTestParameters_P%d_Z%d_C%d_L%lld__%lld", (int)params.pattern, (int)params.zig_zagify, (int)params.connect_polygons, params.line_distance, test_polygon_id);
}
friend std::ostream& operator<<(std::ostream& os, const InfillTestParameters& params)
{
return os << params.name << "(" << (params.valid ? std::string("input OK") : params.fail_reason) << ")";
}
};
constexpr coord_t infill_line_width = 350;
constexpr coord_t infill_overlap = 0;
constexpr size_t infill_multiplier = 1;
const AngleDegrees fill_angle = 0.;
constexpr coord_t z = 100; // Future improvement: Also take an uneven layer, so we get the alternate.
constexpr coord_t shift = 0;
constexpr coord_t max_resolution = 10;
constexpr coord_t max_deviation = 5;
const std::vector<std::string> polygon_filenames =
{
"../tests/resources/polygon_concave.txt",
"../tests/resources/polygon_concave_hole.txt",
"../tests/resources/polygon_square.txt",
"../tests/resources/polygon_square_hole.txt",
"../tests/resources/polygon_triangle.txt",
"../tests/resources/polygon_two_squares.txt",
};
#ifdef TEST_INFILL_SVG_OUTPUT
void writeTestcaseSVG(const InfillTestParameters& params)
{
constexpr int buff_size = 1024;
char buff[buff_size];
std::snprintf(buff, buff_size, "/tmp/%s.svg", params.name.c_str());
const std::string filename(buff);
AABB aabb(params.outline_polygons);
SVG svgFile(filename.c_str(), aabb);
svgFile.writePolygons(params.outline_polygons , SVG::Color::BLUE);
svgFile.writePolygons(params.result_lines, SVG::Color::RED);
svgFile.writePolygons(params.result_polygons, SVG::Color::RED);
// Note: SVG writes 'itself' when the object is destroyed.
}
#endif //TEST_INFILL_SVG_OUTPUT
InfillTestParameters generateInfillToTest(const InfillParameters& params, const size_t& test_polygon_id, const Polygons& outline_polygons)
{
const EFillMethod pattern = params.pattern;
const bool zig_zagify = params.zig_zagify;
const bool connect_polygons = params.connect_polygons;
const coord_t line_distance = params.line_distance;
Infill infill
(
pattern,
zig_zagify,
connect_polygons,
outline_polygons,
infill_line_width,
line_distance,
infill_overlap,
infill_multiplier,
fill_angle,
z,
shift,
max_resolution,
max_deviation
); // There are some optional parameters, but these will do for now (future improvement?).
Settings infill_settings;
VariableWidthPaths result_paths;
Polygons result_polygons;
Polygons result_lines;
infill.generate(result_paths, result_polygons, result_lines, infill_settings, nullptr, nullptr);
InfillTestParameters result = InfillTestParameters(params, test_polygon_id, outline_polygons, result_lines, result_polygons);
return result;
}
std::vector<InfillTestParameters> generateInfillTests()
{
constexpr bool do_zig_zaggify = true;
constexpr bool dont_zig_zaggify = false;
constexpr bool do_connect_polygons = true;
constexpr bool dont_connect_polygons = false;
std::vector<Polygons> shapes;
if (!readTestPolygons(polygon_filenames, shapes))
{
return { InfillTestParameters() }; // return an invalid singleton, that'll trip up the 'file read' assertion in the TEST_P's
}
/* Skip methods:
* - that require the SierpinskyInfillProvider class, since these test classes aren't equipped to handle that yet
* this can be considered a TODO for these testcases here, not in the methods themselves
* (these are; Cross, Cross-3D and Cubic-Subdivision)
* - Gyroid, since it doesn't handle the 100% infill and related cases well
*/
std::vector<EFillMethod> skip_methods = { EFillMethod::CROSS, EFillMethod::CROSS_3D, EFillMethod::CUBICSUBDIV, EFillMethod::GYROID };
std::vector<EFillMethod> methods;
for (int i_method = 0; i_method < static_cast<int>(EFillMethod::NONE); ++i_method)
{
const EFillMethod method = static_cast<EFillMethod>(i_method);
if (std::find(skip_methods.begin(), skip_methods.end(), method) == skip_methods.end()) // Only use if not in skipped.
{
methods.push_back(method);
}
}
std::vector<coord_t> line_distances = { 350, 400, 600, 800, 1200 };
std::vector<InfillTestParameters> parameters_list;
size_t test_polygon_id = 0;
for (const Polygons& polygons : shapes)
{
for (const EFillMethod& method : methods)
{
for (const coord_t& line_distance : line_distances)
{
parameters_list.push_back(generateInfillToTest(InfillParameters(method, dont_zig_zaggify, dont_connect_polygons, line_distance), test_polygon_id, polygons));
parameters_list.push_back(generateInfillToTest(InfillParameters(method, dont_zig_zaggify, do_connect_polygons, line_distance), test_polygon_id, polygons));
parameters_list.push_back(generateInfillToTest(InfillParameters(method, do_zig_zaggify, dont_connect_polygons, line_distance), test_polygon_id, polygons));
parameters_list.push_back(generateInfillToTest(InfillParameters(method, do_zig_zaggify, do_connect_polygons, line_distance), test_polygon_id, polygons));
}
}
++test_polygon_id;
}
return parameters_list;
}
class InfillTest : public testing::TestWithParam<InfillTestParameters> {};
INSTANTIATE_TEST_CASE_P(InfillTestcases, InfillTest, testing::ValuesIn(generateInfillTests()), [](testing::TestParamInfo<InfillTestParameters> info) { return info.param.name; });
TEST_P(InfillTest, TestInfillSanity)
{
InfillTestParameters params = GetParam();
ASSERT_TRUE(params.valid) << params.fail_reason;
ASSERT_FALSE(params.result_polygons.empty() && params.result_lines.empty()) << "Infill should have been generated.";
#ifdef TEST_INFILL_SVG_OUTPUT
writeTestcaseSVG(params);
#endif //TEST_INFILL_SVG_OUTPUT
const double min_available_area = std::abs(params.outline_polygons.offset(-params.params.line_distance / 2).area());
const double max_available_area = std::abs(params.outline_polygons.offset( params.params.line_distance / 2).area());
const double min_expected_infill_area = (min_available_area * infill_line_width) / params.params.line_distance;
const double max_expected_infill_area = (max_available_area * infill_line_width) / params.params.line_distance;
const double out_infill_area = ((params.result_polygons.polygonLength() + params.result_lines.polyLineLength()) * infill_line_width) / getPatternMultiplier(params.params.pattern);
ASSERT_GT((coord_t)max_available_area, (coord_t)out_infill_area) << "Infill area should allways be less than the total area available.";
ASSERT_GT((coord_t)out_infill_area, (coord_t)min_expected_infill_area) << "Infill area should be greater than the minimum area expected to be covered.";
ASSERT_LT((coord_t)out_infill_area, (coord_t)max_expected_infill_area) << "Infill area should be less than the maximum area to be covered.";
const Polygons padded_shape_outline = params.outline_polygons.offset(infill_line_width / 2);
ASSERT_EQ(padded_shape_outline.intersectionPolyLines(params.result_lines).polyLineLength(), params.result_lines.polyLineLength()) << "Infill (lines) should not be outside target polygon.";
ASSERT_EQ(params.result_polygons.difference(padded_shape_outline).area(), 0) << "Infill (polys) should not be outside target polygon.";
}
} //namespace cura
<commit_msg>Temporarily disable parts of test-infill.<commit_after>//Copyright (c) 2019 Ultimaker B.V.
//CuraEngine is released under the terms of the AGPLv3 or higher.
#include <gtest/gtest.h>
#include "../src/infill.h"
#include "ReadTestPolygons.h"
//#define TEST_INFILL_SVG_OUTPUT
#ifdef TEST_INFILL_SVG_OUTPUT
#include <cstdlib>
#include "../src/utils/SVG.h"
#endif //TEST_INFILL_SVG_OUTPUT
namespace cura
{
template<typename ... Ts>
std::string makeName(const std::string& format_string, Ts ... args)
{
constexpr int buff_size = 1024;
char buff[buff_size];
std::snprintf(buff, buff_size, format_string.c_str(), args...);
return std::string(buff);
}
coord_t getPatternMultiplier(const EFillMethod& pattern)
{
switch (pattern)
{
case EFillMethod::GRID: // fallthrough
case EFillMethod::TETRAHEDRAL: // fallthrough
case EFillMethod::QUARTER_CUBIC:
return 2;
case EFillMethod::TRIANGLES: // fallthrough
case EFillMethod::TRIHEXAGON: // fallthrough
case EFillMethod::CUBIC: // fallthrough
case EFillMethod::CUBICSUBDIV:
return 3;
default:
return 1;
}
}
struct InfillParameters
{
public:
// Actual infill parameters:
EFillMethod pattern;
bool zig_zagify;
bool connect_polygons;
coord_t line_distance;
std::string name;
InfillParameters(const EFillMethod& pattern, const bool& zig_zagify, const bool& connect_polygons, const coord_t& line_distance) :
pattern(pattern),
zig_zagify(zig_zagify),
connect_polygons(connect_polygons),
line_distance(line_distance)
{
name = makeName("InfillParameters_%d_%d_%d_%lld", (int)pattern, (int)zig_zagify, (int)connect_polygons, line_distance);
}
};
class InfillTestParameters
{
public:
bool valid; // <-- if the file isn't read (or anything else goes wrong with the setup) we can communicate it to the tests
std::string fail_reason;
size_t test_polygon_id;
// Parameters used to generate the infill:
InfillParameters params;
Polygons outline_polygons;
// Resulting infill:
Polygons result_lines;
Polygons result_polygons;
std::string name;
InfillTestParameters() :
valid(false),
fail_reason("Read of file with test polygons failed (see generateInfillTests), can't continue tests."),
test_polygon_id(-1),
params(InfillParameters(EFillMethod::NONE, false, false, 0)),
outline_polygons(Polygons()),
result_lines(Polygons()),
result_polygons(Polygons()),
name("UNNAMED")
{
}
InfillTestParameters(const InfillParameters& params, const size_t& test_polygon_id, const Polygons& outline_polygons, const Polygons& result_lines, const Polygons& result_polygons) :
valid(true),
fail_reason("__"),
test_polygon_id(test_polygon_id),
params(params),
outline_polygons(outline_polygons),
result_lines(result_lines),
result_polygons(result_polygons)
{
name = makeName("InfillTestParameters_P%d_Z%d_C%d_L%lld__%lld", (int)params.pattern, (int)params.zig_zagify, (int)params.connect_polygons, params.line_distance, test_polygon_id);
}
friend std::ostream& operator<<(std::ostream& os, const InfillTestParameters& params)
{
return os << params.name << "(" << (params.valid ? std::string("input OK") : params.fail_reason) << ")";
}
};
constexpr coord_t infill_line_width = 350;
constexpr coord_t infill_overlap = 0;
constexpr size_t infill_multiplier = 1;
const AngleDegrees fill_angle = 0.;
constexpr coord_t z = 100; // Future improvement: Also take an uneven layer, so we get the alternate.
constexpr coord_t shift = 0;
constexpr coord_t max_resolution = 10;
constexpr coord_t max_deviation = 5;
const std::vector<std::string> polygon_filenames =
{
"../tests/resources/polygon_concave.txt",
"../tests/resources/polygon_concave_hole.txt",
"../tests/resources/polygon_square.txt",
"../tests/resources/polygon_square_hole.txt",
"../tests/resources/polygon_triangle.txt",
"../tests/resources/polygon_two_squares.txt",
};
#ifdef TEST_INFILL_SVG_OUTPUT
void writeTestcaseSVG(const InfillTestParameters& params)
{
constexpr int buff_size = 1024;
char buff[buff_size];
std::snprintf(buff, buff_size, "/tmp/%s.svg", params.name.c_str());
const std::string filename(buff);
AABB aabb(params.outline_polygons);
SVG svgFile(filename.c_str(), aabb);
svgFile.writePolygons(params.outline_polygons , SVG::Color::BLUE);
svgFile.writePolygons(params.result_lines, SVG::Color::RED);
svgFile.writePolygons(params.result_polygons, SVG::Color::RED);
// Note: SVG writes 'itself' when the object is destroyed.
}
#endif //TEST_INFILL_SVG_OUTPUT
InfillTestParameters generateInfillToTest(const InfillParameters& params, const size_t& test_polygon_id, const Polygons& outline_polygons)
{
const EFillMethod pattern = params.pattern;
const bool zig_zagify = params.zig_zagify;
const bool connect_polygons = params.connect_polygons;
const coord_t line_distance = params.line_distance;
Infill infill
(
pattern,
zig_zagify,
connect_polygons,
outline_polygons,
infill_line_width,
line_distance,
infill_overlap,
infill_multiplier,
fill_angle,
z,
shift,
max_resolution,
max_deviation
); // There are some optional parameters, but these will do for now (future improvement?).
Settings infill_settings;
VariableWidthPaths result_paths;
Polygons result_polygons;
Polygons result_lines;
infill.generate(result_paths, result_polygons, result_lines, infill_settings, nullptr, nullptr);
InfillTestParameters result = InfillTestParameters(params, test_polygon_id, outline_polygons, result_lines, result_polygons);
return result;
}
std::vector<InfillTestParameters> generateInfillTests()
{
constexpr bool do_zig_zaggify = true;
constexpr bool dont_zig_zaggify = false;
constexpr bool do_connect_polygons = true;
constexpr bool dont_connect_polygons = false;
std::vector<Polygons> shapes;
if (!readTestPolygons(polygon_filenames, shapes))
{
return { InfillTestParameters() }; // return an invalid singleton, that'll trip up the 'file read' assertion in the TEST_P's
}
/* Skip methods:
* - that require the SierpinskyInfillProvider class, since these test classes aren't equipped to handle that yet
* this can be considered a TODO for these testcases here, not in the methods themselves
* (these are; Cross, Cross-3D and Cubic-Subdivision)
* - Gyroid, since it doesn't handle the 100% infill and related cases well
* - Concentric and ZigZag, since they now use a method that starts from an extra infill wall, which fail these tests (TODO!)
*/
std::vector<EFillMethod> skip_methods = { EFillMethod::CONCENTRIC, EFillMethod::ZIG_ZAG, EFillMethod::CROSS, EFillMethod::CROSS_3D, EFillMethod::CUBICSUBDIV, EFillMethod::GYROID };
std::vector<EFillMethod> methods;
for (int i_method = 0; i_method < static_cast<int>(EFillMethod::NONE); ++i_method)
{
const EFillMethod method = static_cast<EFillMethod>(i_method);
if (std::find(skip_methods.begin(), skip_methods.end(), method) == skip_methods.end()) // Only use if not in skipped.
{
methods.push_back(method);
}
}
std::vector<coord_t> line_distances = { 350, 400, 600, 800, 1200 };
std::vector<InfillTestParameters> parameters_list;
size_t test_polygon_id = 0;
for (const Polygons& polygons : shapes)
{
for (const EFillMethod& method : methods)
{
for (const coord_t& line_distance : line_distances)
{
parameters_list.push_back(generateInfillToTest(InfillParameters(method, dont_zig_zaggify, dont_connect_polygons, line_distance), test_polygon_id, polygons));
parameters_list.push_back(generateInfillToTest(InfillParameters(method, dont_zig_zaggify, do_connect_polygons, line_distance), test_polygon_id, polygons));
//parameters_list.push_back(generateInfillToTest(InfillParameters(method, do_zig_zaggify, dont_connect_polygons, line_distance), test_polygon_id, polygons));
//parameters_list.push_back(generateInfillToTest(InfillParameters(method, do_zig_zaggify, do_connect_polygons, line_distance), test_polygon_id, polygons));
// TODO: Re-enable when the extra infill walls are fully debugged or the discrepancy in the tests is explained.
}
}
++test_polygon_id;
}
return parameters_list;
}
class InfillTest : public testing::TestWithParam<InfillTestParameters> {};
INSTANTIATE_TEST_CASE_P(InfillTestcases, InfillTest, testing::ValuesIn(generateInfillTests()), [](testing::TestParamInfo<InfillTestParameters> info) { return info.param.name; });
TEST_P(InfillTest, TestInfillSanity)
{
InfillTestParameters params = GetParam();
ASSERT_TRUE(params.valid) << params.fail_reason;
ASSERT_FALSE(params.result_polygons.empty() && params.result_lines.empty()) << "Infill should have been generated.";
#ifdef TEST_INFILL_SVG_OUTPUT
writeTestcaseSVG(params);
#endif //TEST_INFILL_SVG_OUTPUT
const double min_available_area = std::abs(params.outline_polygons.offset(-params.params.line_distance / 2).area());
const double max_available_area = std::abs(params.outline_polygons.offset( params.params.line_distance / 2).area());
const double min_expected_infill_area = (min_available_area * infill_line_width) / params.params.line_distance;
const double max_expected_infill_area = (max_available_area * infill_line_width) / params.params.line_distance;
const double out_infill_area = ((params.result_polygons.polygonLength() + params.result_lines.polyLineLength()) * infill_line_width) / getPatternMultiplier(params.params.pattern);
ASSERT_GT((coord_t)max_available_area, (coord_t)out_infill_area) << "Infill area should allways be less than the total area available.";
ASSERT_GT((coord_t)out_infill_area, (coord_t)min_expected_infill_area) << "Infill area should be greater than the minimum area expected to be covered.";
ASSERT_LT((coord_t)out_infill_area, (coord_t)max_expected_infill_area) << "Infill area should be less than the maximum area to be covered.";
const Polygons padded_shape_outline = params.outline_polygons.offset(infill_line_width / 2);
ASSERT_EQ(padded_shape_outline.intersectionPolyLines(params.result_lines).polyLineLength(), params.result_lines.polyLineLength()) << "Infill (lines) should not be outside target polygon.";
ASSERT_EQ(params.result_polygons.difference(padded_shape_outline).area(), 0) << "Infill (polys) should not be outside target polygon.";
}
} //namespace cura
<|endoftext|> |
<commit_before>#ifndef GUARD_VERIFY_HPP
#define GUARD_VERIFY_HPP
#include <numeric>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <mlopen/returns.hpp>
// Compute the value of a range
template<class R>
using range_value = typename std::decay<decltype(*std::declval<R>().begin())>::type;
struct sum_fn
{
template<class T, class U>
auto operator()(T x, U y) const MLOPEN_RETURNS(x + y);
};
struct max_mag_fn
{
template<class T, class U>
auto operator()(T x, U y) const MLOPEN_RETURNS(std::max(std::fabs(x), std::fabs(y)));
};
struct square_diff_fn
{
template<class T, class U>
auto operator()(T x, U y) const MLOPEN_RETURNS((x - y)*(x - y));
};
template<class R1, class R2>
range_value<R1> rms_range(R1&& r1, R2&& r2)
{
std::size_t n = std::distance(r1.begin(), r1.end());
if (n == std::distance(r2.begin(), r2.end()))
{
auto square_diff = std::inner_product(r1.begin(), r1.end(), r2.begin(), 0.0, sum_fn{}, square_diff_fn{});
auto mag = std::inner_product(r1.begin(), r1.end(), r2.begin(), 0.0, sum_fn{}, max_mag_fn{});
return std::sqrt(square_diff / (n*mag));
}
else return std::numeric_limits<range_value<R1>>::max();
}
template<class V, class... Ts>
void verify(V&& v, Ts&&... xs)
{
const double tolerance = 10e-6;
auto out_cpu = v.cpu(xs...);
auto out_gpu = v.gpu(xs...);
CHECK(std::distance(out_cpu.begin(), out_cpu.end()) == std::distance(out_gpu.begin(), out_gpu.end()));
auto error = rms_range(out_cpu, out_gpu);
if (error > tolerance)
{
std::cout << "FAILED: " << error << std::endl;
v.fail(error, xs...);
// TODO: Check if gpu data is all zeros
}
}
#endif
<commit_msg>Improve computing max magnitude<commit_after>#ifndef GUARD_VERIFY_HPP
#define GUARD_VERIFY_HPP
#include <numeric>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <mlopen/returns.hpp>
// Compute the value of a range
template<class R>
using range_value = typename std::decay<decltype(*std::declval<R>().begin())>::type;
struct sum_fn
{
template<class T, class U>
auto operator()(T x, U y) const MLOPEN_RETURNS(x + y);
};
struct compare_mag_fn
{
template<class T, class U>
bool operator()(T x, U y) const
{
return std::fabs(x) < std::fabs(y);
}
};
struct square_diff_fn
{
template<class T, class U>
auto operator()(T x, U y) const MLOPEN_RETURNS((x - y)*(x - y));
};
template<class R1, class R2>
range_value<R1> rms_range(R1&& r1, R2&& r2)
{
std::size_t n = std::distance(r1.begin(), r1.end());
if (n == std::distance(r2.begin(), r2.end()))
{
auto square_diff = std::inner_product(r1.begin(), r1.end(), r2.begin(), 0.0, sum_fn{}, square_diff_fn{});
auto mag1 = *std::max_element(r1.begin(), r1.end(), compare_mag_fn{});
auto mag2 = *std::max_element(r2.begin(), r2.end(), compare_mag_fn{});
auto mag = std::max<decltype(mag1)>(std::max(mag1, mag2), 1);
return std::sqrt(square_diff / (n*mag));
}
else return std::numeric_limits<range_value<R1>>::max();
}
template<class V, class... Ts>
void verify(V&& v, Ts&&... xs)
{
const double tolerance = 10e-6;
auto out_cpu = v.cpu(xs...);
auto out_gpu = v.gpu(xs...);
CHECK(std::distance(out_cpu.begin(), out_cpu.end()) == std::distance(out_gpu.begin(), out_gpu.end()));
auto error = rms_range(out_cpu, out_gpu);
if (error > tolerance)
{
std::cout << "FAILED: " << error << std::endl;
v.fail(error, xs...);
// TODO: Check if gpu data is all zeros
}
}
#endif
<|endoftext|> |
<commit_before>#include <boost/interprocess/ipc/message_queue.hpp>
#include <iostream>
#include <vector>
#include <boost/archive/text_iarchive.hpp>
#include <time.h>
#include "liblager_connect.h"
#include <X11/Xlib.h>
#include <X11/Intrinsic.h>
#include <X11/extensions/XTest.h>
#include <unistd.h>
using namespace boost::interprocess;
using std::cout;
using std::endl;
using std::string;
using std::stringstream;
struct timespec sleep_interval = { 0, 250000000 }; // 250 ms
/**
* Takes a key symbol and a modifier key. Sends X Server a press and release
* for the main key. If a modifier is specified, it first sends a press for the
* modifier and sends a release for it at the very end.
*
* Based on code from
* https://bharathisubramanian.wordpress.com/2010/03/14/x11-fake-key-event-generation-using-xtest-ext/ab
*/
static void SendKey(Display * display, KeySym key_symbol, KeySym mod_symbol) {
KeyCode key_code = 0, mod_code = 0;
key_code = XKeysymToKeycode(display, key_symbol);
if (key_code == 0)
return;
XTestGrabControl(display, True);
/* Generate modkey press */
if (mod_symbol != 0) {
mod_code = XKeysymToKeycode(display, mod_symbol);
XTestFakeKeyEvent(display, mod_code, True, 0);
}
/* Generate regular key press and release */
XTestFakeKeyEvent(display, key_code, True, 0);
XTestFakeKeyEvent(display, key_code, False, 0);
/* Generate modkey release */
if (mod_symbol != 0) {
XTestFakeKeyEvent(display, mod_code, False, 0);
}
XSync(display, False);
XTestGrabControl(display, False);
}
/**
* Sends X Server the key presses to close a tab in Google Chrome.
*/
void CloseTab(Display* display) {
// Ctrl + W
SendKey(display, XK_W, XK_Control_L);
}
/**
* Sends X Server the key presses to maximize a window.
*/
void MaximizeWindow(Display* display) {
// Windows + Up
SendKey(display, XK_Up, XK_Super_L);
}
/**
* Sends X Server the key presses to open a new tab in Google Chrome.
*/
void NewTab(Display* display) {
// Ctrl + T
SendKey(display, XK_T, XK_Control_L);
}
/**
* Sends X Server a series of key presses to bring up the open application
* dialog in Unity and start Google Chrome.
*/
void OpenChrome(Display* display) {
struct timespec sleep_interval = { 0, 750000 }; // microseconds
// Alt + F2 brings up the open application dialog on Ubuntu Unity
SendKey(display, XK_F2, XK_Alt_L);
// Give it time to open
sleep(1);
// Delete any old entries
SendKey(display, XK_BackSpace, 0);
// Enter google-chrome
SendKey(display, XK_G, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_minus, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_H, 0);
SendKey(display, XK_R, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
SendKey(display, XK_E, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the CNN URL and press Enter.
*/
void OpenCnn(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.cnn.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_N, 0);
SendKey(display, XK_N, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Google URL and press Enter.
*/
void OpenGoogle(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.google.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Google Play Music URL and press Enter.
*/
void OpenMusic(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type play.google.com/music
SendKey(display, XK_P, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_A, 0);
SendKey(display, XK_Y, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
SendKey(display, XK_slash, 0);
SendKey(display, XK_M, 0);
SendKey(display, XK_U, 0);
SendKey(display, XK_S, 0);
SendKey(display, XK_I, 0);
SendKey(display, XK_C, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Netflix URL and press Enter.
*/
void OpenNetflix(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.netflix.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_N, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_T, 0);
SendKey(display, XK_F, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_I, 0);
SendKey(display, XK_X, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Google URL and press Enter.
*/
void OpenWeather(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type weather
SendKey(display, XK_W, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_A, 0);
SendKey(display, XK_T, 0);
SendKey(display, XK_H, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_R, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the YouTube URL and press Enter.
*/
void OpenYouTube(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.youtube.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_Y, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_U, 0);
SendKey(display, XK_T, 0);
SendKey(display, XK_U, 0);
SendKey(display, XK_B, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key press to refresh a page in Google Chrome.
*/
void RefreshTab(Display* display) {
// F5
SendKey(display, XK_F5, 0);
}
/**
* Sends X Server the key presses to restore a window.
*/
void RestoreWindow(Display* display) {
// Windows + Down
SendKey(display, XK_Down, XK_Super_L);
}
/**
* Sends X Server the key presses to scroll down.
*/
void ScrollDown(Display* display) {
// PgDown
SendKey(display, XK_KP_Page_Down, 0);
}
/**
* Sends X Server the key presses to scroll up.
*/
void ScrollUp(Display* display) {
// PgUp
SendKey(display, XK_KP_Page_Up, 0);
}
/**
* Sends X Server the key presses to zoom in in Google Chrome.
*/
void ZoomIn(Display* display) {
// Ctrl + Plus
SendKey(display, XK_plus, XK_Control_L);
}
/**
* Sends X Server the key presses to zoom out in Google Chrome.
*/
void ZoomOut(Display* display) {
// Ctrl + Minus
SendKey(display, XK_minus, XK_Control_L);
}
/**
* The main loop of the LaGeR Injector.
*/
int main() {
Display* display = XOpenDisplay(NULL);
string gesture_name;
string gestures_file_name;
SubscribeToGesturesInFile(string(getenv("HOME")) + "/.lager/injector/gestures.dat");
while (true) {
gesture_name = GetDetectedGestureMessage().get_gesture_name();
cout << "Injector: Received message for gesture \"" << gesture_name << "\""
<< endl;
if (gesture_name.compare("CloseTab") == 0) {
CloseTab(display);
} else if (gesture_name.compare("MaximizeWindow") == 0) {
MaximizeWindow(display);
} else if (gesture_name.compare("NewTab") == 0) {
NewTab(display);
} else if (gesture_name.compare("OpenChrome") == 0) {
OpenChrome(display);
} else if (gesture_name.compare("OpenCNN") == 0) {
OpenCnn(display);
} else if (gesture_name.compare("OpenGoogle") == 0) {
OpenGoogle(display);
} else if (gesture_name.compare("OpenMusic") == 0) {
OpenMusic(display);
} else if (gesture_name.compare("OpenNetflix") == 0) {
OpenNetflix(display);
} else if (gesture_name.compare("OpenWeather") == 0) {
OpenWeather(display);
} else if (gesture_name.compare("OpenYouTube") == 0) {
OpenYouTube(display);
} else if (gesture_name.compare("RefreshTab") == 0) {
RefreshTab(display);
} else if (gesture_name.compare("RestoreWindow") == 0) {
RestoreWindow(display);
} else if (gesture_name.compare("ScrollDown") == 0) {
ScrollDown(display);
} else if (gesture_name.compare("ScrollUp") == 0) {
ScrollUp(display);
} else if (gesture_name.compare("ZoomIn") == 0) {
ZoomIn(display);
} else if (gesture_name.compare("ZoomOut") == 0) {
ZoomOut(display);
} else {
cout << "Error: Received unexpected gesture: \"" << gesture_name << "\""
<< endl;
}
}
return 0;
}
<commit_msg>Lager Injector: Use GNOME Shell shortcut to speed up OpenChrome action<commit_after>#include <boost/interprocess/ipc/message_queue.hpp>
#include <iostream>
#include <vector>
#include <boost/archive/text_iarchive.hpp>
#include <time.h>
#include "liblager_connect.h"
#include <X11/Xlib.h>
#include <X11/Intrinsic.h>
#include <X11/extensions/XTest.h>
#include <unistd.h>
using namespace boost::interprocess;
using std::cout;
using std::endl;
using std::string;
using std::stringstream;
struct timespec sleep_interval = { 0, 250000000 }; // 250 ms
/**
* Takes a key symbol and a modifier key. Sends X Server a press and release
* for the main key. If a modifier is specified, it first sends a press for the
* modifier and sends a release for it at the very end.
*
* Based on code from
* https://bharathisubramanian.wordpress.com/2010/03/14/x11-fake-key-event-generation-using-xtest-ext/ab
*/
static void SendKey(Display * display, KeySym key_symbol, KeySym mod_symbol) {
KeyCode key_code = 0, mod_code = 0;
key_code = XKeysymToKeycode(display, key_symbol);
if (key_code == 0)
return;
XTestGrabControl(display, True);
/* Generate modkey press */
if (mod_symbol != 0) {
mod_code = XKeysymToKeycode(display, mod_symbol);
XTestFakeKeyEvent(display, mod_code, True, 0);
}
/* Generate regular key press and release */
XTestFakeKeyEvent(display, key_code, True, 0);
XTestFakeKeyEvent(display, key_code, False, 0);
/* Generate modkey release */
if (mod_symbol != 0) {
XTestFakeKeyEvent(display, mod_code, False, 0);
}
XSync(display, False);
XTestGrabControl(display, False);
}
/**
* Sends X Server the key presses to close a tab in Google Chrome.
*/
void CloseTab(Display* display) {
// Ctrl + W
SendKey(display, XK_W, XK_Control_L);
}
/**
* Sends X Server the key presses to maximize a window.
*/
void MaximizeWindow(Display* display) {
// Windows + Up
SendKey(display, XK_Up, XK_Super_L);
}
/**
* Sends X Server the key presses to open a new tab in Google Chrome.
*/
void NewTab(Display* display) {
// Ctrl + T
SendKey(display, XK_T, XK_Control_L);
}
/**
* Sends X Server a series of key presses to start Google Chrome via
* a system shortcut. Note that the number below corresponds to the
* position of the Google Chrome favorite on GNOME Shell dock.
*/
void OpenChrome(Display* display) {
// Windows + 1
SendKey(display, XK_1, XK_Super_L);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the CNN URL and press Enter.
*/
void OpenCnn(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.cnn.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_N, 0);
SendKey(display, XK_N, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Google URL and press Enter.
*/
void OpenGoogle(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.google.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Google Play Music URL and press Enter.
*/
void OpenMusic(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type play.google.com/music
SendKey(display, XK_P, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_A, 0);
SendKey(display, XK_Y, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_G, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
SendKey(display, XK_slash, 0);
SendKey(display, XK_M, 0);
SendKey(display, XK_U, 0);
SendKey(display, XK_S, 0);
SendKey(display, XK_I, 0);
SendKey(display, XK_C, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Netflix URL and press Enter.
*/
void OpenNetflix(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.netflix.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_N, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_T, 0);
SendKey(display, XK_F, 0);
SendKey(display, XK_L, 0);
SendKey(display, XK_I, 0);
SendKey(display, XK_X, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the Google URL and press Enter.
*/
void OpenWeather(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type weather
SendKey(display, XK_W, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_A, 0);
SendKey(display, XK_T, 0);
SendKey(display, XK_H, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_R, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key presses to go to the navigation bar,
* type the YouTube URL and press Enter.
*/
void OpenYouTube(Display* display) {
// Ctrl + L shifts the focus to the navigation bar
SendKey(display, XK_L, XK_Control_L);
// Sleep to give time for the focus to shift
nanosleep(&sleep_interval, NULL);
// Type www.youtube.com
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_W, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_Y, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_U, 0);
SendKey(display, XK_T, 0);
SendKey(display, XK_U, 0);
SendKey(display, XK_B, 0);
SendKey(display, XK_E, 0);
SendKey(display, XK_period, 0);
SendKey(display, XK_C, 0);
SendKey(display, XK_O, 0);
SendKey(display, XK_M, 0);
// Press Enter
SendKey(display, XK_Return, 0);
}
/**
* Sends X Server the key press to refresh a page in Google Chrome.
*/
void RefreshTab(Display* display) {
// F5
SendKey(display, XK_F5, 0);
}
/**
* Sends X Server the key presses to restore a window.
*/
void RestoreWindow(Display* display) {
// Windows + Down
SendKey(display, XK_Down, XK_Super_L);
}
/**
* Sends X Server the key presses to scroll down.
*/
void ScrollDown(Display* display) {
// PgDown
SendKey(display, XK_KP_Page_Down, 0);
}
/**
* Sends X Server the key presses to scroll up.
*/
void ScrollUp(Display* display) {
// PgUp
SendKey(display, XK_KP_Page_Up, 0);
}
/**
* Sends X Server the key presses to zoom in in Google Chrome.
*/
void ZoomIn(Display* display) {
// Ctrl + Plus
SendKey(display, XK_plus, XK_Control_L);
}
/**
* Sends X Server the key presses to zoom out in Google Chrome.
*/
void ZoomOut(Display* display) {
// Ctrl + Minus
SendKey(display, XK_minus, XK_Control_L);
}
/**
* The main loop of the LaGeR Injector.
*/
int main() {
Display* display = XOpenDisplay(NULL);
string gesture_name;
string gestures_file_name;
SubscribeToGesturesInFile(string(getenv("HOME")) + "/.lager/injector/gestures.dat");
while (true) {
gesture_name = GetDetectedGestureMessage().get_gesture_name();
cout << "Injector: Received message for gesture \"" << gesture_name << "\""
<< endl;
if (gesture_name.compare("CloseTab") == 0) {
CloseTab(display);
} else if (gesture_name.compare("MaximizeWindow") == 0) {
MaximizeWindow(display);
} else if (gesture_name.compare("NewTab") == 0) {
NewTab(display);
} else if (gesture_name.compare("OpenChrome") == 0) {
OpenChrome(display);
} else if (gesture_name.compare("OpenCNN") == 0) {
OpenCnn(display);
} else if (gesture_name.compare("OpenGoogle") == 0) {
OpenGoogle(display);
} else if (gesture_name.compare("OpenMusic") == 0) {
OpenMusic(display);
} else if (gesture_name.compare("OpenNetflix") == 0) {
OpenNetflix(display);
} else if (gesture_name.compare("OpenWeather") == 0) {
OpenWeather(display);
} else if (gesture_name.compare("OpenYouTube") == 0) {
OpenYouTube(display);
} else if (gesture_name.compare("RefreshTab") == 0) {
RefreshTab(display);
} else if (gesture_name.compare("RestoreWindow") == 0) {
RestoreWindow(display);
} else if (gesture_name.compare("ScrollDown") == 0) {
ScrollDown(display);
} else if (gesture_name.compare("ScrollUp") == 0) {
ScrollUp(display);
} else if (gesture_name.compare("ZoomIn") == 0) {
ZoomIn(display);
} else if (gesture_name.compare("ZoomOut") == 0) {
ZoomOut(display);
} else {
cout << "Error: Received unexpected gesture: \"" << gesture_name << "\""
<< endl;
}
}
return 0;
}
<|endoftext|> |
<commit_before>//===-- X86FastISel.cpp - X86 FastISel implementation ---------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the X86-specific support for the FastISel class. Much
// of the target-specific code is generated by tablegen in the file
// X86GenFastISel.inc, which is #included here.
//
//===----------------------------------------------------------------------===//
#include "X86.h"
#include "X86InstrBuilder.h"
#include "X86ISelLowering.h"
#include "X86RegisterInfo.h"
#include "X86Subtarget.h"
#include "X86TargetMachine.h"
#include "llvm/CodeGen/FastISel.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
using namespace llvm;
class X86FastISel : public FastISel {
/// Subtarget - Keep a pointer to the X86Subtarget around so that we can
/// make the right decision when generating code for different targets.
const X86Subtarget *Subtarget;
public:
explicit X86FastISel(MachineFunction &mf,
DenseMap<const Value *, unsigned> &vm,
DenseMap<const BasicBlock *, MachineBasicBlock *> &bm)
: FastISel(mf, vm, bm) {
Subtarget = &TM.getSubtarget<X86Subtarget>();
}
virtual bool TargetSelectInstruction(Instruction *I);
#include "X86GenFastISel.inc"
private:
bool X86SelectConstAddr(Value *V, unsigned &Op0);
bool X86SelectLoad(Instruction *I);
bool X86SelectStore(Instruction *I);
};
/// X86SelectConstAddr - Select and emit code to materialize constant address.
///
bool X86FastISel::X86SelectConstAddr(Value *V,
unsigned &Op0) {
// FIXME: Only GlobalAddress for now.
GlobalValue *GV = dyn_cast<GlobalValue>(V);
if (!GV)
return false;
if (Subtarget->GVRequiresExtraLoad(GV, TM, false)) {
// Issue load from stub if necessary.
unsigned Opc = 0;
const TargetRegisterClass *RC = NULL;
if (TLI.getPointerTy() == MVT::i32) {
Opc = X86::MOV32rm;
RC = X86::GR32RegisterClass;
} else {
Opc = X86::MOV64rm;
RC = X86::GR64RegisterClass;
}
Op0 = createResultReg(RC);
X86AddressMode AM;
AM.GV = GV;
addFullAddress(BuildMI(MBB, TII.get(Opc), Op0), AM);
// Prevent loading GV stub multiple times in same MBB.
LocalValueMap[V] = Op0;
}
return true;
}
/// X86SelectStore - Select and emit code to implement store instructions.
bool X86FastISel::X86SelectStore(Instruction* I) {
MVT VT = MVT::getMVT(I->getOperand(0)->getType());
if (VT == MVT::Other || !VT.isSimple())
// Unhandled type. Halt "fast" selection and bail.
return false;
if (VT == MVT::iPTR)
// Use pointer type.
VT = TLI.getPointerTy();
// We only handle legal types. For example, on x86-32 the instruction
// selector contains all of the 64-bit instructions from x86-64,
// under the assumption that i64 won't be used if the target doesn't
// support it.
if (!TLI.isTypeLegal(VT))
return false;
unsigned Op0 = getRegForValue(I->getOperand(0));
if (Op0 == 0)
// Unhandled operand. Halt "fast" selection and bail.
return false;
Value *V = I->getOperand(1);
unsigned Op1 = getRegForValue(V);
if (Op1 == 0) {
// Handle constant load address.
if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op1))
// Unhandled operand. Halt "fast" selection and bail.
return false;
}
// Get opcode and regclass of the output for the given load instruction.
unsigned Opc = 0;
const TargetRegisterClass *RC = NULL;
switch (VT.getSimpleVT()) {
default: return false;
case MVT::i8:
Opc = X86::MOV8mr;
RC = X86::GR8RegisterClass;
break;
case MVT::i16:
Opc = X86::MOV16mr;
RC = X86::GR16RegisterClass;
break;
case MVT::i32:
Opc = X86::MOV32mr;
RC = X86::GR32RegisterClass;
break;
case MVT::i64:
// Must be in x86-64 mode.
Opc = X86::MOV64mr;
RC = X86::GR64RegisterClass;
break;
case MVT::f32:
if (Subtarget->hasSSE1()) {
Opc = X86::MOVSSmr;
RC = X86::FR32RegisterClass;
} else {
Opc = X86::ST_Fp32m;
RC = X86::RFP32RegisterClass;
}
break;
case MVT::f64:
if (Subtarget->hasSSE2()) {
Opc = X86::MOVSDmr;
RC = X86::FR64RegisterClass;
} else {
Opc = X86::ST_Fp64m;
RC = X86::RFP64RegisterClass;
}
break;
case MVT::f80:
Opc = X86::ST_FP80m;
RC = X86::RFP80RegisterClass;
break;
}
X86AddressMode AM;
if (Op1)
// Address is in register.
AM.Base.Reg = Op1;
else
AM.GV = cast<GlobalValue>(V);
addFullAddress(BuildMI(MBB, TII.get(Opc)), AM).addReg(Op0);
return true;
}
/// X86SelectLoad - Select and emit code to implement load instructions.
///
bool X86FastISel::X86SelectLoad(Instruction *I) {
MVT VT = MVT::getMVT(I->getType(), /*HandleUnknown=*/true);
if (VT == MVT::Other || !VT.isSimple())
// Unhandled type. Halt "fast" selection and bail.
return false;
if (VT == MVT::iPTR)
// Use pointer type.
VT = TLI.getPointerTy();
// We only handle legal types. For example, on x86-32 the instruction
// selector contains all of the 64-bit instructions from x86-64,
// under the assumption that i64 won't be used if the target doesn't
// support it.
if (!TLI.isTypeLegal(VT))
return false;
Value *V = I->getOperand(0);
unsigned Op0 = getRegForValue(V);
if (Op0 == 0) {
// Handle constant load address.
if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op0))
// Unhandled operand. Halt "fast" selection and bail.
return false;
}
// Get opcode and regclass of the output for the given load instruction.
unsigned Opc = 0;
const TargetRegisterClass *RC = NULL;
switch (VT.getSimpleVT()) {
default: return false;
case MVT::i8:
Opc = X86::MOV8rm;
RC = X86::GR8RegisterClass;
break;
case MVT::i16:
Opc = X86::MOV16rm;
RC = X86::GR16RegisterClass;
break;
case MVT::i32:
Opc = X86::MOV32rm;
RC = X86::GR32RegisterClass;
break;
case MVT::i64:
// Must be in x86-64 mode.
Opc = X86::MOV64rm;
RC = X86::GR64RegisterClass;
break;
case MVT::f32:
if (Subtarget->hasSSE1()) {
Opc = X86::MOVSSrm;
RC = X86::FR32RegisterClass;
} else {
Opc = X86::LD_Fp32m;
RC = X86::RFP32RegisterClass;
}
break;
case MVT::f64:
if (Subtarget->hasSSE2()) {
Opc = X86::MOVSDrm;
RC = X86::FR64RegisterClass;
} else {
Opc = X86::LD_Fp64m;
RC = X86::RFP64RegisterClass;
}
break;
case MVT::f80:
Opc = X86::LD_Fp80m;
RC = X86::RFP80RegisterClass;
break;
}
unsigned ResultReg = createResultReg(RC);
X86AddressMode AM;
if (Op0)
// Address is in register.
AM.Base.Reg = Op0;
else
AM.GV = cast<GlobalValue>(V);
addFullAddress(BuildMI(MBB, TII.get(Opc), ResultReg), AM);
UpdateValueMap(I, ResultReg);
return true;
}
bool
X86FastISel::TargetSelectInstruction(Instruction *I) {
switch (I->getOpcode()) {
default: break;
case Instruction::Load:
return X86SelectLoad(I);
case Instruction::Store:
return X86SelectStore(I);
}
return false;
}
namespace llvm {
llvm::FastISel *X86::createFastISel(MachineFunction &mf,
DenseMap<const Value *, unsigned> &vm,
DenseMap<const BasicBlock *, MachineBasicBlock *> &bm) {
return new X86FastISel(mf, vm, bm);
}
}
<commit_msg>X86FastISel support for ICmpInst and FCmpInst.<commit_after>//===-- X86FastISel.cpp - X86 FastISel implementation ---------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the X86-specific support for the FastISel class. Much
// of the target-specific code is generated by tablegen in the file
// X86GenFastISel.inc, which is #included here.
//
//===----------------------------------------------------------------------===//
#include "X86.h"
#include "X86InstrBuilder.h"
#include "X86ISelLowering.h"
#include "X86RegisterInfo.h"
#include "X86Subtarget.h"
#include "X86TargetMachine.h"
#include "llvm/InstrTypes.h"
#include "llvm/DerivedTypes.h"
#include "llvm/CodeGen/FastISel.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
using namespace llvm;
class X86FastISel : public FastISel {
/// Subtarget - Keep a pointer to the X86Subtarget around so that we can
/// make the right decision when generating code for different targets.
const X86Subtarget *Subtarget;
public:
explicit X86FastISel(MachineFunction &mf,
DenseMap<const Value *, unsigned> &vm,
DenseMap<const BasicBlock *, MachineBasicBlock *> &bm)
: FastISel(mf, vm, bm) {
Subtarget = &TM.getSubtarget<X86Subtarget>();
}
virtual bool TargetSelectInstruction(Instruction *I);
#include "X86GenFastISel.inc"
private:
bool X86SelectConstAddr(Value *V, unsigned &Op0);
bool X86SelectLoad(Instruction *I);
bool X86SelectStore(Instruction *I);
bool X86SelectCmp(Instruction *I);
};
/// X86SelectConstAddr - Select and emit code to materialize constant address.
///
bool X86FastISel::X86SelectConstAddr(Value *V,
unsigned &Op0) {
// FIXME: Only GlobalAddress for now.
GlobalValue *GV = dyn_cast<GlobalValue>(V);
if (!GV)
return false;
if (Subtarget->GVRequiresExtraLoad(GV, TM, false)) {
// Issue load from stub if necessary.
unsigned Opc = 0;
const TargetRegisterClass *RC = NULL;
if (TLI.getPointerTy() == MVT::i32) {
Opc = X86::MOV32rm;
RC = X86::GR32RegisterClass;
} else {
Opc = X86::MOV64rm;
RC = X86::GR64RegisterClass;
}
Op0 = createResultReg(RC);
X86AddressMode AM;
AM.GV = GV;
addFullAddress(BuildMI(MBB, TII.get(Opc), Op0), AM);
// Prevent loading GV stub multiple times in same MBB.
LocalValueMap[V] = Op0;
}
return true;
}
/// X86SelectStore - Select and emit code to implement store instructions.
bool X86FastISel::X86SelectStore(Instruction* I) {
MVT VT = MVT::getMVT(I->getOperand(0)->getType());
if (VT == MVT::Other || !VT.isSimple())
// Unhandled type. Halt "fast" selection and bail.
return false;
if (VT == MVT::iPTR)
// Use pointer type.
VT = TLI.getPointerTy();
// We only handle legal types. For example, on x86-32 the instruction
// selector contains all of the 64-bit instructions from x86-64,
// under the assumption that i64 won't be used if the target doesn't
// support it.
if (!TLI.isTypeLegal(VT))
return false;
unsigned Op0 = getRegForValue(I->getOperand(0));
if (Op0 == 0)
// Unhandled operand. Halt "fast" selection and bail.
return false;
Value *V = I->getOperand(1);
unsigned Op1 = getRegForValue(V);
if (Op1 == 0) {
// Handle constant load address.
if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op1))
// Unhandled operand. Halt "fast" selection and bail.
return false;
}
// Get opcode and regclass of the output for the given load instruction.
unsigned Opc = 0;
const TargetRegisterClass *RC = NULL;
switch (VT.getSimpleVT()) {
default: return false;
case MVT::i8:
Opc = X86::MOV8mr;
RC = X86::GR8RegisterClass;
break;
case MVT::i16:
Opc = X86::MOV16mr;
RC = X86::GR16RegisterClass;
break;
case MVT::i32:
Opc = X86::MOV32mr;
RC = X86::GR32RegisterClass;
break;
case MVT::i64:
// Must be in x86-64 mode.
Opc = X86::MOV64mr;
RC = X86::GR64RegisterClass;
break;
case MVT::f32:
if (Subtarget->hasSSE1()) {
Opc = X86::MOVSSmr;
RC = X86::FR32RegisterClass;
} else {
Opc = X86::ST_Fp32m;
RC = X86::RFP32RegisterClass;
}
break;
case MVT::f64:
if (Subtarget->hasSSE2()) {
Opc = X86::MOVSDmr;
RC = X86::FR64RegisterClass;
} else {
Opc = X86::ST_Fp64m;
RC = X86::RFP64RegisterClass;
}
break;
case MVT::f80:
Opc = X86::ST_FP80m;
RC = X86::RFP80RegisterClass;
break;
}
X86AddressMode AM;
if (Op1)
// Address is in register.
AM.Base.Reg = Op1;
else
AM.GV = cast<GlobalValue>(V);
addFullAddress(BuildMI(MBB, TII.get(Opc)), AM).addReg(Op0);
return true;
}
/// X86SelectLoad - Select and emit code to implement load instructions.
///
bool X86FastISel::X86SelectLoad(Instruction *I) {
MVT VT = MVT::getMVT(I->getType(), /*HandleUnknown=*/true);
if (VT == MVT::Other || !VT.isSimple())
// Unhandled type. Halt "fast" selection and bail.
return false;
if (VT == MVT::iPTR)
// Use pointer type.
VT = TLI.getPointerTy();
// We only handle legal types. For example, on x86-32 the instruction
// selector contains all of the 64-bit instructions from x86-64,
// under the assumption that i64 won't be used if the target doesn't
// support it.
if (!TLI.isTypeLegal(VT))
return false;
Value *V = I->getOperand(0);
unsigned Op0 = getRegForValue(V);
if (Op0 == 0) {
// Handle constant load address.
if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op0))
// Unhandled operand. Halt "fast" selection and bail.
return false;
}
// Get opcode and regclass of the output for the given load instruction.
unsigned Opc = 0;
const TargetRegisterClass *RC = NULL;
switch (VT.getSimpleVT()) {
default: return false;
case MVT::i8:
Opc = X86::MOV8rm;
RC = X86::GR8RegisterClass;
break;
case MVT::i16:
Opc = X86::MOV16rm;
RC = X86::GR16RegisterClass;
break;
case MVT::i32:
Opc = X86::MOV32rm;
RC = X86::GR32RegisterClass;
break;
case MVT::i64:
// Must be in x86-64 mode.
Opc = X86::MOV64rm;
RC = X86::GR64RegisterClass;
break;
case MVT::f32:
if (Subtarget->hasSSE1()) {
Opc = X86::MOVSSrm;
RC = X86::FR32RegisterClass;
} else {
Opc = X86::LD_Fp32m;
RC = X86::RFP32RegisterClass;
}
break;
case MVT::f64:
if (Subtarget->hasSSE2()) {
Opc = X86::MOVSDrm;
RC = X86::FR64RegisterClass;
} else {
Opc = X86::LD_Fp64m;
RC = X86::RFP64RegisterClass;
}
break;
case MVT::f80:
Opc = X86::LD_Fp80m;
RC = X86::RFP80RegisterClass;
break;
}
unsigned ResultReg = createResultReg(RC);
X86AddressMode AM;
if (Op0)
// Address is in register.
AM.Base.Reg = Op0;
else
AM.GV = cast<GlobalValue>(V);
addFullAddress(BuildMI(MBB, TII.get(Opc), ResultReg), AM);
UpdateValueMap(I, ResultReg);
return true;
}
bool X86FastISel::X86SelectCmp(Instruction *I) {
CmpInst *CI = cast<CmpInst>(I);
unsigned Op0Reg = getRegForValue(CI->getOperand(0));
unsigned Op1Reg = getRegForValue(CI->getOperand(1));
unsigned Opc;
switch (TLI.getValueType(I->getOperand(0)->getType()).getSimpleVT()) {
case MVT::i8: Opc = X86::CMP8rr; break;
case MVT::i16: Opc = X86::CMP16rr; break;
case MVT::i32: Opc = X86::CMP32rr; break;
case MVT::i64: Opc = X86::CMP64rr; break;
case MVT::f32: Opc = X86::UCOMISSrr; break;
case MVT::f64: Opc = X86::UCOMISDrr; break;
default: return false;
}
unsigned ResultReg = createResultReg(&X86::GR8RegClass);
switch (CI->getPredicate()) {
case CmpInst::FCMP_OEQ: {
unsigned EReg = createResultReg(&X86::GR8RegClass);
unsigned NPReg = createResultReg(&X86::GR8RegClass);
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETEr), EReg);
BuildMI(MBB, TII.get(X86::SETNPr), NPReg);
BuildMI(MBB, TII.get(X86::AND8rr), ResultReg).addReg(NPReg).addReg(EReg);
break;
}
case CmpInst::FCMP_UNE: {
unsigned NEReg = createResultReg(&X86::GR8RegClass);
unsigned PReg = createResultReg(&X86::GR8RegClass);
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETNEr), NEReg);
BuildMI(MBB, TII.get(X86::SETPr), PReg);
BuildMI(MBB, TII.get(X86::OR8rr), ResultReg).addReg(PReg).addReg(NEReg);
break;
}
case CmpInst::FCMP_OGT:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETAr), ResultReg);
break;
case CmpInst::FCMP_OGE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETAEr), ResultReg);
break;
case CmpInst::FCMP_OLT:
BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
BuildMI(MBB, TII.get(X86::SETAr), ResultReg);
break;
case CmpInst::FCMP_OLE:
BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
BuildMI(MBB, TII.get(X86::SETAEr), ResultReg);
break;
case CmpInst::FCMP_ONE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETNEr), ResultReg);
break;
case CmpInst::FCMP_ORD:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETNPr), ResultReg);
break;
case CmpInst::FCMP_UNO:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETPr), ResultReg);
break;
case CmpInst::FCMP_UEQ:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETEr), ResultReg);
break;
case CmpInst::FCMP_UGT:
BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
BuildMI(MBB, TII.get(X86::SETBr), ResultReg);
break;
case CmpInst::FCMP_UGE:
BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
BuildMI(MBB, TII.get(X86::SETBEr), ResultReg);
break;
case CmpInst::FCMP_ULT:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETBr), ResultReg);
break;
case CmpInst::FCMP_ULE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETBEr), ResultReg);
break;
case CmpInst::ICMP_EQ:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETEr), ResultReg);
break;
case CmpInst::ICMP_NE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETNEr), ResultReg);
break;
case CmpInst::ICMP_UGT:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETAr), ResultReg);
break;
case CmpInst::ICMP_UGE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETAEr), ResultReg);
break;
case CmpInst::ICMP_ULT:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETBr), ResultReg);
break;
case CmpInst::ICMP_ULE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETBEr), ResultReg);
break;
case CmpInst::ICMP_SGT:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETGr), ResultReg);
break;
case CmpInst::ICMP_SGE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETGEr), ResultReg);
break;
case CmpInst::ICMP_SLT:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETLr), ResultReg);
break;
case CmpInst::ICMP_SLE:
BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
BuildMI(MBB, TII.get(X86::SETLEr), ResultReg);
break;
default:
return false;
}
UpdateValueMap(I, ResultReg);
return true;
}
bool
X86FastISel::TargetSelectInstruction(Instruction *I) {
switch (I->getOpcode()) {
default: break;
case Instruction::Load:
return X86SelectLoad(I);
case Instruction::Store:
return X86SelectStore(I);
case Instruction::ICmp:
case Instruction::FCmp:
return X86SelectCmp(I);
}
return false;
}
namespace llvm {
llvm::FastISel *X86::createFastISel(MachineFunction &mf,
DenseMap<const Value *, unsigned> &vm,
DenseMap<const BasicBlock *, MachineBasicBlock *> &bm) {
return new X86FastISel(mf, vm, bm);
}
}
<|endoftext|> |
<commit_before>// =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Alessandro Tasora
// =============================================================================
//
// FEA for 3D beams
//
// =============================================================================
#include "chrono/physics/ChSystemSMC.h"
#include "chrono/physics/ChLinkMate.h"
#include "chrono/physics/ChBodyEasy.h"
#include "chrono/physics/ChLinkMotorRotationSpeed.h"
#include "chrono/timestepper/ChTimestepper.h"
#include "chrono/utils/ChUtilsCreators.h"
#include "chrono/collision/ChCollisionSystemBullet.h"
#include "chrono/fea/ChElementBeamEuler.h"
#include "chrono/fea/ChBuilderBeam.h"
#include "chrono/fea/ChMesh.h"
#include "chrono/fea/ChVisualizationFEAmesh.h"
#include "chrono/fea/ChLinkPointFrame.h"
#include "chrono/fea/ChLinkDirFrame.h"
#include "chrono/fea/ChContactSurfaceMesh.h"
#include "chrono/fea/ChContactSurfaceNodeCloud.h"
#include "chrono_irrlicht/ChIrrApp.h"
#include "chrono_mkl/ChSolverMKL.h"
using namespace chrono;
using namespace chrono::fea;
using namespace chrono::irrlicht;
using namespace irr;
// A helper function that creates a'lobed gear', almost a macro user in main()
// to quickly create one or two rotating obstacles for the extruding beam
std::shared_ptr<ChBody> CreateLobedGear (
ChVector<> gear_center,
int lobe_copies,
double lobe_width,
double lobe_primitive_rad,
double lobe_inner_rad,
double lobe_outer_rad,
double lobe_thickness,
ChSystem& my_system,
std::shared_ptr<ChMaterialSurface> mysurfmaterial
) {
auto mgear = chrono_types::make_shared<ChBody>();
mgear->SetPos(gear_center);
my_system.Add(mgear);
// add cylindrical lobes
mgear->GetCollisionModel()->ClearModel();
for (int i = 0; i< lobe_copies; ++i) {
double phase = CH_C_2PI * ((double)i/(double)lobe_copies);
// this is a quick shortcut from ChUtilsCreators.h,
// it both adds the collision shape and the visualization asset:
utils::AddCylinderGeometry(
mgear.get(), mysurfmaterial, //
lobe_width * 0.5, lobe_thickness * 0.5, //
ChVector<>(lobe_primitive_rad * sin(phase), lobe_primitive_rad * cos(phase), 0), //
Q_from_AngAxis(CH_C_PI_2, VECT_X), // rotate cylinder axis: from default on Y axis, to Z axis
true);
////utils::AddBoxGeometry(
//// mgear.get(), mysurfmaterial,
//// ChVector<>(lobe_width, lobe_outer_rad - lobe_inner_rad, lobe_thickness) * 0.5,
//// ChVector<>(0.5 * (lobe_outer_rad + lobe_inner_rad) * sin(phase),
//// 0.5 * (lobe_outer_rad + lobe_inner_rad) * cos(phase), 0),
//// Q_from_AngAxis(-phase, VECT_Z), // rotate cylinder axis: from default on Y axis, to Z axis
//// true);
}
utils::AddCylinderGeometry(mgear.get(), mysurfmaterial, lobe_inner_rad, lobe_thickness * 0.5, ChVector<>(0, 0, 0),
Q_from_AngAxis(CH_C_PI_2, VECT_X), true);
mgear->GetCollisionModel()->BuildModel();
mgear->SetCollide(true);
return mgear;
}
int main(int argc, char* argv[]) {
GetLog() << "Copyright (c) 2017 projectchrono.org\nChrono version: " << CHRONO_VERSION << "\n\n";
// Create a Chrono::Engine physical system
ChSystemSMC my_system;
// Here set the inward-outward margins for collision shapes: should make sense in the scale of the model
collision::ChCollisionModel::SetDefaultSuggestedEnvelope(0.001);
collision::ChCollisionModel::SetDefaultSuggestedMargin(0.002);
collision::ChCollisionSystemBullet::SetContactBreakingThreshold(0.0001);
// Create a ground object, useful reference for connecting constraints etc.
auto mground = chrono_types::make_shared<ChBody>();
mground->SetBodyFixed(true);
my_system.Add(mground);
// Create a mesh, that is a container for groups
// of elements and their referenced nodes.
auto my_mesh = chrono_types::make_shared<ChMesh>();
my_system.Add(my_mesh);
// Create a section, i.e. thickness and material properties
// for beams. This will be shared among some beams.
double wire_diameter = 0.010;
auto minertia = chrono_types::make_shared<ChInertiaCosseratSimple>();
minertia->SetAsCircularSection(wire_diameter, 2700); // automatically sets A etc., from width, height, density
auto melasticity = chrono_types::make_shared<ChElasticityCosseratSimple>();
melasticity->SetYoungModulus(0.5e9);
melasticity->SetGshearModulus(0.5e9 * 0.7);
melasticity->SetAsCircularSection(wire_diameter);
auto mdamping = chrono_types::make_shared<ChDampingCosseratLinear>();
mdamping->SetDampingCoefficientsRe((1e-3)*ChVector<>(1, 1, 1));
mdamping->SetDampingCoefficientsRk((1e-4)*ChVector<>(1, 1, 1)); //***??? -/+
auto mplasticity = chrono_types::make_shared<ChPlasticityCosseratLumped>();
mplasticity->n_yeld_Mx = chrono_types::make_shared<ChFunction_Ramp>(1, 0.01);
mplasticity->n_yeld_My = chrono_types::make_shared<ChFunction_Ramp>(0.2, 0.001);
mplasticity->n_yeld_Mz = chrono_types::make_shared<ChFunction_Ramp>(0.2, 0.001);
auto msection = chrono_types::make_shared<ChBeamSectionCosserat>(minertia, melasticity, mplasticity, mdamping);
msection->SetCircular(true);
msection->SetDrawCircularRadius(wire_diameter/2.);
// Create the surface material for the contacts; this contains information about friction etc.
// It is a SMC (penalty) material: interpenetration might happen for low Young stiffness,
// but unstable simulation might happen for high stiffness, requiring smaller timesteps.
/*
// option A: Hertz contact force model
my_system.SetContactForceModel(ChSystemSMC::ContactForceModel::Hertz);
auto mysurfmaterial = chrono_types::make_shared<ChMaterialSurfaceSMC>();
mysurfmaterial->SetYoungModulus(20e3); // to adjust heuristically..
mysurfmaterial->SetRestitution(0.1f);
mysurfmaterial->SetFriction(0.2f);
*/
// Option B: Hooke force model
my_system.SetContactForceModel(ChSystemSMC::ContactForceModel::Hooke);
my_system.UseMaterialProperties(false);
auto mysurfmaterial = chrono_types::make_shared<ChMaterialSurfaceSMC>();
mysurfmaterial->SetKn(350); // contact normal stiffness
mysurfmaterial->SetKt(350); // contact tangential stiffness
mysurfmaterial->SetGn(25); // contact normal damping
mysurfmaterial->SetGt(25); // contact tangential damping
mysurfmaterial->SetFriction(0.2f);
//
// Add the EXTRUDER
//
auto extruder = chrono_types::make_shared<ChExtruderBeamIGA>(
&my_system, // the physical system
my_mesh, // the mesh where to add the beams
msection, // section for created beam
0.015, // beam element length (size of discretization: the smaller, the more precise)
ChCoordsys<>(ChVector<>(0,0,0)), // outlet coordinate system (x axis is the extrusion dir)
0.08, // the extrusion speed
1 // the order of beams
);
// Enable collision for extruded beam
extruder->SetContact( mysurfmaterial, // the NSC material for contact surfaces
1.15*wire_diameter*0.5 // the radius of the collision spheres at the nodes, (enlarge 15%)
);
// Do we want gravity effect on FEA elements in this demo?
my_mesh->SetAutomaticGravity(false);
//
// Attach a visualization of the FEM mesh.
//
auto mvisualizebeamA = chrono_types::make_shared<ChVisualizationFEAmesh>(*(my_mesh.get()));
mvisualizebeamA->SetFEMdataType(ChVisualizationFEAmesh::E_PLOT_ELEM_BEAM_MZ);
mvisualizebeamA->SetColorscaleMinMax(-0.4, 0.4);
mvisualizebeamA->SetSmoothFaces(true);
mvisualizebeamA->SetWireframe(false);
my_mesh->AddAsset(mvisualizebeamA);
auto mvisualizebeamC = chrono_types::make_shared<ChVisualizationFEAmesh>(*(my_mesh.get()));
mvisualizebeamC->SetFEMglyphType(ChVisualizationFEAmesh::E_GLYPH_NODE_CSYS);
mvisualizebeamC->SetFEMdataType(ChVisualizationFEAmesh::E_PLOT_NONE);
mvisualizebeamC->SetSymbolsThickness(0.006);
mvisualizebeamC->SetSymbolsScale(0.01);
mvisualizebeamC->SetZbufferHide(false);
my_mesh->AddAsset(mvisualizebeamC);
//
// Add some obstacles. two rotating lobed gears.
//
// Here create two rotating lobed gears, just for fun, that wil trap the
// extruded beam. To quickly create them, use the CreateLobedGear() function
// implemented at the top of this file.
// Also, create two simple constant speed motors to rotate the lobed gears.
int lobe_copies = 8;
double lobe_width = 0.03;
double lobe_primitive_rad = 0.3;
double lobe_inner_rad = 0.13;
double lobe_outer_rad = 0.34;
double lobe_thickness = 0.08;
ChVector<> gear_centerLOW(0.3,-lobe_primitive_rad+0.01,0);
ChVector<> gear_centerHI (0.3, lobe_primitive_rad-0.01,0);
auto gearLOW = CreateLobedGear (gear_centerLOW, lobe_copies, lobe_width, lobe_primitive_rad,
lobe_inner_rad, lobe_outer_rad, lobe_thickness, my_system, mysurfmaterial);
auto mgear_motorLOW = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
mgear_motorLOW->Initialize(gearLOW, mground, ChFrame<>(gear_centerLOW));
my_system.Add(mgear_motorLOW);
auto mgear_speedLOW = chrono_types::make_shared<ChFunction_Const>(-0.2); // [rad/s]
mgear_motorLOW->SetSpeedFunction(mgear_speedLOW);
auto gearHI = CreateLobedGear (gear_centerHI, lobe_copies, lobe_width, lobe_primitive_rad,
lobe_inner_rad, lobe_outer_rad, lobe_thickness, my_system, mysurfmaterial);
gearHI->SetRot(Q_from_AngZ(0.5*CH_C_2PI/lobe_copies)); // to phase half step respect to other gear
auto mgear_motorHI = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
mgear_motorHI->Initialize(gearHI, mground, ChFrame<>(gear_centerHI));
my_system.Add(mgear_motorHI);
auto mgear_speedHI = chrono_types::make_shared<ChFunction_Const>( 0.2); // [rad/s]
mgear_motorHI->SetSpeedFunction(mgear_speedHI);
// Create the Irrlicht visualization (open the Irrlicht device,
// bind a simple user interface, etc. etc.)
ChIrrApp application(&my_system, L"Beam continuous extrusion and FEA contacts", core::dimension2d<u32>(800, 600),
false, true);
// Easy shortcuts to add camera, lights, logo and sky in Irrlicht scene:
application.AddTypicalLogo();
application.AddTypicalSky();
application.AddTypicalLights();
application.AddTypicalCamera(core::vector3df(-0.1f, 0.2f, -0.2f));
// ==IMPORTANT!== Use this function for adding a ChIrrNodeAsset to all items
// in the system. These ChIrrNodeAsset assets are 'proxies' to the Irrlicht meshes.
// If you need a finer control on which item really needs a visualization proxy in
// Irrlicht, just use application.AssetBind(myitem); on a per-item basis.
application.AssetBindAll();
// ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
// that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
application.AssetUpdateAll();
// SIMULATION LOOP
auto mkl_solver = chrono_types::make_shared<ChSolverMKL>();
mkl_solver->LockSparsityPattern(true);
my_system.SetSolver(mkl_solver);
application.SetTimestep(0.0002);
application.SetVideoframeSaveInterval(20);
while (application.GetDevice()->run()) {
application.BeginScene();
application.DrawAll();
ChIrrTools::drawGrid(application.GetVideoDriver(), 0.1, 0.1,20,20,CSYSNORM, irr::video::SColor(255,100,100,100),true);
application.DoStep();
bool modified = extruder->Update(); //***REMEMBER*** to do this to update the extrusion
if (modified) {
// A system change occurred: if using a sparse direct linear solver and if using the sparsity pattern
// learner (enabled by default), then we must force a re-evaluation of system matrix sparsity pattern!
mkl_solver->ForceSparsityPatternUpdate();
}
application.EndScene();
}
return 0;
}
<commit_msg>Adjust motor angular speed to prevent an ambiguous first contact<commit_after>// =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Alessandro Tasora
// =============================================================================
//
// FEA for 3D beams
//
// =============================================================================
#include "chrono/physics/ChSystemSMC.h"
#include "chrono/physics/ChLinkMate.h"
#include "chrono/physics/ChBodyEasy.h"
#include "chrono/physics/ChLinkMotorRotationSpeed.h"
#include "chrono/timestepper/ChTimestepper.h"
#include "chrono/utils/ChUtilsCreators.h"
#include "chrono/collision/ChCollisionSystemBullet.h"
#include "chrono/fea/ChElementBeamEuler.h"
#include "chrono/fea/ChBuilderBeam.h"
#include "chrono/fea/ChMesh.h"
#include "chrono/fea/ChVisualizationFEAmesh.h"
#include "chrono/fea/ChLinkPointFrame.h"
#include "chrono/fea/ChLinkDirFrame.h"
#include "chrono/fea/ChContactSurfaceMesh.h"
#include "chrono/fea/ChContactSurfaceNodeCloud.h"
#include "chrono_irrlicht/ChIrrApp.h"
#include "chrono_mkl/ChSolverMKL.h"
using namespace chrono;
using namespace chrono::fea;
using namespace chrono::irrlicht;
using namespace irr;
// A helper function that creates a'lobed gear', almost a macro user in main()
// to quickly create one or two rotating obstacles for the extruding beam
std::shared_ptr<ChBody> CreateLobedGear (
ChVector<> gear_center,
int lobe_copies,
double lobe_width,
double lobe_primitive_rad,
double lobe_inner_rad,
double lobe_outer_rad,
double lobe_thickness,
ChSystem& my_system,
std::shared_ptr<ChMaterialSurface> mysurfmaterial
) {
auto mgear = chrono_types::make_shared<ChBody>();
mgear->SetPos(gear_center);
my_system.Add(mgear);
// add cylindrical lobes
mgear->GetCollisionModel()->ClearModel();
for (int i = 0; i< lobe_copies; ++i) {
double phase = CH_C_2PI * ((double)i/(double)lobe_copies);
// this is a quick shortcut from ChUtilsCreators.h,
// it both adds the collision shape and the visualization asset:
utils::AddCylinderGeometry(
mgear.get(), mysurfmaterial, //
lobe_width * 0.5, lobe_thickness * 0.5, //
ChVector<>(lobe_primitive_rad * sin(phase), lobe_primitive_rad * cos(phase), 0), //
Q_from_AngAxis(CH_C_PI_2, VECT_X), // rotate cylinder axis: from default on Y axis, to Z axis
true);
////utils::AddBoxGeometry(
//// mgear.get(), mysurfmaterial,
//// ChVector<>(lobe_width, lobe_outer_rad - lobe_inner_rad, lobe_thickness) * 0.5,
//// ChVector<>(0.5 * (lobe_outer_rad + lobe_inner_rad) * sin(phase),
//// 0.5 * (lobe_outer_rad + lobe_inner_rad) * cos(phase), 0),
//// Q_from_AngAxis(-phase, VECT_Z), // rotate cylinder axis: from default on Y axis, to Z axis
//// true);
}
utils::AddCylinderGeometry(mgear.get(), mysurfmaterial, lobe_inner_rad, lobe_thickness * 0.5, ChVector<>(0, 0, 0),
Q_from_AngAxis(CH_C_PI_2, VECT_X), true);
mgear->GetCollisionModel()->BuildModel();
mgear->SetCollide(true);
return mgear;
}
int main(int argc, char* argv[]) {
GetLog() << "Copyright (c) 2017 projectchrono.org\nChrono version: " << CHRONO_VERSION << "\n\n";
// Create a Chrono::Engine physical system
ChSystemSMC my_system;
// Here set the inward-outward margins for collision shapes: should make sense in the scale of the model
collision::ChCollisionModel::SetDefaultSuggestedEnvelope(0.001);
collision::ChCollisionModel::SetDefaultSuggestedMargin(0.002);
collision::ChCollisionSystemBullet::SetContactBreakingThreshold(0.0001);
// Create a ground object, useful reference for connecting constraints etc.
auto mground = chrono_types::make_shared<ChBody>();
mground->SetBodyFixed(true);
my_system.Add(mground);
// Create a mesh, that is a container for groups
// of elements and their referenced nodes.
auto my_mesh = chrono_types::make_shared<ChMesh>();
my_system.Add(my_mesh);
// Create a section, i.e. thickness and material properties
// for beams. This will be shared among some beams.
double wire_diameter = 0.010;
auto minertia = chrono_types::make_shared<ChInertiaCosseratSimple>();
minertia->SetAsCircularSection(wire_diameter, 2700); // automatically sets A etc., from width, height, density
auto melasticity = chrono_types::make_shared<ChElasticityCosseratSimple>();
melasticity->SetYoungModulus(0.5e9);
melasticity->SetGshearModulus(0.5e9 * 0.7);
melasticity->SetAsCircularSection(wire_diameter);
auto mdamping = chrono_types::make_shared<ChDampingCosseratLinear>();
mdamping->SetDampingCoefficientsRe((1e-3)*ChVector<>(1, 1, 1));
mdamping->SetDampingCoefficientsRk((1e-4)*ChVector<>(1, 1, 1)); //***??? -/+
auto mplasticity = chrono_types::make_shared<ChPlasticityCosseratLumped>();
mplasticity->n_yeld_Mx = chrono_types::make_shared<ChFunction_Ramp>(1, 0.01);
mplasticity->n_yeld_My = chrono_types::make_shared<ChFunction_Ramp>(0.2, 0.001);
mplasticity->n_yeld_Mz = chrono_types::make_shared<ChFunction_Ramp>(0.2, 0.001);
auto msection = chrono_types::make_shared<ChBeamSectionCosserat>(minertia, melasticity, mplasticity, mdamping);
msection->SetCircular(true);
msection->SetDrawCircularRadius(wire_diameter/2.);
// Create the surface material for the contacts; this contains information about friction etc.
// It is a SMC (penalty) material: interpenetration might happen for low Young stiffness,
// but unstable simulation might happen for high stiffness, requiring smaller timesteps.
/*
// option A: Hertz contact force model
my_system.SetContactForceModel(ChSystemSMC::ContactForceModel::Hertz);
auto mysurfmaterial = chrono_types::make_shared<ChMaterialSurfaceSMC>();
mysurfmaterial->SetYoungModulus(20e3); // to adjust heuristically..
mysurfmaterial->SetRestitution(0.1f);
mysurfmaterial->SetFriction(0.2f);
*/
// Option B: Hooke force model
my_system.SetContactForceModel(ChSystemSMC::ContactForceModel::Hooke);
my_system.UseMaterialProperties(false);
auto mysurfmaterial = chrono_types::make_shared<ChMaterialSurfaceSMC>();
mysurfmaterial->SetKn(350); // contact normal stiffness
mysurfmaterial->SetKt(350); // contact tangential stiffness
mysurfmaterial->SetGn(25); // contact normal damping
mysurfmaterial->SetGt(25); // contact tangential damping
mysurfmaterial->SetFriction(0.2f);
//
// Add the EXTRUDER
//
auto extruder = chrono_types::make_shared<ChExtruderBeamIGA>(
&my_system, // the physical system
my_mesh, // the mesh where to add the beams
msection, // section for created beam
0.015, // beam element length (size of discretization: the smaller, the more precise)
ChCoordsys<>(ChVector<>(0,0,0)), // outlet coordinate system (x axis is the extrusion dir)
0.08, // the extrusion speed
1 // the order of beams
);
// Enable collision for extruded beam
extruder->SetContact( mysurfmaterial, // the NSC material for contact surfaces
1.15*wire_diameter*0.5 // the radius of the collision spheres at the nodes, (enlarge 15%)
);
// Do we want gravity effect on FEA elements in this demo?
my_mesh->SetAutomaticGravity(false);
//
// Attach a visualization of the FEM mesh.
//
auto mvisualizebeamA = chrono_types::make_shared<ChVisualizationFEAmesh>(*(my_mesh.get()));
mvisualizebeamA->SetFEMdataType(ChVisualizationFEAmesh::E_PLOT_ELEM_BEAM_MZ);
mvisualizebeamA->SetColorscaleMinMax(-0.4, 0.4);
mvisualizebeamA->SetSmoothFaces(true);
mvisualizebeamA->SetWireframe(false);
my_mesh->AddAsset(mvisualizebeamA);
auto mvisualizebeamC = chrono_types::make_shared<ChVisualizationFEAmesh>(*(my_mesh.get()));
mvisualizebeamC->SetFEMglyphType(ChVisualizationFEAmesh::E_GLYPH_NODE_CSYS);
mvisualizebeamC->SetFEMdataType(ChVisualizationFEAmesh::E_PLOT_NONE);
mvisualizebeamC->SetSymbolsThickness(0.006);
mvisualizebeamC->SetSymbolsScale(0.01);
mvisualizebeamC->SetZbufferHide(false);
my_mesh->AddAsset(mvisualizebeamC);
//
// Add some obstacles. two rotating lobed gears.
//
// Here create two rotating lobed gears, just for fun, that wil trap the
// extruded beam. To quickly create them, use the CreateLobedGear() function
// implemented at the top of this file.
// Also, create two simple constant speed motors to rotate the lobed gears.
int lobe_copies = 8;
double lobe_width = 0.03;
double lobe_primitive_rad = 0.3;
double lobe_inner_rad = 0.13;
double lobe_outer_rad = 0.34;
double lobe_thickness = 0.08;
ChVector<> gear_centerLOW(0.3,-lobe_primitive_rad+0.01,0);
ChVector<> gear_centerHI (0.3, lobe_primitive_rad-0.01,0);
auto gearLOW = CreateLobedGear (gear_centerLOW, lobe_copies, lobe_width, lobe_primitive_rad,
lobe_inner_rad, lobe_outer_rad, lobe_thickness, my_system, mysurfmaterial);
auto mgear_motorLOW = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
mgear_motorLOW->Initialize(gearLOW, mground, ChFrame<>(gear_centerLOW));
my_system.Add(mgear_motorLOW);
auto mgear_speedLOW = chrono_types::make_shared<ChFunction_Const>(-0.18); // [rad/s]
mgear_motorLOW->SetSpeedFunction(mgear_speedLOW);
auto gearHI = CreateLobedGear (gear_centerHI, lobe_copies, lobe_width, lobe_primitive_rad,
lobe_inner_rad, lobe_outer_rad, lobe_thickness, my_system, mysurfmaterial);
gearHI->SetRot(Q_from_AngZ(0.5*CH_C_2PI/lobe_copies)); // to phase half step respect to other gear
auto mgear_motorHI = chrono_types::make_shared<ChLinkMotorRotationSpeed>();
mgear_motorHI->Initialize(gearHI, mground, ChFrame<>(gear_centerHI));
my_system.Add(mgear_motorHI);
auto mgear_speedHI = chrono_types::make_shared<ChFunction_Const>( 0.18); // [rad/s]
mgear_motorHI->SetSpeedFunction(mgear_speedHI);
// Create the Irrlicht visualization (open the Irrlicht device,
// bind a simple user interface, etc. etc.)
ChIrrApp application(&my_system, L"Beam continuous extrusion and FEA contacts", core::dimension2d<u32>(800, 600),
false, true);
// Easy shortcuts to add camera, lights, logo and sky in Irrlicht scene:
application.AddTypicalLogo();
application.AddTypicalSky();
application.AddTypicalLights();
application.AddTypicalCamera(core::vector3df(-0.1f, 0.2f, -0.2f));
// ==IMPORTANT!== Use this function for adding a ChIrrNodeAsset to all items
// in the system. These ChIrrNodeAsset assets are 'proxies' to the Irrlicht meshes.
// If you need a finer control on which item really needs a visualization proxy in
// Irrlicht, just use application.AssetBind(myitem); on a per-item basis.
application.AssetBindAll();
// ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
// that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
application.AssetUpdateAll();
// SIMULATION LOOP
auto mkl_solver = chrono_types::make_shared<ChSolverMKL>();
mkl_solver->LockSparsityPattern(true);
my_system.SetSolver(mkl_solver);
application.SetTimestep(0.0002);
application.SetVideoframeSaveInterval(20);
while (application.GetDevice()->run()) {
application.BeginScene();
application.DrawAll();
ChIrrTools::drawGrid(application.GetVideoDriver(), 0.1, 0.1,20,20,CSYSNORM, irr::video::SColor(255,100,100,100),true);
application.DoStep();
bool modified = extruder->Update(); //***REMEMBER*** to do this to update the extrusion
if (modified) {
// A system change occurred: if using a sparse direct linear solver and if using the sparsity pattern
// learner (enabled by default), then we must force a re-evaluation of system matrix sparsity pattern!
mkl_solver->ForceSparsityPatternUpdate();
}
application.EndScene();
}
return 0;
}
<|endoftext|> |
<commit_before>/*
Copyright 2014 Sarah Wong
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 "../schemeinterface.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"
TEST(Scheme, HelloWorld)
{
schemeinterface::SchemeInterface si;
auto ptr = si.read_eval("\"hello world!\"");
ASSERT_TRUE(ptr.is_string());
EXPECT_EQ(std::string(ptr.string_value()),
std::string("hello world!"));
}
<commit_msg>parse error test<commit_after>/*
Copyright 2014 Sarah Wong
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 "../schemeinterface.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"
TEST(Scheme, HelloWorld)
{
schemeinterface::SchemeInterface si;
auto ptr = si.read_eval("\"hello world!\"");
ASSERT_TRUE(ptr.is_string());
EXPECT_EQ(std::string(ptr.string_value()),
std::string("hello world!"));
}
TEST(Scheme, ParseError)
{
schemeinterface::SchemeInterface si;
EXPECT_THROW(si.read_eval(")"), // syntax error
schemeinterface::SchemeReturnCodeException);
}
<|endoftext|> |
<commit_before><commit_msg>Fixed issues retrieving shader program link logs in ShaderUtils<commit_after><|endoftext|> |
<commit_before>//===- DCE.cpp - Code to perform dead code elimination --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the Aggressive Dead Code Elimination pass. This pass
// optimistically assumes that all instructions are dead until proven otherwise,
// allowing it to eliminate dead computations that other DCE passes do not
// catch, particularly involving loop computations.
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "adce"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/SmallPtrSet.h"
using namespace llvm;
STATISTIC(NumRemoved, "Number of instructions removed");
namespace {
struct VISIBILITY_HIDDEN ADCE : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
ADCE() : FunctionPass((intptr_t)&ID) {}
virtual bool runOnFunction(Function& F);
virtual void getAnalysisUsage(AnalysisUsage& AU) const {
AU.setPreservesCFG();
}
};
}
char ADCE::ID = 0;
static RegisterPass<ADCE> X("adce", "Aggressive Dead Code Elimination");
bool ADCE::runOnFunction(Function& F) {
SmallPtrSet<Instruction*, 32> alive;
std::vector<Instruction*> worklist;
// Collect the set of "root" instructions that are known live.
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
if (isa<TerminatorInst>(I.getInstructionIterator()) ||
I->mayWriteToMemory()) {
alive.insert(I.getInstructionIterator());
worklist.push_back(I.getInstructionIterator());
}
// Propagate liveness backwards to operands.
while (!worklist.empty()) {
Instruction* curr = worklist.back();
worklist.pop_back();
for (Instruction::op_iterator OI = curr->op_begin(), OE = curr->op_end();
OI != OE; ++OI)
if (Instruction* Inst = dyn_cast<Instruction>(OI))
if (alive.insert(Inst))
worklist.push_back(Inst);
}
// The inverse of the live set is the dead set. These are those instructions
// which have no side effects and do not influence the control flow or return
// value of the function, and may therefore be deleted safely.
SmallPtrSet<Instruction*, 32> dead;
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
if (!alive.count(I.getInstructionIterator())) {
dead.insert(I.getInstructionIterator());
I->dropAllReferences();
}
for (SmallPtrSet<Instruction*, 32>::iterator I = dead.begin(),
E = dead.end(); I != E; ++I) {
NumRemoved++;
(*I)->eraseFromParent();
}
return !dead.empty();
}
FunctionPass *llvm::createAggressiveDCEPass() {
return new ADCE();
}
<commit_msg>At Chris' suggestion, move the liveness and worklist datastructures into instance variables so they can be allocated just once, and reuse the worklist as the dead list as well.<commit_after>//===- DCE.cpp - Code to perform dead code elimination --------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the Aggressive Dead Code Elimination pass. This pass
// optimistically assumes that all instructions are dead until proven otherwise,
// allowing it to eliminate dead computations that other DCE passes do not
// catch, particularly involving loop computations.
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "adce"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
STATISTIC(NumRemoved, "Number of instructions removed");
namespace {
struct VISIBILITY_HIDDEN ADCE : public FunctionPass {
static char ID; // Pass identification, replacement for typeid
ADCE() : FunctionPass((intptr_t)&ID) {}
SmallPtrSet<Instruction*, 1024> alive;
SmallVector<Instruction*, 1024> worklist;
virtual bool runOnFunction(Function& F);
virtual void getAnalysisUsage(AnalysisUsage& AU) const {
AU.setPreservesCFG();
}
};
}
char ADCE::ID = 0;
static RegisterPass<ADCE> X("adce", "Aggressive Dead Code Elimination");
bool ADCE::runOnFunction(Function& F) {
alive.clear();
worklist.clear();
// Collect the set of "root" instructions that are known live.
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
if (isa<TerminatorInst>(I.getInstructionIterator()) ||
I->mayWriteToMemory()) {
alive.insert(I.getInstructionIterator());
worklist.push_back(I.getInstructionIterator());
}
// Propagate liveness backwards to operands.
while (!worklist.empty()) {
Instruction* curr = worklist.back();
worklist.pop_back();
for (Instruction::op_iterator OI = curr->op_begin(), OE = curr->op_end();
OI != OE; ++OI)
if (Instruction* Inst = dyn_cast<Instruction>(OI))
if (alive.insert(Inst))
worklist.push_back(Inst);
}
// The inverse of the live set is the dead set. These are those instructions
// which have no side effects and do not influence the control flow or return
// value of the function, and may therefore be deleted safely.
// NOTE: We reuse the worklist vector here for memory efficiency.
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
if (!alive.count(I.getInstructionIterator())) {
worklist.push_back(I.getInstructionIterator());
I->dropAllReferences();
}
for (SmallVector<Instruction*, 1024>::iterator I = worklist.begin(),
E = worklist.end(); I != E; ++I) {
NumRemoved++;
(*I)->eraseFromParent();
}
return !worklist.empty();
}
FunctionPass *llvm::createAggressiveDCEPass() {
return new ADCE();
}
<|endoftext|> |
<commit_before>#include "stdafx.h"
#include "SimplifyMesh.h"
#include "mesh/TriangleMeshCall.h"
#include "mmcore/param/FloatParam.h"
#include "mmcore/utility/DataHash.h"
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Point_3.h>
#include <CGAL/Segment_3.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h>
#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
#include <CGAL/Surface_mesh_simplification/edge_collapse.h>
#include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h>
#include <memory>
#include <vector>
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef K::Point_3 Point;
typedef K::Segment_3 Segment;
typedef CGAL::Surface_mesh<Point> Mesh;
typedef std::vector<std::size_t> CGAL_Polygon;
namespace PMP = CGAL::Polygon_mesh_processing;
namespace SMS = CGAL::Surface_mesh_simplification;
megamol::mesh::SimplifyMesh::SimplifyMesh()
: mesh_lhs_slot("mesh_lhs_slot", "Simplified mesh.")
, mesh_rhs_slot("mesh_rhs_slot", "Input surface mesh.")
, stop_ratio("stop_ratio", "Ratio defining the number of resulting faces compared to the original mesh.")
, input_hash(9868752) {
// Connect input slot
this->mesh_rhs_slot.SetCompatibleCall<mesh::TriangleMeshCall::triangle_mesh_description>();
this->MakeSlotAvailable(&this->mesh_rhs_slot);
// Connect output slots
this->mesh_lhs_slot.SetCallback(
mesh::TriangleMeshCall::ClassName(), "get_data", &SimplifyMesh::getMeshDataCallback);
this->mesh_lhs_slot.SetCallback(
mesh::TriangleMeshCall::ClassName(), "get_extent", &SimplifyMesh::getMeshMetaDataCallback);
this->MakeSlotAvailable(&this->mesh_lhs_slot);
// Initialize parameter slots
this->stop_ratio << new core::param::FloatParam(1.0f);
this->MakeSlotAvailable(&this->stop_ratio);
}
megamol::mesh::SimplifyMesh::~SimplifyMesh() {
this->Release();
}
bool megamol::mesh::SimplifyMesh::create() {
return true;
}
void megamol::mesh::SimplifyMesh::release() {}
bool megamol::mesh::SimplifyMesh::getMeshDataCallback(core::Call& _call) {
assert(dynamic_cast<mesh::TriangleMeshCall*>(&_call) != nullptr);
auto& call = static_cast<mesh::TriangleMeshCall&>(_call);
if (!compute()) {
return false;
}
call.set_vertices(this->output.vertices);
call.set_normals(this->output.normals);
call.set_indices(this->output.indices);
call.SetDataHash(this->input_hash);
return true;
}
bool megamol::mesh::SimplifyMesh::getMeshMetaDataCallback(core::Call& _call) {
assert(dynamic_cast<mesh::TriangleMeshCall*>(&_call) != nullptr);
auto& call = static_cast<mesh::TriangleMeshCall&>(_call);
// Get input extent
auto tmc_ptr = this->mesh_rhs_slot.CallAs<mesh::TriangleMeshCall>();
if (tmc_ptr == nullptr || !(*tmc_ptr)(1)) {
return false;
}
call.set_dimension(tmc_ptr->get_dimension());
call.set_bounding_box(tmc_ptr->get_bounding_box());
return true;
}
bool megamol::mesh::SimplifyMesh::compute() {
// Check input connection and get data
auto tmc_ptr = this->mesh_rhs_slot.CallAs<mesh::TriangleMeshCall>();
if (tmc_ptr == nullptr) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Triangle mesh input is not connected. [%s, %s, line %d]\n", __FILE__, __FUNCTION__, __LINE__);
return false;
}
auto& tmc = *tmc_ptr;
if (!tmc(0)) {
if (tmc.DataHash() != this->input_hash) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Error getting triangle mesh. [%s, %s, line %d]\n", __FILE__, __FUNCTION__, __LINE__);
this->input_hash = tmc.DataHash();
}
return false;
}
bool input_changed = false;
if (compute_hash(tmc.DataHash()) != this->input_hash) {
this->input.vertices = tmc.get_vertices();
this->input.normals = tmc.get_normals();
this->input.indices = tmc.get_indices();
this->input_hash = compute_hash(tmc.DataHash());
input_changed = true;
}
// Set empty output when encountering empty input
if (this->input.vertices == nullptr) {
this->output.vertices = nullptr;
this->output.normals = nullptr;
this->output.indices = nullptr;
input_changed = false;
return true;
}
// Perform computation
if (input_changed) {
this->output.vertices = std::make_shared<std::vector<float>>();
this->output.normals = std::make_shared<std::vector<float>>();
this->output.indices = std::make_shared<std::vector<unsigned int>>();
// Create surface mesh from input triangles and bounding box
Mesh mesh;
{
std::vector<Point> points;
std::vector<CGAL_Polygon> polygon_vec;
// Add input mesh to polygon soup
points.resize(this->input.vertices->size() / 3);
polygon_vec.resize(this->input.indices->size() / 3);
for (std::size_t i = 0; i < points.size(); ++i) {
points[i] = Point((*this->input.vertices)[i * 3 + 0], (*this->input.vertices)[i * 3 + 1],
(*this->input.vertices)[i * 3 + 2]);
}
for (std::size_t i = 0; i < polygon_vec.size(); ++i) {
polygon_vec[i] = {(*this->input.indices)[i * 3 + 0], (*this->input.indices)[i * 3 + 1],
(*this->input.indices)[i * 3 + 2]};
}
// Create CGAL surface mesh from polygon soup
{
PMP::remove_isolated_points_in_polygon_soup(points, polygon_vec);
PMP::merge_duplicate_points_in_polygon_soup(points, polygon_vec);
PMP::duplicate_non_manifold_edges_in_polygon_soup(points, polygon_vec);
if (!PMP::orient_polygon_soup(points, polygon_vec)) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Error orienting the triangles to form a surface mesh. [%s, %s, line %d]\n", __FILE__,
__FUNCTION__, __LINE__);
return false;
}
if (!PMP::is_polygon_soup_a_polygon_mesh(polygon_vec)) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Cannot form a surface mesh from the input triangles. [%s, %s, line %d]\n", __FILE__,
__FUNCTION__, __LINE__);
return false;
}
PMP::polygon_soup_to_polygon_mesh(points, polygon_vec, mesh);
}
}
// Simplify mesh
const auto stop_ratio = this->stop_ratio.Param<core::param::FloatParam>()->Value();
if (stop_ratio < 1.0f) {
SMS::Count_ratio_stop_predicate<Mesh> stop(stop_ratio);
SMS::edge_collapse(mesh, stop);
}
// Create output
for (auto point_it = mesh.points().begin(); point_it != mesh.points().end(); ++point_it) {
this->output.vertices->push_back(static_cast<float>(point_it->cartesian(0)));
this->output.vertices->push_back(static_cast<float>(point_it->cartesian(1)));
this->output.vertices->push_back(static_cast<float>(point_it->cartesian(2)));
}
for (auto face_it = mesh.faces_begin(); face_it != mesh.faces_end(); ++face_it) {
const auto range = mesh.vertices_around_face(mesh.halfedge(*face_it));
for (auto vert_it = range.begin(); vert_it != range.end(); ++vert_it) {
this->output.indices->push_back(vert_it->idx());
}
}
}
return true;
}
SIZE_T megamol::mesh::SimplifyMesh::compute_hash(const SIZE_T data_hash) const {
return core::utility::DataHash(data_hash, this->stop_ratio.Param<core::param::FloatParam>()->Value());
}
<commit_msg>Bug fix<commit_after>#include "stdafx.h"
#include "SimplifyMesh.h"
#include "mesh/TriangleMeshCall.h"
#include "mmcore/param/FloatParam.h"
#include "mmcore/utility/DataHash.h"
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Point_3.h>
#include <CGAL/Segment_3.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h>
#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
#include <CGAL/Surface_mesh_simplification/edge_collapse.h>
#include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h>
#include <memory>
#include <vector>
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef K::Point_3 Point;
typedef K::Segment_3 Segment;
typedef CGAL::Surface_mesh<Point> Mesh;
typedef std::vector<std::size_t> CGAL_Polygon;
namespace PMP = CGAL::Polygon_mesh_processing;
namespace SMS = CGAL::Surface_mesh_simplification;
megamol::mesh::SimplifyMesh::SimplifyMesh()
: mesh_lhs_slot("mesh_lhs_slot", "Simplified mesh.")
, mesh_rhs_slot("mesh_rhs_slot", "Input surface mesh.")
, stop_ratio("stop_ratio", "Ratio defining the number of resulting faces compared to the original mesh.")
, input_hash(9868752) {
// Connect input slot
this->mesh_rhs_slot.SetCompatibleCall<mesh::TriangleMeshCall::triangle_mesh_description>();
this->MakeSlotAvailable(&this->mesh_rhs_slot);
// Connect output slots
this->mesh_lhs_slot.SetCallback(
mesh::TriangleMeshCall::ClassName(), "get_data", &SimplifyMesh::getMeshDataCallback);
this->mesh_lhs_slot.SetCallback(
mesh::TriangleMeshCall::ClassName(), "get_extent", &SimplifyMesh::getMeshMetaDataCallback);
this->MakeSlotAvailable(&this->mesh_lhs_slot);
// Initialize parameter slots
this->stop_ratio << new core::param::FloatParam(1.0f);
this->MakeSlotAvailable(&this->stop_ratio);
}
megamol::mesh::SimplifyMesh::~SimplifyMesh() {
this->Release();
}
bool megamol::mesh::SimplifyMesh::create() {
return true;
}
void megamol::mesh::SimplifyMesh::release() {}
bool megamol::mesh::SimplifyMesh::getMeshDataCallback(core::Call& _call) {
assert(dynamic_cast<mesh::TriangleMeshCall*>(&_call) != nullptr);
auto& call = static_cast<mesh::TriangleMeshCall&>(_call);
if (!compute()) {
return false;
}
call.set_vertices(this->output.vertices);
call.set_normals(this->output.normals);
call.set_indices(this->output.indices);
call.SetDataHash(this->input_hash);
return true;
}
bool megamol::mesh::SimplifyMesh::getMeshMetaDataCallback(core::Call& _call) {
assert(dynamic_cast<mesh::TriangleMeshCall*>(&_call) != nullptr);
auto& call = static_cast<mesh::TriangleMeshCall&>(_call);
// Get input extent
auto tmc_ptr = this->mesh_rhs_slot.CallAs<mesh::TriangleMeshCall>();
if (tmc_ptr == nullptr || !(*tmc_ptr)(1)) {
return false;
}
call.set_dimension(tmc_ptr->get_dimension());
call.set_bounding_box(tmc_ptr->get_bounding_box());
return true;
}
bool megamol::mesh::SimplifyMesh::compute() {
// Check input connection and get data
auto tmc_ptr = this->mesh_rhs_slot.CallAs<mesh::TriangleMeshCall>();
if (tmc_ptr == nullptr) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Triangle mesh input is not connected. [%s, %s, line %d]\n", __FILE__, __FUNCTION__, __LINE__);
return false;
}
auto& tmc = *tmc_ptr;
if (!tmc(0)) {
if (tmc.DataHash() != this->input_hash) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Error getting triangle mesh. [%s, %s, line %d]\n", __FILE__, __FUNCTION__, __LINE__);
this->input_hash = tmc.DataHash();
}
return false;
}
bool input_changed = false;
if (compute_hash(tmc.DataHash()) != this->input_hash) {
this->input.vertices = tmc.get_vertices();
this->input.normals = tmc.get_normals();
this->input.indices = tmc.get_indices();
this->input_hash = compute_hash(tmc.DataHash());
input_changed = true;
}
// Set empty output when encountering empty input
if (this->input.vertices == nullptr) {
this->output.vertices = nullptr;
this->output.normals = nullptr;
this->output.indices = nullptr;
input_changed = false;
return true;
}
// Perform computation
if (input_changed) {
this->output.vertices = std::make_shared<std::vector<float>>();
this->output.normals = std::make_shared<std::vector<float>>();
this->output.indices = std::make_shared<std::vector<unsigned int>>();
// Create surface mesh from input triangles and bounding box
Mesh mesh;
{
std::vector<Point> points;
std::vector<CGAL_Polygon> polygon_vec;
// Add input mesh to polygon soup
points.resize(this->input.vertices->size() / 3);
polygon_vec.resize(this->input.indices->size() / 3);
for (std::size_t i = 0; i < points.size(); ++i) {
points[i] = Point((*this->input.vertices)[i * 3 + 0], (*this->input.vertices)[i * 3 + 1],
(*this->input.vertices)[i * 3 + 2]);
}
for (std::size_t i = 0; i < polygon_vec.size(); ++i) {
polygon_vec[i] = {(*this->input.indices)[i * 3 + 0], (*this->input.indices)[i * 3 + 1],
(*this->input.indices)[i * 3 + 2]};
}
// Create CGAL surface mesh from polygon soup
{
PMP::remove_isolated_points_in_polygon_soup(points, polygon_vec);
PMP::merge_duplicate_points_in_polygon_soup(points, polygon_vec);
PMP::duplicate_non_manifold_edges_in_polygon_soup(points, polygon_vec);
if (!PMP::orient_polygon_soup(points, polygon_vec)) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Error orienting the triangles to form a surface mesh. [%s, %s, line %d]\n", __FILE__,
__FUNCTION__, __LINE__);
return false;
}
if (!PMP::is_polygon_soup_a_polygon_mesh(polygon_vec)) {
megamol::core::utility::log::Log::DefaultLog.WriteError(
"Cannot form a surface mesh from the input triangles. [%s, %s, line %d]\n", __FILE__,
__FUNCTION__, __LINE__);
return false;
}
PMP::polygon_soup_to_polygon_mesh(points, polygon_vec, mesh);
}
}
// Simplify mesh
const auto stop_ratio = this->stop_ratio.Param<core::param::FloatParam>()->Value();
if (stop_ratio < 1.0f) {
SMS::Count_ratio_stop_predicate<Mesh> stop(stop_ratio);
SMS::edge_collapse(mesh, stop);
}
// Create output
for (auto point_it = mesh.points().begin(); point_it != mesh.points().end(); ++point_it) {
this->output.vertices->push_back(static_cast<float>(point_it->cartesian(0)));
this->output.vertices->push_back(static_cast<float>(point_it->cartesian(1)));
this->output.vertices->push_back(static_cast<float>(point_it->cartesian(2)));
}
for (auto face_it = mesh.faces_begin(); face_it != mesh.faces_end(); ++face_it) {
const auto range = mesh.vertices_around_face(mesh.halfedge(*face_it));
for (auto vert_it = range.begin(); vert_it != range.end(); ++vert_it) {
this->output.indices->push_back(vert_it->idx());
}
}
this->output.normals = nullptr;
}
return true;
}
SIZE_T megamol::mesh::SimplifyMesh::compute_hash(const SIZE_T data_hash) const {
return core::utility::DataHash(data_hash, this->stop_ratio.Param<core::param::FloatParam>()->Value());
}
<|endoftext|> |
<commit_before>/*
* @file soundcloud_widget.cc
* @author Arthur Fait
* @date 31.08.15
*
*/
#include "soundcloud_widget.h"
#include <stdlib.h>
extern "C" {
#include <audacious/i18n.h>
#include <audacious/misc.h>
#include <audacious/playlist.h>
#include <audacious/plugin.h>
#include <libaudcore/audstrings.h>
#include <libaudcore/hook.h>
#include <libaudgui/list.h>
#include <libaudgui/menu.h>
}
static void entry_cb (GtkEntry *entry, void *data)
{
(void)entry;
SoundCloudWidget* that = reinterpret_cast<SoundCloudWidget*>(data);
if (that)
that->OnEntryChanged();
}
static gboolean connect_timeoutCB(gpointer data)
{
SoundCloudWidget* that = reinterpret_cast<SoundCloudWidget*>(data);
if (that)
that->OnConnect();
return FALSE;
}
static void page_nextButtonCB(GtkWidget *widget, gpointer data)
{
SoundCloudWidget* that = reinterpret_cast<SoundCloudWidget*>(data);
if (that)
that->nextPage();
}
static void activate_cb (GtkTreeView * tree,
GtkTreePath * path,
GtkTreeViewColumn * col, SoundCloudWidget * that) {
int row = gtk_tree_path_get_indices (path)[0];
// std::cout << "clicked: " << row << "\n";
that->OnActivate(row);
}
void SoundCloudWidget::OnEntryChanged()
{
const char* searchCString = gtk_entry_get_text ((GtkEntry*)entry);
if (searchCString && strlen(searchCString)) {
if (m_searchTimer) {
g_source_remove(m_searchTimer);
}
m_searchString.assign(searchCString);
m_searchTimer = g_timeout_add(500, connect_timeoutCB, this);
}
}
void SoundCloudWidget::OnActivate(int index)
{
auto url = m_client.resolveTrackStream(m_currentTrackList[index]);
// std::cout << "url: " << url << "\n";
// std::cout << "num: " << aud_playlist_get_active() << "\n";
Index * filenames = index_new ();
Index * tuples = index_new ();
// for (int m = 0; m < item->matches->len; m ++) {
index_insert (filenames, -1, str_to_utf8(url.c_str(), url.size()));
Tuple* tup = tuple_new();
char *artist = str_to_utf8(m_currentTrackList[index].c_userName(), m_currentTrackList[index].user().username().size());
tuple_set_str(tup, FIELD_ARTIST, artist);
str_unref(artist);
char *title = str_to_utf8(m_currentTrackList[index].c_title(), m_currentTrackList[index].title().size());
tuple_set_str(tup, FIELD_TITLE, title);
str_unref(title);
char *genre = str_to_utf8(m_currentTrackList[index].c_genre(), m_currentTrackList[index].genre().size());
tuple_set_str(tup, FIELD_GENRE, genre);
str_unref(genre);
// tuple_set_str(tup, FIELD_COMMENT, str_to_utf8(m_currentTrackList[index].c_description(), m_currentTrackList[index].description().size()));
tuple_set_int(tup, FIELD_LENGTH, m_currentTrackList[index].duration());
index_insert (tuples, -1, tup);
// }
aud_playlist_entry_insert_batch (aud_playlist_get_active (), -1, filenames,
tuples, 1);
}
void SoundCloudWidget::fillPQList(const std::vector<soundcloud::Track>& tracks)
{
gtk_list_store_clear(playQueuestore);
GtkTreeIter iter;
m_currentTrackList = tracks;
for (auto &track: tracks) {
gtk_list_store_append (playQueuestore, &iter);
gtk_list_store_set (playQueuestore, &iter,
TITLE_COLUMN, track.title().c_str(),
ALBUM_COLUMN, track.genre().c_str(),
ARTIST_COLUMN, track.user().username().c_str(),
-1);
}
}
const std::string kClientID = "a5a98f5d549a83896d565f69eb644b65";
SoundCloudWidget::SoundCloudWidget()
: m_client(kClientID)
{
createContent();
}
void SoundCloudWidget::createContent()
{
// prevButton = gtk_button_new_with_label("prev");
// g_signal_connect(prevButton, "clicked", G_CALLBACK(prev_callback),(gpointer) this);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_placeholder_text ((GtkEntry *) entry, "Search SoundCloud");
gtk_entry_set_text((GtkEntry *) entry, m_searchString.c_str());
g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry);
g_signal_connect (entry, "changed", (GCallback) entry_cb, (gpointer)this);
// g_signal_connect (entry, "activate", (GCallback) action_play, (gpointer)this);
page_nextButton = gtk_button_new_with_label("show next 30 tracks");
g_signal_connect(page_nextButton, "clicked", G_CALLBACK(page_nextButtonCB),(gpointer) this);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box), 2);
// gtk_box_pack_start (GTK_BOX (box), connectButton, FALSE, FALSE, 3);
gtk_box_pack_start ((GtkBox *) box, entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), page_nextButton, FALSE, FALSE, 3);
// gtk_widget_show(connectButton);
gtk_widget_show(page_nextButton);
playQueuestore = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
pqTree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(playQueuestore));
// gtk_tree_view_set_fixed_height_mode ((GtkTreeView *) pqTree, true);
// gtk_tree_view_set_vadjustment((GtkTreeView*) pqTree, GTK_ADJUSTMENT(gtk_adjustment_new(0,0,100,1,10,100)));
pqTreeScrollWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pqTreeScrollWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Track",
renderer,
"text", TITLE_COLUMN,
nullptr);
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (pqTree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Genre",
renderer,
"text", ALBUM_COLUMN,
nullptr);
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (pqTree), column);
renderer = gtk_cell_renderer_text_new ();
// g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
column = gtk_tree_view_column_new_with_attributes ("Added by",
renderer,
"text", ARTIST_COLUMN,
nullptr);
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (pqTree), column);
g_signal_connect (pqTree, "row-activated", (GCallback) activate_cb, this);
gtk_container_add(GTK_CONTAINER(pqTreeScrollWindow), pqTree);
gtk_widget_show(pqTree);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), pqTreeScrollWindow, true, true, 3);
gtk_widget_show(box);
gtk_widget_show(pqTreeScrollWindow);
gtk_widget_show(vbox);
m_searchTimer = g_timeout_add(500, connect_timeoutCB, this);
}
void SoundCloudWidget::OnConnect()
{
m_searchTimer = 0;
std::vector<std::string> taglist = {};
std::vector<std::string> genres = {};
std::string query = "";
if (m_searchString[0] == '@') {
genres.push_back(m_searchString.substr(1));
} else if (m_searchString[0] == '#') {
taglist.push_back(m_searchString.substr(1));
} else {
query = m_searchString.substr(1);
}
m_currentRequest = m_client.getTracks(query, taglist, genres, 30);
auto tracks = m_currentRequest->next();
fillPQList(tracks);
}
void SoundCloudWidget::nextPage()
{
auto tracks = m_currentRequest->next();
fillPQList(tracks);
}
<commit_msg>fix #6 Disable autoplay on add track<commit_after>/*
* @file soundcloud_widget.cc
* @author Arthur Fait
* @date 31.08.15
*
*/
#include "soundcloud_widget.h"
#include <stdlib.h>
extern "C" {
#include <audacious/i18n.h>
#include <audacious/misc.h>
#include <audacious/playlist.h>
#include <audacious/plugin.h>
#include <libaudcore/audstrings.h>
#include <libaudcore/hook.h>
#include <libaudgui/list.h>
#include <libaudgui/menu.h>
}
static void entry_cb (GtkEntry *entry, void *data)
{
(void)entry;
SoundCloudWidget* that = reinterpret_cast<SoundCloudWidget*>(data);
if (that)
that->OnEntryChanged();
}
static gboolean connect_timeoutCB(gpointer data)
{
SoundCloudWidget* that = reinterpret_cast<SoundCloudWidget*>(data);
if (that)
that->OnConnect();
return FALSE;
}
static void page_nextButtonCB(GtkWidget *widget, gpointer data)
{
SoundCloudWidget* that = reinterpret_cast<SoundCloudWidget*>(data);
if (that)
that->nextPage();
}
static void activate_cb (GtkTreeView * tree,
GtkTreePath * path,
GtkTreeViewColumn * col, SoundCloudWidget * that) {
int row = gtk_tree_path_get_indices (path)[0];
// std::cout << "clicked: " << row << "\n";
that->OnActivate(row);
}
void SoundCloudWidget::OnEntryChanged()
{
const char* searchCString = gtk_entry_get_text ((GtkEntry*)entry);
if (searchCString && strlen(searchCString)) {
if (m_searchTimer) {
g_source_remove(m_searchTimer);
}
m_searchString.assign(searchCString);
m_searchTimer = g_timeout_add(500, connect_timeoutCB, this);
}
}
void SoundCloudWidget::OnActivate(int index)
{
auto url = m_client.resolveTrackStream(m_currentTrackList[index]);
// std::cout << "url: " << url << "\n";
// std::cout << "num: " << aud_playlist_get_active() << "\n";
Index * filenames = index_new ();
Index * tuples = index_new ();
// for (int m = 0; m < item->matches->len; m ++) {
index_insert (filenames, -1, str_to_utf8(url.c_str(), url.size()));
Tuple* tup = tuple_new();
char *artist = str_to_utf8(m_currentTrackList[index].c_userName(), m_currentTrackList[index].user().username().size());
tuple_set_str(tup, FIELD_ARTIST, artist);
str_unref(artist);
char *title = str_to_utf8(m_currentTrackList[index].c_title(), m_currentTrackList[index].title().size());
tuple_set_str(tup, FIELD_TITLE, title);
str_unref(title);
char *genre = str_to_utf8(m_currentTrackList[index].c_genre(), m_currentTrackList[index].genre().size());
tuple_set_str(tup, FIELD_GENRE, genre);
str_unref(genre);
// tuple_set_str(tup, FIELD_COMMENT, str_to_utf8(m_currentTrackList[index].c_description(), m_currentTrackList[index].description().size()));
tuple_set_int(tup, FIELD_LENGTH, m_currentTrackList[index].duration());
index_insert (tuples, -1, tup);
// }
aud_playlist_entry_insert_batch (aud_playlist_get_active (), -1, filenames,
tuples, 0);
}
void SoundCloudWidget::fillPQList(const std::vector<soundcloud::Track>& tracks)
{
gtk_list_store_clear(playQueuestore);
GtkTreeIter iter;
m_currentTrackList = tracks;
for (auto &track: tracks) {
gtk_list_store_append (playQueuestore, &iter);
gtk_list_store_set (playQueuestore, &iter,
TITLE_COLUMN, track.title().c_str(),
ALBUM_COLUMN, track.genre().c_str(),
ARTIST_COLUMN, track.user().username().c_str(),
-1);
}
}
const std::string kClientID = "a5a98f5d549a83896d565f69eb644b65";
SoundCloudWidget::SoundCloudWidget()
: m_client(kClientID)
{
createContent();
}
void SoundCloudWidget::createContent()
{
// prevButton = gtk_button_new_with_label("prev");
// g_signal_connect(prevButton, "clicked", G_CALLBACK(prev_callback),(gpointer) this);
entry = gtk_entry_new ();
gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_placeholder_text ((GtkEntry *) entry, "Search SoundCloud");
gtk_entry_set_text((GtkEntry *) entry, m_searchString.c_str());
g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry);
g_signal_connect (entry, "changed", (GCallback) entry_cb, (gpointer)this);
// g_signal_connect (entry, "activate", (GCallback) action_play, (gpointer)this);
page_nextButton = gtk_button_new_with_label("show next 30 tracks");
g_signal_connect(page_nextButton, "clicked", G_CALLBACK(page_nextButtonCB),(gpointer) this);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (box), 2);
// gtk_box_pack_start (GTK_BOX (box), connectButton, FALSE, FALSE, 3);
gtk_box_pack_start ((GtkBox *) box, entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), page_nextButton, FALSE, FALSE, 3);
// gtk_widget_show(connectButton);
gtk_widget_show(page_nextButton);
playQueuestore = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
pqTree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(playQueuestore));
// gtk_tree_view_set_fixed_height_mode ((GtkTreeView *) pqTree, true);
// gtk_tree_view_set_vadjustment((GtkTreeView*) pqTree, GTK_ADJUSTMENT(gtk_adjustment_new(0,0,100,1,10,100)));
pqTreeScrollWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pqTreeScrollWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Track",
renderer,
"text", TITLE_COLUMN,
nullptr);
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (pqTree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Genre",
renderer,
"text", ALBUM_COLUMN,
nullptr);
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (pqTree), column);
renderer = gtk_cell_renderer_text_new ();
// g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
column = gtk_tree_view_column_new_with_attributes ("Added by",
renderer,
"text", ARTIST_COLUMN,
nullptr);
gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (pqTree), column);
g_signal_connect (pqTree, "row-activated", (GCallback) activate_cb, this);
gtk_container_add(GTK_CONTAINER(pqTreeScrollWindow), pqTree);
gtk_widget_show(pqTree);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), pqTreeScrollWindow, true, true, 3);
gtk_widget_show(box);
gtk_widget_show(pqTreeScrollWindow);
gtk_widget_show(vbox);
m_searchTimer = g_timeout_add(500, connect_timeoutCB, this);
}
void SoundCloudWidget::OnConnect()
{
m_searchTimer = 0;
std::vector<std::string> taglist = {};
std::vector<std::string> genres = {};
std::string query = "";
if (m_searchString[0] == '@') {
genres.push_back(m_searchString.substr(1));
} else if (m_searchString[0] == '#') {
taglist.push_back(m_searchString.substr(1));
} else {
query = m_searchString.substr(1);
}
m_currentRequest = m_client.getTracks(query, taglist, genres, 30);
auto tracks = m_currentRequest->next();
fillPQList(tracks);
}
void SoundCloudWidget::nextPage()
{
auto tracks = m_currentRequest->next();
fillPQList(tracks);
}
<|endoftext|> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.