text
stringlengths 54
60.6k
|
|---|
<commit_before>/*************************************************************************/
/* bone_attachment.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "bone_attachment.h"
bool BoneAttachment::_get(const StringName& p_name,Variant &r_ret) const {
if (String(p_name)=="bone_name") {
r_ret=get_bone_name();
return true;
}
return false;
}
bool BoneAttachment::_set(const StringName& p_name, const Variant& p_value){
if (String(p_name)=="bone_name") {
set_bone_name(p_value);
return true;
}
return false;
}
void BoneAttachment::_get_property_list( List<PropertyInfo>* p_list ) const{
Skeleton *parent=NULL;
if(get_parent())
parent=get_parent()->cast_to<Skeleton>();
if (parent) {
String names;
for(int i=0;i<parent->get_bone_count();i++) {
if(i>0)
names+=",";
names+=parent->get_bone_name(i);
}
p_list->push_back(PropertyInfo(Variant::STRING,"bone_name",PROPERTY_HINT_ENUM,names));
} else {
p_list->push_back(PropertyInfo(Variant::STRING,"bone_name"));
}
}
void BoneAttachment::_check_bind() {
if (get_parent() && get_parent()->cast_to<Skeleton>()) {
Skeleton *sk = get_parent()->cast_to<Skeleton>();
int idx = sk->find_bone(bone_name);
if (idx!=-1) {
sk->bind_child_node_to_bone(idx,this);;
bound=true;
}
}
}
void BoneAttachment::_check_unbind() {
if (bound) {
if (get_parent() && get_parent()->cast_to<Skeleton>()) {
Skeleton *sk = get_parent()->cast_to<Skeleton>();
int idx = sk->find_bone(bone_name);
if (idx!=-1) {
sk->unbind_child_node_from_bone(idx,this);;
}
}
bound=false;
}
}
void BoneAttachment::set_bone_name(const String& p_name) {
if (is_inside_tree())
_check_unbind();
bone_name=p_name;
if (is_inside_tree())
_check_bind();
}
String BoneAttachment::get_bone_name() const{
return bone_name;
}
void BoneAttachment::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_ENTER_TREE: {
_check_bind();
} break;
case NOTIFICATION_EXIT_TREE: {
_check_unbind();
} break;
}
}
BoneAttachment::BoneAttachment()
{
bound=false;
}
<commit_msg>BoneAttachments now position themselves instantly during bind.<commit_after>/*************************************************************************/
/* bone_attachment.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "bone_attachment.h"
bool BoneAttachment::_get(const StringName& p_name,Variant &r_ret) const {
if (String(p_name)=="bone_name") {
r_ret=get_bone_name();
return true;
}
return false;
}
bool BoneAttachment::_set(const StringName& p_name, const Variant& p_value){
if (String(p_name)=="bone_name") {
set_bone_name(p_value);
return true;
}
return false;
}
void BoneAttachment::_get_property_list( List<PropertyInfo>* p_list ) const{
Skeleton *parent=NULL;
if(get_parent())
parent=get_parent()->cast_to<Skeleton>();
if (parent) {
String names;
for(int i=0;i<parent->get_bone_count();i++) {
if(i>0)
names+=",";
names+=parent->get_bone_name(i);
}
p_list->push_back(PropertyInfo(Variant::STRING,"bone_name",PROPERTY_HINT_ENUM,names));
} else {
p_list->push_back(PropertyInfo(Variant::STRING,"bone_name"));
}
}
void BoneAttachment::_check_bind() {
if (get_parent() && get_parent()->cast_to<Skeleton>()) {
Skeleton *sk = get_parent()->cast_to<Skeleton>();
int idx = sk->find_bone(bone_name);
if (idx!=-1) {
sk->bind_child_node_to_bone(idx,this);;
set_transform(sk->get_bone_global_pose(idx));
bound=true;
}
}
}
void BoneAttachment::_check_unbind() {
if (bound) {
if (get_parent() && get_parent()->cast_to<Skeleton>()) {
Skeleton *sk = get_parent()->cast_to<Skeleton>();
int idx = sk->find_bone(bone_name);
if (idx!=-1) {
sk->unbind_child_node_from_bone(idx,this);;
}
}
bound=false;
}
}
void BoneAttachment::set_bone_name(const String& p_name) {
if (is_inside_tree())
_check_unbind();
bone_name=p_name;
if (is_inside_tree())
_check_bind();
}
String BoneAttachment::get_bone_name() const{
return bone_name;
}
void BoneAttachment::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_ENTER_TREE: {
_check_bind();
} break;
case NOTIFICATION_EXIT_TREE: {
_check_unbind();
} break;
}
}
BoneAttachment::BoneAttachment()
{
bound=false;
}
<|endoftext|> |
<commit_before>// RUN: cat %s | %cling | FileCheck %s
// The test verifies the expected behavior in cling::utils::Transform class,
// which is supposed to provide different transformation of AST nodes and types.
#include "cling/Interpreter/Interpreter.h"
#include "cling/Interpreter/LookupHelper.h"
#include "cling/Utils/AST.h"
#include "clang/AST/Type.h"
#include "llvm/ADT/SmallSet.h"
#include "clang/Sema/Sema.h"
.rawInput 1
typedef double Double32_t;
typedef int Int_t;
typedef long Long_t;
typedef Int_t* IntPtr_t;
template <typename T> class A {};
template <typename T, typename U> class B {};
template <typename T, typename U> class C {};
typedef C<A<B<Double32_t, Int_t> >, Double32_t > CTD;
typedef C<A<B<const Double32_t, const Int_t> >, Double32_t > CTDConst;
#include <string>
namespace Details {
class Impl {};
}
namespace NS {
template <typename T, int size = 0> class ArrayType {};
template <typename T> class Array {};
template <typename T> class Container {
public:
class Content {};
typedef T Value_t;
typedef Content Content_t;
typedef ::Details::Impl Impl_t;
};
template <typename T> class TDataPoint {};
typedef TDataPoint<float> TDataPointF;
typedef TDataPoint<Double32_t> TDataPointD32;
}
.rawInput 0
const cling::LookupHelper& lookup = gCling->getLookupHelper();
const clang::ASTContext& Ctx = gCling->getSema().getASTContext();
llvm::SmallSet<const clang::Type*, 4> skip;
skip.insert(lookup.findType("Double32_t").getTypePtr());
const clang::Type* t = 0;
clang::QualType QT;
using namespace cling::utils;
// Test desugaring pointers types:
QT = lookup.findType("Int_t*");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int *"
QT = lookup.findType("const IntPtr_t*");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int *const *"
// Test desugaring reference (both r- or l- value) types:
QT = lookup.findType("const IntPtr_t&");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int *const &"
//TODO: QT = lookup.findType("IntPtr_t[32]");
//Desugar template parameters:
lookup.findScope("A<B<Double32_t, Int_t*> >", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "A<B<Double32_t, int *> >"
lookup.findScope("CTD", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "C<A<B<Double32_t, int> >, Double32_t>"
lookup.findScope("CTDConst", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "C<A<B<const Double32_t, const int> >, Double32_t>"
lookup.findScope("std::pair<const std::string,int>", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "std::pair<const std::string, int>"
lookup.findScope("NS::Array<NS::ArrayType<double> >", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Array<NS::ArrayType<double> >"
lookup.findScope("NS::Array<NS::ArrayType<Double32_t> >", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Array<NS::ArrayType<Double32_t> >"
lookup.findScope("NS::Container<Long_t>::Content", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<long>::Content"
QT = lookup.findType("NS::Container<Long_t>::Value_t");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "long"
lookup.findScope("NS::Container<Long_t>::Content_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<long>::Content"
lookup.findScope("NS::Container<Long_t>::Impl_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "::Details::Impl"
// Note it should probably return "Details::Impl"
lookup.findScope("NS::Container<Double32_t>::Content", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<Double32_t>::Content"
QT = lookup.findType("NS::Container<Double32_t>::Value_t");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "double"
// Really we would want it to say Double32_t but oh well.
lookup.findScope("NS::Container<Double32_t>::Content_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<Double32_t>::Content"
lookup.findScope("NS::Container<Double32_t>::Impl_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "::Details::Impl"
// Note it should probably return "Details::Impl"
lookup.findScope("NS::TDataPointF", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::TDataPoint<float>"
lookup.findScope("NS::TDataPointD32", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::TDataPoint<Double32_t>"
<commit_msg>extend testing of typedef to reference<commit_after>// RUN: cat %s | %cling | FileCheck %s
// The test verifies the expected behavior in cling::utils::Transform class,
// which is supposed to provide different transformation of AST nodes and types.
#include "cling/Interpreter/Interpreter.h"
#include "cling/Interpreter/LookupHelper.h"
#include "cling/Utils/AST.h"
#include "clang/AST/Type.h"
#include "llvm/ADT/SmallSet.h"
#include "clang/Sema/Sema.h"
.rawInput 1
typedef double Double32_t;
typedef int Int_t;
typedef long Long_t;
typedef Int_t* IntPtr_t;
typedef Int_t& IntRef_t;
template <typename T> class A {};
template <typename T, typename U> class B {};
template <typename T, typename U> class C {};
typedef C<A<B<Double32_t, Int_t> >, Double32_t > CTD;
typedef C<A<B<const Double32_t, const Int_t> >, Double32_t > CTDConst;
#include <string>
namespace Details {
class Impl {};
}
namespace NS {
template <typename T, int size = 0> class ArrayType {};
template <typename T> class Array {};
template <typename T> class Container {
public:
class Content {};
typedef T Value_t;
typedef Content Content_t;
typedef ::Details::Impl Impl_t;
};
template <typename T> class TDataPoint {};
typedef TDataPoint<float> TDataPointF;
typedef TDataPoint<Double32_t> TDataPointD32;
}
.rawInput 0
const cling::LookupHelper& lookup = gCling->getLookupHelper();
const clang::ASTContext& Ctx = gCling->getSema().getASTContext();
llvm::SmallSet<const clang::Type*, 4> skip;
skip.insert(lookup.findType("Double32_t").getTypePtr());
const clang::Type* t = 0;
clang::QualType QT;
using namespace cling::utils;
// Test desugaring pointers types:
QT = lookup.findType("Int_t*");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int *"
QT = lookup.findType("const IntPtr_t*");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int *const *"
// Test desugaring reference (both r- or l- value) types:
QT = lookup.findType("const IntPtr_t&");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int *const &"
//TODO: QT = lookup.findType("IntPtr_t[32]");
// To do: findType does not return the const below:
// Test desugaring reference (both r- or l- value) types:
//QT = lookup.findType("const IntRef_t");
//Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// should print:(const char * const) "int &const"
// Test desugaring reference (both r- or l- value) types:
QT = lookup.findType("IntRef_t");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "int &"
//Desugar template parameters:
lookup.findScope("A<B<Double32_t, Int_t*> >", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK:(const char * const) "A<B<Double32_t, int *> >"
lookup.findScope("CTD", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "C<A<B<Double32_t, int> >, Double32_t>"
lookup.findScope("CTDConst", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "C<A<B<const Double32_t, const int> >, Double32_t>"
lookup.findScope("std::pair<const std::string,int>", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "std::pair<const std::string, int>"
lookup.findScope("NS::Array<NS::ArrayType<double> >", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Array<NS::ArrayType<double> >"
lookup.findScope("NS::Array<NS::ArrayType<Double32_t> >", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Array<NS::ArrayType<Double32_t> >"
lookup.findScope("NS::Container<Long_t>::Content", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<long>::Content"
QT = lookup.findType("NS::Container<Long_t>::Value_t");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "long"
lookup.findScope("NS::Container<Long_t>::Content_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<long>::Content"
lookup.findScope("NS::Container<Long_t>::Impl_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "::Details::Impl"
// Note it should probably return "Details::Impl"
lookup.findScope("NS::Container<Double32_t>::Content", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<Double32_t>::Content"
QT = lookup.findType("NS::Container<Double32_t>::Value_t");
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "double"
// Really we would want it to say Double32_t but oh well.
lookup.findScope("NS::Container<Double32_t>::Content_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::Container<Double32_t>::Content"
lookup.findScope("NS::Container<Double32_t>::Impl_t", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "::Details::Impl"
// Note it should probably return "Details::Impl"
lookup.findScope("NS::TDataPointF", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::TDataPoint<float>"
lookup.findScope("NS::TDataPointD32", &t);
QT = clang::QualType(t, 0);
Transform::GetPartiallyDesugaredType(Ctx, QT, skip).getAsString().c_str()
// CHECK: (const char * const) "NS::TDataPoint<Double32_t>"
<|endoftext|> |
<commit_before>#pragma once
#include <bts/blockchain/types.hpp>
#include <bts/blockchain/operations.hpp>
#include <bts/blockchain/error_codes.hpp>
#include <fc/optional.hpp>
#include <fc/reflect/variant.hpp>
#include <fc/io/raw.hpp>
#include <unordered_set>
namespace bts { namespace blockchain {
class chain_interface;
typedef std::shared_ptr<chain_interface> chain_interface_ptr;
/**
* A transaction is a set of operations that are
* performed atomicly and must be internally consistant.
*
* Every transaction votes for
*/
struct transaction
{
transaction(){}
digest_type digest()const;
fc::optional<fc::time_point_sec> expiration;
fc::optional<name_id_type> delegate_id; // delegate being voted for in required payouts
std::vector<operation> operations;
void withdraw( const account_id_type& account, share_type amount );
void deposit( const address& addr, const asset& amount, name_id_type delegate_id );
void reserve_name( const std::string& name, const std::string& json_data, const public_key_type& master, const public_key_type& active, bool as_delegate = false );
void update_name( name_id_type name_id, const fc::optional<std::string>& json_data, const fc::optional<public_key_type>& active, bool as_delegate = false );
};
struct signed_transaction : public transaction
{
transaction_id_type id()const;
size_t data_size()const;
void sign( const fc::ecc::private_key& signer );
std::vector<fc::ecc::compact_signature> signatures;
};
typedef std::vector<signed_transaction> signed_transactions;
typedef fc::optional<signed_transaction> osigned_transaction;
/**
* While evaluating a transaction there is a lot of intermediate
* state that must be tracked. Any shares withdrawn from the
* database must be stored in the transaction state until they
* are sent back to the database as either new balances or
* as fees collected.
*
* Some outputs such as markets, options, etc require certain
* payments to be made. So payments made are tracked and
* compared against payments required.
*
*/
class transaction_evaluation_state
{
public:
transaction_evaluation_state( const chain_interface_ptr& blockchain );
transaction_evaluation_state(){};
virtual ~transaction_evaluation_state();
virtual share_type get_fees( asset_id_type id = 0)const;
virtual void reset();
virtual void evaluate( const signed_transaction& trx );
virtual void evaluate_operation( const operation& op );
/** perform any final operations based upon the current state of
* the operation such as updating fees paid etc.
*/
virtual void post_evaluate();
/** can be specalized to handle many different forms of
* fee payment.
*/
virtual void validate_required_fee();
/**
* apply collected vote changes
*/
virtual void update_delegate_votes();
virtual void evaluate_withdraw( const withdraw_operation& op );
virtual void evaluate_deposit( const deposit_operation& op );
virtual void evaluate_reserve_name( const reserve_name_operation& op );
virtual void evaluate_update_name( const update_name_operation& op );
virtual void evaluate_create_asset( const create_asset_operation& op );
virtual void evaluate_update_asset( const update_asset_operation& op );
virtual void evaluate_issue_asset( const issue_asset_operation& op );
virtual void fail( bts_error_code error_code, const fc::variant& data );
bool check_signature( const address& a )const;
void add_required_signature( const address& a );
// steps performed as the transaction is validated
/**
* subtracts amount from a withdraw_with_signature account with the
* owner_key and amount.asset_id and the delegate_id of the transaction.
*/
void add_required_deposit( const address& owner_key, const asset& amount );
/** contains address funds were deposited into for use in
* incrementing required_deposits balance
*/
void sub_balance( const account_id_type& addr, const asset& amount );
void add_balance( const asset& amount );
/** any time a balance is deposited increment the vote for the delegate,
* if delegate_id then it is a vote against abs(delegate_id)
*/
void add_vote( name_id_type delegate_id, share_type amount );
void sub_vote( name_id_type delegate_id, share_type amount );
signed_transaction trx;
std::unordered_set<address> signed_keys;
std::unordered_set<address> required_keys;
// increases with funds are withdrawn, decreases when funds are deposited or fees paid
uint32_t validation_error_code;
fc::variant validation_error_data;
/** every time a deposit is made this balance is increased
* every time a deposit is required this balance is decreased
*
* This balance cannot be negative without an error.
*/
std::unordered_map<account_id_type, asset> required_deposits;
std::unordered_map<account_id_type, asset> provided_deposits;
// track deposits and withdraws by asset type
std::unordered_map<asset_id_type, asset> deposits;
std::unordered_map<asset_id_type, asset> withdraws;
/**
* As operation withdraw funds, input balance grows...
* As operations consume funds (deposit) input balance decreases
*
* Any left-over input balance can be seen as fees
*
* @note - this value should always equal the sum of deposits-withdraws
* and is maintained for the purpose of seralization.
*/
std::unordered_map<asset_id_type, share_type> balance;
struct vote_state
{
vote_state():votes_for(0),votes_against(0){}
int64_t votes_for;
int64_t votes_against;
};
/**
* Tracks the votes for or against each delegate based upon
* the deposits and withdraws to addresses.
*/
std::unordered_map<name_id_type, vote_state> net_delegate_votes;
protected:
chain_interface_ptr _current_state;
};
typedef std::shared_ptr<transaction_evaluation_state> transaction_evaluation_state_ptr;
struct transaction_location
{
transaction_location( uint32_t block_num = 0, uint32_t trx_num = 0 )
:block_num(0),trx_num(0){}
uint32_t block_num;
uint32_t trx_num;
};
typedef fc::optional<transaction_location> otransaction_location;
} } // bts::blockchain
FC_REFLECT( bts::blockchain::transaction, (expiration)(delegate_id)(operations) )
FC_REFLECT_DERIVED( bts::blockchain::signed_transaction, (bts::blockchain::transaction), (signatures) )
FC_REFLECT( bts::blockchain::transaction_evaluation_state::vote_state, (votes_for)(votes_against) )
FC_REFLECT( bts::blockchain::transaction_evaluation_state,
(trx)(signed_keys)(required_keys)
(validation_error_code)
(validation_error_data)
(required_deposits)
(provided_deposits)
(deposits)(withdraws)(balance)(net_delegate_votes)(balance) )
FC_REFLECT( bts::blockchain::transaction_location, (block_num)(trx_num) )
<commit_msg>adding definition for transaction_summary<commit_after>#pragma once
#include <bts/blockchain/types.hpp>
#include <bts/blockchain/operations.hpp>
#include <bts/blockchain/error_codes.hpp>
#include <fc/optional.hpp>
#include <fc/reflect/variant.hpp>
#include <fc/io/raw.hpp>
#include <unordered_set>
namespace bts { namespace blockchain {
class chain_interface;
typedef std::shared_ptr<chain_interface> chain_interface_ptr;
/**
* A transaction is a set of operations that are
* performed atomicly and must be internally consistant.
*
* Every transaction votes for
*/
struct transaction
{
transaction(){}
digest_type digest()const;
fc::optional<fc::time_point_sec> expiration;
fc::optional<name_id_type> delegate_id; // delegate being voted for in required payouts
std::vector<operation> operations;
void withdraw( const account_id_type& account, share_type amount );
void deposit( const address& addr, const asset& amount, name_id_type delegate_id );
void reserve_name( const std::string& name, const std::string& json_data, const public_key_type& master, const public_key_type& active, bool as_delegate = false );
void update_name( name_id_type name_id, const fc::optional<std::string>& json_data, const fc::optional<public_key_type>& active, bool as_delegate = false );
};
struct transaction_summary_details
{
/**
* Bitcoin compatibility
*/
///@{
std::string account;
std::string category;
std::string address;
share_type amount;
///@}
};
struct transaction_summary
{
transaction_summary():amount(0),confirmations(0),blockindex(0){}
/**
* Bitcoin compatibility
*/
///@{
share_type amount;
uint32_t confirmations;
block_id_type blockhash;
uint32_t blockindex;
fc::time_point_sec blocktime;
transaction_id_type txid;
fc::time_point_sec time;
fc::time_point_sec timereceived;
transaction_summary_details details;
///@}
std::vector<asset> fees;
std::vector<asset> amounts;
};
struct signed_transaction : public transaction
{
transaction_id_type id()const;
size_t data_size()const;
void sign( const fc::ecc::private_key& signer );
std::vector<fc::ecc::compact_signature> signatures;
};
typedef std::vector<signed_transaction> signed_transactions;
typedef fc::optional<signed_transaction> osigned_transaction;
/**
* While evaluating a transaction there is a lot of intermediate
* state that must be tracked. Any shares withdrawn from the
* database must be stored in the transaction state until they
* are sent back to the database as either new balances or
* as fees collected.
*
* Some outputs such as markets, options, etc require certain
* payments to be made. So payments made are tracked and
* compared against payments required.
*
*/
class transaction_evaluation_state
{
public:
transaction_evaluation_state( const chain_interface_ptr& blockchain );
transaction_evaluation_state(){};
virtual ~transaction_evaluation_state();
virtual share_type get_fees( asset_id_type id = 0)const;
virtual void reset();
virtual void evaluate( const signed_transaction& trx );
virtual void evaluate_operation( const operation& op );
/** perform any final operations based upon the current state of
* the operation such as updating fees paid etc.
*/
virtual void post_evaluate();
/** can be specalized to handle many different forms of
* fee payment.
*/
virtual void validate_required_fee();
/**
* apply collected vote changes
*/
virtual void update_delegate_votes();
virtual void evaluate_withdraw( const withdraw_operation& op );
virtual void evaluate_deposit( const deposit_operation& op );
virtual void evaluate_reserve_name( const reserve_name_operation& op );
virtual void evaluate_update_name( const update_name_operation& op );
virtual void evaluate_create_asset( const create_asset_operation& op );
virtual void evaluate_update_asset( const update_asset_operation& op );
virtual void evaluate_issue_asset( const issue_asset_operation& op );
virtual void fail( bts_error_code error_code, const fc::variant& data );
bool check_signature( const address& a )const;
void add_required_signature( const address& a );
// steps performed as the transaction is validated
/**
* subtracts amount from a withdraw_with_signature account with the
* owner_key and amount.asset_id and the delegate_id of the transaction.
*/
void add_required_deposit( const address& owner_key, const asset& amount );
/** contains address funds were deposited into for use in
* incrementing required_deposits balance
*/
void sub_balance( const account_id_type& addr, const asset& amount );
void add_balance( const asset& amount );
/** any time a balance is deposited increment the vote for the delegate,
* if delegate_id then it is a vote against abs(delegate_id)
*/
void add_vote( name_id_type delegate_id, share_type amount );
void sub_vote( name_id_type delegate_id, share_type amount );
signed_transaction trx;
std::unordered_set<address> signed_keys;
std::unordered_set<address> required_keys;
// increases with funds are withdrawn, decreases when funds are deposited or fees paid
uint32_t validation_error_code;
fc::variant validation_error_data;
/** every time a deposit is made this balance is increased
* every time a deposit is required this balance is decreased
*
* This balance cannot be negative without an error.
*/
std::unordered_map<account_id_type, asset> required_deposits;
std::unordered_map<account_id_type, asset> provided_deposits;
// track deposits and withdraws by asset type
std::unordered_map<asset_id_type, asset> deposits;
std::unordered_map<asset_id_type, asset> withdraws;
/**
* As operation withdraw funds, input balance grows...
* As operations consume funds (deposit) input balance decreases
*
* Any left-over input balance can be seen as fees
*
* @note - this value should always equal the sum of deposits-withdraws
* and is maintained for the purpose of seralization.
*/
std::unordered_map<asset_id_type, share_type> balance;
struct vote_state
{
vote_state():votes_for(0),votes_against(0){}
int64_t votes_for;
int64_t votes_against;
};
/**
* Tracks the votes for or against each delegate based upon
* the deposits and withdraws to addresses.
*/
std::unordered_map<name_id_type, vote_state> net_delegate_votes;
protected:
chain_interface_ptr _current_state;
};
typedef std::shared_ptr<transaction_evaluation_state> transaction_evaluation_state_ptr;
struct transaction_location
{
transaction_location( uint32_t block_num = 0, uint32_t trx_num = 0 )
:block_num(0),trx_num(0){}
uint32_t block_num;
uint32_t trx_num;
};
typedef fc::optional<transaction_location> otransaction_location;
} } // bts::blockchain
FC_REFLECT( bts::blockchain::transaction, (expiration)(delegate_id)(operations) )
FC_REFLECT_DERIVED( bts::blockchain::signed_transaction, (bts::blockchain::transaction), (signatures) )
FC_REFLECT( bts::blockchain::transaction_evaluation_state::vote_state, (votes_for)(votes_against) )
FC_REFLECT( bts::blockchain::transaction_evaluation_state,
(trx)(signed_keys)(required_keys)
(validation_error_code)
(validation_error_data)
(required_deposits)
(provided_deposits)
(deposits)(withdraws)(balance)(net_delegate_votes)(balance) )
FC_REFLECT( bts::blockchain::transaction_location, (block_num)(trx_num) )
FC_REFLECT( bts::blockchain::transaction_summary_details, (account)(category)(address)(amount) )
FC_REFLECT( bts::blockchain::transaction_summary, (amount)(confirmations)(blockhash)(blockindex)(blocktime)(txid)(time)(timereceived)(details)(fees)(amounts) )
<|endoftext|> |
<commit_before>
//
// This source file is part of appleseed.
// Visit https://appleseedhq.net/ for additional information and resources.
//
// This software is released under the MIT license.
//
// Copyright (c) 2019 Luke Wilimitis, The appleseedhq Organization
//
// 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.
//
// Interface header.
#include "pixelerroraov.h"
// appleseed.renderer headers.
#include "renderer/kernel/aov/aovaccumulator.h"
#include "renderer/modeling/aov/aov.h"
#include "renderer/modeling/frame/frame.h"
// appleseed.foundation headers.
#include "foundation/image/analysis.h"
#include "foundation/image/color.h"
#include "foundation/image/image.h"
#include "foundation/utility/api/specializedapiarrays.h"
#include "foundation/utility/containers/dictionary.h"
// Standard headers.
#include <algorithm>
#include <cstddef>
#include <memory>
#include <string>
using namespace foundation;
using namespace std;
namespace renderer
{
namespace
{
//
// Pixel Error AOV.
//
const char* PixelErrorAOVModel = "pixel_error_aov";
class PixelErrorAOV
: public UnfilteredAOV
{
public:
explicit PixelErrorAOV(const ParamArray& params)
: UnfilteredAOV("pixel_error", params)
{
}
const char* get_model() const override
{
return PixelErrorAOVModel;
}
void post_process_image(const Frame& frame) override
{
if (!frame.has_valid_ref_image())
return;
// TODO: Convert to inferno color map.
static const Color3f Blue(0.0f, 0.0f, 1.0f);
static const Color3f Red(1.0f, 0.0f, 0.0f);
const AABB2u& crop_window = frame.get_crop_window();
float max_error = 0.0f;
for (size_t y = crop_window.min.y; y <= crop_window.max.y; ++y)
{
for (size_t x = crop_window.min.x; x <= crop_window.max.x; ++x)
{
Color3f image_color;
frame.image().get_pixel(x, y, image_color);
Color3f ref_color;
frame.ref_image()->get_pixel(x, y, ref_color);
const float error = sqrt(compute_error_squared(image_color, ref_color));
max_error = max(max_error, error);
m_image->set_pixel(x, y, &error, 1);
}
}
if (max_error == 0.0f)
return;
for (size_t y = crop_window.min.y; y <= crop_window.max.y; ++y)
{
for (size_t x = crop_window.min.x; x <= crop_window.max.x; ++x)
{
float error;
m_image->get_pixel(x, y, &error, 1);
const float k = fit(error, 0.0f, max_error, 0.0f, 1.0f);
assert(k >= 0.0f && k <= 1.0f);
m_image->set_pixel(x, y, lerp(Blue, Red, k));
}
}
}
private:
auto_release_ptr<AOVAccumulator> create_accumulator() const override
{
return auto_release_ptr<AOVAccumulator>(new AOVAccumulator());
}
};
}
//
// PixelErrorAOVFactory class implementation.
//
void PixelErrorAOVFactory::release()
{
delete this;
}
const char* PixelErrorAOVFactory::get_model() const
{
return PixelErrorAOVModel;
}
Dictionary PixelErrorAOVFactory::get_model_metadata() const
{
return
Dictionary()
.insert("name", PixelErrorAOVModel)
.insert("label", "Pixel Error");
}
DictionaryArray PixelErrorAOVFactory::get_input_metadata() const
{
DictionaryArray metadata;
return metadata;
}
auto_release_ptr<AOV> PixelErrorAOVFactory::create(const ParamArray& params) const
{
return auto_release_ptr<AOV>(new PixelErrorAOV(params));
}
} // namespace renderer
<commit_msg>Use Inferno color map in Pixel Error AOV<commit_after>
//
// This source file is part of appleseed.
// Visit https://appleseedhq.net/ for additional information and resources.
//
// This software is released under the MIT license.
//
// Copyright (c) 2019 Luke Wilimitis, The appleseedhq Organization
//
// 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.
//
// Interface header.
#include "pixelerroraov.h"
// appleseed.renderer headers.
#include "renderer/kernel/aov/aovaccumulator.h"
#include "renderer/modeling/aov/aov.h"
#include "renderer/modeling/frame/frame.h"
// appleseed.foundation headers.
#include "foundation/image/analysis.h"
#include "foundation/image/color.h"
#include "foundation/image/colormap.h"
#include "foundation/image/colormapdata.h"
#include "foundation/image/image.h"
#include "foundation/utility/api/specializedapiarrays.h"
#include "foundation/utility/containers/dictionary.h"
// Standard headers.
#include <algorithm>
#include <cstddef>
#include <memory>
#include <string>
using namespace foundation;
using namespace std;
namespace renderer
{
namespace
{
//
// Pixel Error AOV.
//
const char* PixelErrorAOVModel = "pixel_error_aov";
class PixelErrorAOV
: public UnfilteredAOV
{
public:
explicit PixelErrorAOV(const ParamArray& params)
: UnfilteredAOV("pixel_error", params)
{
}
const char* get_model() const override
{
return PixelErrorAOVModel;
}
void post_process_image(const Frame& frame) override
{
if (!frame.has_valid_ref_image())
return;
ColorMap color_map;
color_map.set_palette_from_array(InfernoColorMapLinearRGB, countof(InfernoColorMapLinearRGB) / 3);
const AABB2u& crop_window = frame.get_crop_window();
float max_error = 0.0f;
for (size_t y = crop_window.min.y; y <= crop_window.max.y; ++y)
{
for (size_t x = crop_window.min.x; x <= crop_window.max.x; ++x)
{
Color3f image_color;
frame.image().get_pixel(x, y, image_color);
Color3f ref_color;
frame.ref_image()->get_pixel(x, y, ref_color);
const float error = sqrt(compute_error_squared(image_color, ref_color));
max_error = max(max_error, error);
m_image->set_pixel(x, y, &error, 1);
}
}
if (max_error == 0.0f)
return;
color_map.remap_red_channel(*m_image, crop_window, 0.0f, max_error);
}
private:
auto_release_ptr<AOVAccumulator> create_accumulator() const override
{
return auto_release_ptr<AOVAccumulator>(new AOVAccumulator());
}
};
}
//
// PixelErrorAOVFactory class implementation.
//
void PixelErrorAOVFactory::release()
{
delete this;
}
const char* PixelErrorAOVFactory::get_model() const
{
return PixelErrorAOVModel;
}
Dictionary PixelErrorAOVFactory::get_model_metadata() const
{
return
Dictionary()
.insert("name", PixelErrorAOVModel)
.insert("label", "Pixel Error");
}
DictionaryArray PixelErrorAOVFactory::get_input_metadata() const
{
DictionaryArray metadata;
return metadata;
}
auto_release_ptr<AOV> PixelErrorAOVFactory::create(const ParamArray& params) const
{
return auto_release_ptr<AOV>(new PixelErrorAOV(params));
}
} // namespace renderer
<|endoftext|> |
<commit_before>/**
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __STOUT_FLAGS_PARSE_HPP__
#define __STOUT_FLAGS_PARSE_HPP__
#include <sstream> // For istringstream.
#include <string>
#include <stout/duration.hpp>
#include <stout/error.hpp>
#include <stout/json.hpp>
#include <stout/strings.hpp>
#include <stout/try.hpp>
#include <stout/os/read.hpp>
namespace flags {
template <typename T>
Try<T> parse(const std::string& value)
{
T t;
std::istringstream in(value);
in >> t;
if (!in.good() && !in.eof()) {
return Error("Failed to convert into required type");
}
return t;
}
template <>
inline Try<std::string> parse(const std::string& value)
{
return value;
}
template <>
inline Try<bool> parse(const std::string& value)
{
if (value == "true" || value == "1") {
return true;
} else if (value == "false" || value == "0") {
return false;
}
return Error("Expecting a boolean (e.g., true or false)");
}
template <>
inline Try<Duration> parse(const std::string& value)
{
return Duration::parse(value);
}
template <>
inline Try<Bytes> parse(const std::string& value)
{
return Bytes::parse(value);
}
template <>
inline Try<JSON::Object> parse(const std::string& value)
{
// If the flag value corresponds to a file parse the contents of the
// file as JSON.
// TODO(vinod): We do not support relative paths because it is
// tricky to figure out if a flag value corresponds to a relative
// path or a JSON string. For example, "{", " {" and " \n {" are
// all valid prefixes of a JSON string.
if (strings::startsWith(value, "/") ||
strings::startsWith(value, "file://")) {
const std::string& path =
strings::remove(value, "file://", strings::PREFIX);
Try<std::string> read = os::read(path);
if (read.isError()) {
return Error("Error reading file '" + path + "': " + read.error());
}
return JSON::parse<JSON::Object>(read.get());
}
return JSON::parse<JSON::Object>(value);
}
} // namespace flags {
#endif // __STOUT_FLAGS_PARSE_HPP__
<commit_msg>Fixed blank line in flags/parse.hpp.<commit_after>/**
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __STOUT_FLAGS_PARSE_HPP__
#define __STOUT_FLAGS_PARSE_HPP__
#include <sstream> // For istringstream.
#include <string>
#include <stout/duration.hpp>
#include <stout/error.hpp>
#include <stout/json.hpp>
#include <stout/strings.hpp>
#include <stout/try.hpp>
#include <stout/os/read.hpp>
namespace flags {
template <typename T>
Try<T> parse(const std::string& value)
{
T t;
std::istringstream in(value);
in >> t;
if (!in.good() && !in.eof()) {
return Error("Failed to convert into required type");
}
return t;
}
template <>
inline Try<std::string> parse(const std::string& value)
{
return value;
}
template <>
inline Try<bool> parse(const std::string& value)
{
if (value == "true" || value == "1") {
return true;
} else if (value == "false" || value == "0") {
return false;
}
return Error("Expecting a boolean (e.g., true or false)");
}
template <>
inline Try<Duration> parse(const std::string& value)
{
return Duration::parse(value);
}
template <>
inline Try<Bytes> parse(const std::string& value)
{
return Bytes::parse(value);
}
template <>
inline Try<JSON::Object> parse(const std::string& value)
{
// If the flag value corresponds to a file parse the contents of the
// file as JSON.
// TODO(vinod): We do not support relative paths because it is
// tricky to figure out if a flag value corresponds to a relative
// path or a JSON string. For example, "{", " {" and " \n {" are
// all valid prefixes of a JSON string.
if (strings::startsWith(value, "/") ||
strings::startsWith(value, "file://")) {
const std::string& path =
strings::remove(value, "file://", strings::PREFIX);
Try<std::string> read = os::read(path);
if (read.isError()) {
return Error("Error reading file '" + path + "': " + read.error());
}
return JSON::parse<JSON::Object>(read.get());
}
return JSON::parse<JSON::Object>(value);
}
} // namespace flags {
#endif // __STOUT_FLAGS_PARSE_HPP__
<|endoftext|> |
<commit_before>// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2013 - 2017)
// Rene Milk (2014, 2016 - 2018)
// Sven Kaulmann (2014)
// Tobias Leibner (2014, 2016 - 2017)
#ifndef DUNE_GDT_SPACES_INTERFACE_HH
#define DUNE_GDT_SPACES_INTERFACE_HH
#include <dune/geometry/type.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/gdt/exceptions.hh>
#include <dune/gdt/local/finite-elements/interfaces.hh>
#include <dune/gdt/spaces/basis/interface.hh>
#include <dune/gdt/spaces/mapper/interfaces.hh>
#include <dune/gdt/spaces/parallel/communication.hh>
#include <dune/gdt/type_traits.hh>
namespace Dune {
namespace GDT {
template <class GridView, size_t range_dim, size_t range_dim_columns = 1, class RangeField = double>
class SpaceInterface
{
static_assert(XT::Grid::is_view<GridView>::value, "");
public:
using GridViewType = GridView;
using GV = GridViewType;
using D = typename GridViewType::ctype;
static const constexpr size_t d = GridViewType::dimension;
using R = RangeField;
static const constexpr size_t r = range_dim;
static const constexpr size_t rC = range_dim_columns;
using GlobalBasisType = GlobalBasisInterface<GridViewType, r, rC, R>;
using MapperType = MapperInterface<GridViewType>;
using FiniteElementType = LocalFiniteElementInterface<D, d, R, r, rC>;
using DofCommunicatorType = typename DofCommunicationChooser<GridViewType>::Type;
SpaceInterface()
: dof_communicator_(nullptr)
{
}
virtual ~SpaceInterface() = default;
virtual const GridViewType& grid_view() const = 0;
/**
* \name These methods provide the actual functionality, they have to be implemented.
* \{
**/
virtual const MapperType& mapper() const = 0;
virtual const GlobalBasisType& basis() const = 0;
virtual const FiniteElementType& finite_element(const GeometryType& geometry_type) const = 0;
/// \}
/**
* \name These methods help to identify the space, they have to be implemented.
* \{
**/
virtual SpaceType type() const = 0;
virtual int min_polorder() const = 0;
virtual int max_polorder() const = 0;
/**
* To query if elements of this space (functions) are continuous (i.e., in C^0), use `continuous(0)`.
*/
virtual bool continuous(const int diff_order) const = 0;
virtual bool continuous_normal_components() const = 0;
/**
* If this returns true, every finite_element() is expected to provide lagrange_points().
*/
virtual bool is_lagrangian() const = 0;
/// \}
/**
* \name These methods are required for MPI communication, they are provided.
* \{
*/
virtual const DofCommunicatorType& dof_communicator() const
{
if (!dof_communicator_)
DUNE_THROW(Exceptions::space_error,
"The actual space has to either implement its own dof_communicator() or call "
"create_communicator() in the ctor!");
return *dof_communicator_;
}
/// \}
protected:
void create_communicator()
{
if (!dof_communicator_) {
dof_communicator_ =
std::shared_ptr<DofCommunicatorType>(DofCommunicationChooser<GridViewType>::create(grid_view()));
DofCommunicationChooser<GridViewType>::prepare(*this, *dof_communicator_);
}
}
private:
std::shared_ptr<DofCommunicatorType> dof_communicator_;
}; // class SpaceInterface
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_SPACES_INTERFACE_HH
<commit_msg>[spaces.interface] let range_dim default to 1<commit_after>// This file is part of the dune-gdt project:
// https://github.com/dune-community/dune-gdt
// Copyright 2010-2018 dune-gdt developers and contributors. All rights reserved.
// License: Dual licensed as BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
// or GPL-2.0+ (http://opensource.org/licenses/gpl-license)
// with "runtime exception" (http://www.dune-project.org/license.html)
// Authors:
// Felix Schindler (2013 - 2017)
// Rene Milk (2014, 2016 - 2018)
// Sven Kaulmann (2014)
// Tobias Leibner (2014, 2016 - 2017)
#ifndef DUNE_GDT_SPACES_INTERFACE_HH
#define DUNE_GDT_SPACES_INTERFACE_HH
#include <dune/geometry/type.hh>
#include <dune/xt/grid/type_traits.hh>
#include <dune/gdt/exceptions.hh>
#include <dune/gdt/local/finite-elements/interfaces.hh>
#include <dune/gdt/spaces/basis/interface.hh>
#include <dune/gdt/spaces/mapper/interfaces.hh>
#include <dune/gdt/spaces/parallel/communication.hh>
#include <dune/gdt/type_traits.hh>
namespace Dune {
namespace GDT {
template <class GridView, size_t range_dim = 1, size_t range_dim_columns = 1, class RangeField = double>
class SpaceInterface
{
static_assert(XT::Grid::is_view<GridView>::value, "");
public:
using GridViewType = GridView;
using GV = GridViewType;
using D = typename GridViewType::ctype;
static const constexpr size_t d = GridViewType::dimension;
using R = RangeField;
static const constexpr size_t r = range_dim;
static const constexpr size_t rC = range_dim_columns;
using GlobalBasisType = GlobalBasisInterface<GridViewType, r, rC, R>;
using MapperType = MapperInterface<GridViewType>;
using FiniteElementType = LocalFiniteElementInterface<D, d, R, r, rC>;
using DofCommunicatorType = typename DofCommunicationChooser<GridViewType>::Type;
SpaceInterface()
: dof_communicator_(nullptr)
{
}
virtual ~SpaceInterface() = default;
virtual const GridViewType& grid_view() const = 0;
/**
* \name These methods provide the actual functionality, they have to be implemented.
* \{
**/
virtual const MapperType& mapper() const = 0;
virtual const GlobalBasisType& basis() const = 0;
virtual const FiniteElementType& finite_element(const GeometryType& geometry_type) const = 0;
/// \}
/**
* \name These methods help to identify the space, they have to be implemented.
* \{
**/
virtual SpaceType type() const = 0;
virtual int min_polorder() const = 0;
virtual int max_polorder() const = 0;
/**
* To query if elements of this space (functions) are continuous (i.e., in C^0), use `continuous(0)`.
*/
virtual bool continuous(const int diff_order) const = 0;
virtual bool continuous_normal_components() const = 0;
/**
* If this returns true, every finite_element() is expected to provide lagrange_points().
*/
virtual bool is_lagrangian() const = 0;
/// \}
/**
* \name These methods are required for MPI communication, they are provided.
* \{
*/
virtual const DofCommunicatorType& dof_communicator() const
{
if (!dof_communicator_)
DUNE_THROW(Exceptions::space_error,
"The actual space has to either implement its own dof_communicator() or call "
"create_communicator() in the ctor!");
return *dof_communicator_;
}
/// \}
protected:
void create_communicator()
{
if (!dof_communicator_) {
dof_communicator_ =
std::shared_ptr<DofCommunicatorType>(DofCommunicationChooser<GridViewType>::create(grid_view()));
DofCommunicationChooser<GridViewType>::prepare(*this, *dof_communicator_);
}
}
private:
std::shared_ptr<DofCommunicatorType> dof_communicator_;
}; // class SpaceInterface
} // namespace GDT
} // namespace Dune
#endif // DUNE_GDT_SPACES_INTERFACE_HH
<|endoftext|> |
<commit_before>//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the MIT License (MIT).
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************
#include "pch.h"
#include "CompiledShaders\StateMachineLib.h"
namespace FallbackLayer
{
void CompilePSO(ID3D12Device *pDevice, D3D12_SHADER_BYTECODE shaderByteCode, const StateObjectCollection &stateObjectCollection, ID3D12PipelineState **ppPipelineState)
{
D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.CS = CD3DX12_SHADER_BYTECODE(shaderByteCode);
psoDesc.NodeMask = stateObjectCollection.m_nodeMask;
psoDesc.pRootSignature = stateObjectCollection.m_pGlobalRootSignature;
ThrowInternalFailure(pDevice->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(ppPipelineState)));
}
StateIdentifier UberShaderRaytracingProgram::GetStateIdentfier(LPCWSTR pExportName)
{
StateIdentifier id = 0;
if (pExportName)
{
auto shaderIdentifier = m_ExportNameToShaderIdentifier.find(pExportName);
if (shaderIdentifier != m_ExportNameToShaderIdentifier.end())
{
id = shaderIdentifier->second.StateId;
}
else
{
ThrowFailure(E_INVALIDARG, L"Hit group is referring to a shader name that wasn't found in the state object");
}
}
return id;
}
UberShaderRaytracingProgram::UberShaderRaytracingProgram(ID3D12Device *pDevice, DxilShaderPatcher &dxilShaderPatcher, const StateObjectCollection &stateObjectCollection) :
m_DxilShaderPatcher(dxilShaderPatcher)
{
UINT numLibraries = (UINT)stateObjectCollection.m_dxilLibraries.size();
UINT numShaders = 0;
for (auto &lib : stateObjectCollection.m_dxilLibraries)
{
numShaders += lib.NumExports;
}
std::vector<DxilLibraryInfo> librariesInfo;
std::vector<LPCWSTR> exportNames;
std::vector<CComPtr<IDxcBlob>> patchedBlobList;
UINT cbvSrvUavHandleSize = pDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
UINT samplerHandleSize = pDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
for (UINT i = 0; i < numLibraries; i++)
{
auto &library = stateObjectCollection.m_dxilLibraries[i];
if (library.NumExports > 0)
{
DxilLibraryInfo outputLibInfo((void *)library.DXILLibrary.pShaderBytecode, (UINT)library.DXILLibrary.BytecodeLength);
CComPtr<IDxcBlob> pOutputBlob;
for (UINT exportIndex = 0; exportIndex < library.NumExports; exportIndex++)
{
std::wstring exportName = library.pExports[exportIndex].Name;
auto pShaderAssociation = stateObjectCollection.m_shaderAssociations.find(exportName);
if (pShaderAssociation == stateObjectCollection.m_shaderAssociations.end())
{
for (auto &hitgroup : stateObjectCollection.m_hitGroups)
{
LPCWSTR imports[] = {
hitgroup.second.ClosestHitShaderImport,
hitgroup.second.AnyHitShaderImport,
hitgroup.second.IntersectionShaderImport
};
for(auto hitgroupImport : imports)
{
if (hitgroupImport && exportName == std::wstring(hitgroupImport))
{
pShaderAssociation = stateObjectCollection.m_shaderAssociations.find(hitgroup.first);
}
}
}
}
if (pShaderAssociation != stateObjectCollection.m_shaderAssociations.end() && pShaderAssociation->second.m_pRootSignature)
{
CComPtr<ID3D12VersionedRootSignatureDeserializer> pDeserializer;
ShaderInfo shaderInfo;
shaderInfo.pRootSignatureDesc = GetDescFromRootSignature(pShaderAssociation->second.m_pRootSignature, pDeserializer);
if (GetNumParameters(*shaderInfo.pRootSignatureDesc) > 0)
{
shaderInfo.SamplerDescriptorSizeInBytes = samplerHandleSize;
shaderInfo.SrvCbvUavDescriptorSizeInBytes = cbvSrvUavHandleSize;
shaderInfo.ShaderRecordIdentifierSizeInBytes = sizeof(ShaderIdentifier);
shaderInfo.ExportName = exportName.c_str();
CComPtr<IDxcBlob> pPatchedBlob;
m_DxilShaderPatcher.PatchShaderBindingTables(
(const BYTE *)outputLibInfo.pByteCode,
(UINT)outputLibInfo.BytecodeLength,
&shaderInfo,
&pPatchedBlob);
pOutputBlob = pPatchedBlob;
outputLibInfo = DxilLibraryInfo(pOutputBlob->GetBufferPointer(), pOutputBlob->GetBufferSize());
}
}
}
patchedBlobList.push_back(pOutputBlob);
librariesInfo.emplace_back(outputLibInfo);
}
for(UINT exportIndex = 0; exportIndex < library.NumExports; exportIndex++)
exportNames.push_back(library.pExports[exportIndex].Name);
}
{
auto &traversalShader = stateObjectCollection.m_traversalShader.DXILLibrary;
librariesInfo.emplace_back((void *)traversalShader.pShaderBytecode, traversalShader.BytecodeLength);
exportNames.push_back(L"Fallback_TraceRay");
}
{
librariesInfo.emplace_back((void *)g_pStateMachineLib, ARRAYSIZE(g_pStateMachineLib));
}
std::vector<FallbackLayer::StateIdentifier> stateIdentifiers;
CComPtr<IDxcBlob> pLinkedBlob;
m_DxilShaderPatcher.LinkShaders((UINT)stateObjectCollection.m_pipelineStackSize, librariesInfo, exportNames, stateIdentifiers, &pLinkedBlob);
for (size_t i = 0; i < exportNames.size(); ++i)
{
m_ExportNameToShaderIdentifier[exportNames[i]] = { stateIdentifiers[i], 0 };
}
for (auto &hitGroupMapEntry : stateObjectCollection.m_hitGroups)
{
auto closestHitName = hitGroupMapEntry.second.ClosestHitShaderImport;
auto anyHitName = hitGroupMapEntry.second.AnyHitShaderImport;
auto intersectionName = hitGroupMapEntry.second.IntersectionShaderImport;
ShaderIdentifier shaderId = {};
shaderId.StateId = GetStateIdentfier(closestHitName);
shaderId.AnyHitId = GetStateIdentfier(anyHitName);
shaderId.IntersectionShaderId = GetStateIdentfier(intersectionName);
auto hitGroupName = hitGroupMapEntry.first;
m_ExportNameToShaderIdentifier[hitGroupName] = shaderId;
}
CompilePSO(
pDevice,
CD3DX12_SHADER_BYTECODE(pLinkedBlob->GetBufferPointer(), pLinkedBlob->GetBufferSize()),
stateObjectCollection,
&m_pRayTracePSO);
UINT sizeOfParamterStart = sizeof(m_patchRootSignatureParameterStart);
ThrowFailure(stateObjectCollection.m_pGlobalRootSignature->GetPrivateData(
FallbackLayerPatchedParameterStartGUID,
&sizeOfParamterStart,
&m_patchRootSignatureParameterStart),
L"Root signatures in a state object must be created through "
L"Fallback Layer-specific interaces. Either use RaytracingDevice::D3D12SerializeRootSignature "
L"or RaytracingDevice::D3D12SerializeFallbackRootSignature and create with "
L"RaytracingDevice::CreateRootSignature");
}
ShaderIdentifier *UberShaderRaytracingProgram::GetShaderIdentifier(LPCWSTR pExportName)
{
auto pEntry = m_ExportNameToShaderIdentifier.find(pExportName);
if (pEntry == m_ExportNameToShaderIdentifier.end())
{
return nullptr;
}
else
{
// Handing out this pointer is safe because the map is read-only at this point
return &pEntry->second;
}
}
void UberShaderRaytracingProgram::DispatchRays(
ID3D12GraphicsCommandList *pCommandList,
ID3D12DescriptorHeap *pSrvCbvUavDescriptorHeap,
ID3D12DescriptorHeap *pSamplerDescriptorHeap,
const std::unordered_map<UINT, WRAPPED_GPU_POINTER> &boundAccelerationStructures,
const D3D12_FALLBACK_DISPATCH_RAYS_DESC &desc)
{
assert(pSrvCbvUavDescriptorHeap);
pCommandList->SetComputeRootDescriptorTable(m_patchRootSignatureParameterStart + CbvSrvUavDescriptorHeapAliasedTables, pSrvCbvUavDescriptorHeap->GetGPUDescriptorHandleForHeapStart());
if (pSamplerDescriptorHeap)
{
pCommandList->SetComputeRootDescriptorTable(m_patchRootSignatureParameterStart + SamplerDescriptorHeapAliasedTables, pSamplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart());
}
if (desc.HitGroupTable.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + HitGroupRecord, desc.HitGroupTable.StartAddress);
}
if (desc.MissShaderTable.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + MissShaderRecord, desc.MissShaderTable.StartAddress);
}
if (desc.RayGenerationShaderRecord.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + RayGenShaderRecord, desc.RayGenerationShaderRecord.StartAddress);
}
if (desc.CallableShaderTable.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + CallableShaderRecord, desc.CallableShaderTable.StartAddress);
}
DispatchRaysConstants constants;
constants.RayDispatchDimensionsWidth = desc.Width;
constants.RayDispatchDimensionsHeight = desc.Height;
constants.HitGroupShaderRecordStride = static_cast<UINT>(desc.HitGroupTable.StrideInBytes);
constants.MissShaderRecordStride = static_cast<UINT>(desc.MissShaderTable.StrideInBytes);
constants.SrvCbvUavDescriptorHeapStart = pSrvCbvUavDescriptorHeap->GetGPUDescriptorHandleForHeapStart().ptr;
constants.SamplerDescriptorHeapStart = pSamplerDescriptorHeap ? pSamplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart().ptr : 0;
pCommandList->SetComputeRoot32BitConstants(m_patchRootSignatureParameterStart + DispatchConstants, SizeOfInUint32(DispatchRaysConstants), &constants, 0);
UINT entriesAdded = 0;
std::vector<WRAPPED_GPU_POINTER> AccelerationStructuresEntries(boundAccelerationStructures.size());
for (auto &entry : boundAccelerationStructures)
{
AccelerationStructuresEntries[entriesAdded++] = entry.second;
}
pCommandList->SetComputeRoot32BitConstants(
m_patchRootSignatureParameterStart + AccelerationStructuresList, (UINT)(AccelerationStructuresEntries.size() * (SizeOfInUint32(*AccelerationStructuresEntries.data()))), AccelerationStructuresEntries.data(), 0);
#ifdef DEBUG
m_pPredispatchCallback(pCommandList, m_patchRootSignatureParameterStart);
#endif
UINT dispatchWidth = DivideAndRoundUp<UINT>(desc.Width, THREAD_GROUP_WIDTH);
UINT dispatchHeight = DivideAndRoundUp<UINT>(desc.Height, THREAD_GROUP_HEIGHT);
pCommandList->SetPipelineState(m_pRayTracePSO);
pCommandList->Dispatch(dispatchWidth, dispatchHeight, 1);
}
}
<commit_msg> Adding workaround to enable recursion to work well when the intersection/anyhit shader is active<commit_after>//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the MIT License (MIT).
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************
#include "pch.h"
#include "CompiledShaders\StateMachineLib.h"
namespace FallbackLayer
{
void CompilePSO(ID3D12Device *pDevice, D3D12_SHADER_BYTECODE shaderByteCode, const StateObjectCollection &stateObjectCollection, ID3D12PipelineState **ppPipelineState)
{
D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = {};
psoDesc.CS = CD3DX12_SHADER_BYTECODE(shaderByteCode);
psoDesc.NodeMask = stateObjectCollection.m_nodeMask;
psoDesc.pRootSignature = stateObjectCollection.m_pGlobalRootSignature;
ThrowInternalFailure(pDevice->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(ppPipelineState)));
}
StateIdentifier UberShaderRaytracingProgram::GetStateIdentfier(LPCWSTR pExportName)
{
StateIdentifier id = 0;
if (pExportName)
{
auto shaderIdentifier = m_ExportNameToShaderIdentifier.find(pExportName);
if (shaderIdentifier != m_ExportNameToShaderIdentifier.end())
{
id = shaderIdentifier->second.StateId;
}
else
{
ThrowFailure(E_INVALIDARG, L"Hit group is referring to a shader name that wasn't found in the state object");
}
}
return id;
}
UberShaderRaytracingProgram::UberShaderRaytracingProgram(ID3D12Device *pDevice, DxilShaderPatcher &dxilShaderPatcher, const StateObjectCollection &stateObjectCollection) :
m_DxilShaderPatcher(dxilShaderPatcher)
{
UINT numLibraries = (UINT)stateObjectCollection.m_dxilLibraries.size();
UINT numShaders = 0;
for (auto &lib : stateObjectCollection.m_dxilLibraries)
{
numShaders += lib.NumExports;
}
std::vector<DxilLibraryInfo> librariesInfo;
std::vector<LPCWSTR> exportNames;
std::vector<CComPtr<IDxcBlob>> patchedBlobList;
UINT cbvSrvUavHandleSize = pDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
UINT samplerHandleSize = pDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
for (UINT i = 0; i < numLibraries; i++)
{
auto &library = stateObjectCollection.m_dxilLibraries[i];
if (library.NumExports > 0)
{
DxilLibraryInfo outputLibInfo((void *)library.DXILLibrary.pShaderBytecode, (UINT)library.DXILLibrary.BytecodeLength);
CComPtr<IDxcBlob> pOutputBlob;
for (UINT exportIndex = 0; exportIndex < library.NumExports; exportIndex++)
{
std::wstring exportName = library.pExports[exportIndex].Name;
auto pShaderAssociation = stateObjectCollection.m_shaderAssociations.find(exportName);
if (pShaderAssociation == stateObjectCollection.m_shaderAssociations.end())
{
for (auto &hitgroup : stateObjectCollection.m_hitGroups)
{
LPCWSTR imports[] = {
hitgroup.second.ClosestHitShaderImport,
hitgroup.second.AnyHitShaderImport,
hitgroup.second.IntersectionShaderImport
};
for(auto hitgroupImport : imports)
{
if (hitgroupImport && exportName == std::wstring(hitgroupImport))
{
pShaderAssociation = stateObjectCollection.m_shaderAssociations.find(hitgroup.first);
}
}
}
}
if (pShaderAssociation != stateObjectCollection.m_shaderAssociations.end() && pShaderAssociation->second.m_pRootSignature)
{
CComPtr<ID3D12VersionedRootSignatureDeserializer> pDeserializer;
ShaderInfo shaderInfo;
shaderInfo.pRootSignatureDesc = GetDescFromRootSignature(pShaderAssociation->second.m_pRootSignature, pDeserializer);
if (GetNumParameters(*shaderInfo.pRootSignatureDesc) > 0)
{
shaderInfo.SamplerDescriptorSizeInBytes = samplerHandleSize;
shaderInfo.SrvCbvUavDescriptorSizeInBytes = cbvSrvUavHandleSize;
shaderInfo.ShaderRecordIdentifierSizeInBytes = sizeof(ShaderIdentifier);
shaderInfo.ExportName = exportName.c_str();
CComPtr<IDxcBlob> pPatchedBlob;
m_DxilShaderPatcher.PatchShaderBindingTables(
(const BYTE *)outputLibInfo.pByteCode,
(UINT)outputLibInfo.BytecodeLength,
&shaderInfo,
&pPatchedBlob);
pOutputBlob = pPatchedBlob;
outputLibInfo = DxilLibraryInfo(pOutputBlob->GetBufferPointer(), pOutputBlob->GetBufferSize());
}
}
}
patchedBlobList.push_back(pOutputBlob);
librariesInfo.emplace_back(outputLibInfo);
}
for(UINT exportIndex = 0; exportIndex < library.NumExports; exportIndex++)
exportNames.push_back(library.pExports[exportIndex].Name);
}
{
auto &traversalShader = stateObjectCollection.m_traversalShader.DXILLibrary;
librariesInfo.emplace_back((void *)traversalShader.pShaderBytecode, traversalShader.BytecodeLength);
exportNames.push_back(L"Fallback_TraceRay");
}
{
librariesInfo.emplace_back((void *)g_pStateMachineLib, ARRAYSIZE(g_pStateMachineLib));
}
std::vector<FallbackLayer::StateIdentifier> stateIdentifiers;
CComPtr<IDxcBlob> pLinkedBlob;
UINT stackSize = (UINT)stateObjectCollection.m_pipelineStackSize;
if (stackSize == 0 && (stateObjectCollection.IsUsingAnyHit || stateObjectCollection.IsUsingIntersection))
{
// TODO: The stack size used by the traversal shader is high when it's split by a continuation from the
// Intersection shader or the Anyhit. Currently setting a higher hard-coded value, this can go-away
// once API-specified stack-sizes are supported
stackSize = 2048;
}
m_DxilShaderPatcher.LinkShaders(stackSize, librariesInfo, exportNames, stateIdentifiers, &pLinkedBlob);
for (size_t i = 0; i < exportNames.size(); ++i)
{
m_ExportNameToShaderIdentifier[exportNames[i]] = { stateIdentifiers[i], 0 };
}
for (auto &hitGroupMapEntry : stateObjectCollection.m_hitGroups)
{
auto closestHitName = hitGroupMapEntry.second.ClosestHitShaderImport;
auto anyHitName = hitGroupMapEntry.second.AnyHitShaderImport;
auto intersectionName = hitGroupMapEntry.second.IntersectionShaderImport;
ShaderIdentifier shaderId = {};
shaderId.StateId = GetStateIdentfier(closestHitName);
shaderId.AnyHitId = GetStateIdentfier(anyHitName);
shaderId.IntersectionShaderId = GetStateIdentfier(intersectionName);
auto hitGroupName = hitGroupMapEntry.first;
m_ExportNameToShaderIdentifier[hitGroupName] = shaderId;
}
CompilePSO(
pDevice,
CD3DX12_SHADER_BYTECODE(pLinkedBlob->GetBufferPointer(), pLinkedBlob->GetBufferSize()),
stateObjectCollection,
&m_pRayTracePSO);
UINT sizeOfParamterStart = sizeof(m_patchRootSignatureParameterStart);
ThrowFailure(stateObjectCollection.m_pGlobalRootSignature->GetPrivateData(
FallbackLayerPatchedParameterStartGUID,
&sizeOfParamterStart,
&m_patchRootSignatureParameterStart),
L"Root signatures in a state object must be created through "
L"Fallback Layer-specific interaces. Either use RaytracingDevice::D3D12SerializeRootSignature "
L"or RaytracingDevice::D3D12SerializeFallbackRootSignature and create with "
L"RaytracingDevice::CreateRootSignature");
}
ShaderIdentifier *UberShaderRaytracingProgram::GetShaderIdentifier(LPCWSTR pExportName)
{
auto pEntry = m_ExportNameToShaderIdentifier.find(pExportName);
if (pEntry == m_ExportNameToShaderIdentifier.end())
{
return nullptr;
}
else
{
// Handing out this pointer is safe because the map is read-only at this point
return &pEntry->second;
}
}
void UberShaderRaytracingProgram::DispatchRays(
ID3D12GraphicsCommandList *pCommandList,
ID3D12DescriptorHeap *pSrvCbvUavDescriptorHeap,
ID3D12DescriptorHeap *pSamplerDescriptorHeap,
const std::unordered_map<UINT, WRAPPED_GPU_POINTER> &boundAccelerationStructures,
const D3D12_FALLBACK_DISPATCH_RAYS_DESC &desc)
{
assert(pSrvCbvUavDescriptorHeap);
pCommandList->SetComputeRootDescriptorTable(m_patchRootSignatureParameterStart + CbvSrvUavDescriptorHeapAliasedTables, pSrvCbvUavDescriptorHeap->GetGPUDescriptorHandleForHeapStart());
if (pSamplerDescriptorHeap)
{
pCommandList->SetComputeRootDescriptorTable(m_patchRootSignatureParameterStart + SamplerDescriptorHeapAliasedTables, pSamplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart());
}
if (desc.HitGroupTable.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + HitGroupRecord, desc.HitGroupTable.StartAddress);
}
if (desc.MissShaderTable.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + MissShaderRecord, desc.MissShaderTable.StartAddress);
}
if (desc.RayGenerationShaderRecord.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + RayGenShaderRecord, desc.RayGenerationShaderRecord.StartAddress);
}
if (desc.CallableShaderTable.StartAddress)
{
pCommandList->SetComputeRootShaderResourceView(m_patchRootSignatureParameterStart + CallableShaderRecord, desc.CallableShaderTable.StartAddress);
}
DispatchRaysConstants constants;
constants.RayDispatchDimensionsWidth = desc.Width;
constants.RayDispatchDimensionsHeight = desc.Height;
constants.HitGroupShaderRecordStride = static_cast<UINT>(desc.HitGroupTable.StrideInBytes);
constants.MissShaderRecordStride = static_cast<UINT>(desc.MissShaderTable.StrideInBytes);
constants.SrvCbvUavDescriptorHeapStart = pSrvCbvUavDescriptorHeap->GetGPUDescriptorHandleForHeapStart().ptr;
constants.SamplerDescriptorHeapStart = pSamplerDescriptorHeap ? pSamplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart().ptr : 0;
pCommandList->SetComputeRoot32BitConstants(m_patchRootSignatureParameterStart + DispatchConstants, SizeOfInUint32(DispatchRaysConstants), &constants, 0);
UINT entriesAdded = 0;
std::vector<WRAPPED_GPU_POINTER> AccelerationStructuresEntries(boundAccelerationStructures.size());
for (auto &entry : boundAccelerationStructures)
{
AccelerationStructuresEntries[entriesAdded++] = entry.second;
}
pCommandList->SetComputeRoot32BitConstants(
m_patchRootSignatureParameterStart + AccelerationStructuresList, (UINT)(AccelerationStructuresEntries.size() * (SizeOfInUint32(*AccelerationStructuresEntries.data()))), AccelerationStructuresEntries.data(), 0);
#ifdef DEBUG
m_pPredispatchCallback(pCommandList, m_patchRootSignatureParameterStart);
#endif
UINT dispatchWidth = DivideAndRoundUp<UINT>(desc.Width, THREAD_GROUP_WIDTH);
UINT dispatchHeight = DivideAndRoundUp<UINT>(desc.Height, THREAD_GROUP_HEIGHT);
pCommandList->SetPipelineState(m_pRayTracePSO);
pCommandList->Dispatch(dispatchWidth, dispatchHeight, 1);
}
}
<|endoftext|> |
<commit_before>//////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007-2009, Image Engine Design Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of Image Engine Design nor the names of any
// other contributors to this software may be used to endorse or
// promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <iterator>
#include <fstream>
#include "boost/bind.hpp"
#include "boost/version.hpp"
#if BOOST_VERSION >= 103600
#define BOOST_SPIRIT_USE_OLD_NAMESPACE
#include "boost/spirit/include/classic.hpp"
#else
#include "boost/spirit.hpp"
#endif
#include "IECore/OBJReader.h"
#include "IECore/CompoundData.h"
#include "IECore/SimpleTypedData.h"
#include "IECore/VectorTypedData.h"
#include "IECore/MessageHandler.h"
#include "IECore/NumericParameter.h"
#include "IECore/TypedParameter.h"
#include "IECore/MeshPrimitive.h"
#include "IECore/CompoundParameter.h"
#include "IECore/FileNameParameter.h"
#include "IECore/ObjectParameter.h"
#include "IECore/NullObject.h"
using namespace std;
using namespace IECore;
using namespace Imath;
using namespace boost;
using namespace boost::spirit;
IE_CORE_DEFINERUNTIMETYPED(OBJReader);
// syntactic sugar for specifying our grammar
typedef boost::spirit::rule<boost::spirit::phrase_scanner_t> srule;
const Reader::ReaderDescription<OBJReader> OBJReader::m_readerDescription("obj");
OBJReader::OBJReader( const string &name )
: Reader(name, "Alias Wavefront OBJ 3D data reader", new ObjectParameter("result", "the loaded 3D object", new
NullObject, MeshPrimitive::staticTypeId()))
{
m_fileNameParameter->setTypedValue(name);
}
bool OBJReader::canRead( const string &fileName )
{
// there really are no magic numbers, .obj is a simple ascii text file
// so: enforce at least that the file has '.obj' extension
if(fileName.rfind(".obj") != fileName.length() - 4)
return false;
// attempt to open the file
ifstream in(fileName.c_str());
return in.is_open();
}
ObjectPtr OBJReader::doOperation(ConstCompoundObjectPtr operands)
{
// for now we are going to retrieve vertex, texture, normal coordinates, faces.
// later (when we have the primitives), we will handle a larger subset of the
// OBJ format
IntVectorDataPtr vpf = new IntVectorData();
m_vpf = &vpf->writable();
IntVectorDataPtr vids = new IntVectorData();
m_vids = &vids->writable();
PrimitiveVariable::Interpolation i = PrimitiveVariable::Vertex;
MeshPrimitivePtr mesh = new MeshPrimitive();
V3fVectorDataPtr vertices = new V3fVectorData();
m_vertices = &vertices->writable();
mesh->variables.insert(PrimitiveVariableMap::value_type("P", PrimitiveVariable(i, vertices)));
// separate texture coordinates
FloatVectorDataPtr sTextureCoordinates = new FloatVectorData();
m_sTextureCoordinates = &sTextureCoordinates->writable();
mesh->variables.insert(PrimitiveVariableMap::value_type("s", PrimitiveVariable(i, sTextureCoordinates)));
FloatVectorDataPtr tTextureCoordinates = new FloatVectorData();
m_tTextureCoordinates = &tTextureCoordinates->writable();
mesh->variables.insert(PrimitiveVariableMap::value_type("t", PrimitiveVariable(i, tTextureCoordinates)));
// build normals
V3fVectorDataPtr normals = new V3fVectorData();
m_normals = &normals->writable();
mesh->variables.insert(PrimitiveVariableMap::value_type("N", PrimitiveVariable(i, normals)));
// parse the file
parseOBJ();
// create our MeshPrimitive
mesh->setTopology(vpf, vids, "linear");
return mesh;
}
// parse a vertex
void OBJReader::parseVertex(const char * begin, const char * end)
{
vector<float> vec;
srule vertex = "v" >> real_p[append(vec)] >> real_p[append(vec)] >> real_p[append(vec)];
parse_info<> result = parse(begin, vertex, space_p);
// build v
V3f v;
v[0] = vec[0];
v[1] = vec[1];
v[2] = vec[2];
// add this vertex
m_vertices->push_back(v);
}
// parse a texture coordinate
void OBJReader::parseTextureCoordinate(const char * begin, const char * end)
{
vector<float> vec;
srule vertex = "vt" >> real_p[append(vec)] >> real_p[append(vec)] >> *(real_p[append(vec)]);
parse_info<> result = parse(begin, vertex, space_p);
// build v
V3f vt;
vt[0] = vec[0];
vt[1] = vec[1];
vt[2] = vec.size() == 3 ? vec[2] : 0.0f;
// add this texture coordinate
m_introducedTextureCoordinates.push_back(vt);
}
// parse a normal
void OBJReader::parseNormal(const char * begin, const char * end)
{
vector<float> vec;
srule vertex = "vn" >> real_p[append(vec)] >> real_p[append(vec)] >> real_p[append(vec)];
parse_info<> result = parse(begin, vertex, space_p);
// build v
V3f vn;
vn[0] = vec[0];
vn[1] = vec[1];
vn[2] = vec[2];
// add this normal
m_introducedNormals.push_back(vn);
}
// parse face
void OBJReader::parseFace(const char * begin, const char * end)
{
vector<int> vec;
vector<int> tvec;
vector<int> nvec;
srule entry = int_p[append(vec)] >>
(
("/" >> (int_p[append(tvec)] | epsilon_p) >> "/" >> (int_p[append(nvec)] | epsilon_p))
| epsilon_p
);
srule face = "f" >> entry >> entry >> entry >> *(entry);
parse_info<> result = parse(begin, face, space_p);
// push back the degree of the face
m_vpf->push_back(vec.size());
// merge in the edges. we index from 0, so shift them down.
// also, vertices may be indexed negatively, in which case they are relative to
// the current set of vertices
for(vector<int>::const_iterator i = vec.begin(); i != vec.end(); ++i)
{
m_vids->push_back(*i > 0 ? *i - 1 : m_vertices->size() + *i);
}
// merge in texture coordinates and normals, if present
// OBJ format requires an encoding for faces which uses one of the vertex/texture/normal specifications
// consistently across the entire face. eg. we can have all v/vt/vn, or all v//vn, or all v, but not
// v//vn then v/vt/vn ...
if(!nvec.empty())
{
if(nvec.size() != vec.size())
throw Exception("invalid face specification");
// copy in these references to normal vectors to the mesh's normal vector
for(vector<int>::const_iterator i = nvec.begin(); i != nvec.end(); ++i)
{
m_normals->push_back(m_introducedNormals[*i > 0 ? *i - 1 : m_introducedNormals.size() + *i]);
}
}
// otherwise, check if we have specified normals in some previous face
// if so, and no normals were given here (examples, encoders that do this?), pump in
// default normal. the default normal defined here is the zero normal, which is by
// definition orthogonal to every other vector. this might result in odd lighting.
else
{
V3f zero(0.0f, 0.0f, 0.0f);
for(unsigned int i = 0; i < nvec.size(); ++i)
{
m_normals->push_back(zero);
}
}
//
// merge in texture coordinates, if present
//
if(!tvec.empty())
{
if(tvec.size() != vec.size())
throw Exception("invalid face specification");
for(unsigned int i = 0; i < tvec.size(); ++i)
{
int index = tvec[i] > 0 ? tvec[i] - 1 : m_introducedTextureCoordinates.size() + tvec[i];
m_sTextureCoordinates->push_back(m_introducedTextureCoordinates[index][0]);
m_tTextureCoordinates->push_back(m_introducedTextureCoordinates[index][1]);
}
}
else
{
for(unsigned int i = 0; i < tvec.size(); ++i)
{
m_sTextureCoordinates->push_back(0.0f);
m_tTextureCoordinates->push_back(0.0f);
}
}
}
void OBJReader::parseGroup(const char *begin, const char *end)
{
// set current group
vector<string> groupNames;
srule grouping = "g" >> *(lexeme_d[alnum_p >> *(alnum_p)][append(groupNames)]);
parse_info<> result = parse(begin, grouping, space_p);
// from 'http://local.wasp.uwa.edu.au/~pbourke/dataformats/obj/':
// The default group name is default.
if(groupNames.empty())
{
groupNames.push_back("default");
}
// \todo associate mesh objects with group names
}
void OBJReader::parseOBJ() {
srule comment = comment_p("#");
// see
// http://local.wasp.uwa.edu.au/~pbourke/dataformats/obj/
// vertices
srule vertex = ("v" >> real_p >> real_p >> real_p) [bind(&OBJReader::parseVertex, ref(this), _1, _2)];
srule vertex_texture = ("vt" >> real_p >> real_p) [bind(&OBJReader::parseTextureCoordinate, ref(this), _1, _2)];
srule vertex_normal = ("vn" >> real_p >> real_p >> real_p) [bind(&OBJReader::parseNormal, ref(this), _1, _2)];
//srule vertex_parameter_space = "vp" >> real_p >> real_p >> real_p;
// srule cs_types = ("bmatrix" | "bezier" | "bspline" | "cardinal" | "taylor");
// srule vertex_curve_or_surface = "cstype" >> "rat" >> cs_types;
// srule vertex_degree = "deg" >> real_p >> real_p;
// srule vertex_basis_matrix = "bmat";
// srule vertex_step_size = "step" >> int_p >> int_p;
srule vertex_type = vertex | vertex_texture | vertex_normal;
// elements
srule point = "p" >> real_p >> *(real_p);
srule line = "l" >> int_p >> int_p >> *(int_p);
srule face = (ch_p('f') >> *(anychar_p))[bind(&OBJReader::parseFace, ref(this), _1, _2)];
// srule curve = "curv";
// srule curve_2d = "curv2";
// srule surface = "surf";
srule element = point | line | face;
// free-form curve / surface statements
// srule parameter = "parm";
// srule trim_loop = "trim";
// srule hole_loop = "hole";
// srule special_curve = "scrv";
// srule special_point = "sp";
// srule end_statement = "end";
// connectivity
//srule connect = "con";
// grouping
srule group_name = ("g" >> *(anychar_p))[bind(&OBJReader::parseGroup, ref(this), _1, _2)];
// srule smoothing_group = "s";
// srule merging_group = "mg";
srule object_name = "o" >> int_p;
srule grouping = group_name | object_name;
// display and render attributes
// srule bevel_interpretation = "bevel";
// srule color_interpolation = "c_interp";
// srule dissolve_interpolation = "d_interp";
// srule level_of_detail = "lod";
// srule material_name = "usemtl";
// srule material_library = "mtllib";
// srule shadow_casting = "shadow_obj";
// srule ray_tracing = "trace_obj";
// srule curve_approximation_technique = "ctech";
// srule surface_approximation_technique = "stech";
ifstream in(fileName().c_str());
string str;
while(getline(in, str))
parse(str.c_str(), vertex_type | element | grouping | comment, space_p);
}
<commit_msg>Correcting interpolation of texture coordinates and normals to be FaceVarying, courtesy of Roberto Hradec. Also only adding these primvars if they actually contain data, to avoid adding invalid variables.<commit_after>//////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007-2009, Image Engine Design Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of Image Engine Design nor the names of any
// other contributors to this software may be used to endorse or
// promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <iterator>
#include <fstream>
#include "boost/bind.hpp"
#include "boost/version.hpp"
#if BOOST_VERSION >= 103600
#define BOOST_SPIRIT_USE_OLD_NAMESPACE
#include "boost/spirit/include/classic.hpp"
#else
#include "boost/spirit.hpp"
#endif
#include "IECore/OBJReader.h"
#include "IECore/CompoundData.h"
#include "IECore/SimpleTypedData.h"
#include "IECore/VectorTypedData.h"
#include "IECore/MessageHandler.h"
#include "IECore/NumericParameter.h"
#include "IECore/TypedParameter.h"
#include "IECore/MeshPrimitive.h"
#include "IECore/CompoundParameter.h"
#include "IECore/FileNameParameter.h"
#include "IECore/ObjectParameter.h"
#include "IECore/NullObject.h"
using namespace std;
using namespace IECore;
using namespace Imath;
using namespace boost;
using namespace boost::spirit;
IE_CORE_DEFINERUNTIMETYPED(OBJReader);
// syntactic sugar for specifying our grammar
typedef boost::spirit::rule<boost::spirit::phrase_scanner_t> srule;
const Reader::ReaderDescription<OBJReader> OBJReader::m_readerDescription("obj");
OBJReader::OBJReader( const string &name )
: Reader(name, "Alias Wavefront OBJ 3D data reader", new ObjectParameter("result", "the loaded 3D object", new
NullObject, MeshPrimitive::staticTypeId()))
{
m_fileNameParameter->setTypedValue(name);
}
bool OBJReader::canRead( const string &fileName )
{
// there really are no magic numbers, .obj is a simple ascii text file
// so: enforce at least that the file has '.obj' extension
if(fileName.rfind(".obj") != fileName.length() - 4)
return false;
// attempt to open the file
ifstream in(fileName.c_str());
return in.is_open();
}
ObjectPtr OBJReader::doOperation(ConstCompoundObjectPtr operands)
{
// for now we are going to retrieve vertex, texture, normal coordinates, faces.
// later (when we have the primitives), we will handle a larger subset of the
// OBJ format
IntVectorDataPtr vpf = new IntVectorData();
m_vpf = &vpf->writable();
IntVectorDataPtr vids = new IntVectorData();
m_vids = &vids->writable();
V3fVectorDataPtr vertices = new V3fVectorData();
m_vertices = &vertices->writable();
// separate texture coordinates
FloatVectorDataPtr sTextureCoordinates = new FloatVectorData();
m_sTextureCoordinates = &sTextureCoordinates->writable();
FloatVectorDataPtr tTextureCoordinates = new FloatVectorData();
m_tTextureCoordinates = &tTextureCoordinates->writable();
// build normals
V3fVectorDataPtr normals = new V3fVectorData();
m_normals = &normals->writable();
// parse the file
parseOBJ();
// create our MeshPrimitive
MeshPrimitivePtr mesh = new MeshPrimitive( vpf, vids, "linear", vertices );
if( sTextureCoordinates->readable().size() )
{
mesh->variables.insert(PrimitiveVariableMap::value_type("s", PrimitiveVariable( PrimitiveVariable::FaceVarying, sTextureCoordinates)));
}
if( tTextureCoordinates->readable().size() )
{
mesh->variables.insert(PrimitiveVariableMap::value_type("t", PrimitiveVariable( PrimitiveVariable::FaceVarying, tTextureCoordinates)));
}
if( normals->readable().size() )
{
mesh->variables.insert(PrimitiveVariableMap::value_type("N", PrimitiveVariable( PrimitiveVariable::FaceVarying, normals)));
}
return mesh;
}
// parse a vertex
void OBJReader::parseVertex(const char * begin, const char * end)
{
vector<float> vec;
srule vertex = "v" >> real_p[append(vec)] >> real_p[append(vec)] >> real_p[append(vec)];
parse_info<> result = parse(begin, vertex, space_p);
// build v
V3f v;
v[0] = vec[0];
v[1] = vec[1];
v[2] = vec[2];
// add this vertex
m_vertices->push_back(v);
}
// parse a texture coordinate
void OBJReader::parseTextureCoordinate(const char * begin, const char * end)
{
vector<float> vec;
srule vertex = "vt" >> real_p[append(vec)] >> real_p[append(vec)] >> *(real_p[append(vec)]);
parse_info<> result = parse(begin, vertex, space_p);
// build v
V3f vt;
vt[0] = vec[0];
vt[1] = vec[1];
vt[2] = vec.size() == 3 ? vec[2] : 0.0f;
// add this texture coordinate
m_introducedTextureCoordinates.push_back(vt);
}
// parse a normal
void OBJReader::parseNormal(const char * begin, const char * end)
{
vector<float> vec;
srule vertex = "vn" >> real_p[append(vec)] >> real_p[append(vec)] >> real_p[append(vec)];
parse_info<> result = parse(begin, vertex, space_p);
// build v
V3f vn;
vn[0] = vec[0];
vn[1] = vec[1];
vn[2] = vec[2];
// add this normal
m_introducedNormals.push_back(vn);
}
// parse face
void OBJReader::parseFace(const char * begin, const char * end)
{
vector<int> vec;
vector<int> tvec;
vector<int> nvec;
srule entry = int_p[append(vec)] >>
(
("/" >> (int_p[append(tvec)] | epsilon_p) >> "/" >> (int_p[append(nvec)] | epsilon_p))
| epsilon_p
);
srule face = "f" >> entry >> entry >> entry >> *(entry);
parse_info<> result = parse(begin, face, space_p);
// push back the degree of the face
m_vpf->push_back(vec.size());
// merge in the edges. we index from 0, so shift them down.
// also, vertices may be indexed negatively, in which case they are relative to
// the current set of vertices
for(vector<int>::const_iterator i = vec.begin(); i != vec.end(); ++i)
{
m_vids->push_back(*i > 0 ? *i - 1 : m_vertices->size() + *i);
}
// merge in texture coordinates and normals, if present
// OBJ format requires an encoding for faces which uses one of the vertex/texture/normal specifications
// consistently across the entire face. eg. we can have all v/vt/vn, or all v//vn, or all v, but not
// v//vn then v/vt/vn ...
if(!nvec.empty())
{
if(nvec.size() != vec.size())
throw Exception("invalid face specification");
// copy in these references to normal vectors to the mesh's normal vector
for(vector<int>::const_iterator i = nvec.begin(); i != nvec.end(); ++i)
{
m_normals->push_back(m_introducedNormals[*i > 0 ? *i - 1 : m_introducedNormals.size() + *i]);
}
}
// otherwise, check if we have specified normals in some previous face
// if so, and no normals were given here (examples, encoders that do this?), pump in
// default normal. the default normal defined here is the zero normal, which is by
// definition orthogonal to every other vector. this might result in odd lighting.
else
{
V3f zero(0.0f, 0.0f, 0.0f);
for(unsigned int i = 0; i < nvec.size(); ++i)
{
m_normals->push_back(zero);
}
}
//
// merge in texture coordinates, if present
//
if(!tvec.empty())
{
if(tvec.size() != vec.size())
throw Exception("invalid face specification");
for(unsigned int i = 0; i < tvec.size(); ++i)
{
int index = tvec[i] > 0 ? tvec[i] - 1 : m_introducedTextureCoordinates.size() + tvec[i];
m_sTextureCoordinates->push_back(m_introducedTextureCoordinates[index][0]);
m_tTextureCoordinates->push_back(m_introducedTextureCoordinates[index][1]);
}
}
else
{
for(unsigned int i = 0; i < tvec.size(); ++i)
{
m_sTextureCoordinates->push_back(0.0f);
m_tTextureCoordinates->push_back(0.0f);
}
}
}
void OBJReader::parseGroup(const char *begin, const char *end)
{
// set current group
vector<string> groupNames;
srule grouping = "g" >> *(lexeme_d[alnum_p >> *(alnum_p)][append(groupNames)]);
parse_info<> result = parse(begin, grouping, space_p);
// from 'http://local.wasp.uwa.edu.au/~pbourke/dataformats/obj/':
// The default group name is default.
if(groupNames.empty())
{
groupNames.push_back("default");
}
// \todo associate mesh objects with group names
}
void OBJReader::parseOBJ() {
srule comment = comment_p("#");
// see
// http://local.wasp.uwa.edu.au/~pbourke/dataformats/obj/
// vertices
srule vertex = ("v" >> real_p >> real_p >> real_p) [bind(&OBJReader::parseVertex, ref(this), _1, _2)];
srule vertex_texture = ("vt" >> real_p >> real_p) [bind(&OBJReader::parseTextureCoordinate, ref(this), _1, _2)];
srule vertex_normal = ("vn" >> real_p >> real_p >> real_p) [bind(&OBJReader::parseNormal, ref(this), _1, _2)];
//srule vertex_parameter_space = "vp" >> real_p >> real_p >> real_p;
// srule cs_types = ("bmatrix" | "bezier" | "bspline" | "cardinal" | "taylor");
// srule vertex_curve_or_surface = "cstype" >> "rat" >> cs_types;
// srule vertex_degree = "deg" >> real_p >> real_p;
// srule vertex_basis_matrix = "bmat";
// srule vertex_step_size = "step" >> int_p >> int_p;
srule vertex_type = vertex | vertex_texture | vertex_normal;
// elements
srule point = "p" >> real_p >> *(real_p);
srule line = "l" >> int_p >> int_p >> *(int_p);
srule face = (ch_p('f') >> *(anychar_p))[bind(&OBJReader::parseFace, ref(this), _1, _2)];
// srule curve = "curv";
// srule curve_2d = "curv2";
// srule surface = "surf";
srule element = point | line | face;
// free-form curve / surface statements
// srule parameter = "parm";
// srule trim_loop = "trim";
// srule hole_loop = "hole";
// srule special_curve = "scrv";
// srule special_point = "sp";
// srule end_statement = "end";
// connectivity
//srule connect = "con";
// grouping
srule group_name = ("g" >> *(anychar_p))[bind(&OBJReader::parseGroup, ref(this), _1, _2)];
// srule smoothing_group = "s";
// srule merging_group = "mg";
srule object_name = "o" >> int_p;
srule grouping = group_name | object_name;
// display and render attributes
// srule bevel_interpretation = "bevel";
// srule color_interpolation = "c_interp";
// srule dissolve_interpolation = "d_interp";
// srule level_of_detail = "lod";
// srule material_name = "usemtl";
// srule material_library = "mtllib";
// srule shadow_casting = "shadow_obj";
// srule ray_tracing = "trace_obj";
// srule curve_approximation_technique = "ctech";
// srule surface_approximation_technique = "stech";
ifstream in(fileName().c_str());
string str;
while(getline(in, str))
parse(str.c_str(), vertex_type | element | grouping | comment, space_p);
}
<|endoftext|> |
<commit_before>// This file is part of the dune-stuff project:
// https://github.com/wwu-numerik/dune-stuff
// Copyright holders: Rene Milk, Felix Schindler
// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
/**
* \file logging.hh
* \brief logging
**/
#ifndef DUNE_STUFF_COMMON_LOGGING_HH
#define DUNE_STUFF_COMMON_LOGGING_HH
#include <map>
#include <string>
#include <mutex>
#include <atomic>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <dune/stuff/common/disable_warnings.hh>
# include <dune/common/parallel/mpihelper.hh>
# include <dune/common/timer.hh>
#include <dune/stuff/common/reenable_warnings.hh>
#include "logstreams.hh"
#include "color.hh"
namespace Dune {
namespace Stuff {
namespace Common {
class Logging;
Logging& Logger();
/** \brief handles all logging
**/
class Logging
{
private:
Logging();
//! cleanup stream and flag containers
void deinit();
public:
~Logging();
/** \brief setup loglevel, logfilename
* \param logflags any OR'd combination of flags
* \param logfile filename for log, can contain paths, but creation will fail if dir is non-existant
**/
void create(int logflags = (LOG_FILE | LOG_CONSOLE | LOG_ERROR),
const std::string logfile = "dune_stuff_log",
const std::string datadir = "data",
const std::string _logdir = std::string("log"));
//! \attention This will probably not do wht we want it to!
void setPrefix(std::string prefix);
void setStreamFlags(int streamID, int flags);
int getStreamFlags(int streamID) const;
/** \name forwarded Log functions
* \{
*/
template< class T >
void log(T c, int streamID)
{
getStream(streamID) << c;
} // Log
/** \}
*/
LogStream& getStream(int streamId);
LogStream& error() { return getStream(LOG_ERROR); }
LogStream& info() { return getStream(LOG_INFO); }
LogStream& debug() { return getStream(LOG_DEBUG); }
LogStream& devnull() { return emptyLogStream_; }
//! flush all active streams
void flush();
//! creates a new LogStream with given id
int addStream(int flags);
//! re-enable all logging below given priority level
void resume(LogStream::PriorityType prio = LogStream::default_suspend_priority);
//! (temporarily) disable all logging below given priority level
void suspend(LogStream::PriorityType prio = LogStream::default_suspend_priority);
struct SuspendLocal
{
LogStream::PriorityType prio_;
SuspendLocal(LogStream::PriorityType prio = LogStream::default_suspend_priority)
: prio_(prio) {
Logger().suspend(prio_);
}
~SuspendLocal() {
Logger().resume(prio_);
}
};
struct ResumeLocal
{
LogStream::PriorityType prio_;
ResumeLocal(LogStream::PriorityType prio = LogStream::default_suspend_priority)
: prio_(prio) {
Logger().resume(prio_);
}
~ResumeLocal() {
Logger().suspend(prio_);
}
};
private:
boost::filesystem::path filename_;
boost::filesystem::path filenameWoTime_;
boost::filesystem::ofstream logfile_;
typedef std::map< int, int > FlagMap;
FlagMap flagmap_;
typedef std::map< int, std::unique_ptr< LogStream> > StreamMap;
StreamMap streammap_;
typedef std::vector< int > IdVec;
IdVec streamIDs_;
int logflags_;
EmptyLogStream emptyLogStream_;
friend Logging& Logger();
// satisfy stricter warnings wrt copying
Logging(const Logging&) = delete;
Logging& operator=(const Logging&) = delete;
};
//! global Logging instance
inline Logging& Logger()
{
static Logging log;
return log;
}
/**
* \brief A logging manager that provides info, debug and warning streams
*
* \note Most likely you do not want to use this class directly but TimedLogger() instead.
*/
class TimedLogManager
{
public:
TimedLogManager(const Timer& timer,
const std::string info_prefix,
const std::string debug_prefix,
const std::string warning_prefix,
const ssize_t max_info_level,
const ssize_t max_debug_level,
const bool enable_warnings,
std::atomic< ssize_t >& current_level,
std::ostream& disabled_out = dev_null,
std::ostream& enabled_out = std::cout,
std::ostream& warn_out = std::cerr);
~TimedLogManager();
std::ostream& info();
std::ostream& debug();
std::ostream& warn();
private:
const Timer& timer_;
std::atomic< ssize_t >& current_level_;
std::shared_ptr< std::ostream > info_;
std::shared_ptr< std::ostream > debug_;
std::shared_ptr< std::ostream > warn_;
}; // class TimedLogManager
/**
* \brief A logger that provides colored and prefixed streams.
*
* \note Most likely you do not want to use this class directly, but TimedLogger() instead.
*/
class TimedLogging
{
public:
static const ssize_t default_max_info_level = -1;
static const ssize_t default_max_debug_level = -1;
static const bool default_enable_warnings = true;
static const bool default_enable_colors = true;
static const std::string default_info_color() { return "white"; }
static const std::string default_debug_color() { return "lightgray"; }
static const std::string default_warning_color() { return "red"; }
TimedLogging();
/**
* \brief sets the state
*
* This methos is mainly intended to be used on the global TimedLogger() instance. Before calling this method
* the state is set according to the defaults default_max_info_level, default_max_debug_level and
* default_enable_warnings.
* \note Calling this method more than once will throw an Exceptions::you_are_using_this_wrong, following the idea of
* least surprise.
*/
void create(const ssize_t max_info_level = default_max_info_level,
const ssize_t max_debug_level = default_max_debug_level,
const bool enable_warnings = default_enable_warnings,
const bool enable_colors = default_enable_colors,
const std::string info_color = default_info_color(),
const std::string debug_color = default_debug_color(),
const std::string warning_color = default_warning_color());
TimedLogManager get(const std::string id);
private:
void update_colors();
ssize_t max_info_level_;
ssize_t max_debug_level_;
bool enable_warnings_;
bool enable_colors_;
std::string info_prefix_;
std::string debug_prefix_;
std::string warning_prefix_;
std::string info_suffix_;
std::string debug_suffix_;
std::string warning_suffix_;
bool created_;
std::atomic< ssize_t > current_level_;
Timer timer_;
std::mutex mutex_;
}; // class TimedLogging
/**
* \brief Global instance of the timed logger.
*
* This global logger instance is intended to be used in two ways:
* - Many classes or functions use this instance to log info, debug or warning messages. You can do so in your
* code by calling the TimedLogging::get() method, providing an identifier that should resemble the current
* scope:
\code
void user_function()
{
TimedLogger().get("user_function").info() << "some information" << std::endl;
for (size_t ii = 0; ii < 100; ++ii)
TimedLogger().get("user_function").debug() << "debug output number " << ii << std::endl;
}
\endcode
You can also hold a TimedLogManager object within the current scope or class, if wished:
\code
class UserClass
{
public:
UserClass()
: logger_(TimedLogger().get("UserClass"))
{}
void some_method()
{
logger_.warn() << "something is severly wrong!" << std::endl;
}
private:
TimedLogManager logger_;
}
\endcode
* Each time a new TimedLogManager is created using TimedLogging::get() the loglevel is increased, each time
* such a logger goes out of scope the loglevel is decreased.
* - You can use this instance to control the level (and style) of logging you want to have enabled in your
* application. You should call TimedLogging::create() as soon as possible (and only once!), until then all
* logging (execpt warnings) is disabled:
\code
void silent_function()
{
auto logger = TimedLogger().get("silent_function");
logger.info() << "This will never show!" << std::endl;
const bool all_is_well = false;
if (!all_is_well)
logger.warn() << "But this warning will!" << std::endl;
}
int main()
{
TimedLogger().create(0, // max info level (only the first)
-1, // max debug level (disabled)
true // warnings are enabled
);
auto logger = TimedLogger().get("main");
logger.info() << "Welcome to my application!" << std::endl;
logger.debug() << "This will never show!" << std::endl;
silent_function();
}
\endcode
* In addition you can enable coloring of the streams (see TimedPrefixedLogStream) and give their respective
* colors, if wished (see the implementation of color_map() or the foreground colors of Colors for available
* colors):
\code
int main()
{
TimedLogger().create(10, // max info level
2, // max debug level
true, // warnings are enabled (the default)
true, // colors are enabled (the default)
"white", // info color (the default)
"lightgrey", // debug color (the default)
"red" // warning color (the default)
);
auto logger = TimedLogger().get("main");
logger.info() << "<- The 'main' prefix left of this should be white!" << std::endl;
logger.warn() << "<- The 'warn' prefix left of this should be red!" << std::endl;
}
\endcode
* \note Debug logging is only enabled if NDEBUG is not defined.
*/
TimedLogging& TimedLogger();
} // namespace Common
} // namespace Stuff
} // namespace Dune
#define DSC_LOG Dune::Stuff::Common::Logger()
#define DSC_LOG_INFO DSC_LOG.info()
#define DSC_LOG_DEBUG DSC_LOG.debug()
#define DSC_LOG_ERROR DSC_LOG.error()
#define DSC_LOG_DEVNULL DSC_LOG.devnull()
#define DSC_LOG_INFO_0 \
(Dune::MPIHelper::getCollectiveCommunication().rank() == 0 ? DSC_LOG.info() : DSC_LOG.devnull())
#define DSC_LOG_DEBUG_0 \
(Dune::MPIHelper::getCollectiveCommunication().rank() == 0 ? DSC_LOG.debug() : DSC_LOG.devnull())
#define DSC_LOG_ERROR_0 \
(Dune::MPIHelper::getCollectiveCommunication().rank() == 0 ? DSC_LOG.error() : DSC_LOG.devnull())
#endif // DUNE_STUFF_COMMON_LOGGING_HH
<commit_msg>[common.logging] updated default debug color and documentation<commit_after>// This file is part of the dune-stuff project:
// https://github.com/wwu-numerik/dune-stuff
// Copyright holders: Rene Milk, Felix Schindler
// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
/**
* \file logging.hh
* \brief logging
**/
#ifndef DUNE_STUFF_COMMON_LOGGING_HH
#define DUNE_STUFF_COMMON_LOGGING_HH
#include <map>
#include <string>
#include <mutex>
#include <atomic>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <dune/stuff/common/disable_warnings.hh>
# include <dune/common/parallel/mpihelper.hh>
# include <dune/common/timer.hh>
#include <dune/stuff/common/reenable_warnings.hh>
#include "logstreams.hh"
#include "color.hh"
namespace Dune {
namespace Stuff {
namespace Common {
class Logging;
Logging& Logger();
/** \brief handles all logging
**/
class Logging
{
private:
Logging();
//! cleanup stream and flag containers
void deinit();
public:
~Logging();
/** \brief setup loglevel, logfilename
* \param logflags any OR'd combination of flags
* \param logfile filename for log, can contain paths, but creation will fail if dir is non-existant
**/
void create(int logflags = (LOG_FILE | LOG_CONSOLE | LOG_ERROR),
const std::string logfile = "dune_stuff_log",
const std::string datadir = "data",
const std::string _logdir = std::string("log"));
//! \attention This will probably not do wht we want it to!
void setPrefix(std::string prefix);
void setStreamFlags(int streamID, int flags);
int getStreamFlags(int streamID) const;
/** \name forwarded Log functions
* \{
*/
template< class T >
void log(T c, int streamID)
{
getStream(streamID) << c;
} // Log
/** \}
*/
LogStream& getStream(int streamId);
LogStream& error() { return getStream(LOG_ERROR); }
LogStream& info() { return getStream(LOG_INFO); }
LogStream& debug() { return getStream(LOG_DEBUG); }
LogStream& devnull() { return emptyLogStream_; }
//! flush all active streams
void flush();
//! creates a new LogStream with given id
int addStream(int flags);
//! re-enable all logging below given priority level
void resume(LogStream::PriorityType prio = LogStream::default_suspend_priority);
//! (temporarily) disable all logging below given priority level
void suspend(LogStream::PriorityType prio = LogStream::default_suspend_priority);
struct SuspendLocal
{
LogStream::PriorityType prio_;
SuspendLocal(LogStream::PriorityType prio = LogStream::default_suspend_priority)
: prio_(prio) {
Logger().suspend(prio_);
}
~SuspendLocal() {
Logger().resume(prio_);
}
};
struct ResumeLocal
{
LogStream::PriorityType prio_;
ResumeLocal(LogStream::PriorityType prio = LogStream::default_suspend_priority)
: prio_(prio) {
Logger().resume(prio_);
}
~ResumeLocal() {
Logger().suspend(prio_);
}
};
private:
boost::filesystem::path filename_;
boost::filesystem::path filenameWoTime_;
boost::filesystem::ofstream logfile_;
typedef std::map< int, int > FlagMap;
FlagMap flagmap_;
typedef std::map< int, std::unique_ptr< LogStream> > StreamMap;
StreamMap streammap_;
typedef std::vector< int > IdVec;
IdVec streamIDs_;
int logflags_;
EmptyLogStream emptyLogStream_;
friend Logging& Logger();
// satisfy stricter warnings wrt copying
Logging(const Logging&) = delete;
Logging& operator=(const Logging&) = delete;
};
//! global Logging instance
inline Logging& Logger()
{
static Logging log;
return log;
}
/**
* \brief A logging manager that provides info, debug and warning streams
*
* \note Most likely you do not want to use this class directly but TimedLogger() instead.
*/
class TimedLogManager
{
public:
TimedLogManager(const Timer& timer,
const std::string info_prefix,
const std::string debug_prefix,
const std::string warning_prefix,
const ssize_t max_info_level,
const ssize_t max_debug_level,
const bool enable_warnings,
std::atomic< ssize_t >& current_level,
std::ostream& disabled_out = dev_null,
std::ostream& enabled_out = std::cout,
std::ostream& warn_out = std::cerr);
~TimedLogManager();
std::ostream& info();
std::ostream& debug();
std::ostream& warn();
private:
const Timer& timer_;
std::atomic< ssize_t >& current_level_;
std::shared_ptr< std::ostream > info_;
std::shared_ptr< std::ostream > debug_;
std::shared_ptr< std::ostream > warn_;
}; // class TimedLogManager
/**
* \brief A logger that provides colored and prefixed streams.
*
* \note Most likely you do not want to use this class directly, but TimedLogger() instead.
*/
class TimedLogging
{
public:
static const ssize_t default_max_info_level = -1;
static const ssize_t default_max_debug_level = -1;
static const bool default_enable_warnings = true;
static const bool default_enable_colors = true;
static const std::string default_info_color() { return "white"; }
static const std::string default_debug_color() { return "darkgray"; }
static const std::string default_warning_color() { return "red"; }
TimedLogging();
/**
* \brief sets the state
*
* This methos is mainly intended to be used on the global TimedLogger() instance. Before calling this method
* the state is set according to the defaults default_max_info_level, default_max_debug_level and
* default_enable_warnings.
* \note Calling this method more than once will throw an Exceptions::you_are_using_this_wrong, following the idea of
* least surprise.
*/
void create(const ssize_t max_info_level = default_max_info_level,
const ssize_t max_debug_level = default_max_debug_level,
const bool enable_warnings = default_enable_warnings,
const bool enable_colors = default_enable_colors,
const std::string info_color = default_info_color(),
const std::string debug_color = default_debug_color(),
const std::string warning_color = default_warning_color());
TimedLogManager get(const std::string id);
private:
void update_colors();
ssize_t max_info_level_;
ssize_t max_debug_level_;
bool enable_warnings_;
bool enable_colors_;
std::string info_prefix_;
std::string debug_prefix_;
std::string warning_prefix_;
std::string info_suffix_;
std::string debug_suffix_;
std::string warning_suffix_;
bool created_;
std::atomic< ssize_t > current_level_;
Timer timer_;
std::mutex mutex_;
}; // class TimedLogging
/**
* \brief Global instance of the timed logger.
*
* This global logger instance is intended to be used in two ways:
* - Many classes or functions use this instance to log info, debug or warning messages. You can do so in your
* code by calling the TimedLogging::get() method, providing an identifier that should resemble the current
* scope:
\code
void user_function()
{
TimedLogger().get("user_function").info() << "some information" << std::endl;
for (size_t ii = 0; ii < 100; ++ii)
TimedLogger().get("user_function").debug() << "debug output number " << ii << std::endl;
}
\endcode
You can also hold a TimedLogManager object within the current scope or class, if wished:
\code
class UserClass
{
public:
UserClass()
: logger_(TimedLogger().get("UserClass"))
{}
void some_method()
{
logger_.warn() << "something is severly wrong!" << std::endl;
}
private:
TimedLogManager logger_;
}
\endcode
* Each time a new TimedLogManager is created using TimedLogging::get() the loglevel is increased, each time
* such a logger goes out of scope the loglevel is decreased.
* - You can use this instance to control the level (and style) of logging you want to have enabled in your
* application. You should call TimedLogging::create() as soon as possible (and only once!), until then all
* logging (execpt warnings) is disabled:
\code
void silent_function()
{
auto logger = TimedLogger().get("silent_function");
logger.info() << "This will never show!" << std::endl;
const bool all_is_well = false;
if (!all_is_well)
logger.warn() << "But this warning will!" << std::endl;
}
int main()
{
TimedLogger().create(0, // max info level (only the first)
-1, // max debug level (disabled)
true // warnings are enabled
);
auto logger = TimedLogger().get("main");
logger.info() << "Welcome to my application!" << std::endl;
logger.debug() << "This will never show!" << std::endl;
silent_function();
}
\endcode
* In addition you can enable coloring of the streams (see TimedPrefixedLogStream) and give their respective
* colors, if wished (see the implementation of color_map() or the foreground colors of Colors for available
* colors):
\code
int main()
{
TimedLogger().create(10, // max info level
2, // max debug level
true, // warnings are enabled (the default)
true, // colors are enabled (the default)
"white", // info color (the default)
"lightgrey", // debug color (the default)
"red" // warning color (the default)
);
auto logger = TimedLogger().get("main");
logger.info() << "<- The 'main' prefix left of this should be white!" << std::endl;
logger.warn() << "<- The 'warn' prefix left of this should be red!" << std::endl;
}
\endcode
* \note Debug logging is only enabled if NDEBUG is not defined but you might still want to guard calls to
* logger.debug() for performance reasons.
*/
TimedLogging& TimedLogger();
} // namespace Common
} // namespace Stuff
} // namespace Dune
#define DSC_LOG Dune::Stuff::Common::Logger()
#define DSC_LOG_INFO DSC_LOG.info()
#define DSC_LOG_DEBUG DSC_LOG.debug()
#define DSC_LOG_ERROR DSC_LOG.error()
#define DSC_LOG_DEVNULL DSC_LOG.devnull()
#define DSC_LOG_INFO_0 \
(Dune::MPIHelper::getCollectiveCommunication().rank() == 0 ? DSC_LOG.info() : DSC_LOG.devnull())
#define DSC_LOG_DEBUG_0 \
(Dune::MPIHelper::getCollectiveCommunication().rank() == 0 ? DSC_LOG.debug() : DSC_LOG.devnull())
#define DSC_LOG_ERROR_0 \
(Dune::MPIHelper::getCollectiveCommunication().rank() == 0 ? DSC_LOG.error() : DSC_LOG.devnull())
#endif // DUNE_STUFF_COMMON_LOGGING_HH
<|endoftext|> |
<commit_before>//
// Alert system
//
#include <algorithm>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/thread.hpp>
#include <map>
#include "alert.h"
#include "key.h"
#include "net.h"
#include "sync.h"
#include "ui_interface.h"
#include "uint256.h"
using namespace std;
map<uint256, CAlert> mapAlerts;
CCriticalSection cs_mapAlerts;
static const char* pszMainKey = "0486bce1bac0d543f104cbff2bd23680056a3b9ea05e1137d2ff90eeb5e08472eb500322593a2cb06fbf8297d7beb6cd30cb90f98153b5b7cce1493749e41e0284";
// TestNet alerts pubKey
static const char* pszTestKey = "0471dc165db490094d35cde15b1f5d755fa6ad6f2b5ed0f340e3f17f57389c3c2af113a8cbcc885bde73305a553b5640c83021128008ddf882e856336269080496";
// TestNet alerts private key
// "308201130201010420b665cff1884e53da26376fd1b433812c9a5a8a4d5221533b15b9629789bb7e42a081a53081a2020101302c06072a8648ce3d0101022100fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f300604010004010704410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8022100fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141020101a1440342000471dc165db490094d35cde15b1f5d755fa6ad6f2b5ed0f340e3f17f57389c3c2af113a8cbcc885bde73305a553b5640c83021128008ddf882e856336269080496"
void CUnsignedAlert::SetNull()
{
nVersion = 1;
nRelayUntil = 0;
nExpiration = 0;
nID = 0;
nCancel = 0;
setCancel.clear();
nMinVer = 0;
nMaxVer = 0;
setSubVer.clear();
nPriority = 0;
strComment.clear();
strStatusBar.clear();
strReserved.clear();
}
std::string CUnsignedAlert::ToString() const
{
std::string strSetCancel;
for (auto &n : setCancel)
strSetCancel += strprintf("%d ", n);
std::string strSetSubVer;
for (auto const& str : setSubVer)
strSetSubVer += "\"" + str + "\" ";
return strprintf(
"CAlert(\n"
" nVersion = %d\n"
" nRelayUntil = %" PRId64 "\n"
" nExpiration = %" PRId64 "\n"
" nID = %d\n"
" nCancel = %d\n"
" setCancel = %s\n"
" nMinVer = %d\n"
" nMaxVer = %d\n"
" setSubVer = %s\n"
" nPriority = %d\n"
" strComment = \"%s\"\n"
" strStatusBar = \"%s\"\n"
")\n",
nVersion,
nRelayUntil,
nExpiration,
nID,
nCancel,
strSetCancel.c_str(),
nMinVer,
nMaxVer,
strSetSubVer.c_str(),
nPriority,
strComment.c_str(),
strStatusBar.c_str());
}
void CUnsignedAlert::print() const
{
printf("%s", ToString().c_str());
}
void CAlert::SetNull()
{
CUnsignedAlert::SetNull();
vchMsg.clear();
vchSig.clear();
}
bool CAlert::IsNull() const
{
return (nExpiration == 0);
}
uint256 CAlert::GetHash() const
{
return Hash(this->vchMsg.begin(), this->vchMsg.end());
}
bool CAlert::IsInEffect() const
{
return (GetAdjustedTime() < nExpiration);
}
bool CAlert::Cancels(const CAlert& alert) const
{
if (!IsInEffect())
return false; // this was a no-op before 31403
return (alert.nID <= nCancel || setCancel.count(alert.nID));
}
bool CAlert::AppliesTo(int nVersion, std::string strSubVerIn) const
{
// TODO: rework for client-version-embedded-in-strSubVer ?
return (IsInEffect() &&
nMinVer <= nVersion && nVersion <= nMaxVer &&
(setSubVer.empty() || setSubVer.count(strSubVerIn)));
}
bool CAlert::AppliesToMe() const
{
return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
}
bool CAlert::RelayTo(CNode* pnode) const
{
if (!IsInEffect())
return false;
// returns true if wasn't already contained in the set
if (pnode->setKnown.insert(GetHash()).second)
{
if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
AppliesToMe() ||
GetAdjustedTime() < nRelayUntil)
{
pnode->PushMessage("alert", *this);
return true;
}
}
return false;
}
bool CAlert::CheckSignature() const
{
CKey key;
if (!key.SetPubKey(ParseHex(fTestNet ? pszTestKey : pszMainKey)))
return error("CAlert::CheckSignature() : SetPubKey failed");
if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
return error("CAlert::CheckSignature() : verify signature failed");
// Now unserialize the data
CDataStream sMsg(vchMsg, SER_NETWORK, PROTOCOL_VERSION);
sMsg >> *(CUnsignedAlert*)this;
return true;
}
CAlert CAlert::getAlertByHash(const uint256 &hash)
{
CAlert retval;
{
LOCK(cs_mapAlerts);
map<uint256, CAlert>::iterator mi = mapAlerts.find(hash);
if(mi != mapAlerts.end())
retval = mi->second;
}
return retval;
}
bool CAlert::ProcessAlert(bool fThread)
{
if (!CheckSignature())
return false;
if (!IsInEffect())
return false;
// alert.nID=max is reserved for if the alert key is
// compromised. It must have a pre-defined message,
// must never expire, must apply to all versions,
// and must cancel all previous
// alerts or it will be ignored (so an attacker can't
// send an "everything is OK, don't panic" version that
// cannot be overridden):
int maxInt = std::numeric_limits<int>::max();
if (nID == maxInt)
{
if (!(
nExpiration == maxInt &&
nCancel == (maxInt-1) &&
nMinVer == 0 &&
nMaxVer == maxInt &&
setSubVer.empty() &&
nPriority == maxInt &&
strStatusBar == "URGENT: Alert key compromised, upgrade required"
))
return false;
}
{
LOCK(cs_mapAlerts);
// Cancel previous alerts
for (map<uint256, CAlert>::iterator mi = mapAlerts.begin(); mi != mapAlerts.end();)
{
const CAlert& alert = (*mi).second;
if (Cancels(alert))
{
printf("cancelling alert %d\n", alert.nID);
uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
mapAlerts.erase(mi++);
}
else if (!alert.IsInEffect())
{
printf("expiring alert %d\n", alert.nID);
uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
mapAlerts.erase(mi++);
}
else
mi++;
}
// Check if this alert has been cancelled
for (auto const& item : mapAlerts)
{
const CAlert& alert = item.second;
if (alert.Cancels(*this))
{
printf("alert already cancelled by %d\n", alert.nID);
return false;
}
}
// Add to mapAlerts
mapAlerts.insert(make_pair(GetHash(), *this));
// Notify UI and -alertnotify if it applies to me
if(AppliesToMe())
{
uiInterface.NotifyAlertChanged(GetHash(), CT_NEW);
std::string strCmd = GetArg("-alertnotify", "");
if (!strCmd.empty())
{
// Alert text should be plain ascii coming from a trusted source, but to
// be safe we first strip anything not in safeChars, then add single quotes around
// the whole string before passing it to the shell:
std::string singleQuote("'");
// safeChars chosen to allow simple messages/URLs/email addresses, but avoid anything
// even possibly remotely dangerous like & ; $ or >
std::string safeChars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890 .,_/:?@");
std::string safeStatus;
for (std::string::size_type i = 0; i < strStatusBar.size(); i++)
{
if (safeChars.find(strStatusBar[i]) != std::string::npos)
safeStatus.push_back(strStatusBar[i]);
}
safeStatus = singleQuote+safeStatus+singleQuote;
boost::replace_all(strCmd, "%s", safeStatus);
if (fThread)
boost::thread t(runCommand, strCmd); // thread runs free
else
runCommand(strCmd);
}
}
}
printf("accepted alert %d, AppliesToMe()=%d\n", nID, AppliesToMe());
return true;
}
<commit_msg>Change Alert key to same as Master Project key.<commit_after>//
// Alert system
//
#include <algorithm>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/thread.hpp>
#include <map>
#include "alert.h"
#include "key.h"
#include "net.h"
#include "sync.h"
#include "ui_interface.h"
#include "uint256.h"
using namespace std;
map<uint256, CAlert> mapAlerts;
CCriticalSection cs_mapAlerts;
// same as master project key now
static const char* pszMainKey = "049ac003b3318d9fe28b2830f6a95a2624ce2a69fb0c0c7ac0b513efcc1e93a6a6e8eba84481155dd82f2f1104e0ff62c69d662b0094639b7106abc5d84f948c0a";
// TestNet alerts pubKey
static const char* pszTestKey = "0471dc165db490094d35cde15b1f5d755fa6ad6f2b5ed0f340e3f17f57389c3c2af113a8cbcc885bde73305a553b5640c83021128008ddf882e856336269080496";
// TestNet alerts private key
// "308201130201010420b665cff1884e53da26376fd1b433812c9a5a8a4d5221533b15b9629789bb7e42a081a53081a2020101302c06072a8648ce3d0101022100fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f300604010004010704410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8022100fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141020101a1440342000471dc165db490094d35cde15b1f5d755fa6ad6f2b5ed0f340e3f17f57389c3c2af113a8cbcc885bde73305a553b5640c83021128008ddf882e856336269080496"
void CUnsignedAlert::SetNull()
{
nVersion = 1;
nRelayUntil = 0;
nExpiration = 0;
nID = 0;
nCancel = 0;
setCancel.clear();
nMinVer = 0;
nMaxVer = 0;
setSubVer.clear();
nPriority = 0;
strComment.clear();
strStatusBar.clear();
strReserved.clear();
}
std::string CUnsignedAlert::ToString() const
{
std::string strSetCancel;
for (auto &n : setCancel)
strSetCancel += strprintf("%d ", n);
std::string strSetSubVer;
for (auto const& str : setSubVer)
strSetSubVer += "\"" + str + "\" ";
return strprintf(
"CAlert(\n"
" nVersion = %d\n"
" nRelayUntil = %" PRId64 "\n"
" nExpiration = %" PRId64 "\n"
" nID = %d\n"
" nCancel = %d\n"
" setCancel = %s\n"
" nMinVer = %d\n"
" nMaxVer = %d\n"
" setSubVer = %s\n"
" nPriority = %d\n"
" strComment = \"%s\"\n"
" strStatusBar = \"%s\"\n"
")\n",
nVersion,
nRelayUntil,
nExpiration,
nID,
nCancel,
strSetCancel.c_str(),
nMinVer,
nMaxVer,
strSetSubVer.c_str(),
nPriority,
strComment.c_str(),
strStatusBar.c_str());
}
void CUnsignedAlert::print() const
{
printf("%s", ToString().c_str());
}
void CAlert::SetNull()
{
CUnsignedAlert::SetNull();
vchMsg.clear();
vchSig.clear();
}
bool CAlert::IsNull() const
{
return (nExpiration == 0);
}
uint256 CAlert::GetHash() const
{
return Hash(this->vchMsg.begin(), this->vchMsg.end());
}
bool CAlert::IsInEffect() const
{
return (GetAdjustedTime() < nExpiration);
}
bool CAlert::Cancels(const CAlert& alert) const
{
if (!IsInEffect())
return false; // this was a no-op before 31403
return (alert.nID <= nCancel || setCancel.count(alert.nID));
}
bool CAlert::AppliesTo(int nVersion, std::string strSubVerIn) const
{
// TODO: rework for client-version-embedded-in-strSubVer ?
return (IsInEffect() &&
nMinVer <= nVersion && nVersion <= nMaxVer &&
(setSubVer.empty() || setSubVer.count(strSubVerIn)));
}
bool CAlert::AppliesToMe() const
{
return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
}
bool CAlert::RelayTo(CNode* pnode) const
{
if (!IsInEffect())
return false;
// returns true if wasn't already contained in the set
if (pnode->setKnown.insert(GetHash()).second)
{
if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
AppliesToMe() ||
GetAdjustedTime() < nRelayUntil)
{
pnode->PushMessage("alert", *this);
return true;
}
}
return false;
}
bool CAlert::CheckSignature() const
{
CKey key;
if (!key.SetPubKey(ParseHex(fTestNet ? pszTestKey : pszMainKey)))
return error("CAlert::CheckSignature() : SetPubKey failed");
if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
return error("CAlert::CheckSignature() : verify signature failed");
// Now unserialize the data
CDataStream sMsg(vchMsg, SER_NETWORK, PROTOCOL_VERSION);
sMsg >> *(CUnsignedAlert*)this;
return true;
}
CAlert CAlert::getAlertByHash(const uint256 &hash)
{
CAlert retval;
{
LOCK(cs_mapAlerts);
map<uint256, CAlert>::iterator mi = mapAlerts.find(hash);
if(mi != mapAlerts.end())
retval = mi->second;
}
return retval;
}
bool CAlert::ProcessAlert(bool fThread)
{
if (!CheckSignature())
return false;
if (!IsInEffect())
return false;
// alert.nID=max is reserved for if the alert key is
// compromised. It must have a pre-defined message,
// must never expire, must apply to all versions,
// and must cancel all previous
// alerts or it will be ignored (so an attacker can't
// send an "everything is OK, don't panic" version that
// cannot be overridden):
int maxInt = std::numeric_limits<int>::max();
if (nID == maxInt)
{
if (!(
nExpiration == maxInt &&
nCancel == (maxInt-1) &&
nMinVer == 0 &&
nMaxVer == maxInt &&
setSubVer.empty() &&
nPriority == maxInt &&
strStatusBar == "URGENT: Alert key compromised, upgrade required"
))
return false;
}
{
LOCK(cs_mapAlerts);
// Cancel previous alerts
for (map<uint256, CAlert>::iterator mi = mapAlerts.begin(); mi != mapAlerts.end();)
{
const CAlert& alert = (*mi).second;
if (Cancels(alert))
{
printf("cancelling alert %d\n", alert.nID);
uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
mapAlerts.erase(mi++);
}
else if (!alert.IsInEffect())
{
printf("expiring alert %d\n", alert.nID);
uiInterface.NotifyAlertChanged((*mi).first, CT_DELETED);
mapAlerts.erase(mi++);
}
else
mi++;
}
// Check if this alert has been cancelled
for (auto const& item : mapAlerts)
{
const CAlert& alert = item.second;
if (alert.Cancels(*this))
{
printf("alert already cancelled by %d\n", alert.nID);
return false;
}
}
// Add to mapAlerts
mapAlerts.insert(make_pair(GetHash(), *this));
// Notify UI and -alertnotify if it applies to me
if(AppliesToMe())
{
uiInterface.NotifyAlertChanged(GetHash(), CT_NEW);
std::string strCmd = GetArg("-alertnotify", "");
if (!strCmd.empty())
{
// Alert text should be plain ascii coming from a trusted source, but to
// be safe we first strip anything not in safeChars, then add single quotes around
// the whole string before passing it to the shell:
std::string singleQuote("'");
// safeChars chosen to allow simple messages/URLs/email addresses, but avoid anything
// even possibly remotely dangerous like & ; $ or >
std::string safeChars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890 .,_/:?@");
std::string safeStatus;
for (std::string::size_type i = 0; i < strStatusBar.size(); i++)
{
if (safeChars.find(strStatusBar[i]) != std::string::npos)
safeStatus.push_back(strStatusBar[i]);
}
safeStatus = singleQuote+safeStatus+singleQuote;
boost::replace_all(strCmd, "%s", safeStatus);
if (fThread)
boost::thread t(runCommand, strCmd); // thread runs free
else
runCommand(strCmd);
}
}
}
printf("accepted alert %d, AppliesToMe()=%d\n", nID, AppliesToMe());
return true;
}
<|endoftext|> |
<commit_before>//////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007, Image Engine Design Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of Image Engine Design nor the names of any
// other contributors to this software may be used to endorse or
// promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////
#include "IECore/Primitive.h"
#include "IECore/VectorTypedData.h"
#include "IECore/TypedDataDespatch.h"
using namespace IECore;
using namespace boost;
using namespace std;
using namespace Imath;
/////////////////////////////////////////////////////////////////////////////////////
// Primitive
/////////////////////////////////////////////////////////////////////////////////////
const unsigned int Primitive::m_ioVersion = 1;
IE_CORE_DEFINEABSTRACTOBJECTTYPEDESCRIPTION( Primitive );
Primitive::Primitive()
{
}
Primitive::~Primitive()
{
}
Imath::Box3f Primitive::bound() const
{
Box3f result;
PrimitiveVariableMap::const_iterator it = variables.find( "P" );
if( it!=variables.end() )
{
ConstV3fVectorDataPtr p = runTimeCast<const V3fVectorData>( it->second.data );
if( p )
{
const vector<V3f> &pp = p->readable();
for( size_t i=0; i<pp.size(); i++ )
{
result.extendBy( pp[i] );
}
}
}
return result;
}
void Primitive::copyFrom( IECore::ConstObjectPtr other, IECore::Object::CopyContext *context )
{
VisibleRenderable::copyFrom( other, context );
const Primitive *tOther = static_cast<const Primitive *>( other.get() );
variables.clear();
for( PrimitiveVariableMap::const_iterator it=tOther->variables.begin(); it!=tOther->variables.end(); it++ )
{
variables.insert( PrimitiveVariableMap::value_type( it->first, PrimitiveVariable( it->second.interpolation, context->copy<Data>( it->second.data ) ) ) );
}
}
void Primitive::save( IECore::Object::SaveContext *context ) const
{
VisibleRenderable::save( context );
IndexedIOInterfacePtr container = context->container( staticTypeName(), m_ioVersion );
container->mkdir( "variables" );
container->chdir( "variables" );
for( PrimitiveVariableMap::const_iterator it=variables.begin(); it!=variables.end(); it++ )
{
container->mkdir( it->first );
container->chdir( it->first );
const int i = it->second.interpolation;
container->write( "interpolation", i );
context->save( it->second.data, container, "data" );
container->chdir( ".." );
}
container->chdir( ".." );
}
void Primitive::load( IECore::Object::LoadContextPtr context )
{
unsigned int v = m_ioVersion;
IndexedIOInterfacePtr container = context->container( staticTypeName(), v );
// we changed the inheritance hierarchy at io version 1
if( v==0 )
{
Renderable::load( context );
}
else
{
VisibleRenderable::load( context );
}
container->chdir( "variables" );
variables.clear();
IndexedIO::EntryList names = container->ls();
IndexedIO::EntryList::const_iterator it;
for( it=names.begin(); it!=names.end(); it++ )
{
container->chdir( it->id() );
int i; container->read( "interpolation", i );
variables.insert( PrimitiveVariableMap::value_type( it->id(), PrimitiveVariable( (PrimitiveVariable::Interpolation)i, context->load<Data>( container, "data" ) ) ) );
container->chdir( ".." );
}
container->chdir( ".." );
}
bool Primitive::isEqualTo( ConstObjectPtr other ) const
{
if( !VisibleRenderable::isEqualTo( other ) )
{
return false;
}
const Primitive *tOther = static_cast<const Primitive *>( other.get() );
if( tOther->variables!=variables )
{
return false;
}
return true;
}
void Primitive::memoryUsage( Object::MemoryAccumulator &a ) const
{
VisibleRenderable::memoryUsage( a );
for( PrimitiveVariableMap::const_iterator it=variables.begin(); it!=variables.end(); it++ )
{
a.accumulate( it->second.data );
}
}
struct Args
{
size_t m_variableSize;
};
template<typename T>
struct ValidateArraySize
{
bool operator() ( typename T::Ptr data, const Args &args )
{
typedef typename T::ValueType Vector;
const Vector &v = data->readable();
return v.size() == args.m_variableSize;
}
};
template<typename T>
struct ReturnTrue
{
bool operator() ( typename T::Ptr data, void *args )
{
assert( !args );
return true;
}
};
bool Primitive::isPrimitiveVariableValid( const PrimitiveVariable &pv )
{
if (! pv.data )
{
return false;
}
size_t sz = variableSize( pv.interpolation );
try
{
if ( sz == 1 )
{
return despatchSimpleTypedDataFn<bool, ReturnTrue, void*>( static_pointer_cast<Data>( pv.data ), 0 );
}
}
catch ( InvalidArgumentException &e )
{
}
Args args;
args.m_variableSize = sz;
return despatchVectorTypedDataFn<bool, ValidateArraySize, Args>( static_pointer_cast<Data>( pv.data ), args );
}
bool Primitive::arePrimitiveVariablesValid()
{
for( PrimitiveVariableMap::const_iterator it=variables.begin(); it!=variables.end(); it++ )
{
if ( !isPrimitiveVariableValid( it->second ) )
{
return false;
}
}
return true;
}
<commit_msg>Updated to use new despatchTypedData<commit_after>//////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007, Image Engine Design Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of Image Engine Design nor the names of any
// other contributors to this software may be used to endorse or
// promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////
#include <cassert>
#include "IECore/Primitive.h"
#include "IECore/VectorTypedData.h"
#include "IECore/TypeTraits.h"
#include "IECore/DespatchTypedData.h"
using namespace IECore;
using namespace boost;
using namespace std;
using namespace Imath;
/////////////////////////////////////////////////////////////////////////////////////
// Primitive
/////////////////////////////////////////////////////////////////////////////////////
const unsigned int Primitive::m_ioVersion = 1;
IE_CORE_DEFINEABSTRACTOBJECTTYPEDESCRIPTION( Primitive );
Primitive::Primitive()
{
}
Primitive::~Primitive()
{
}
Imath::Box3f Primitive::bound() const
{
Box3f result;
PrimitiveVariableMap::const_iterator it = variables.find( "P" );
if( it!=variables.end() )
{
ConstV3fVectorDataPtr p = runTimeCast<const V3fVectorData>( it->second.data );
if( p )
{
const vector<V3f> &pp = p->readable();
for( size_t i=0; i<pp.size(); i++ )
{
result.extendBy( pp[i] );
}
}
}
return result;
}
void Primitive::copyFrom( IECore::ConstObjectPtr other, IECore::Object::CopyContext *context )
{
VisibleRenderable::copyFrom( other, context );
const Primitive *tOther = static_cast<const Primitive *>( other.get() );
variables.clear();
for( PrimitiveVariableMap::const_iterator it=tOther->variables.begin(); it!=tOther->variables.end(); it++ )
{
variables.insert( PrimitiveVariableMap::value_type( it->first, PrimitiveVariable( it->second.interpolation, context->copy<Data>( it->second.data ) ) ) );
}
}
void Primitive::save( IECore::Object::SaveContext *context ) const
{
VisibleRenderable::save( context );
IndexedIOInterfacePtr container = context->container( staticTypeName(), m_ioVersion );
container->mkdir( "variables" );
container->chdir( "variables" );
for( PrimitiveVariableMap::const_iterator it=variables.begin(); it!=variables.end(); it++ )
{
container->mkdir( it->first );
container->chdir( it->first );
const int i = it->second.interpolation;
container->write( "interpolation", i );
context->save( it->second.data, container, "data" );
container->chdir( ".." );
}
container->chdir( ".." );
}
void Primitive::load( IECore::Object::LoadContextPtr context )
{
unsigned int v = m_ioVersion;
IndexedIOInterfacePtr container = context->container( staticTypeName(), v );
// we changed the inheritance hierarchy at io version 1
if( v==0 )
{
Renderable::load( context );
}
else
{
VisibleRenderable::load( context );
}
container->chdir( "variables" );
variables.clear();
IndexedIO::EntryList names = container->ls();
IndexedIO::EntryList::const_iterator it;
for( it=names.begin(); it!=names.end(); it++ )
{
container->chdir( it->id() );
int i; container->read( "interpolation", i );
variables.insert( PrimitiveVariableMap::value_type( it->id(), PrimitiveVariable( (PrimitiveVariable::Interpolation)i, context->load<Data>( container, "data" ) ) ) );
container->chdir( ".." );
}
container->chdir( ".." );
}
bool Primitive::isEqualTo( ConstObjectPtr other ) const
{
if( !VisibleRenderable::isEqualTo( other ) )
{
return false;
}
const Primitive *tOther = static_cast<const Primitive *>( other.get() );
if( tOther->variables!=variables )
{
return false;
}
return true;
}
void Primitive::memoryUsage( Object::MemoryAccumulator &a ) const
{
VisibleRenderable::memoryUsage( a );
for( PrimitiveVariableMap::const_iterator it=variables.begin(); it!=variables.end(); it++ )
{
a.accumulate( it->second.data );
}
}
struct ValidateArraySize
{
typedef bool ReturnType;
ValidateArraySize( size_t sz ) : m_variableSize( sz )
{
}
template<typename T>
bool operator() ( typename T::Ptr data )
{
assert( data );
const typename T::ValueType &v = data->readable();
return v.size() == m_variableSize;
}
private:
size_t m_variableSize;
};
struct ReturnTrue
{
typedef bool ReturnType;
template<typename T>
bool operator() ( typename T::Ptr data )
{
return true;
}
};
bool Primitive::isPrimitiveVariableValid( const PrimitiveVariable &pv )
{
if (! pv.data )
{
return false;
}
size_t sz = variableSize( pv.interpolation );
try
{
if ( sz == 1 )
{
ReturnTrue func;
return despatchTypedData<ReturnTrue, TypeTraits::IsSimpleTypedData>( static_pointer_cast<Data>( pv.data ), func );
}
}
catch ( InvalidArgumentException &e )
{
}
ValidateArraySize func( sz );
return despatchTypedData<ValidateArraySize, TypeTraits::IsVectorTypedData>( static_pointer_cast<Data>( pv.data ), func );
}
bool Primitive::arePrimitiveVariablesValid()
{
for( PrimitiveVariableMap::const_iterator it=variables.begin(); it!=variables.end(); it++ )
{
if ( !isPrimitiveVariableValid( it->second ) )
{
return false;
}
}
return true;
}
<|endoftext|> |
<commit_before>#include <pwd.h>
#include <grp.h>
#include <sys/wait.h>
#include "org_simplenfast_security_PAMUser.h"
#include "common.h"
#include "auth.h"
#include "ex.h"
static bool
set_principals(
JNIEnv *env,
jobject obj,
const char *user)
{
const char *who = "set_principals";
int retval = 0;
int error = 0;
struct passwd *result = 0;
struct passwd pwd;
int ngrps = 0;
jlong *jgrps = 0;
char message[512];
char errbuf[ERRSTRLEN + 1];
jclass cls;
jmethodID mid;
size_t bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufsize < 0) {
bufsize = 16 * 1024;
}
char *buf = (char *)malloc(bufsize);
if (buf == 0) {
ThrowNativeException(
env,
"malloc of passwd buffer failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
return false;
}
errno = 0;
retval = getpwnam_r(user, &pwd, buf, bufsize, &result);
if ((retval != 0) || (result == 0)) {
free(buf);
if (retval == 0) {
snprintf(message, sizeof(message),
"getpwnam_r for user %s did not find any data", user);
} else {
snprintf(message, sizeof(message),
"getpwnam_r for user %s failed", user);
}
ThrowNativeException(
env,
message,
retval,
GetErrorStr(errbuf, ERRSTRLEN, retval),
who,
__FILE__,
__LINE__);
return false;
}
if (initgroups(pwd.pw_name, pwd.pw_gid) < 0) {
error = errno;
free(buf);
snprintf(message, sizeof(message),
"initgroups for user %s (gid %d) failed",
pwd.pw_name, (int) (pwd.pw_gid));
ThrowNativeException(
env,
message,
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
getgrouplist(pwd.pw_name, pwd.pw_gid, 0, &ngrps);
if (ngrps > 0) {
gid_t *grps = (gid_t *)calloc(ngrps, sizeof(gid_t));
if (grps == 0) {
free(buf);
ThrowNativeException(
env,
"malloc of group ID buffer failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
return false;
}
getgrouplist(pwd.pw_name, pwd.pw_gid, grps, &ngrps);
jgrps = (jlong *)calloc(ngrps, sizeof(jlong));
if (jgrps == 0) {
free(buf);
free(grps);
ThrowNativeException(
env,
"malloc of Java group ID buffer failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
return false;
}
for (int i = 0; i < ngrps; ++i) {
jgrps[i] = (jlong)(grps[i]);
}
free(grps);
}
cls = env->GetObjectClass(obj);
mid = env->GetMethodID(
cls,
"setUID",
"(J)V");
env->CallVoidMethod(obj, mid, long(pwd.pw_uid));
mid = env->GetMethodID(
cls,
"setGID",
"(J)V");
env->CallVoidMethod(obj, mid, long(pwd.pw_gid));
free(buf);
if (ngrps > 0) {
jlongArray jgids = env->NewLongArray(ngrps);
env->SetLongArrayRegion(jgids, 0, ngrps, jgrps);
free(jgrps);
mid = env->GetMethodID(
cls,
"setSupplementaryGIDs",
"([J)V");
env->CallVoidMethod(obj, mid, jgids);
env->DeleteLocalRef(jgids);
}
return true;
}
JNIEXPORT jlong JNICALL
Java_org_simplenfast_security_PAMUser_login0(
JNIEnv *env,
jobject obj,
jstring svc,
jstring usr,
jcharArray pwd)
{
pam_handle_t *pamh;
const char *service = env->GetStringUTFChars(svc, NULL);
const char *user = env->GetStringUTFChars(usr, NULL);
char *password = jcharArrayToCString(env, pwd);
if (password == 0) {
return 0;
}
if (pam_login(env, service, user, password, &pamh)) {
if (!set_principals(env, obj, user)) {
pam_logout(pamh);
pamh = 0;
}
} else {
pamh = 0;
}
free(password);
env->ReleaseStringUTFChars(usr, user);
env->ReleaseStringUTFChars(svc, service);
return (long)pamh;
}
static bool
CreatePipe(
JNIEnv *env,
int fd[],
bool readInheritable,
bool writeInheritable)
{
const char *who = "CreatePipe";
char errbuf[ERRSTRLEN + 1];
int f[2];
if (pipe(f) < 0) {
int error = errno;
ThrowNativeException(
env,
"pipe failed",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
if (!readInheritable) {
if (fcntl(f[0], F_SETFD, FD_CLOEXEC) < 0) {
int error = errno;
close(f[0]);
close(f[1]);
ThrowNativeException(
env,
"fcntl failed to set FD_CLOEXEC flag on read handle",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
}
if (!writeInheritable) {
if (fcntl(f[1], F_SETFD, FD_CLOEXEC) < 0) {
int error = errno;
close(f[0]);
close(f[1]);
ThrowNativeException(
env,
"fcntl failed to set FD_CLOEXEC flag on write handle",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
}
fd[0] = f[0];
fd[1] = f[1];
return true;
}
JNIEXPORT jlong JNICALL
Java_org_simplenfast_security_PAMUser_execute0(
JNIEnv *env,
jobject obj,
jstring binary,
jobjectArray arguments,
jstring directory,
jlongArray stdFds)
{
const char *who = "Java_org_simplenfast_security_PAMUser_execute0";
int error = 0;
int std_in[2];
int std_out[2];
int std_err[2];
uid_t uid = -1;
gid_t gid = -1;
jclass cls;
jmethodID mid;
char message[512];
char errbuf[ERRSTRLEN + 1];
cls = env->GetObjectClass(obj);
mid = env->GetMethodID(
cls,
"getUID",
"()J");
uid = (uid_t) env->CallLongMethod(obj, mid);
mid = env->GetMethodID(
cls,
"getGID",
"()J");
gid = (gid_t) env->CallLongMethod(obj, mid);
if (!CreatePipe(env, std_in, true, false)) {
return (jlong)(-1L);
}
if (!CreatePipe(env, std_out, false, true)) {
close(std_in[0]);
close(std_in[1]);
return (jlong)(-1L);
}
if (!CreatePipe(env, std_err, false, true)) {
close(std_in[0]);
close(std_in[1]);
close(std_out[0]);
close(std_out[1]);
return (jlong)(-1L);
}
pid_t pid = fork();
if (pid == 0) {
dup2(std_in[0], 0);
close(std_in[0]);
close(std_in[1]);
dup2(std_out[1], 1);
close(std_out[1]);
close(std_out[0]);
dup2(std_err[1], 2);
close(std_err[1]);
close(std_err[0]);
if (setuid(uid) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"setuid to %d failed: %s (%d)",
(int) uid,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
if (setgid(gid) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"setgid to %d failed: %s (%d)",
(int) gid,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
char *dir = (char *) env->GetStringUTFChars(directory, NULL);
if (dir && *dir) {
if (chdir(dir) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"chdir to %s failed: %s (%d)",
dir,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
env->ReleaseStringUTFChars(directory, dir);
}
char *bin = (char *) env->GetStringUTFChars(binary, NULL);
jsize argLen = env->GetArrayLength(arguments);
char **args = (char **)calloc(argLen + 1, sizeof(char *));
for (jsize i = 0; i < argLen; ++i) {
jstring arg = (jstring) env->GetObjectArrayElement(arguments, i);
args[i] = (char *) env->GetStringUTFChars(arg, NULL);
}
if (execvp(bin, args) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"exec of %s failed: %s (%d)",
bin,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
} else if (pid > 0) {
close(std_in[0]);
close(std_out[1]);
close(std_err[1]);
jlong std_fds[3] = { (jlong)std_in[1], jlong(std_out[0]), jlong(std_err[0]) };
env->SetLongArrayRegion(stdFds, 0, 3, std_fds);
} else {
close(std_in[0]);
close(std_in[1]);
close(std_out[0]);
close(std_out[1]);
close(std_err[0]);
close(std_err[1]);
ThrowNativeException(
env,
"fork failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
}
return (jlong)pid;
}
JNIEXPORT jint JNICALL
Java_org_simplenfast_security_PAMUser_getExitCode0(
JNIEnv *env,
jobject obj,
jlong procId,
jlong timeout)
{
const char *who = "Java_org_simplenfast_security_PAMUser_getExitCode0";
bool done = false;
jint ec = -1;
int error = 0;
pid_t pid = (pid_t)procId;
char errbuf[ERRSTRLEN + 1];
while ((timeout > 0) && !done) {
int cstat;
pid_t rpid = waitpid(pid, &cstat, WNOHANG);
if (rpid == pid) {
ec = WEXITSTATUS(cstat);
done = true;
} else if (rpid == 0) {
sleep(1);
timeout--;
} else if (rpid < 0) {
error = errno;
kill(pid, SIGTERM);
ThrowNativeException(
env,
"waitpid failed",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
done = true;
}
}
if (!done) {
kill(pid, SIGTERM);
ThrowNativeException(
env,
"process timed out",
-1,
"",
who,
__FILE__,
__LINE__);
}
return ec;
}
JNIEXPORT jboolean JNICALL
Java_org_simplenfast_security_PAMUser_logout0(
JNIEnv *env,
jobject obj,
jlong ctx)
{
pam_handle_t *pamh = (pam_handle_t *)ctx;
if (pam_logout(pamh)) {
return JNI_TRUE;
}
return JNI_FALSE;
}
<commit_msg>Added initgroups to initatailize groups list for the user.<commit_after>#include <pwd.h>
#include <grp.h>
#include <sys/wait.h>
#include "org_simplenfast_security_PAMUser.h"
#include "common.h"
#include "auth.h"
#include "ex.h"
static bool
set_principals(
JNIEnv *env,
jobject obj,
const char *user)
{
const char *who = "set_principals";
int retval = 0;
int error = 0;
struct passwd *result = 0;
struct passwd pwd;
int ngrps = 0;
jlong *jgrps = 0;
char message[512];
char errbuf[ERRSTRLEN + 1];
jclass cls;
jmethodID mid;
size_t bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
if (bufsize < 0) {
bufsize = 16 * 1024;
}
char *buf = (char *)malloc(bufsize);
if (buf == 0) {
ThrowNativeException(
env,
"malloc of passwd buffer failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
return false;
}
errno = 0;
retval = getpwnam_r(user, &pwd, buf, bufsize, &result);
if ((retval != 0) || (result == 0)) {
free(buf);
if (retval == 0) {
snprintf(message, sizeof(message),
"getpwnam_r for user %s did not find any data", user);
} else {
snprintf(message, sizeof(message),
"getpwnam_r for user %s failed", user);
}
ThrowNativeException(
env,
message,
retval,
GetErrorStr(errbuf, ERRSTRLEN, retval),
who,
__FILE__,
__LINE__);
return false;
}
if (initgroups(pwd.pw_name, pwd.pw_gid) < 0) {
error = errno;
free(buf);
snprintf(message, sizeof(message),
"initgroups for user %s (gid %d) failed",
pwd.pw_name, (int) (pwd.pw_gid));
ThrowNativeException(
env,
message,
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
getgrouplist(pwd.pw_name, pwd.pw_gid, 0, &ngrps);
if (ngrps > 0) {
gid_t *grps = (gid_t *)calloc(ngrps, sizeof(gid_t));
if (grps == 0) {
free(buf);
ThrowNativeException(
env,
"malloc of group ID buffer failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
return false;
}
getgrouplist(pwd.pw_name, pwd.pw_gid, grps, &ngrps);
jgrps = (jlong *)calloc(ngrps, sizeof(jlong));
if (jgrps == 0) {
free(buf);
free(grps);
ThrowNativeException(
env,
"malloc of Java group ID buffer failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
return false;
}
for (int i = 0; i < ngrps; ++i) {
jgrps[i] = (jlong)(grps[i]);
}
free(grps);
}
cls = env->GetObjectClass(obj);
mid = env->GetMethodID(
cls,
"setUID",
"(J)V");
env->CallVoidMethod(obj, mid, long(pwd.pw_uid));
mid = env->GetMethodID(
cls,
"setGID",
"(J)V");
env->CallVoidMethod(obj, mid, long(pwd.pw_gid));
free(buf);
if (ngrps > 0) {
jlongArray jgids = env->NewLongArray(ngrps);
env->SetLongArrayRegion(jgids, 0, ngrps, jgrps);
free(jgrps);
mid = env->GetMethodID(
cls,
"setSupplementaryGIDs",
"([J)V");
env->CallVoidMethod(obj, mid, jgids);
env->DeleteLocalRef(jgids);
}
return true;
}
JNIEXPORT jlong JNICALL
Java_org_simplenfast_security_PAMUser_login0(
JNIEnv *env,
jobject obj,
jstring svc,
jstring usr,
jcharArray pwd)
{
pam_handle_t *pamh;
const char *service = env->GetStringUTFChars(svc, NULL);
const char *user = env->GetStringUTFChars(usr, NULL);
char *password = jcharArrayToCString(env, pwd);
if (password == 0) {
return 0;
}
if (pam_login(env, service, user, password, &pamh)) {
if (!set_principals(env, obj, user)) {
pam_logout(pamh);
pamh = 0;
}
} else {
pamh = 0;
}
free(password);
env->ReleaseStringUTFChars(usr, user);
env->ReleaseStringUTFChars(svc, service);
return (long)pamh;
}
static bool
CreatePipe(
JNIEnv *env,
int fd[],
bool readInheritable,
bool writeInheritable)
{
const char *who = "CreatePipe";
char errbuf[ERRSTRLEN + 1];
int f[2];
if (pipe(f) < 0) {
int error = errno;
ThrowNativeException(
env,
"pipe failed",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
if (!readInheritable) {
if (fcntl(f[0], F_SETFD, FD_CLOEXEC) < 0) {
int error = errno;
close(f[0]);
close(f[1]);
ThrowNativeException(
env,
"fcntl failed to set FD_CLOEXEC flag on read handle",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
}
if (!writeInheritable) {
if (fcntl(f[1], F_SETFD, FD_CLOEXEC) < 0) {
int error = errno;
close(f[0]);
close(f[1]);
ThrowNativeException(
env,
"fcntl failed to set FD_CLOEXEC flag on write handle",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
return false;
}
}
fd[0] = f[0];
fd[1] = f[1];
return true;
}
JNIEXPORT jlong JNICALL
Java_org_simplenfast_security_PAMUser_execute0(
JNIEnv *env,
jobject obj,
jstring binary,
jobjectArray arguments,
jstring directory,
jlongArray stdFds)
{
const char *who = "Java_org_simplenfast_security_PAMUser_execute0";
int error = 0;
int std_in[2];
int std_out[2];
int std_err[2];
uid_t uid = -1;
gid_t gid = -1;
const char *userName;
jstring usr;
jclass cls;
jmethodID mid;
char message[512];
char errbuf[ERRSTRLEN + 1];
cls = env->GetObjectClass(obj);
mid = env->GetMethodID(
cls,
"getUID",
"()J");
uid = (uid_t) env->CallLongMethod(obj, mid);
mid = env->GetMethodID(
cls,
"getUserName",
"()Ljava/lang/String;");
usr = (jstring) env->CallObjectMethod(obj, mid);
userName = env->GetStringUTFChars(usr, 0);
mid = env->GetMethodID(
cls,
"getGID",
"()J");
gid = (gid_t) env->CallLongMethod(obj, mid);
if (!CreatePipe(env, std_in, true, false)) {
return (jlong)(-1L);
}
if (!CreatePipe(env, std_out, false, true)) {
close(std_in[0]);
close(std_in[1]);
return (jlong)(-1L);
}
if (!CreatePipe(env, std_err, false, true)) {
close(std_in[0]);
close(std_in[1]);
close(std_out[0]);
close(std_out[1]);
return (jlong)(-1L);
}
pid_t pid = fork();
if (pid == 0) {
dup2(std_in[0], 0);
close(std_in[0]);
close(std_in[1]);
dup2(std_out[1], 1);
close(std_out[1]);
close(std_out[0]);
dup2(std_err[1], 2);
close(std_err[1]);
close(std_err[0]);
if (initgroups(userName, gid) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"initgroups for %s:%d failed: %s (%d)",
userName,
(int) gid,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
env->ReleaseStringUTFChars(usr, userName);
if (setgid(gid) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"setgid to %d failed: %s (%d)",
(int) gid,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
if (setuid(uid) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"setuid to %d failed: %s (%d)",
(int) uid,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
char *dir = (char *) env->GetStringUTFChars(directory, NULL);
if (dir && *dir) {
if (chdir(dir) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"chdir to %s failed: %s (%d)",
dir,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
env->ReleaseStringUTFChars(directory, dir);
}
char *bin = (char *) env->GetStringUTFChars(binary, NULL);
jsize argLen = env->GetArrayLength(arguments);
char **args = (char **)calloc(argLen + 1, sizeof(char *));
for (jsize i = 0; i < argLen; ++i) {
jstring arg = (jstring) env->GetObjectArrayElement(arguments, i);
args[i] = (char *) env->GetStringUTFChars(arg, NULL);
}
if (execvp(bin, args) < 0) {
error = errno;
size_t n = snprintf(message, sizeof(message),
"exec of %s failed: %s (%d)",
bin,
GetErrorStr(errbuf, ERRSTRLEN, error),
error);
n = write(2, message, n);
exit(error);
}
} else if (pid > 0) {
close(std_in[0]);
close(std_out[1]);
close(std_err[1]);
jlong std_fds[3] = { (jlong)std_in[1], jlong(std_out[0]), jlong(std_err[0]) };
env->SetLongArrayRegion(stdFds, 0, 3, std_fds);
} else {
close(std_in[0]);
close(std_in[1]);
close(std_out[0]);
close(std_out[1]);
close(std_err[0]);
close(std_err[1]);
ThrowNativeException(
env,
"fork failed",
errno,
GetErrorStr(errbuf, ERRSTRLEN, errno),
who,
__FILE__,
__LINE__);
}
return (jlong)pid;
}
JNIEXPORT jint JNICALL
Java_org_simplenfast_security_PAMUser_getExitCode0(
JNIEnv *env,
jobject obj,
jlong procId,
jlong timeout)
{
const char *who = "Java_org_simplenfast_security_PAMUser_getExitCode0";
bool done = false;
jint ec = -1;
int error = 0;
pid_t pid = (pid_t)procId;
char errbuf[ERRSTRLEN + 1];
while ((timeout > 0) && !done) {
int cstat;
pid_t rpid = waitpid(pid, &cstat, WNOHANG);
if (rpid == pid) {
ec = WEXITSTATUS(cstat);
done = true;
} else if (rpid == 0) {
sleep(1);
timeout--;
} else if (rpid < 0) {
error = errno;
kill(pid, SIGTERM);
ThrowNativeException(
env,
"waitpid failed",
error,
GetErrorStr(errbuf, ERRSTRLEN, error),
who,
__FILE__,
__LINE__);
done = true;
}
}
if (!done) {
kill(pid, SIGTERM);
ThrowNativeException(
env,
"process timed out",
-1,
"",
who,
__FILE__,
__LINE__);
}
return ec;
}
JNIEXPORT jboolean JNICALL
Java_org_simplenfast_security_PAMUser_logout0(
JNIEnv *env,
jobject obj,
jlong ctx)
{
pam_handle_t *pamh = (pam_handle_t *)ctx;
if (pam_logout(pamh)) {
return JNI_TRUE;
}
return JNI_FALSE;
}
<|endoftext|> |
<commit_before>// Macro designed for use with the AliAnalysisTaskDptDptCorrelations task.
// Author: Prabhat Pujahari & Claude Pruneau, Wayne State
// system: 0: PbPb 1: pPb
// singlesOnly: 0: full correlations 1: singles only
// useWeights: 0: no 1: yes
// centralityMethod: 3: track count 4: V0 centrality 7: V0A centrality for pPb
// chargeSet: 0: ++ 1: +- 2: -+ 3: --
/////////////////////////////////////////////////////////////////////////////////
AliAnalysisTaskDptDptCorrelations *AddTaskDptDptCorr_dca1
(int system = 0,
int singlesOnly = 0,
int useWeights = 0,
int centralityMethod = 4,
int chargeSet = 1,
double zMin = -10.,
double zMax = 10.,
int trackFilterBit = 128,
int nClusterMin = 80,
double eta1Min = -0.8,
double eta1Max = 0.8,
double eta2Min = -0.8,
double eta2Max = 0.8,
double dcaZMin = -3.2,
double dcaZMax = 3.2,
double dcaXYMin = -2.4,
double dcaXYMax = 2.4,
int nCentrality = 1,
Bool_t trigger = kFALSE,
const char* taskname = "dcaz2",
char *inputHistogramFileName = "alien:///alice/cern.ch/user/p/prabhat/CalibFiles/PbPbCalib_dca1.root")
{
// Set Default Configuration of this analysis
// ==========================================
int debugLevel = 0;
int rejectPileup = 1;
int rejectPairConversion = 1;
int sameFilter = 1;
//int nCentrality;
double minCentrality[10];
double maxCentrality[10];
if (system==0) // PbPb
{
if (centralityMethod == 4)
{
minCentrality[0] = 0.0; maxCentrality[0] = 5.0;
minCentrality[1] = 5.0; maxCentrality[1] = 10.;
minCentrality[2] = 30.; maxCentrality[2] = 40.;
minCentrality[3] = 60.; maxCentrality[3] = 70.;
}
else
{
//cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". centralityMethod:" << centralityMethod << " Option NOT AVAILABLE. ABORT."
return 0;
}
}
else if (system==1) // pPb
{
if (centralityMethod == 7)
{
minCentrality[0] = 0; maxCentrality[0] = 20.0;
minCentrality[1] = 20.; maxCentrality[1] = 40.;
minCentrality[2] = 40.; maxCentrality[2] = 60.;
minCentrality[3] = 60.; maxCentrality[3] = 80.;
}
else
{
//cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". centralityMethod:" << centralityMethod << " Option NOT AVAILABLE. ABORT."
return 0;
}
}
else
{
//cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". Option NOT CURRENTLY AVAILABLE. ABORT."
return 0;
}
//double zMin = -10.;
//double zMax = 10.;
double ptMin = 0.2;
double ptMax = 2.0;
double dedxMin = 0.0;
double dedxMax = 20000.0;
int requestedCharge1 = 1; //default
int requestedCharge2 = -1; //default
// Get the pointer to the existing analysis manager via the static access method.
// ==============================================================================
AliAnalysisManager *analysisManager = AliAnalysisManager::GetAnalysisManager();
if (!analysisManager)
{
::Error("AddTaskDptDptCorrelations", "No analysis manager to connect to.");
return NULL;
}
TString part1Name;
TString part2Name;
TString eventName;
TString prefixName = "Corr_";
TString pileupRejecSuffix = "_PileupRejec";
TString pairRejecSuffix = "_PairRejec";
TString calibSuffix = "_calib";
TString singlesOnlySuffix = "_SO";
TString suffix;
TString inputPath = ".";
TString outputPath = ".";
TString baseName;
TString listName;
TString taskName;
//TString inputHistogramFileName;
TString outputHistogramFileName;
// Create the task and add subtask.
// ===========================================================================
int iTask = 0; // task counter
AliAnalysisDataContainer *taskInputContainer;
AliAnalysisDataContainer *taskOutputContainer;
AliAnalysisTaskDptDptCorrelations* task;
for (int iCentrality=0; iCentrality < nCentrality; ++iCentrality)
{
switch (chargeSet)
{
case 0: part1Name = "P_"; part2Name = "P_"; requestedCharge1 = 1; requestedCharge2 = 1; sameFilter = 1; break;
case 1: part1Name = "P_"; part2Name = "M_"; requestedCharge1 = 1; requestedCharge2 = -1; sameFilter = 0; break;
case 2: part1Name = "M_"; part2Name = "P_"; requestedCharge1 = -1; requestedCharge2 = 1; sameFilter = 0; break;
case 3: part1Name = "M_"; part2Name = "M_"; requestedCharge1 = -1; requestedCharge2 = -1; sameFilter = 1; break;
}
part1Name += "eta";
part1Name += int(1000*eta1Max);
part1Name += "_";
part1Name += int(1000*ptMin);
part1Name += "pt";
part1Name += int(1000*ptMax);
part1Name += "_";
part1Name += int(1000*dcaZMin);
part1Name += "DCA";
part1Name += int(1000*dcaZMax);
part1Name += "_";
part2Name += "eta";
part2Name += int(1000*eta2Max);
part2Name += "_";
part2Name += int(1000*ptMin);
part2Name += "pt";
part2Name += int(1000*ptMax);
part2Name += "_";
part2Name += int(1000*dcaZMin);
part2Name += "DCA";
part2Name += int(1000*dcaZMax);
part2Name += "_";
eventName = "";
eventName += int(10.*minCentrality[iCentrality] );
eventName += "Vo";
eventName += int(10.*maxCentrality[iCentrality] );
baseName = prefixName;
baseName += part1Name;
baseName += part2Name;
baseName += eventName;
listName = baseName;
taskName = baseName;
outputHistogramFileName = baseName;
if (singlesOnly) outputHistogramFileName += singlesOnlySuffix;
outputHistogramFileName += ".root";
TFile * inputFile = 0;
TList * histoList = 0;
TH3F * weight_1 = 0;
TH3F * weight_2 = 0;
if (useWeights)
{
TGrid::Connect("alien:");
inputFile = TFile::Open(inputHistogramFileName,"OLD");
if (!inputFile)
{
//cout << "Requested file:" << inputHistogramFileName << " was not opened. ABORT." << endl;
return;
}
TString nameHistoBase = "correction_";
TString nameHisto;
nameHistoBase += eventName;
if (requestedCharge1 == 1)
{
nameHisto = nameHistoBase + "_p";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_1 = (TH3F *) inputFile->Get(nameHisto);
}
else
{
nameHisto = nameHistoBase + "_m";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_1 = (TH3F *) inputFile->Get(nameHisto);
}
if (!weight_1)
{
//cout << "Requested histogram 'correction_p/m' was not found. ABORT." << endl;
return 0;
}
if (!sameFilter)
{
weight_2 = 0;
if (requestedCharge2 == 1)
{
nameHisto = nameHistoBase + "_p";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_2 = (TH3F *) inputFile->Get(nameHisto);
}
else
{
nameHisto = nameHistoBase + "_m";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_2 = (TH3F *) inputFile->Get(nameHisto);
}
if (!weight_2)
{
//cout << "Requested histogram 'correction_p/m' was not found. ABORT." << endl;
return 0;
}
}
}
task = new AliAnalysisTaskDptDptCorrelations(taskName);
//configure my task
task->SetDebugLevel( debugLevel );
task->SetSameFilter( sameFilter );
task->SetSinglesOnly( singlesOnly );
task->SetUseWeights( useWeights );
task->SetRejectPileup( rejectPileup );
task->SetRejectPairConversion(rejectPairConversion);
task->SetVertexZMin( zMin );
task->SetVertexZMax( zMax );
task->SetVertexXYMin( -1. );
task->SetVertexXYMax( 1. );
task->SetCentralityMethod( centralityMethod);
task->SetCentrality( minCentrality[iCentrality], maxCentrality[iCentrality]);
task->SetPtMin1( ptMin );
task->SetPtMax1( ptMax );
task->SetEtaMin1( eta1Min );
task->SetEtaMax1( eta1Max );
task->SetPtMin2( ptMin );
task->SetPtMax2( ptMax );
task->SetEtaMin2( eta2Min );
task->SetEtaMax2( eta2Max );
task->SetDcaZMin( dcaZMin );
task->SetDcaZMax( dcaZMax );
task->SetDcaXYMin( dcaXYMin );
task->SetDcaXYMax( dcaXYMax ); //checking by prp
task->SetDedxMin( dedxMin );
task->SetDedxMax( dedxMax );
task->SetNClusterMin( nClusterMin );
task->SetTrackFilterBit( trackFilterBit );
task->SetRequestedCharge_1( requestedCharge1);
task->SetRequestedCharge_2( requestedCharge2);
task->SetWeigth_1( weight_1 );
task->SetWeigth_2( weight_2 );
if(trigger) task->SelectCollisionCandidates(AliVEvent::kINT7);
else task->SelectCollisionCandidates(AliVEvent::kMB);
cout << "Creating task output container" << endl;
taskOutputContainer = analysisManager->CreateContainer(listName,
TList::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s:%s", AliAnalysisManager::GetCommonFileName(),taskname));
cout << "Add task to analysis manager and connect it to input and output containers" << endl;
analysisManager->AddTask(task);
analysisManager->ConnectInput( task, 0, analysisManager->GetCommonInputContainer());
analysisManager->ConnectOutput(task, 0, taskOutputContainer );
//cout << "Task added ...." << endl;
iTask++;
}
return task;
}
<commit_msg>Update on DptDpt Corr: prabhat<commit_after>// Macro designed for use with the AliAnalysisTaskDptDptCorrelations task.
// Author: Prabhat Pujahari & Claude Pruneau, Wayne State
// system: 0: PbPb 1: pPb
// singlesOnly: 0: full correlations 1: singles only
// useWeights: 0: no 1: yes
// centralityMethod: 3: track count 4: V0 centrality 7: V0A centrality for pPb
// chargeSet: 0: ++ 1: +- 2: -+ 3: --
/////////////////////////////////////////////////////////////////////////////////
AliAnalysisTaskDptDptCorrelations *AddTaskDptDptCorr_dca1
(int system = 0,
int singlesOnly = 0,
int useWeights = 1,
int centralityMethod = 4,
int chargeSet = 1,
double zMin = -10.,
double zMax = 10.,
int trackFilterBit = 128,
int nClusterMin = 80,
double eta1Min = -0.8,
double eta1Max = 0.8,
double eta2Min = -0.8,
double eta2Max = 0.8,
double dcaZMin = -3.2,
double dcaZMax = 3.2,
double dcaXYMin = -2.4,
double dcaXYMax = 2.4,
int nCentrality = 1,
Bool_t trigger = kFALSE,
const char* taskname = "dcaz2",
char *inputHistogramFileName = "alien:///alice/cern.ch/user/p/prabhat/CalibFiles/PbPbCalib_dca1.root")
{
// Set Default Configuration of this analysis
// ==========================================
int debugLevel = 0;
int rejectPileup = 1;
int rejectPairConversion = 1;
int sameFilter = 1;
//int nCentrality;
double minCentrality[10];
double maxCentrality[10];
if (system==0) // PbPb
{
if (centralityMethod == 4)
{
minCentrality[0] = 0.0; maxCentrality[0] = 5.0;
minCentrality[1] = 5.0; maxCentrality[1] = 10.;
minCentrality[2] = 10.; maxCentrality[2] = 20.;
minCentrality[3] = 20.; maxCentrality[3] = 30.;
minCentrality[4] = 30.; maxCentrality[4] = 40.;
minCentrality[5] = 40.; maxCentrality[5] = 50.;
minCentrality[6] = 50.; maxCentrality[6] = 60.;
minCentrality[7] = 60.; maxCentrality[7] = 70.;
minCentrality[8] = 70.; maxCentrality[8] = 80.;
}
else
{
//cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". centralityMethod:" << centralityMethod << " Option NOT AVAILABLE. ABORT."
return 0;
}
}
else if (system==1) // pPb
{
if (centralityMethod == 7)
{
minCentrality[0] = 0; maxCentrality[0] = 20.0;
minCentrality[1] = 20.; maxCentrality[1] = 40.;
minCentrality[2] = 40.; maxCentrality[2] = 60.;
minCentrality[3] = 60.; maxCentrality[3] = 80.;
}
else
{
//cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". centralityMethod:" << centralityMethod << " Option NOT AVAILABLE. ABORT."
return 0;
}
}
else
{
//cout << "-F- AddTaskDptDptCorrelations() system:" << system << ". Option NOT CURRENTLY AVAILABLE. ABORT."
return 0;
}
//double zMin = -10.;
//double zMax = 10.;
double ptMin = 0.2;
double ptMax = 2.0;
double dedxMin = 0.0;
double dedxMax = 20000.0;
int requestedCharge1 = 1; //default
int requestedCharge2 = -1; //default
// Get the pointer to the existing analysis manager via the static access method.
// ==============================================================================
AliAnalysisManager *analysisManager = AliAnalysisManager::GetAnalysisManager();
if (!analysisManager)
{
::Error("AddTaskDptDptCorrelations", "No analysis manager to connect to.");
return NULL;
}
TString part1Name;
TString part2Name;
TString eventName;
TString prefixName = "Corr_";
TString pileupRejecSuffix = "_PileupRejec";
TString pairRejecSuffix = "_PairRejec";
TString calibSuffix = "_calib";
TString singlesOnlySuffix = "_SO";
TString suffix;
TString inputPath = ".";
TString outputPath = ".";
TString baseName;
TString listName;
TString taskName;
//TString inputHistogramFileName;
TString outputHistogramFileName;
// Create the task and add subtask.
// ===========================================================================
int iTask = 0; // task counter
AliAnalysisDataContainer *taskInputContainer;
AliAnalysisDataContainer *taskOutputContainer;
AliAnalysisTaskDptDptCorrelations* task;
for (int iCentrality=0; iCentrality < nCentrality; ++iCentrality)
{
switch (chargeSet)
{
case 0: part1Name = "P_"; part2Name = "P_"; requestedCharge1 = 1; requestedCharge2 = 1; sameFilter = 1; break;
case 1: part1Name = "P_"; part2Name = "M_"; requestedCharge1 = 1; requestedCharge2 = -1; sameFilter = 0; break;
case 2: part1Name = "M_"; part2Name = "P_"; requestedCharge1 = -1; requestedCharge2 = 1; sameFilter = 0; break;
case 3: part1Name = "M_"; part2Name = "M_"; requestedCharge1 = -1; requestedCharge2 = -1; sameFilter = 1; break;
}
part1Name += "eta";
part1Name += int(1000*eta1Max);
part1Name += "_";
part1Name += int(1000*ptMin);
part1Name += "pt";
part1Name += int(1000*ptMax);
part1Name += "_";
part1Name += int(1000*dcaZMin);
part1Name += "DCA";
part1Name += int(1000*dcaZMax);
part1Name += "_";
part2Name += "eta";
part2Name += int(1000*eta2Max);
part2Name += "_";
part2Name += int(1000*ptMin);
part2Name += "pt";
part2Name += int(1000*ptMax);
part2Name += "_";
part2Name += int(1000*dcaZMin);
part2Name += "DCA";
part2Name += int(1000*dcaZMax);
part2Name += "_";
eventName = "";
eventName += int(10.*minCentrality[iCentrality] );
eventName += "Vo";
eventName += int(10.*maxCentrality[iCentrality] );
baseName = prefixName;
baseName += part1Name;
baseName += part2Name;
baseName += eventName;
listName = baseName;
taskName = baseName;
outputHistogramFileName = baseName;
if (singlesOnly) outputHistogramFileName += singlesOnlySuffix;
outputHistogramFileName += ".root";
TFile * inputFile = 0;
TList * histoList = 0;
TH3F * weight_1 = 0;
TH3F * weight_2 = 0;
if (useWeights)
{
TGrid::Connect("alien:");
inputFile = TFile::Open(inputHistogramFileName,"OLD");
if (!inputFile)
{
//cout << "Requested file:" << inputHistogramFileName << " was not opened. ABORT." << endl;
return;
}
TString nameHistoBase = "correction_";
TString nameHisto;
nameHistoBase += eventName;
if (requestedCharge1 == 1)
{
nameHisto = nameHistoBase + "_p";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_1 = (TH3F *) inputFile->Get(nameHisto);
}
else
{
nameHisto = nameHistoBase + "_m";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_1 = (TH3F *) inputFile->Get(nameHisto);
}
if (!weight_1)
{
//cout << "Requested histogram 'correction_p/m' was not found. ABORT." << endl;
return 0;
}
if (!sameFilter)
{
weight_2 = 0;
if (requestedCharge2 == 1)
{
nameHisto = nameHistoBase + "_p";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_2 = (TH3F *) inputFile->Get(nameHisto);
}
else
{
nameHisto = nameHistoBase + "_m";
//cout << "Input Histogram named: " << nameHisto << endl;
weight_2 = (TH3F *) inputFile->Get(nameHisto);
}
if (!weight_2)
{
//cout << "Requested histogram 'correction_p/m' was not found. ABORT." << endl;
return 0;
}
}
}
task = new AliAnalysisTaskDptDptCorrelations(taskName);
//configure my task
task->SetDebugLevel( debugLevel );
task->SetSameFilter( sameFilter );
task->SetSinglesOnly( singlesOnly );
task->SetUseWeights( useWeights );
task->SetRejectPileup( rejectPileup );
task->SetRejectPairConversion(rejectPairConversion);
task->SetVertexZMin( zMin );
task->SetVertexZMax( zMax );
task->SetVertexXYMin( -1. );
task->SetVertexXYMax( 1. );
task->SetCentralityMethod( centralityMethod);
task->SetCentrality( minCentrality[iCentrality], maxCentrality[iCentrality]);
task->SetPtMin1( ptMin );
task->SetPtMax1( ptMax );
task->SetEtaMin1( eta1Min );
task->SetEtaMax1( eta1Max );
task->SetPtMin2( ptMin );
task->SetPtMax2( ptMax );
task->SetEtaMin2( eta2Min );
task->SetEtaMax2( eta2Max );
task->SetDcaZMin( dcaZMin );
task->SetDcaZMax( dcaZMax );
task->SetDcaXYMin( dcaXYMin );
task->SetDcaXYMax( dcaXYMax ); //checking by prp
task->SetDedxMin( dedxMin );
task->SetDedxMax( dedxMax );
task->SetNClusterMin( nClusterMin );
task->SetTrackFilterBit( trackFilterBit );
task->SetRequestedCharge_1( requestedCharge1);
task->SetRequestedCharge_2( requestedCharge2);
task->SetWeigth_1( weight_1 );
task->SetWeigth_2( weight_2 );
if(trigger) task->SelectCollisionCandidates(AliVEvent::kINT7);
else task->SelectCollisionCandidates(AliVEvent::kMB);
cout << "Creating task output container" << endl;
taskOutputContainer = analysisManager->CreateContainer(listName,
TList::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s:%s", AliAnalysisManager::GetCommonFileName(),taskname));
cout << "Add task to analysis manager and connect it to input and output containers" << endl;
analysisManager->AddTask(task);
analysisManager->ConnectInput( task, 0, analysisManager->GetCommonInputContainer());
analysisManager->ConnectOutput(task, 0, taskOutputContainer );
//cout << "Task added ...." << endl;
iTask++;
}
return task;
}
<|endoftext|> |
<commit_before>/*
* This file is a part of Xpiks - cross platform application for
* keywording and uploading images for microstocks
* Copyright (C) 2014-2016 Taras Kushnir <[email protected]>
*
* Xpiks is distributed under the GNU General Public License, version 3.0
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "artworkmetadata.h"
#include <QReadLocker>
#include <QWriteLocker>
#include <QStringBuilder>
#include <QDir>
#include "../Helpers/keywordvalidator.h"
#include "settingsmodel.h"
#include "../SpellCheck/spellsuggestionsitem.h"
#include "../SpellCheck/spellcheckitem.h"
#include "../SpellCheck/spellcheckiteminfo.h"
#include "../Common/defines.h"
namespace Models {
ArtworkMetadata::ArtworkMetadata(const QString &filepath, qint64 ID) :
Common::BasicKeywordsModel(),
m_ArtworkFilepath(filepath),
m_ID(ID),
m_IsModified(false),
m_IsUnavailable(false),
m_IsSelected(false),
m_IsInitialized(false),
m_HasAttachedVector(false)
{
setSpellCheckInfo(new SpellCheck::SpellCheckItemInfo());
}
ArtworkMetadata::~ArtworkMetadata() {
this->freeSpellCheckInfo();
}
bool ArtworkMetadata::initialize(const QString &title,
const QString &description, const QStringList &rawKeywords, bool overwrite) {
bool anythingModified = false;
if (overwrite || (isTitleEmpty() && !title.trimmed().isEmpty())) {
anythingModified = true;
BasicKeywordsModel::setTitle(title);
}
if (overwrite || (isDescriptionEmpty() && !description.trimmed().isEmpty())) {
anythingModified = true;
BasicKeywordsModel::setDescription(description);
}
if (overwrite) {
anythingModified = anythingModified || (!(areKeywordsEmpty() && rawKeywords.isEmpty()));
beginResetModel();
BasicKeywordsModel::resetKeywords();
BasicKeywordsModel::addKeywords(rawKeywords);
endResetModel();
} else if (!rawKeywords.isEmpty()) {
int appendedCount = appendKeywords(rawKeywords);
anythingModified = anythingModified || (appendedCount > 0);
}
m_IsModified = false;
m_IsInitialized = true;
return anythingModified;
}
bool ArtworkMetadata::isInDirectory(const QString &directoryAbsolutePath) const {
bool isInDir = false;
Q_ASSERT(directoryAbsolutePath == QDir(directoryAbsolutePath).absolutePath());
if (m_ArtworkFilepath.startsWith(directoryAbsolutePath)) {
QFileInfo fi(m_ArtworkFilepath);
QString artworksDirectory = fi.absolutePath();
isInDir = artworksDirectory == directoryAbsolutePath;
}
return isInDir;
}
void ArtworkMetadata::attachVector(const QString &vectorFilepath) {
m_HasAttachedVector = true;
m_AttachedVector = vectorFilepath;
}
void ArtworkMetadata::detachVector() {
m_HasAttachedVector = false;
m_AttachedVector.clear();
}
void ArtworkMetadata::clearModel() {
BasicKeywordsModel::clearModel();
markModified();
}
bool ArtworkMetadata::clearKeywords() {
bool result = BasicKeywordsModel::clearKeywords();
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::editKeyword(int index, const QString &replacement) {
bool result = BasicKeywordsModel::editKeyword(index, replacement);
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::removeKeywordAt(int index) {
QString removed;
bool result = BasicKeywordsModel::takeKeywordAt(index, removed);
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::removeLastKeyword() {
QString removed;
bool result = BasicKeywordsModel::takeLastKeyword(removed);
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::appendKeyword(const QString &keyword) {
bool result = BasicKeywordsModel::appendKeyword(keyword);
if (result) { markModified(); }
return result;
}
int ArtworkMetadata::appendKeywords(const QStringList &keywordsList) {
int result = BasicKeywordsModel::appendKeywords(keywordsList);
LOG_DEBUG << "Appended" << result << "keywords out of" << keywordsList.length();
if (result > 0) { markModified(); }
return result;
}
void ArtworkMetadata::markModified() {
if (!m_IsModified) {
m_IsModified = true;
emit modifiedChanged(m_IsModified);
}
}
}
<commit_msg>reorder to correspond to init order<commit_after>/*
* This file is a part of Xpiks - cross platform application for
* keywording and uploading images for microstocks
* Copyright (C) 2014-2016 Taras Kushnir <[email protected]>
*
* Xpiks is distributed under the GNU General Public License, version 3.0
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "artworkmetadata.h"
#include <QReadLocker>
#include <QWriteLocker>
#include <QStringBuilder>
#include <QDir>
#include "../Helpers/keywordvalidator.h"
#include "settingsmodel.h"
#include "../SpellCheck/spellsuggestionsitem.h"
#include "../SpellCheck/spellcheckitem.h"
#include "../SpellCheck/spellcheckiteminfo.h"
#include "../Common/defines.h"
namespace Models {
ArtworkMetadata::ArtworkMetadata(const QString &filepath, qint64 ID) :
Common::BasicKeywordsModel(),
m_ArtworkFilepath(filepath),
m_ID(ID),
m_IsModified(false),
m_IsSelected(false),
m_IsInitialized(false),
m_HasAttachedVector(false),
m_IsUnavailable(false)
{
setSpellCheckInfo(new SpellCheck::SpellCheckItemInfo());
}
ArtworkMetadata::~ArtworkMetadata() {
this->freeSpellCheckInfo();
}
bool ArtworkMetadata::initialize(const QString &title,
const QString &description, const QStringList &rawKeywords, bool overwrite) {
bool anythingModified = false;
if (overwrite || (isTitleEmpty() && !title.trimmed().isEmpty())) {
anythingModified = true;
BasicKeywordsModel::setTitle(title);
}
if (overwrite || (isDescriptionEmpty() && !description.trimmed().isEmpty())) {
anythingModified = true;
BasicKeywordsModel::setDescription(description);
}
if (overwrite) {
anythingModified = anythingModified || (!(areKeywordsEmpty() && rawKeywords.isEmpty()));
beginResetModel();
BasicKeywordsModel::resetKeywords();
BasicKeywordsModel::addKeywords(rawKeywords);
endResetModel();
} else if (!rawKeywords.isEmpty()) {
int appendedCount = appendKeywords(rawKeywords);
anythingModified = anythingModified || (appendedCount > 0);
}
m_IsModified = false;
m_IsInitialized = true;
return anythingModified;
}
bool ArtworkMetadata::isInDirectory(const QString &directoryAbsolutePath) const {
bool isInDir = false;
Q_ASSERT(directoryAbsolutePath == QDir(directoryAbsolutePath).absolutePath());
if (m_ArtworkFilepath.startsWith(directoryAbsolutePath)) {
QFileInfo fi(m_ArtworkFilepath);
QString artworksDirectory = fi.absolutePath();
isInDir = artworksDirectory == directoryAbsolutePath;
}
return isInDir;
}
void ArtworkMetadata::attachVector(const QString &vectorFilepath) {
m_HasAttachedVector = true;
m_AttachedVector = vectorFilepath;
}
void ArtworkMetadata::detachVector() {
m_HasAttachedVector = false;
m_AttachedVector.clear();
}
void ArtworkMetadata::clearModel() {
BasicKeywordsModel::clearModel();
markModified();
}
bool ArtworkMetadata::clearKeywords() {
bool result = BasicKeywordsModel::clearKeywords();
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::editKeyword(int index, const QString &replacement) {
bool result = BasicKeywordsModel::editKeyword(index, replacement);
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::removeKeywordAt(int index) {
QString removed;
bool result = BasicKeywordsModel::takeKeywordAt(index, removed);
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::removeLastKeyword() {
QString removed;
bool result = BasicKeywordsModel::takeLastKeyword(removed);
if (result) { markModified(); }
return result;
}
bool ArtworkMetadata::appendKeyword(const QString &keyword) {
bool result = BasicKeywordsModel::appendKeyword(keyword);
if (result) { markModified(); }
return result;
}
int ArtworkMetadata::appendKeywords(const QStringList &keywordsList) {
int result = BasicKeywordsModel::appendKeywords(keywordsList);
LOG_DEBUG << "Appended" << result << "keywords out of" << keywordsList.length();
if (result > 0) { markModified(); }
return result;
}
void ArtworkMetadata::markModified() {
if (!m_IsModified) {
m_IsModified = true;
emit modifiedChanged(m_IsModified);
}
}
}
<|endoftext|> |
<commit_before>#include <easylogging.h>
#include <glm/gtc/type_ptr.hpp>
#include "core/model.h"
#include <stdexcept>
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim)) {
elems.push_back(item);
}
return elems;
}
std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
split(s, delim, elems);
return elems;
}
void Model::addGroup(std::string g) {
groups[g];
}
Model::Model(std::string filename) {
mode = G308_SHADE_POLYGON;
m_glGeomListPoly = 0;
m_glGeomListWire = 0;
std::string line;
std::ifstream myfile(filename);
int v1, v2, v3, n1, n2, n3, t1, t2, t3;
std::string g;
if (myfile.is_open())
{
while (getline(myfile, line))
{
//LOG(INFO) << line;
if (line.size()<=1 || line[0] == '#') continue;
std::vector<std::string> t = split(line, ' ');
if (t[0] == "v" && t.size() == 4) {
vertices.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
std::stof(t[3])));
}
else if (t[0] == "vt" && t.size() == 4) {
uv.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
std::stof(t[3])));
}
else if (t[0] == "vt" && t.size() == 3) {
uv.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
0));
}
else if (t[0] == "vn" && t.size() == 4) {
normals.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
std::stof(t[3])));
}
else if (t[0] == "f") {
if (t.size() == 5) {
int v[4];
int n[4];
int u[4];
for (size_t i = 1; i < t.size(); i++) {
//LOG(INFO) << t[i];
v[i-1] = std::stoi(t[i].substr(0, t[i].find_first_of('/')),nullptr);
u[i - 1] = std::stoi(t[i].substr(t[i].find_first_of('/') + 1, t[i].find_last_of('/') - t[i].find_first_of('/') - 1));
n[i - 1] = std::stoi(t[i].substr(t[i].find_last_of('/') + 1, t[i].size() - t[i].find_last_of('/') - 1));
}
if (g.size() == 0) {
g = "default";
addGroup(g);
}
groups[g].triangles.push_back(Triangle(glm::ivec3(v[0] - 1, v[1] - 1, v[3] - 1),
glm::ivec3(n[0] - 1, n[1] - 1, n[3] - 1),
glm::ivec3(u[0] - 1, u[1] - 1, u[3] - 1)));
groups[g].triangles.push_back(Triangle(glm::ivec3(v[3] - 1, v[1] - 1, v[2] - 1),
glm::ivec3(n[3] - 1, n[1] - 1, n[2] - 1),
glm::ivec3(u[3] - 1, u[1] - 1, u[2] - 1)));
}
else if (t[0].size()) {
int scan = sscanf(line.c_str(), "f %d/%d/%d %d/%d/%d %d/%d/%d", &v1, &t1, &n1, &v2, &t2, &n2, &v3, &t3, &n3);
if (scan < 9) {
scan = sscanf(line.c_str(), "f %d//%d %d//%d %d//%d", &v1, &n1, &v2, &n2, &v3, &n3);
if (scan < 6) {
scan = sscanf(line.c_str(), "f %d/%d %d/%d %d/%d", &v1, &t1, &v2, &t2, &v3, &t3);
if (scan < 6) {
LOG(ERROR) << "Failed to parse '" << line << "'.";
throw std::runtime_error("");
}
}
}
if (g.size() == 0) {
g = "default";
addGroup(g);
}
groups[g].triangles.push_back(Triangle(glm::ivec3(v1 - 1, v2 - 1, v3 - 1),
glm::ivec3(n1 - 1, n2 - 1, n3 - 1),
glm::ivec3(t1 - 1, t2 - 1, t3 - 1)));
}
}
else if (t[0] == "mtllib") {
size_t found = filename.find_last_of("/");
if (found == std::string::npos) readMTL(t[1]);
else {
readMTL(filename.substr(0, found + 1) + t[1]);
}
}
else if (t[0] == "usemtl") {
if (g.size() == 0) {
g = "default";
addGroup(g);
}
groups[g].materialIdx = t[1];
if (materials.find(t[1]) == materials.end()) {
LOG(ERROR) << "missing material " << t[1];
throw std::runtime_error("");
}
}
else if (t[0] == "g") {
g = t[1];
addGroup(g);
}
else if (t[0] == "s") {
groups[g].s = t[1];
}
else {
LOG(ERROR) << "Failed to parse '" << line << "'.";
throw std::runtime_error("");
}
}
myfile.close();
}
LOG(INFO) << "Finished loading '" << filename << "'.";
LOG(TRACE) << vertices.size() << " vertices, "
<< uv.size() << " texcoords, "
<< normals.size() << " normals.";
}
void Model::readMTL(std::string filename) {
std::string line;
std::ifstream myfile(filename);
int prev = materials.size();
LOG(INFO) << "reading mtl file" << filename;
if (myfile.is_open())
{
std::string mtl;
while (getline(myfile, line)) {
std::vector<std::string> t = split(line, ' ');
if (t.size() == 0 || t[0] == "#" || t[0] == "\n");
else if (t[0] == "newmtl") {
mtl = t[1];
materials[mtl];
}
else if (t[0] == "illum") materials[mtl].illum = std::stoi(t[1]);
else if (t[0] == "Ka") materials[mtl].Ka = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Kd") materials[mtl].Kd = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Ks") materials[mtl].Ks = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Ke") materials[mtl].Ke = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Tf") materials[mtl].Tf = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Ns") materials[mtl].Ns = std::stof(t[1]);
else if (t[0] == "Ni") materials[mtl].Ni = std::stof(t[1]);
else if (t[0] == "d") materials[mtl].d = std::stof(t[1]);
else if (t[0] == "Tr") materials[mtl].Tr = std::stof(t[1]);
/*else if (t2[0] == "map_Kd") {
m.map_Kd = new gl::texture2D(t2[1], GL_UNSIGNED_BYTE);
}*/
else {
LOG(ERROR) << t[0];
}
}
}
LOG(INFO) << "finished reading mtl file " << std::to_string(materials.size() - prev);
}
void Model::display() {
if (drawLists.empty()) {
CreateDrawingLists();
}
if (mode == G308_SHADE_POLYGON) {
if (m_glGeomListPoly == 0) CreateGLPolyGeometry();
glCallList(m_glGeomListPoly);
}
else if (mode == G308_SHADE_WIREFRAME) {
if (m_glGeomListWire == 0) CreateGLWireGeometry();
glCallList(m_glGeomListWire);
}
else {
printf("Warning: Wrong Shading Mode. \n");
}
}
void Model::useMTL(std::string mtl) {
glMaterialfv(GL_FRONT, GL_AMBIENT, glm::value_ptr(materials[mtl].Ka));
glMaterialfv(GL_FRONT, GL_DIFFUSE, glm::value_ptr(materials[mtl].Kd));
glMaterialfv(GL_FRONT, GL_SPECULAR, glm::value_ptr(glm::vec4(materials[mtl].Ks, materials[mtl].Ns)));
//glEnable(GL_TEXTURE_2D);
//materials[mtl].map_Kd->bind(0);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
void Model::addToList(int v, int n, int u) {
if (uv.size()>0) glTexCoord2f(uv[u].x, uv[u].y);
glNormal3f(normals[n].x, normals[n].y, normals[n].z); //Add the normal
glVertex3f(vertices[v].x, vertices[v].y, vertices[v].z); //Add the vertex
}
void Model::CreateDrawingLists() {
if (!drawLists.empty()) {
for each (std::pair<std::string,int> var in drawLists)
{
glDeleteLists(var.second, 1);
}
drawLists.clear();
}
for (auto& g : groups) {
int l = glGenLists(1);
glBegin(GL_TRIANGLES);
for (Triangle t : g.second.triangles) {
addToList(t.v[0], t.n[0], t.t[0]);
addToList(t.v[1], t.n[1], t.t[1]);
addToList(t.v[2], t.n[2], t.t[2]);
}
glEnd();
drawLists.push_back(std::pair<std::string, int>(g.second.materialIdx, l));
}
}<commit_msg>model now compiles<commit_after>#include <easylogging.h>
#include <glm/gtc/type_ptr.hpp>
#include "core/model.h"
#include <stdexcept>
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim)) {
elems.push_back(item);
}
return elems;
}
std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
split(s, delim, elems);
return elems;
}
void Model::addGroup(std::string g) {
groups[g];
}
Model::Model(std::string filename) {
std::string line;
std::ifstream myfile(filename);
int v1, v2, v3, n1, n2, n3, t1, t2, t3;
std::string g;
if (myfile.is_open())
{
while (getline(myfile, line))
{
//LOG(INFO) << line;
if (line.size()<=1 || line[0] == '#') continue;
std::vector<std::string> t = split(line, ' ');
if (t[0] == "v" && t.size() == 4) {
vertices.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
std::stof(t[3])));
}
else if (t[0] == "vt" && t.size() == 4) {
uv.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
std::stof(t[3])));
}
else if (t[0] == "vt" && t.size() == 3) {
uv.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
0));
}
else if (t[0] == "vn" && t.size() == 4) {
normals.push_back(glm::vec3(std::stof(t[1]),
std::stof(t[2]),
std::stof(t[3])));
}
else if (t[0] == "f") {
if (t.size() == 5) {
int v[4];
int n[4];
int u[4];
for (size_t i = 1; i < t.size(); i++) {
//LOG(INFO) << t[i];
v[i-1] = std::stoi(t[i].substr(0, t[i].find_first_of('/')),nullptr);
u[i - 1] = std::stoi(t[i].substr(t[i].find_first_of('/') + 1, t[i].find_last_of('/') - t[i].find_first_of('/') - 1));
n[i - 1] = std::stoi(t[i].substr(t[i].find_last_of('/') + 1, t[i].size() - t[i].find_last_of('/') - 1));
}
if (g.size() == 0) {
g = "default";
addGroup(g);
}
groups[g].triangles.push_back(Triangle(glm::ivec3(v[0] - 1, v[1] - 1, v[3] - 1),
glm::ivec3(n[0] - 1, n[1] - 1, n[3] - 1),
glm::ivec3(u[0] - 1, u[1] - 1, u[3] - 1)));
groups[g].triangles.push_back(Triangle(glm::ivec3(v[3] - 1, v[1] - 1, v[2] - 1),
glm::ivec3(n[3] - 1, n[1] - 1, n[2] - 1),
glm::ivec3(u[3] - 1, u[1] - 1, u[2] - 1)));
}
else if (t[0].size()) {
int scan = sscanf(line.c_str(), "f %d/%d/%d %d/%d/%d %d/%d/%d", &v1, &t1, &n1, &v2, &t2, &n2, &v3, &t3, &n3);
if (scan < 9) {
scan = sscanf(line.c_str(), "f %d//%d %d//%d %d//%d", &v1, &n1, &v2, &n2, &v3, &n3);
if (scan < 6) {
scan = sscanf(line.c_str(), "f %d/%d %d/%d %d/%d", &v1, &t1, &v2, &t2, &v3, &t3);
if (scan < 6) {
LOG(ERROR) << "Failed to parse '" << line << "'.";
throw std::runtime_error("");
}
}
}
if (g.size() == 0) {
g = "default";
addGroup(g);
}
groups[g].triangles.push_back(Triangle(glm::ivec3(v1 - 1, v2 - 1, v3 - 1),
glm::ivec3(n1 - 1, n2 - 1, n3 - 1),
glm::ivec3(t1 - 1, t2 - 1, t3 - 1)));
}
}
else if (t[0] == "mtllib") {
size_t found = filename.find_last_of("/");
if (found == std::string::npos) readMTL(t[1]);
else {
readMTL(filename.substr(0, found + 1) + t[1]);
}
}
else if (t[0] == "usemtl") {
if (g.size() == 0) {
g = "default";
addGroup(g);
}
groups[g].materialIdx = t[1];
if (materials.find(t[1]) == materials.end()) {
LOG(ERROR) << "missing material " << t[1];
throw std::runtime_error("");
}
}
else if (t[0] == "g") {
g = t[1];
addGroup(g);
}
else if (t[0] == "s") {
groups[g].s = t[1];
}
else {
LOG(ERROR) << "Failed to parse '" << line << "'.";
throw std::runtime_error("");
}
}
myfile.close();
}
LOG(INFO) << "Finished loading '" << filename << "'.";
LOG(TRACE) << vertices.size() << " vertices, "
<< uv.size() << " texcoords, "
<< normals.size() << " normals.";
}
void Model::readMTL(std::string filename) {
std::string line;
std::ifstream myfile(filename);
int prev = materials.size();
LOG(INFO) << "reading mtl file" << filename;
if (myfile.is_open())
{
std::string mtl;
while (getline(myfile, line)) {
std::vector<std::string> t = split(line, ' ');
if (t.size() == 0 || t[0] == "#" || t[0] == "\n");
else if (t[0] == "newmtl") {
mtl = t[1];
materials[mtl];
}
else if (t[0] == "illum") materials[mtl].illum = std::stoi(t[1]);
else if (t[0] == "Ka") materials[mtl].Ka = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Kd") materials[mtl].Kd = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Ks") materials[mtl].Ks = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Ke") materials[mtl].Ke = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Tf") materials[mtl].Tf = glm::vec3(std::stof(t[1]), std::stof(t[2]), std::stof(t[3]));
else if (t[0] == "Ns") materials[mtl].Ns = std::stof(t[1]);
else if (t[0] == "Ni") materials[mtl].Ni = std::stof(t[1]);
else if (t[0] == "d") materials[mtl].d = std::stof(t[1]);
else if (t[0] == "Tr") materials[mtl].Tr = std::stof(t[1]);
/*else if (t2[0] == "map_Kd") {
m.map_Kd = new gl::texture2D(t2[1], GL_UNSIGNED_BYTE);
}*/
else {
LOG(ERROR) << t[0];
}
}
}
LOG(INFO) << "finished reading mtl file " << std::to_string(materials.size() - prev);
}
void Model::display() {
if (drawLists.empty()) {
CreateDrawingLists();
}
for each (std::pair<std::string, int> var in drawLists)
{
glCallList(var.second);
}
}
void Model::useMTL(std::string mtl) {
glMaterialfv(GL_FRONT, GL_AMBIENT, glm::value_ptr(materials[mtl].Ka));
glMaterialfv(GL_FRONT, GL_DIFFUSE, glm::value_ptr(materials[mtl].Kd));
glMaterialfv(GL_FRONT, GL_SPECULAR, glm::value_ptr(glm::vec4(materials[mtl].Ks, materials[mtl].Ns)));
//glEnable(GL_TEXTURE_2D);
//materials[mtl].map_Kd->bind(0);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
void Model::addToList(int v, int n, int u) {
if (uv.size()>0) glTexCoord2f(uv[u].x, uv[u].y);
glNormal3f(normals[n].x, normals[n].y, normals[n].z); //Add the normal
glVertex3f(vertices[v].x, vertices[v].y, vertices[v].z); //Add the vertex
}
void Model::CreateDrawingLists() {
if (!drawLists.empty()) {
for each (std::pair<std::string,int> var in drawLists)
{
glDeleteLists(var.second, 1);
}
drawLists.clear();
}
for (auto& g : groups) {
int l = glGenLists(1);
glBegin(GL_TRIANGLES);
for (Triangle t : g.second.triangles) {
addToList(t.v[0], t.n[0], t.t[0]);
addToList(t.v[1], t.n[1], t.t[1]);
addToList(t.v[2], t.n[2], t.t[2]);
}
glEnd();
drawLists.push_back(std::pair<std::string, int>(g.second.materialIdx, l));
}
}<|endoftext|> |
<commit_before>/* -*- mode: c++; c-default-style: "google"; indent-tabs-mode: nil -*- */
/* -------------------------------------------------------------------------
ATS
License: see $AMANZI_DIR/COPYRIGHT
Author: ??
Effectively stolen from Amanzi, with few modifications.
------------------------------------------------------------------------- */
#include <iostream>
#include <cstdlib>
#include <cmath>
#include "Exodus_readers.hh"
#include "Parallel_Exodus_file.hh"
#include <Epetra_Comm.h>
#include <Epetra_MpiComm.h>
#include "Epetra_SerialComm.h"
#include "Teuchos_ParameterList.hpp"
#include "Teuchos_XMLParameterListHelpers.hpp"
#include "Teuchos_CommandLineProcessor.hpp"
#include "Teuchos_GlobalMPISession.hpp"
#include "Teuchos_oblackholestream.hpp"
#include "Teuchos_Version.hpp"
#include "Teuchos_DefaultMpiComm.hpp"
#include "Teuchos_StrUtils.hpp"
#include "Teuchos_TimeMonitor.hpp"
#include "MeshAudit.hh"
#include "MeshFactory.hh"
#include "Domain.hh"
#include "GeometricModel.hh"
#include "coordinator.hh"
#include "State.hh"
#include "errors.hh"
#include "exceptions.hh"
#include "amanzi_unstructured_grid_simulation_driver.hh"
#include "InputParserIS.hh"
#include "global_verbosity.hh"
Amanzi::Simulator::ReturnType AmanziUnstructuredGridSimulationDriver::Run(
const MPI_Comm& mpi_comm, Teuchos::ParameterList& input_parameter_list) {
using Teuchos::OSTab;
setDefaultVerbLevel(Amanzi::VerbosityLevel::level_);
Teuchos::EVerbosityLevel verbLevel = getVerbLevel();
Teuchos::RCP<Teuchos::FancyOStream> out = getOStream();
OSTab tab = getOSTab(); // This sets the line prefix and adds one tab
#ifdef HAVE_MPI
Epetra_MpiComm *comm = new Epetra_MpiComm(mpi_comm);
#else
Epetra_SerialComm *comm = new Epetra_SerialComm();
#endif
int rank;
MPI_Comm_rank(mpi_comm,&rank);
int size;
MPI_Comm_size(mpi_comm,&size);
Teuchos::ParameterList params_copy;
bool native = input_parameter_list.get<bool>("Native Unstructured Input",false);
ASSERT(native);
params_copy = input_parameter_list;
if(out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW,true)) {
// print parameter list
*out << "======================> dumping parameter list <======================" <<
std::endl;
Teuchos::writeParameterListToXmlOStream(params_copy, *out);
*out << "======================> done dumping parameter list. <================" <<
std::endl;
}
// ------ domain and geometric model ------
Teuchos::ParameterList domain_params = params_copy.sublist("Domain");
unsigned int spdim = domain_params.get<int>("Spatial Dimension");
Amanzi::AmanziGeometry::Domain *simdomain_ptr = new Amanzi::AmanziGeometry::Domain(spdim);
// Under the simulation domain we have different geometric
// models. We can also have free geometric regions not associated
// with a geometric model.
// For now create one geometric model from all the regions in the spec
Teuchos::ParameterList reg_params = params_copy.sublist("Regions");
Amanzi::AmanziGeometry::GeometricModelPtr
geom_model_ptr( new Amanzi::AmanziGeometry::GeometricModel(spdim, reg_params, comm) );
// Add the geometric model to the domain
simdomain_ptr->Add_Geometric_Model(geom_model_ptr);
// If we had geometric models and free regions coexisting then we would
// create the free regions here and add them to the simulation domain
// Nothing to do for now
// ------ mesh ------
Amanzi::AmanziMesh::MeshFactory factory(comm);
Teuchos::RCP<Amanzi::AmanziMesh::Mesh> mesh;
// select the mesh framework
Teuchos::ParameterList mesh_plist = params_copy.sublist("Mesh");
int ierr = 0;
try {
std::string framework = mesh_plist.get<string>("Framework");
Amanzi::AmanziMesh::FrameworkPreference prefs(factory.preference());
if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::Simple)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::Simple);
} else if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::MOAB)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::MOAB);
} else if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::STKMESH)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::STKMESH);
} else if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::MSTK)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::MSTK);
} else if (framework == "") {
// do nothing
} else {
std::string s(framework);
s += ": specified mesh framework preference not understood";
amanzi_throw(Errors::Message(s));
}
factory.preference(prefs);
} catch (const Teuchos::Exceptions::InvalidParameterName& e) {
// do nothing, this means that the "Framework" parameter was not in the input
} catch (const std::exception& e) {
std::cout << rank << ": error: " << e.what() << std::endl;
ierr++;
}
int aerr = 0;
comm->SumAll(&ierr, &aerr, 1);
if (aerr > 0) {
return Amanzi::Simulator::FAIL;
}
// Create the mesh
std::string file(""), format("");
if (mesh_plist.isSublist("Read Mesh File")) {
// try to read mesh from file
Teuchos::ParameterList read_params = mesh_plist.sublist("Read Mesh File");
if (read_params.isParameter("File")) {
file = read_params.get<string>("File");
} else {
std::cerr << "Must specify File parameter for Read option under Mesh" << std::endl;
throw std::exception();
}
if (read_params.isParameter("Format")) {
// Is the format one that we can read?
format = read_params.get<string>("Format");
if (format != "Exodus II") {
std::cerr << "Can only read files in Exodus II format" << std::endl;
throw std::exception();
}
} else {
std::cerr << "Must specify Format parameter for Read option under Mesh" << std::endl;
throw std::exception();
}
if (!file.empty()) {
ierr = 0;
try {
// create the mesh from the file
Teuchos::RCP<Teuchos::Time> volmeshtime = Teuchos::TimeMonitor::getNewCounter("volume mesh creation");
Teuchos::TimeMonitor timer(*volmeshtime);
mesh = factory.create(file, geom_model_ptr);
} catch (const std::exception& e) {
std::cerr << rank << ": error: " << e.what() << std::endl;
ierr++;
}
comm->SumAll(&ierr, &aerr, 1);
if (aerr > 0) return Amanzi::Simulator::FAIL;
}
} else if (mesh_plist.isSublist("Generate Mesh")) {
// try to generate the mesh from data in plist
Teuchos::ParameterList gen_params = mesh_plist.sublist("Generate Mesh");
ierr = 0;
try {
mesh = factory.create(gen_params, geom_model_ptr);
} catch (const std::exception& e) {
std::cerr << rank << ": error: " << e.what() << std::endl;
ierr++;
}
comm->SumAll(&ierr, &aerr, 1);
if (aerr > 0) return Amanzi::Simulator::FAIL;
} else {
std::cerr << rank << ": error: "
<< "Neither Read nor Generate options specified for mesh" << std::endl;
throw std::exception();
}
ASSERT(!mesh.is_null());
// mesh verification
bool expert_params_specified = mesh_plist.isSublist("Expert");
if (expert_params_specified) {
Teuchos::ParameterList expert_mesh_params = mesh_plist.sublist("Expert");
bool verify_mesh_param = expert_mesh_params.isParameter("Verify Mesh");
if (verify_mesh_param) {
bool verify = expert_mesh_params.get<bool>("Verify Mesh");
if (verify) {
std::cerr << "Verifying mesh with Mesh Audit..." << std::endl;
if (size == 1) {
Amanzi::MeshAudit mesh_auditor(mesh);
int status = mesh_auditor.Verify();
if (status == 0) {
std::cout << "Mesh Audit confirms that mesh is ok" << std::endl;
} else {
std::cout << "Mesh Audit could not verify correctness of mesh" << std::endl;
return Amanzi::Simulator::FAIL;
}
} else {
std::ostringstream ofile;
ofile << "mesh_audit_" << std::setfill('0') << std::setw(4) << rank << ".txt";
std::ofstream ofs(ofile.str().c_str());
if (rank == 0)
std::cerr << "Writing Mesh Audit output to " << ofile.str() << ", etc." << std::endl;
ierr = 0;
Amanzi::MeshAudit mesh_auditor(mesh, ofs);
int status = mesh_auditor.Verify(); // check the mesh
if (status != 0) ierr++;
comm->SumAll(&ierr, &aerr, 1);
if (aerr == 0) {
std::cerr << "Mesh Audit confirms that mesh is ok" << std::endl;
} else {
if (rank == 0)
std::cerr << "Mesh Audit could not verify correctness of mesh" << std::endl;
return Amanzi::Simulator::FAIL;
}
}
} // if verify
} // if verify_mesh_param
} // If expert_params_specified
// Create the surface mesh if needed
Teuchos::RCP<Amanzi::AmanziMesh::Mesh> surface_mesh = Teuchos::null;
Teuchos::RCP<Amanzi::AmanziMesh::Mesh> surface3D_mesh = Teuchos::null;
if (mesh_plist.isSublist("Surface Mesh")) {
Teuchos::ParameterList surface_plist = mesh_plist.sublist("Surface Mesh");
std::vector<std::string> setnames;
if (surface_plist.isParameter("surface sideset name")) {
setnames.push_back(surface_plist.get<std::string>("surface sideset name"));
} else if (surface_plist.isParameter("surface sideset names")) {
setnames = surface_plist.get<Teuchos::Array<std::string> >("surface sideset names").toVector();
} else {
Errors::Message message("Surface mesh ParameterList needs sideset names.");
Exceptions::amanzi_throw(message);
}
if (mesh->cell_dimension() == 3) {
surface3D_mesh = factory.create(&*mesh,setnames,Amanzi::AmanziMesh::FACE,false,false);
surface_mesh = factory.create(&*mesh,setnames,Amanzi::AmanziMesh::FACE,true,false);
} else {
surface3D_mesh = mesh;
surface_mesh = factory.create(&*mesh,setnames,Amanzi::AmanziMesh::CELL,true,false);
}
}
Teuchos::TimeMonitor::summarize();
Teuchos::TimeMonitor::zeroOutTimers();
// Create the state.
Teuchos::ParameterList state_plist = params_copy.sublist("state");
Teuchos::RCP<Amanzi::State> S = Teuchos::rcp(new Amanzi::State(state_plist));
S->RegisterDomainMesh(mesh);
if (surface3D_mesh != Teuchos::null) S->RegisterMesh("surface_3d", surface3D_mesh);
if (surface_mesh != Teuchos::null) S->RegisterMesh("surface", surface_mesh);
// create the top level Coordinator
Amanzi::Coordinator coordinator(params_copy, S, comm);
// run the simulation
coordinator.cycle_driver();
mesh.reset();
delete comm;
delete simdomain_ptr;
delete geom_model_ptr;
return Amanzi::Simulator::SUCCESS;
}
<commit_msg>adds mesh-audit for surface mesh<commit_after>/* -*- mode: c++; c-default-style: "google"; indent-tabs-mode: nil -*- */
/* -------------------------------------------------------------------------
ATS
License: see $AMANZI_DIR/COPYRIGHT
Author: ??
Effectively stolen from Amanzi, with few modifications.
------------------------------------------------------------------------- */
#include <iostream>
#include <cstdlib>
#include <cmath>
#include "Exodus_readers.hh"
#include "Parallel_Exodus_file.hh"
#include <Epetra_Comm.h>
#include <Epetra_MpiComm.h>
#include "Epetra_SerialComm.h"
#include "Teuchos_ParameterList.hpp"
#include "Teuchos_XMLParameterListHelpers.hpp"
#include "Teuchos_CommandLineProcessor.hpp"
#include "Teuchos_GlobalMPISession.hpp"
#include "Teuchos_oblackholestream.hpp"
#include "Teuchos_Version.hpp"
#include "Teuchos_DefaultMpiComm.hpp"
#include "Teuchos_StrUtils.hpp"
#include "Teuchos_TimeMonitor.hpp"
#include "MeshAudit.hh"
#include "MeshFactory.hh"
#include "Domain.hh"
#include "GeometricModel.hh"
#include "coordinator.hh"
#include "State.hh"
#include "errors.hh"
#include "exceptions.hh"
#include "amanzi_unstructured_grid_simulation_driver.hh"
#include "InputParserIS.hh"
#include "global_verbosity.hh"
Amanzi::Simulator::ReturnType AmanziUnstructuredGridSimulationDriver::Run(
const MPI_Comm& mpi_comm, Teuchos::ParameterList& input_parameter_list) {
using Teuchos::OSTab;
setDefaultVerbLevel(Amanzi::VerbosityLevel::level_);
Teuchos::EVerbosityLevel verbLevel = getVerbLevel();
Teuchos::RCP<Teuchos::FancyOStream> out = getOStream();
OSTab tab = getOSTab(); // This sets the line prefix and adds one tab
#ifdef HAVE_MPI
Epetra_MpiComm *comm = new Epetra_MpiComm(mpi_comm);
#else
Epetra_SerialComm *comm = new Epetra_SerialComm();
#endif
int rank;
MPI_Comm_rank(mpi_comm,&rank);
int size;
MPI_Comm_size(mpi_comm,&size);
Teuchos::ParameterList params_copy;
bool native = input_parameter_list.get<bool>("Native Unstructured Input",false);
ASSERT(native);
params_copy = input_parameter_list;
if(out.get() && includesVerbLevel(verbLevel,Teuchos::VERB_LOW,true)) {
// print parameter list
*out << "======================> dumping parameter list <======================" <<
std::endl;
Teuchos::writeParameterListToXmlOStream(params_copy, *out);
*out << "======================> done dumping parameter list. <================" <<
std::endl;
}
// ------ domain and geometric model ------
Teuchos::ParameterList domain_params = params_copy.sublist("Domain");
unsigned int spdim = domain_params.get<int>("Spatial Dimension");
Amanzi::AmanziGeometry::Domain *simdomain_ptr = new Amanzi::AmanziGeometry::Domain(spdim);
// Under the simulation domain we have different geometric
// models. We can also have free geometric regions not associated
// with a geometric model.
// For now create one geometric model from all the regions in the spec
Teuchos::ParameterList reg_params = params_copy.sublist("Regions");
Amanzi::AmanziGeometry::GeometricModelPtr
geom_model_ptr( new Amanzi::AmanziGeometry::GeometricModel(spdim, reg_params, comm) );
// Add the geometric model to the domain
simdomain_ptr->Add_Geometric_Model(geom_model_ptr);
// If we had geometric models and free regions coexisting then we would
// create the free regions here and add them to the simulation domain
// Nothing to do for now
// ------ mesh ------
Amanzi::AmanziMesh::MeshFactory factory(comm);
Teuchos::RCP<Amanzi::AmanziMesh::Mesh> mesh;
// select the mesh framework
Teuchos::ParameterList mesh_plist = params_copy.sublist("Mesh");
int ierr = 0;
try {
std::string framework = mesh_plist.get<string>("Framework");
Amanzi::AmanziMesh::FrameworkPreference prefs(factory.preference());
if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::Simple)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::Simple);
} else if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::MOAB)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::MOAB);
} else if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::STKMESH)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::STKMESH);
} else if (framework == Amanzi::AmanziMesh::framework_name(Amanzi::AmanziMesh::MSTK)) {
prefs.clear(); prefs.push_back(Amanzi::AmanziMesh::MSTK);
} else if (framework == "") {
// do nothing
} else {
std::string s(framework);
s += ": specified mesh framework preference not understood";
amanzi_throw(Errors::Message(s));
}
factory.preference(prefs);
} catch (const Teuchos::Exceptions::InvalidParameterName& e) {
// do nothing, this means that the "Framework" parameter was not in the input
} catch (const std::exception& e) {
std::cout << rank << ": error: " << e.what() << std::endl;
ierr++;
}
int aerr = 0;
comm->SumAll(&ierr, &aerr, 1);
if (aerr > 0) {
return Amanzi::Simulator::FAIL;
}
// Create the mesh
std::string file(""), format("");
if (mesh_plist.isSublist("Read Mesh File")) {
// try to read mesh from file
Teuchos::ParameterList read_params = mesh_plist.sublist("Read Mesh File");
if (read_params.isParameter("File")) {
file = read_params.get<string>("File");
} else {
std::cerr << "Must specify File parameter for Read option under Mesh" << std::endl;
throw std::exception();
}
if (read_params.isParameter("Format")) {
// Is the format one that we can read?
format = read_params.get<string>("Format");
if (format != "Exodus II") {
std::cerr << "Can only read files in Exodus II format" << std::endl;
throw std::exception();
}
} else {
std::cerr << "Must specify Format parameter for Read option under Mesh" << std::endl;
throw std::exception();
}
if (!file.empty()) {
ierr = 0;
try {
// create the mesh from the file
Teuchos::RCP<Teuchos::Time> volmeshtime = Teuchos::TimeMonitor::getNewCounter("volume mesh creation");
Teuchos::TimeMonitor timer(*volmeshtime);
mesh = factory.create(file, geom_model_ptr);
} catch (const std::exception& e) {
std::cerr << rank << ": error: " << e.what() << std::endl;
ierr++;
}
comm->SumAll(&ierr, &aerr, 1);
if (aerr > 0) return Amanzi::Simulator::FAIL;
}
} else if (mesh_plist.isSublist("Generate Mesh")) {
// try to generate the mesh from data in plist
Teuchos::ParameterList gen_params = mesh_plist.sublist("Generate Mesh");
ierr = 0;
try {
mesh = factory.create(gen_params, geom_model_ptr);
} catch (const std::exception& e) {
std::cerr << rank << ": error: " << e.what() << std::endl;
ierr++;
}
comm->SumAll(&ierr, &aerr, 1);
if (aerr > 0) return Amanzi::Simulator::FAIL;
} else {
std::cerr << rank << ": error: "
<< "Neither Read nor Generate options specified for mesh" << std::endl;
throw std::exception();
}
ASSERT(!mesh.is_null());
// mesh verification
bool expert_params_specified = mesh_plist.isSublist("Expert");
if (expert_params_specified) {
Teuchos::ParameterList expert_mesh_params = mesh_plist.sublist("Expert");
bool verify_mesh_param = expert_mesh_params.isParameter("Verify Mesh");
if (verify_mesh_param) {
bool verify = expert_mesh_params.get<bool>("Verify Mesh");
if (verify) {
std::cerr << "Verifying mesh with Mesh Audit..." << std::endl;
if (size == 1) {
Amanzi::MeshAudit mesh_auditor(mesh);
int status = mesh_auditor.Verify();
if (status == 0) {
std::cout << "Mesh Audit confirms that mesh is ok" << std::endl;
} else {
std::cout << "Mesh Audit could not verify correctness of mesh" << std::endl;
return Amanzi::Simulator::FAIL;
}
} else {
std::ostringstream ofile;
ofile << "mesh_audit_" << std::setfill('0') << std::setw(4) << rank << ".txt";
std::ofstream ofs(ofile.str().c_str());
if (rank == 0)
std::cerr << "Writing Mesh Audit output to " << ofile.str() << ", etc." << std::endl;
ierr = 0;
Amanzi::MeshAudit mesh_auditor(mesh, ofs);
int status = mesh_auditor.Verify(); // check the mesh
if (status != 0) ierr++;
comm->SumAll(&ierr, &aerr, 1);
if (aerr == 0) {
std::cerr << "Mesh Audit confirms that mesh is ok" << std::endl;
} else {
if (rank == 0)
std::cerr << "Mesh Audit could not verify correctness of mesh" << std::endl;
return Amanzi::Simulator::FAIL;
}
}
} // if verify
} // if verify_mesh_param
} // If expert_params_specified
// Create the surface mesh if needed
Teuchos::RCP<Amanzi::AmanziMesh::Mesh> surface_mesh = Teuchos::null;
Teuchos::RCP<Amanzi::AmanziMesh::Mesh> surface3D_mesh = Teuchos::null;
if (mesh_plist.isSublist("Surface Mesh")) {
Teuchos::ParameterList surface_plist = mesh_plist.sublist("Surface Mesh");
std::vector<std::string> setnames;
if (surface_plist.isParameter("surface sideset name")) {
setnames.push_back(surface_plist.get<std::string>("surface sideset name"));
} else if (surface_plist.isParameter("surface sideset names")) {
setnames = surface_plist.get<Teuchos::Array<std::string> >("surface sideset names").toVector();
} else {
Errors::Message message("Surface mesh ParameterList needs sideset names.");
Exceptions::amanzi_throw(message);
}
if (mesh->cell_dimension() == 3) {
surface3D_mesh = factory.create(&*mesh,setnames,Amanzi::AmanziMesh::FACE,false,false);
surface_mesh = factory.create(&*mesh,setnames,Amanzi::AmanziMesh::FACE,true,false);
} else {
surface3D_mesh = mesh;
surface_mesh = factory.create(&*mesh,setnames,Amanzi::AmanziMesh::CELL,true,false);
}
bool surf_expert_params_specified = surface_plist.isSublist("Expert");
if (surf_expert_params_specified) {
Teuchos::ParameterList surf_expert_mesh_params = surface_plist.sublist("Expert");
bool verify_surf_mesh_param = surf_expert_mesh_params.isParameter("Verify Mesh");
if (verify_surf_mesh_param) {
bool verify = surf_expert_mesh_params.get<bool>("Verify Mesh");
if (verify) {
std::cerr << "Verifying surface mesh with Mesh Audit..." << std::endl;
if (size == 1) {
Amanzi::MeshAudit surf_mesh_auditor(surface_mesh);
int status = surf_mesh_auditor.Verify();
if (status == 0) {
std::cout << "Mesh Audit confirms that surface mesh is ok" << std::endl;
} else {
std::cout << "Mesh Audit could not verify correctness of surface mesh" << std::endl;
return Amanzi::Simulator::FAIL;
}
} else {
std::ostringstream ofile;
ofile << "surf_mesh_audit_" << std::setfill('0') << std::setw(4) << rank << ".txt";
std::ofstream ofs(ofile.str().c_str());
if (rank == 0)
std::cerr << "Writing Surface Mesh Audit output to " << ofile.str() << ", etc." << std::endl;
ierr = 0;
Amanzi::MeshAudit surf_mesh_auditor(mesh, ofs);
int status = surf_mesh_auditor.Verify(); // check the mesh
if (status != 0) ierr++;
comm->SumAll(&ierr, &aerr, 1);
if (aerr == 0) {
std::cerr << "Surface Mesh Audit confirms that mesh is ok" << std::endl;
} else {
if (rank == 0)
std::cerr << "Surface Mesh Audit could not verify correctness of mesh" << std::endl;
return Amanzi::Simulator::FAIL;
}
}
} // if verify
} // if verify_mesh_param
} // If expert_params_specified
}
Teuchos::TimeMonitor::summarize();
Teuchos::TimeMonitor::zeroOutTimers();
// Create the state.
Teuchos::ParameterList state_plist = params_copy.sublist("state");
Teuchos::RCP<Amanzi::State> S = Teuchos::rcp(new Amanzi::State(state_plist));
S->RegisterDomainMesh(mesh);
if (surface3D_mesh != Teuchos::null) S->RegisterMesh("surface_3d", surface3D_mesh);
if (surface_mesh != Teuchos::null) S->RegisterMesh("surface", surface_mesh);
// create the top level Coordinator
Amanzi::Coordinator coordinator(params_copy, S, comm);
// run the simulation
coordinator.cycle_driver();
mesh.reset();
delete comm;
delete simdomain_ptr;
delete geom_model_ptr;
return Amanzi::Simulator::SUCCESS;
}
<|endoftext|> |
<commit_before>/*
* Copyright 2010 Alex Graveley
*
* 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 "EventMachine.hh"
#include <sstream>
#include <png.h>
EventMask::EventMask(string mask)
{
istringstream iss(mask, istringstream::in);
string word;
while(iss >> word) {
names.push_back(word);
}
}
bool
EventMask::stateMatch(State *state)
{
vector<string>::iterator i;
for (i = names.begin(); i != names.end(); i++) {
if (!state->getDigitalIn((*i).c_str())) {
return false;
}
}
return true;
}
EventScript::~EventScript()
{
for (uint y=0; y < info->height; y++) {
free(data[y]);
}
#ifndef OSX
png_read_destroy(png, info, NULL);
#endif
}
uint
EventScript::get_frames()
{
return info->height;
}
bool
EventScript::load(string script)
{
/* open file and test for it being a png */
FILE *fp = fopen(script.c_str(), "rb");
if (!fp) {
fprintf(stderr, "Script %s could not be opened for reading", script.c_str());
return false;
}
/* initialize stuff */
png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info = png_create_info_struct(png);
png_init_io(png, fp);
png_read_info(png, info);
png_read_update_info(png, info);
if (info->width != 58) {
fprintf(stderr, "Script %s is not the correct width (expected 58, got %lu).\n",
script.c_str(), info->width);
#ifndef OSX
png_read_destroy(png, info, NULL);
#endif
fclose(fp);
return false;
}
data = (png_bytepp) malloc(sizeof(png_bytep) * info->height);
for (uint y=0; y < info->height; y++) {
data[y] = (png_byte*) malloc(info->rowbytes);
}
png_read_image(png, data);
fclose(fp);
return true;
}
bool
EventScript::update(State *state,
uint frame,
vector<string> lowerLedNames,
vector<string> axonLedNames,
vector<string> upperLedNames,
vector<string> digitalNames)
{
// XXX: constify offsets
unsigned int x=0;
unsigned int y=frame;
if (y >= info->height) {
fprintf(stderr, "Frame %d greater than PNG height %lu\n",
frame, info->height);
return false;
}
png_byte* row = data[y];
vector<string>::iterator i = axonLedNames.begin();
x = 0; //axon LED's start at pixel 0
for (i = axonLedNames.begin(); i != axonLedNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
//fprintf(stderr, "Pixel [x: %d, y: %d] R:%d G:%d B:%d\n",
// x, y, ptr[0], ptr[1], ptr[2]);
state->setLightOut(i->c_str(), ptr[0], ptr[1], ptr[2]);
//printf("%d %d %d | ", ptr[0], ptr[1], ptr[2]);
x++;
}
i = upperLedNames.begin();
x = 10; //upper soma LED's start at pixel 10
for (i = upperLedNames.begin(); i != upperLedNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
state->setLightOut(i->c_str(), ptr[0], ptr[1], ptr[2]);
x++;
}
i = lowerLedNames.begin();
x = 40; //lower soma LED's start at pixel 40
for (i = lowerLedNames.begin(); i != lowerLedNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
state->setLightOut(i->c_str(), ptr[0], ptr[1], ptr[2]);
x++;
}
i = digitalNames.begin();
x = 50; //digital poofers start at pixel 50
for (i = digitalNames.begin(); i != digitalNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
state->setDigitalOut(i->c_str(), ptr[0] + ptr[1] + ptr[2] == 0);
x++;
}
return y < info->height - 1;
}
bool
EventMachine::addScript(string mask, string script)
{
EventScript *es = scriptData[script];
if (!es) {
// load script file, add with name to scriptData
es = new EventScript();
if (!es->load(script)) {
delete es;
fprintf(stderr, "Failed to load script '%s'\n", script.c_str());
return false;
}
}
scriptMasks.push_back(pair<EventMask, string>(EventMask(mask), script));
scriptData[script] = es;
fprintf(stderr, "Added script '%s' with event mask '%s'\n",
script.c_str(), mask.c_str());
return true;
}
void
EventMachine::update(State *state,
vector<string> lowerLedNames,
vector<string> axonLedNames,
vector<string> upperLedNames,
vector<string> digitalNames)
{
for (vector< pair<EventMask, string> >::iterator i = scriptMasks.begin();
i != scriptMasks.end(); i++) {
if (i->first.stateMatch(state)) {
//fprintf(stderr, "Event state matches for script: %s\n",
// i->second.c_str());
EventScript *data = scriptData[i->second];
bool isRunning = false;
vector< pair<EventScript*, uint> >::iterator i2;
for (i2 = scriptStates.begin(); i2 != scriptStates.end(); i2++) {
if (data == i2->first) {
//fprintf(stderr, "Script %p already running.\n",
// i2->first);
isRunning = true;
}
}
if (!isRunning) {
fprintf(stderr, "Restarting script '%s'.\n",
i->second.c_str());
scriptStates.push_back(pair<EventScript *, uint>(data, 0));
}
}
}
vector< pair<EventScript*, uint> > nextStates;
for (vector< pair<EventScript*, uint> >::iterator i2 = scriptStates.begin();
i2 != scriptStates.end(); i2++) {
// Call Ben's event updating for the row at index i2->second.
EventScript *data = i2->first;
uint frame = i2->second;
if (!data) {
fprintf(stderr, "Invalid script data!\n");
continue;
}
if (data->update(state, frame, lowerLedNames, axonLedNames,
upperLedNames, digitalNames)) {
//fprintf(stderr, "Advancing to frame %d of script %p\n", frame, data);
nextStates.push_back(pair<EventScript*, uint>(data, frame + 1));
}
}
scriptStates = nextStates;
}
bool
EventMachine::parseEvent(xmlNodePtr node)
{
bool ret = false;
xmlChar *maskStr = xmlGetProp(node, (const xmlChar *)"mask");
xmlChar *scriptStr = xmlGetProp(node, (const xmlChar *)"script");
if (maskStr == NULL) {
fprintf(stderr, "%s has no mask\n", node->name);
goto err;
}
if (scriptStr == NULL) {
fprintf(stderr, "%s has no script\n", node->name);
goto err;
}
ret = addScript((char *)maskStr, (char *)scriptStr);
err:
xmlFree(maskStr);
xmlFree(scriptStr);
return ret;
}
bool
EventMachine::loadConfig(const char *fileName)
{
xmlDocPtr doc;
xmlNodePtr cur;
xmlNodePtr child;
bool ret = true;
doc = xmlParseFile(fileName);
if (doc == NULL) {
fprintf(stderr, "Document %s not parsed successfully\n",
fileName);
return false;
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr, "empty doc\n");
return false;
}
if (xmlStrcmp(cur->name, (const xmlChar *)"config")){
fprintf(stderr, "config file does not start with config element\n");
goto err0;
}
for (child = cur->xmlChildrenNode;
child != NULL;
child = child->next) {
if (!xmlStrcmp(child->name, (const xmlChar*)"event")) {
ret = parseEvent(child);
if (!ret)
goto err0;
}
}
err0:
xmlFreeDoc(doc);
return ret;
}
<commit_msg>make black the "transparent" color<commit_after>/*
* Copyright 2010 Alex Graveley
*
* 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 "EventMachine.hh"
#include <sstream>
#include <png.h>
EventMask::EventMask(string mask)
{
istringstream iss(mask, istringstream::in);
string word;
while(iss >> word) {
names.push_back(word);
}
}
bool
EventMask::stateMatch(State *state)
{
vector<string>::iterator i;
for (i = names.begin(); i != names.end(); i++) {
if (!state->getDigitalIn((*i).c_str())) {
return false;
}
}
return true;
}
EventScript::~EventScript()
{
for (uint y=0; y < info->height; y++) {
free(data[y]);
}
#ifndef OSX
png_read_destroy(png, info, NULL);
#endif
}
uint
EventScript::get_frames()
{
return info->height;
}
bool
EventScript::load(string script)
{
/* open file and test for it being a png */
FILE *fp = fopen(script.c_str(), "rb");
if (!fp) {
fprintf(stderr, "Script %s could not be opened for reading", script.c_str());
return false;
}
/* initialize stuff */
png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info = png_create_info_struct(png);
png_init_io(png, fp);
png_read_info(png, info);
png_read_update_info(png, info);
if (info->width != 58) {
fprintf(stderr, "Script %s is not the correct width (expected 58, got %lu).\n",
script.c_str(), info->width);
#ifndef OSX
png_read_destroy(png, info, NULL);
#endif
fclose(fp);
return false;
}
data = (png_bytepp) malloc(sizeof(png_bytep) * info->height);
for (uint y=0; y < info->height; y++) {
data[y] = (png_byte*) malloc(info->rowbytes);
}
png_read_image(png, data);
fclose(fp);
return true;
}
bool
EventScript::update(State *state,
uint frame,
vector<string> lowerLedNames,
vector<string> axonLedNames,
vector<string> upperLedNames,
vector<string> digitalNames)
{
// XXX: constify offsets
unsigned int x=0;
unsigned int y=frame;
if (y >= info->height) {
fprintf(stderr, "Frame %d greater than PNG height %lu\n",
frame, info->height);
return false;
}
png_byte* row = data[y];
vector<string>::iterator i = axonLedNames.begin();
x = 0; //axon LED's start at pixel 0
for (i = axonLedNames.begin(); i != axonLedNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
//fprintf(stderr, "Pixel [x: %d, y: %d] R:%d G:%d B:%d\n",
// x, y, ptr[0], ptr[1], ptr[2]);
if (ptr[0] > 5 || ptr[1] > 5 || ptr[2] > 5)
state->setLightOut(i->c_str(), ptr[0], ptr[1], ptr[2]);
//printf("%d %d %d | ", ptr[0], ptr[1], ptr[2]);
x++;
}
i = upperLedNames.begin();
x = 10; //upper soma LED's start at pixel 10
for (i = upperLedNames.begin(); i != upperLedNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
if (ptr[0] > 5 || ptr[1] > 5 || ptr[2] > 5)
state->setLightOut(i->c_str(), ptr[0], ptr[1], ptr[2]);
x++;
}
i = lowerLedNames.begin();
x = 40; //lower soma LED's start at pixel 40
for (i = lowerLedNames.begin(); i != lowerLedNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
if (ptr[0] > 5 || ptr[1] > 5 || ptr[2] > 5)
state->setLightOut(i->c_str(), ptr[0], ptr[1], ptr[2]);
x++;
}
i = digitalNames.begin();
x = 50; //digital poofers start at pixel 50
for (i = digitalNames.begin(); i != digitalNames.end(); i++) {
png_byte* ptr = &(row[x*3]); //get pixel rgb
if (ptr[0] > 5 && ptr[1] > 5 && ptr[2] > 5)
state->setDigitalOut(i->c_str(), true);
x++;
}
return y < info->height - 1;
}
bool
EventMachine::addScript(string mask, string script)
{
EventScript *es = scriptData[script];
if (!es) {
// load script file, add with name to scriptData
es = new EventScript();
if (!es->load(script)) {
delete es;
fprintf(stderr, "Failed to load script '%s'\n", script.c_str());
return false;
}
}
scriptMasks.push_back(pair<EventMask, string>(EventMask(mask), script));
scriptData[script] = es;
fprintf(stderr, "Added script '%s' with event mask '%s'\n",
script.c_str(), mask.c_str());
return true;
}
void
EventMachine::update(State *state,
vector<string> lowerLedNames,
vector<string> axonLedNames,
vector<string> upperLedNames,
vector<string> digitalNames)
{
vector<string>::iterator i;
for (i = digitalNames.begin(); i != digitalNames.end(); i++)
state->setDigitalOut(i->c_str(), false);
for (vector< pair<EventMask, string> >::iterator i = scriptMasks.begin();
i != scriptMasks.end(); i++) {
if (i->first.stateMatch(state)) {
//fprintf(stderr, "Event state matches for script: %s\n",
// i->second.c_str());
EventScript *data = scriptData[i->second];
bool isRunning = false;
vector< pair<EventScript*, uint> >::iterator i2;
for (i2 = scriptStates.begin(); i2 != scriptStates.end(); i2++) {
if (data == i2->first) {
//fprintf(stderr, "Script %p already running.\n",
// i2->first);
isRunning = true;
}
}
if (!isRunning) {
fprintf(stderr, "Restarting script '%s'.\n",
i->second.c_str());
scriptStates.push_back(pair<EventScript *, uint>(data, 0));
}
}
}
vector< pair<EventScript*, uint> > nextStates;
for (vector< pair<EventScript*, uint> >::iterator i2 = scriptStates.begin();
i2 != scriptStates.end(); i2++) {
// Call Ben's event updating for the row at index i2->second.
EventScript *data = i2->first;
uint frame = i2->second;
if (!data) {
fprintf(stderr, "Invalid script data!\n");
continue;
}
if (data->update(state, frame, lowerLedNames, axonLedNames,
upperLedNames, digitalNames)) {
//fprintf(stderr, "Advancing to frame %d of script %p\n", frame, data);
nextStates.push_back(pair<EventScript*, uint>(data, frame + 1));
}
}
scriptStates = nextStates;
}
bool
EventMachine::parseEvent(xmlNodePtr node)
{
bool ret = false;
xmlChar *maskStr = xmlGetProp(node, (const xmlChar *)"mask");
xmlChar *scriptStr = xmlGetProp(node, (const xmlChar *)"script");
if (maskStr == NULL) {
fprintf(stderr, "%s has no mask\n", node->name);
goto err;
}
if (scriptStr == NULL) {
fprintf(stderr, "%s has no script\n", node->name);
goto err;
}
ret = addScript((char *)maskStr, (char *)scriptStr);
err:
xmlFree(maskStr);
xmlFree(scriptStr);
return ret;
}
bool
EventMachine::loadConfig(const char *fileName)
{
xmlDocPtr doc;
xmlNodePtr cur;
xmlNodePtr child;
bool ret = true;
doc = xmlParseFile(fileName);
if (doc == NULL) {
fprintf(stderr, "Document %s not parsed successfully\n",
fileName);
return false;
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr, "empty doc\n");
return false;
}
if (xmlStrcmp(cur->name, (const xmlChar *)"config")){
fprintf(stderr, "config file does not start with config element\n");
goto err0;
}
for (child = cur->xmlChildrenNode;
child != NULL;
child = child->next) {
if (!xmlStrcmp(child->name, (const xmlChar*)"event")) {
ret = parseEvent(child);
if (!ret)
goto err0;
}
}
err0:
xmlFreeDoc(doc);
return ret;
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2013, The Cinder Project (http://libcinder.org)
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that
the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and
the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "ConvexHull.h"
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
namespace cinder {
typedef boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > polygon;
namespace {
template<typename T>
PolyLine<Vec2<T> > toPolyLine( const polygon &p )
{
PolyLine<Vec2<T> > result;
for( auto pt = p.outer().begin(); pt != p.outer().end(); ++pt )
result.push_back( Vec2<T>( boost::geometry::get<0>(*pt), boost::geometry::get<1>(*pt) ) );
return result;
}
boost::geometry::model::d2::point_xy<double> makePoint( const Vec2f &p )
{
return boost::geometry::make<boost::geometry::model::d2::point_xy<double> >( p.x, p.y );
}
void includePathExtremeties( const Path2d &p, polygon *output )
{
size_t firstPoint = 0;
for( size_t s = 0; s < p.getSegments().size(); ++s ) {
switch( p.getSegments()[s] ) {
case Path2d::CUBICTO: {
float monotoneT[4];
int monotoneCnt = Path2d::calcCubicBezierMonotoneRegions( &(p.getPoints()[firstPoint]), monotoneT );
for( int monotoneIdx = 0; monotoneIdx < monotoneCnt; ++monotoneIdx )
output->outer().push_back( makePoint( Path2d::calcCubicBezierPos( &(p.getPoints()[firstPoint]), monotoneT[monotoneIdx] ) ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+1] ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+2] ) );
}
break;
case Path2d::QUADTO: {
float monotoneT[2];
int monotoneCnt = Path2d::calcCubicBezierMonotoneRegions( &(p.getPoints()[firstPoint]), monotoneT );
for( int monotoneIdx = 0; monotoneIdx < monotoneCnt; ++monotoneIdx )
output->outer().push_back( makePoint( Path2d::calcQuadraticBezierPos( &(p.getPoints()[firstPoint]), monotoneT[monotoneIdx] ) ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+1] ) );
}
break;
case Path2d::LINETO:
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
break;
case Path2d::CLOSE:
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
break;
default:
throw Path2dExc();
}
firstPoint += Path2d::sSegmentTypePointCounts[p.getSegments()[s]];
}
}
} // anonymous namespace
PolyLine2f calcConvexHull( const std::vector<Vec2f> &points )
{
return calcConvexHull( &points[0], points.size() );
}
PolyLine2f calcConvexHull( const Vec2f *points, size_t numPoints )
{
polygon poly;
for( size_t p = 0; p < numPoints; ++p )
poly.outer().push_back( boost::geometry::make<boost::geometry::model::d2::point_xy<double> >( points[p].x, points[p].y ) );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
PolyLine2f calcConvexHull( const Shape2d &shape )
{
polygon poly;
for( auto contourIt = shape.getContours().begin(); contourIt != shape.getContours().end(); ++contourIt )
includePathExtremeties( *contourIt, &poly );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
PolyLine2f calcConvexHull( const Path2d &path )
{
polygon poly;
includePathExtremeties( path, &poly );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
PolyLine2f calcConvexHull( const PolyLine2f &polyLine )
{
polygon poly;
for( auto ptIt = polyLine.begin(); ptIt != polyLine.end(); ++ptIt )
poly.outer().push_back( boost::geometry::make<boost::geometry::model::d2::point_xy<double> >( ptIt->x, ptIt->y ) );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
} // namespace cinder<commit_msg>MSW ConvexHull build fixes<commit_after>/*
Copyright (c) 2013, The Cinder Project (http://libcinder.org)
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that
the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and
the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "cinder/ConvexHull.h"
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
namespace cinder {
typedef boost::geometry::model::polygon<boost::geometry::model::d2::point_xy<double> > polygon;
namespace {
template<typename T>
PolyLine<Vec2<T> > toPolyLine( const polygon &p )
{
PolyLine<Vec2<T> > result;
for( auto pt = p.outer().begin(); pt != p.outer().end(); ++pt )
result.push_back( Vec2<T>( (T)boost::geometry::get<0>(*pt), (T)boost::geometry::get<1>(*pt) ) );
return result;
}
boost::geometry::model::d2::point_xy<double> makePoint( const Vec2f &p )
{
return boost::geometry::make<boost::geometry::model::d2::point_xy<double> >( p.x, p.y );
}
void includePathExtremeties( const Path2d &p, polygon *output )
{
size_t firstPoint = 0;
for( size_t s = 0; s < p.getSegments().size(); ++s ) {
switch( p.getSegments()[s] ) {
case Path2d::CUBICTO: {
float monotoneT[4];
int monotoneCnt = Path2d::calcCubicBezierMonotoneRegions( &(p.getPoints()[firstPoint]), monotoneT );
for( int monotoneIdx = 0; monotoneIdx < monotoneCnt; ++monotoneIdx )
output->outer().push_back( makePoint( Path2d::calcCubicBezierPos( &(p.getPoints()[firstPoint]), monotoneT[monotoneIdx] ) ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+1] ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+2] ) );
}
break;
case Path2d::QUADTO: {
float monotoneT[2];
int monotoneCnt = Path2d::calcCubicBezierMonotoneRegions( &(p.getPoints()[firstPoint]), monotoneT );
for( int monotoneIdx = 0; monotoneIdx < monotoneCnt; ++monotoneIdx )
output->outer().push_back( makePoint( Path2d::calcQuadraticBezierPos( &(p.getPoints()[firstPoint]), monotoneT[monotoneIdx] ) ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
output->outer().push_back( makePoint( p.getPoints()[firstPoint+1] ) );
}
break;
case Path2d::LINETO:
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
break;
case Path2d::CLOSE:
output->outer().push_back( makePoint( p.getPoints()[firstPoint+0] ) );
break;
default:
throw Path2dExc();
}
firstPoint += Path2d::sSegmentTypePointCounts[p.getSegments()[s]];
}
}
} // anonymous namespace
PolyLine2f calcConvexHull( const std::vector<Vec2f> &points )
{
return calcConvexHull( &points[0], points.size() );
}
PolyLine2f calcConvexHull( const Vec2f *points, size_t numPoints )
{
polygon poly;
for( size_t p = 0; p < numPoints; ++p )
poly.outer().push_back( boost::geometry::make<boost::geometry::model::d2::point_xy<double> >( points[p].x, points[p].y ) );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
PolyLine2f calcConvexHull( const Shape2d &shape )
{
polygon poly;
for( auto contourIt = shape.getContours().begin(); contourIt != shape.getContours().end(); ++contourIt )
includePathExtremeties( *contourIt, &poly );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
PolyLine2f calcConvexHull( const Path2d &path )
{
polygon poly;
includePathExtremeties( path, &poly );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
PolyLine2f calcConvexHull( const PolyLine2f &polyLine )
{
polygon poly;
for( auto ptIt = polyLine.begin(); ptIt != polyLine.end(); ++ptIt )
poly.outer().push_back( boost::geometry::make<boost::geometry::model::d2::point_xy<double> >( ptIt->x, ptIt->y ) );
polygon result;
boost::geometry::convex_hull( poly, result );
return toPolyLine<float>( result );
}
} // namespace cinder<|endoftext|> |
<commit_before>// NavierStokesModel.cc
//
// Description: Implementation of the NavierStokesModel class
//
// Author(s):
// Clancy Rowley
//
// Date: 3 Jul 2008
//
// $Revision$
// $LastChangedDate$
// $LastChangedBy$
// $HeadURL$
#include "NavierStokesModel.h"
namespace ibpm {
NavierStokesModel::NavierStokesModel(
const Grid& grid,
const Geometry& geometry,
double Reynolds,
const BaseFlow& q_potential
) :
_grid( grid ),
_geometry( geometry ),
_regularizer( grid, geometry ),
_baseFlow( q_potential ),
_ReynoldsNumber( Reynolds ),
_poisson( grid ),
_hasBeenInitialized( false )
{}
NavierStokesModel::NavierStokesModel(
const Grid& grid,
const Geometry& geometry,
double Reynolds
) :
_grid( grid ),
_geometry( geometry ),
_regularizer( grid, geometry ),
_baseFlow( grid ),
_ReynoldsNumber( Reynolds ),
_poisson( grid ),
_hasBeenInitialized( false )
{
_baseFlow.setFlux(0.);
}
NavierStokesModel::~NavierStokesModel() {}
void NavierStokesModel::init() {
if ( _hasBeenInitialized ) return; // do only once
// Update regularizer
_regularizer.update();
_hasBeenInitialized = true;
}
bool NavierStokesModel::isTimeDependent() const {
bool flag = false;
if( (!_geometry.isStationary()) || (!_baseFlow.isStationary()) ) flag = true;
return flag;
}
bool NavierStokesModel::geTimeDependent() const {
bool flag = false;
if( (!_geometry.isStationary()) ) flag = true;
return flag;
}
bool NavierStokesModel::bfTimeDependent() const {
bool flag = false;
if( (!_baseFlow.isStationary()) ) flag = true;
return flag;
}
int NavierStokesModel::getNumPoints() const {
return _geometry.getNumPoints();
}
double NavierStokesModel::getAlpha() const {
return 1. / _ReynoldsNumber;
}
// Return the boundary velocities minus the base flow velocity at the boundary
BoundaryVector NavierStokesModel::getConstraints() const {
BoundaryVector b = _geometry.getVelocities();
BoundaryVector b0 = getBaseFlowBoundaryVelocities();
b -= b0;
return b;
}
void NavierStokesModel::updateOperators( double time ) {
_geometry.moveBodies(time);
_baseFlow.moveFlow(time);
_regularizer.update();
}
void NavierStokesModel::B(const BoundaryVector& f, Scalar& omega ) const {
assert( _hasBeenInitialized );
Flux q = _regularizer.toFlux( f );
Curl( q, omega );
}
void NavierStokesModel::C(const Scalar& omega, BoundaryVector& f) const {
assert( _hasBeenInitialized );
Flux q(_grid);
computeFluxWithoutBaseFlow( omega, q );
f = _regularizer.toBoundary( q );
}
void NavierStokesModel::computeFluxWithoutBaseFlow(const Scalar& omega,
Flux& q ) const {
assert( _hasBeenInitialized );
Scalar streamfunction = vorticityToStreamfunction( omega );
Curl( streamfunction, q );
}
void NavierStokesModel::computeFlux(const Scalar& omega, Flux& q ) const {
assert( _hasBeenInitialized );
computeFluxWithoutBaseFlow( omega, q );
q += _baseFlow.getFlux();
}
void NavierStokesModel::refreshState( State& x ) const {
computeFlux( x.omega, x.q );
}
// Convert vorticity omega into streamfunction psi:
// Laplacian psi = - omega
Scalar NavierStokesModel::vorticityToStreamfunction( const Scalar& omega ) const {
assert( _hasBeenInitialized );
// Solve L psi = omega, with zero Dirichlet bc's
Scalar psi = -1. * omega;
psi.coarsify();
_poisson.solve( psi, psi );
return psi;
}
BoundaryVector NavierStokesModel::getBaseFlowBoundaryVelocities() const {
assert( _hasBeenInitialized );
BoundaryVector velocity = _regularizer.toBoundary( _baseFlow.getFlux() );
return velocity;
}
} // namespace ibpm
<commit_msg>[/branches/ibpm-ubf] Minor modification, fixed NavierStokesModel::updateOperators to keep track of geometry and baseflow motions separately<commit_after>// NavierStokesModel.cc
//
// Description: Implementation of the NavierStokesModel class
//
// Author(s):
// Clancy Rowley
//
// Date: 3 Jul 2008
//
// $Revision$
// $LastChangedDate$
// $LastChangedBy$
// $HeadURL$
#include "NavierStokesModel.h"
namespace ibpm {
NavierStokesModel::NavierStokesModel(
const Grid& grid,
const Geometry& geometry,
double Reynolds,
const BaseFlow& q_potential
) :
_grid( grid ),
_geometry( geometry ),
_regularizer( grid, geometry ),
_baseFlow( q_potential ),
_ReynoldsNumber( Reynolds ),
_poisson( grid ),
_hasBeenInitialized( false )
{}
NavierStokesModel::NavierStokesModel(
const Grid& grid,
const Geometry& geometry,
double Reynolds
) :
_grid( grid ),
_geometry( geometry ),
_regularizer( grid, geometry ),
_baseFlow( grid ),
_ReynoldsNumber( Reynolds ),
_poisson( grid ),
_hasBeenInitialized( false )
{
_baseFlow.setFlux(0.);
}
NavierStokesModel::~NavierStokesModel() {}
void NavierStokesModel::init() {
if ( _hasBeenInitialized ) return; // do only once
// Update regularizer
_regularizer.update();
_hasBeenInitialized = true;
}
bool NavierStokesModel::isTimeDependent() const {
bool flag = false;
if( (!_geometry.isStationary()) || (!_baseFlow.isStationary()) ) flag = true;
return flag;
}
bool NavierStokesModel::geTimeDependent() const {
bool flag = false;
if( (!_geometry.isStationary()) ) flag = true;
return flag;
}
bool NavierStokesModel::bfTimeDependent() const {
bool flag = false;
if( (!_baseFlow.isStationary()) ) flag = true;
return flag;
}
int NavierStokesModel::getNumPoints() const {
return _geometry.getNumPoints();
}
double NavierStokesModel::getAlpha() const {
return 1. / _ReynoldsNumber;
}
// Return the boundary velocities minus the base flow velocity at the boundary
BoundaryVector NavierStokesModel::getConstraints() const {
BoundaryVector b = _geometry.getVelocities();
BoundaryVector b0 = getBaseFlowBoundaryVelocities();
b -= b0;
return b;
}
void NavierStokesModel::updateOperators( double time ) {
if( bfTimeDependent() ) _baseFlow.moveFlow(time);
if( geTimeDependent() ) {
_geometry.moveBodies(time);
_regularizer.update();
}
}
void NavierStokesModel::B(const BoundaryVector& f, Scalar& omega ) const {
assert( _hasBeenInitialized );
Flux q = _regularizer.toFlux( f );
Curl( q, omega );
}
void NavierStokesModel::C(const Scalar& omega, BoundaryVector& f) const {
assert( _hasBeenInitialized );
Flux q(_grid);
computeFluxWithoutBaseFlow( omega, q );
f = _regularizer.toBoundary( q );
}
void NavierStokesModel::computeFluxWithoutBaseFlow(const Scalar& omega,
Flux& q ) const {
assert( _hasBeenInitialized );
Scalar streamfunction = vorticityToStreamfunction( omega );
Curl( streamfunction, q );
}
void NavierStokesModel::computeFlux(const Scalar& omega, Flux& q ) const {
assert( _hasBeenInitialized );
computeFluxWithoutBaseFlow( omega, q );
q += _baseFlow.getFlux();
}
void NavierStokesModel::refreshState( State& x ) const {
computeFlux( x.omega, x.q );
}
// Convert vorticity omega into streamfunction psi:
// Laplacian psi = - omega
Scalar NavierStokesModel::vorticityToStreamfunction( const Scalar& omega ) const {
assert( _hasBeenInitialized );
// Solve L psi = omega, with zero Dirichlet bc's
Scalar psi = -1. * omega;
psi.coarsify();
_poisson.solve( psi, psi );
return psi;
}
BoundaryVector NavierStokesModel::getBaseFlowBoundaryVelocities() const {
assert( _hasBeenInitialized );
BoundaryVector velocity = _regularizer.toBoundary( _baseFlow.getFlux() );
return velocity;
}
} // namespace ibpm
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/io/p9_io_xbus_clear_firs.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_io_xbus_clear_firs.C
/// @brief Clears I/O Firs
///-----------------------------------------------------------------------------
/// *HWP HWP Owner : Chris Steffen <[email protected]>
/// *HWP HWP Backup Owner : Gary Peterson <[email protected]>
/// *HWP FW Owner : Jamie Knight <[email protected]>
/// *HWP Team : IO
/// *HWP Level : 3
/// *HWP Consumed by : FSP:HB
///-----------------------------------------------------------------------------
///
/// @verbatim
/// High-level procedure flow:
///
/// Clears I/O Xbus FIRs on the PHY Rx/Tx.
///
/// Clocks must be running.
///
/// @endverbatim
///----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include <p9_io_xbus_clear_firs.H>
#include <p9_io_scom.H>
#include <p9_io_regs.H>
//-----------------------------------------------------------------------------
// Definitions
//-----------------------------------------------------------------------------
fapi2::ReturnCode io_rx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group );
fapi2::ReturnCode io_tx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group );
/**
* @brief Clears PHY Rx/Tx FIRs on the XBUS(EDI+) specified target. The FIRs
* are cleared by toggling a rx & tx fir reset bit.
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @retval ReturnCode
*/
fapi2::ReturnCode p9_io_xbus_clear_firs(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group )
{
FAPI_IMP( "I/O Start Xbus Clear FIRs" );
FAPI_TRY( io_tx_fir_reset( i_target, i_clock_group ), "Tx Reset Failed" );
FAPI_TRY( io_rx_fir_reset( i_target, i_clock_group ), "Rx Reset Failed" );
fapi_try_exit:
FAPI_IMP( "I/O End Xbus Clear FIRs" );
return fapi2::current_err;
}
/**
* @brief This function resets the Rx Firs on a EDI+ Xbus
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @retval ReturnCode
*/
fapi2::ReturnCode io_rx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group)
{
const uint8_t LANE_00 = 0;
uint64_t l_data = 0;
FAPI_TRY( io::read( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Reading Rx Fir Reg Failed");
io::set (EDIP_RX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Rx Fir Reg Failed");
io::set (EDIP_RX_FIR_RESET, 1, l_data);
FAPI_TRY(io::write( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Rx Fir Reg Failed");
io::set (EDIP_RX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Rx Fir Reg Failed");
fapi_try_exit:
return fapi2::current_err;
}
/**
* @brief This function resets the Tx Firs on a EDI+ Xbus
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @retval ReturnCode
*/
fapi2::ReturnCode io_tx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group)
{
const uint8_t LANE_00 = 0;
uint64_t l_data = 0;
FAPI_TRY( io::read( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Reading Tx Fir Reg Failed");
io::set (EDIP_TX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Tx Fir Reg Failed");
io::set (EDIP_TX_FIR_RESET, 1, l_data);
FAPI_TRY(io::write( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Tx Fir Reg Failed");
io::set (EDIP_TX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Tx Fir Reg Failed");
fapi_try_exit:
return fapi2::current_err;
}
<commit_msg>Move Xbus Erepair FIR Clearing<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/io/p9_io_xbus_clear_firs.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_io_xbus_clear_firs.C
/// @brief Clears I/O Firs
///-----------------------------------------------------------------------------
/// *HWP HWP Owner : Chris Steffen <[email protected]>
/// *HWP HWP Backup Owner : Gary Peterson <[email protected]>
/// *HWP FW Owner : Jamie Knight <[email protected]>
/// *HWP Team : IO
/// *HWP Level : 3
/// *HWP Consumed by : FSP:HB
///-----------------------------------------------------------------------------
///
/// @verbatim
/// High-level procedure flow:
///
/// Clears I/O Xbus FIRs on the PHY Rx/Tx.
///
/// Clocks must be running.
///
/// @endverbatim
///----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include <p9_io_xbus_clear_firs.H>
#include <p9_io_xbus_read_erepair.H>
#include <p9_io_scom.H>
#include <p9_io_regs.H>
#include <p9_xbus_scom_addresses.H>
#include <p9_xbus_scom_addresses_fld.H>
//-----------------------------------------------------------------------------
// Definitions
//-----------------------------------------------------------------------------
fapi2::ReturnCode io_rx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group );
fapi2::ReturnCode io_tx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group );
/**
* @brief Clears PHY Rx/Tx FIRs on the XBUS(EDI+) specified target. The FIRs
* are cleared by toggling a rx & tx fir reset bit.
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @retval ReturnCode
*/
fapi2::ReturnCode p9_io_xbus_clear_firs(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group )
{
FAPI_IMP( "I/O Start Xbus Clear FIRs" );
FAPI_TRY( io_tx_fir_reset( i_target, i_clock_group ), "Tx Reset Failed" );
FAPI_TRY( io_rx_fir_reset( i_target, i_clock_group ), "Rx Reset Failed" );
fapi_try_exit:
FAPI_IMP( "I/O End Xbus Clear FIRs" );
return fapi2::current_err;
}
/**
* @brief This function resets the Rx Firs on a EDI+ Xbus
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @retval ReturnCode
*/
fapi2::ReturnCode io_rx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group)
{
const uint8_t LANE_00 = 0;
uint64_t l_data = 0;
FAPI_TRY( io::read( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Reading Rx Fir Reg Failed");
io::set (EDIP_RX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Rx Fir Reg Failed");
io::set (EDIP_RX_FIR_RESET, 1, l_data);
FAPI_TRY(io::write( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Rx Fir Reg Failed");
io::set (EDIP_RX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_RX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Rx Fir Reg Failed");
fapi_try_exit:
return fapi2::current_err;
}
/**
* @brief This function resets the Tx Firs on a EDI+ Xbus
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @retval ReturnCode
*/
fapi2::ReturnCode io_tx_fir_reset(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group)
{
const uint8_t LANE_00 = 0;
uint64_t l_data = 0;
FAPI_TRY( io::read( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Reading Tx Fir Reg Failed");
io::set (EDIP_TX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Tx Fir Reg Failed");
io::set (EDIP_TX_FIR_RESET, 1, l_data);
FAPI_TRY(io::write( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Tx Fir Reg Failed");
io::set (EDIP_TX_FIR_RESET, 0, l_data);
FAPI_TRY(io::write( EDIP_TX_FIR_RESET, i_target, i_clock_group, LANE_00, l_data ),
"Writing Tx Fir Reg Failed");
fapi_try_exit:
return fapi2::current_err;
}
/**
* @brief This function reads the bad lane data of a EDI+ Xbus
* @param[in] i_target FAPI2 Target
* @param[in] i_clock_group Clock Group
* @param[out] o_bad_lane_data Bit representation of each lane in the clock group
* @retval ReturnCode
*/
fapi2::ReturnCode p9_io_xbus_get_bad_lane_data(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target,
const uint8_t& i_clock_group,
uint32_t& o_bad_lane_data)
{
FAPI_IMP("I/O EDI+ Xbus Get Current Bad Lane Data :: Start");
const uint8_t LN0 = 0;
uint64_t l_data = 0;
std::vector<uint8_t> l_bad_lanes;
FAPI_DBG("Read Bad Lane Vector 0 15");
FAPI_TRY(io::read(EDIP_RX_LANE_BAD_VEC_0_15, i_target, i_clock_group, LN0, l_data),
"rmw to edip_rx_lane_bad_vec_0_15 failed.");
o_bad_lane_data = (io::get(EDIP_RX_LANE_BAD_VEC_0_15, l_data) << 8) & 0x00FFFF00;
FAPI_DBG("Read Bad Lane Vector 16 23");
FAPI_TRY(io::read(EDIP_RX_LANE_BAD_VEC_16_23, i_target, i_clock_group, LN0, l_data),
"rmw to edip_rx_lane_bad_vec_16_23 failed.");
o_bad_lane_data |= (io::get(EDIP_RX_LANE_BAD_VEC_16_23, l_data) & 0x000000FF);
FAPI_DBG("Call xbus read erepair");
FAPI_TRY(p9_io_xbus_read_erepair(i_target, i_clock_group, l_bad_lanes));
for(auto bad_lane : l_bad_lanes)
{
o_bad_lane_data |= (0x1 << (23 - bad_lane));
}
fapi_try_exit:
FAPI_IMP("I/O EDI+ Xbus Get Current Bad Lane Data :: Exit");
return fapi2::current_err;
}
/**
* @brief Clears PHY Rx/Tx FIRs on the XBUS(EDI+) specified target. The FIRs
* are cleared by toggling a rx & tx fir reset bit.
* @param[in] i_target FAPI2 Target
* @retval ReturnCode
*/
fapi2::ReturnCode p9_io_xbus_erepair_cleanup(
const fapi2::Target < fapi2::TARGET_TYPE_XBUS >& i_target)
{
const uint8_t MAX_CLOCK_GROUPS = 2;
bool l_clear_pb_spare_deployed = true;
uint32_t l_grp0_pre_bad_lane_data = 0;
uint32_t l_grp1_pre_bad_lane_data = 0;
uint32_t l_pre_bad_lane_data = 0;
uint32_t l_post_bad_lane_data = 0;
FAPI_IMP("I/O Start Xbus Clear FIRs");
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_IO_XBUS_GRP0_PRE_BAD_LANE_DATA,
i_target, l_grp0_pre_bad_lane_data));
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_IO_XBUS_GRP1_PRE_BAD_LANE_DATA,
i_target, l_grp1_pre_bad_lane_data));
for (uint8_t l_group = 0; l_group < MAX_CLOCK_GROUPS; ++l_group)
{
// Get attribute of pre bad lane data
FAPI_IMP("Get Pre Bad Lane Data");
if (l_group == 0)
{
l_pre_bad_lane_data = l_grp0_pre_bad_lane_data;
}
else
{
l_pre_bad_lane_data = l_grp1_pre_bad_lane_data;
}
// Get current bad lane data
// - bad_lane_vector AND bad_lane_code
FAPI_IMP("Get Current Bad Lane Data");
FAPI_TRY(p9_io_xbus_get_bad_lane_data(i_target, l_group, l_post_bad_lane_data));
FAPI_IMP("Compare Bad Lane Data");
if (l_pre_bad_lane_data == l_post_bad_lane_data)
{
FAPI_DBG("I/O EDI+ Xbus Pre/Post Bad Lane Data Match");
// If the entire bad lane vector equals 0, then we don't need to clear
// any firs.
if (l_pre_bad_lane_data != 0)
{
FAPI_DBG("I/O EDI+ Xbus Clearing PG Firs");
FAPI_TRY(io_tx_fir_reset(i_target, l_group), "Tx Reset Failed");
FAPI_TRY(io_rx_fir_reset(i_target, l_group), "Rx Reset Failed");
}
}
else
{
FAPI_DBG("Bad lane data does NOT match.");
l_clear_pb_spare_deployed = false;
}
}
// Clearing of the Spare Lane Deployed FIR when:
// - the pre/post bad lane data match on both groups. (l_clear_pb_spare_deployed)
// - AND if either groups have nonzero bad lane data
if (l_clear_pb_spare_deployed &&
((l_grp0_pre_bad_lane_data != 0x0) || (l_grp1_pre_bad_lane_data != 0x0)) )
{
fapi2::buffer<uint64_t> l_data;
fapi2::buffer<uint64_t> l_mask;
// Clear BUS0_SPARE_DEPLOYED (Bit 9).
l_data.clearBit<XBUS_1_FIR_REG_RX_BUS0_SPARE_DEPLOYED>();
l_mask.setBit<XBUS_1_FIR_REG_RX_BUS0_SPARE_DEPLOYED>();
FAPI_TRY(fapi2::putScomUnderMask(i_target, XBUS_FIR_REG, l_data, l_mask));
}
fapi_try_exit:
FAPI_IMP("I/O End Xbus Clear FIRs");
return fapi2::current_err;
}
<|endoftext|> |
<commit_before>/*
* Copyright (c) 2015-2016 WinT 3794 <http://wint3794.org>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <QDir>
#include <QApplication>
#include "dashboards.h"
#if defined Q_OS_WIN
#include <windows.h>
#define IS_64_BIT true
#if _WIN32
#undef IS_64_BIT
#define IS_64_BIT GetProcAddress (GetModuleHandle (TEXT ("kernel32")), \
"IsWow64Process")
#endif
#define PF IS_64_BIT ? "C:/Program Files (x86)" : "C:/Program Files"
#endif
#if defined Q_OS_WIN
#define JAVA_OPEN "java -jar"
#elif defined Q_OS_LINUX
#define JAVA_OPEN "xdg-open"
#elif defined Q_OS_MAC
#define JAVA_OPEN "java -jar"
#endif
Dashboards::Dashboards()
{
connect (qApp, &QApplication::aboutToQuit, this, &Dashboards::closeDashboard);
}
QStringList Dashboards::dashboardList()
{
QStringList list;
list.append (tr ("None"));
list.append (tr ("SFX Dashboard"));
list.append (tr ("SmartDashboard"));
#if defined Q_OS_WIN
list.append (tr ("LabVIEW Dashboard"));
#endif
return list;
}
void Dashboards::closeDashboard()
{
m_process.close();
}
void Dashboards::openDashboard (int dashboard)
{
QString path;
QString home = QDir::homePath();
switch (dashboard) {
case kSFXDashboard:
path = QString ("%1 \"%2/wpilib/tools/sfx.jar\"").arg (JAVA_OPEN, home);
break;
case kSmartDashboard:
path = QString ("%1 \"%2/wpilib/tools/SmartDashboard.jar\"")
.arg (JAVA_OPEN , home);
break;
#if defined Q_OS_WIN
case kLabVIEWDashboard:
path = QString ("\"%1/FRC Dashboard/Dashboard.exe\"").arg (PF);
break;
#endif
default:
path = "";
}
closeDashboard();
m_process.start (path);
}
<commit_msg>Use "java -jar" to start dashboards on all platforms.<commit_after>/*
* Copyright (c) 2015-2016 WinT 3794 <http://wint3794.org>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <QDir>
#include <QApplication>
#include "dashboards.h"
#if defined Q_OS_WIN
#include <windows.h>
#define IS_64_BIT true
#if _WIN32
#undef IS_64_BIT
#define IS_64_BIT GetProcAddress (GetModuleHandle (TEXT ("kernel32")), \
"IsWow64Process")
#endif
#define PF IS_64_BIT ? "C:/Program Files (x86)" : "C:/Program Files"
#endif
#define JAVA_OPEN "java -jar"
Dashboards::Dashboards()
{
connect (qApp, &QApplication::aboutToQuit, this, &Dashboards::closeDashboard);
}
QStringList Dashboards::dashboardList()
{
QStringList list;
list.append (tr ("None"));
list.append (tr ("SFX Dashboard"));
list.append (tr ("SmartDashboard"));
#if defined Q_OS_WIN
list.append (tr ("LabVIEW Dashboard"));
#endif
return list;
}
void Dashboards::closeDashboard()
{
m_process.close();
}
void Dashboards::openDashboard (int dashboard)
{
QString path;
QString home = QDir::homePath();
switch (dashboard) {
case kSFXDashboard:
path = QString ("%1 \"%2/wpilib/tools/sfx.jar\"").arg (JAVA_OPEN, home);
break;
case kSmartDashboard:
path = QString ("%1 \"%2/wpilib/tools/SmartDashboard.jar\"")
.arg (JAVA_OPEN , home);
break;
#if defined Q_OS_WIN
case kLabVIEWDashboard:
path = QString ("\"%1/FRC Dashboard/Dashboard.exe\"").arg (PF);
break;
#endif
default:
path = "";
}
closeDashboard();
m_process.start (path);
}
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/memory/lib/phy/phy_cntrl.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file phy_cntrl.C
/// @brief Subroutines for the PHY PC registers
///
// *HWP HWP Owner: Brian Silver <[email protected]>
// *HWP HWP Backup: Andre Marin <[email protected]>
// *HWP Team: Memory
// *HWP Level: 2
// *HWP Consumed by: FSP:HB
#include <fapi2.H>
#include <lib/phy/phy_cntrl.H>
#include <lib/utils/scom.H>
#include <lib/utils/c_str.H>
#include <lib/utils/index.H>
#include <lib/mss_attribute_accessors.H>
using fapi2::TARGET_TYPE_MCA;
namespace mss
{
// Definition of the PHY PC MR shadow registers
// indexed by [rank_pair][MR index]
const std::vector< std::vector<uint64_t> > pcTraits<TARGET_TYPE_MCA>::PC_MR_SHADOW_REGS =
{
{
MCA_DDRPHY_PC_MR0_PRI_RP0_P0,
MCA_DDRPHY_PC_MR1_PRI_RP0_P0,
MCA_DDRPHY_PC_MR2_PRI_RP0_P0,
MCA_DDRPHY_PC_MR3_PRI_RP0_P0,
MCA_DDRPHY_PC_MR0_SEC_RP0_P0,
MCA_DDRPHY_PC_MR1_SEC_RP0_P0,
MCA_DDRPHY_PC_MR2_SEC_RP0_P0,
},
{
MCA_DDRPHY_PC_MR0_PRI_RP1_P0,
MCA_DDRPHY_PC_MR1_PRI_RP1_P0,
MCA_DDRPHY_PC_MR2_PRI_RP1_P0,
MCA_DDRPHY_PC_MR3_PRI_RP1_P0,
MCA_DDRPHY_PC_MR0_SEC_RP1_P0,
MCA_DDRPHY_PC_MR1_SEC_RP1_P0,
MCA_DDRPHY_PC_MR2_SEC_RP1_P0,
},
{
MCA_DDRPHY_PC_MR0_PRI_RP2_P0,
MCA_DDRPHY_PC_MR1_PRI_RP2_P0,
MCA_DDRPHY_PC_MR2_PRI_RP2_P0,
MCA_DDRPHY_PC_MR3_PRI_RP2_P0,
MCA_DDRPHY_PC_MR0_SEC_RP2_P0,
MCA_DDRPHY_PC_MR1_SEC_RP2_P0,
MCA_DDRPHY_PC_MR2_SEC_RP2_P0,
},
{
MCA_DDRPHY_PC_MR0_PRI_RP3_P0,
MCA_DDRPHY_PC_MR1_PRI_RP3_P0,
MCA_DDRPHY_PC_MR2_PRI_RP3_P0,
MCA_DDRPHY_PC_MR3_PRI_RP3_P0,
MCA_DDRPHY_PC_MR0_SEC_RP3_P0,
MCA_DDRPHY_PC_MR1_SEC_RP3_P0,
MCA_DDRPHY_PC_MR2_SEC_RP3_P0,
},
};
namespace pc
{
///
/// @brief Reset the PC CONFIG0 register
/// @param[in] i_target the target (MCA or MBA?)
/// @return FAPI2_RC_SUCCESS if and only if ok
///
template<>
fapi2::ReturnCode reset_config0(const fapi2::Target<TARGET_TYPE_MCA>& i_target)
{
typedef pcTraits<TARGET_TYPE_MCA> TT;
fapi2::buffer<uint64_t> l_data;
l_data.setBit<TT::DDR4_CMD_SIG_REDUCTION>();
l_data.setBit<TT::DDR4_VLEVEL_BANK_GROUP>();
FAPI_TRY( write_config0(i_target, l_data) );
fapi_try_exit:
return fapi2::current_err;
}
///
/// @brief Reset the PC CONFIG1 register
/// @param[in] i_target <the target (MCA or MBA?)
/// @return FAPI2_RC_SUCCESS if and only if ok
///
template<>
fapi2::ReturnCode reset_config1(const fapi2::Target<TARGET_TYPE_MCA>& i_target)
{
typedef pcTraits<TARGET_TYPE_MCA> TT;
// Static table of PHY config values for MEMORY_TYPE.
// [EMPTY, RDIMM, CDIMM, or LRDIMM][EMPTY, DDR3 or DDR4]
constexpr uint64_t memory_type[4][3] =
{
{ 0, 0, 0 }, // Empty, never really used.
{ 0, 0b001, 0b101 }, // RDIMM
{ 0, 0b000, 0b000 }, // CDIMM bits, UDIMM enum (placeholder, never used on Nimbus)
{ 0, 0b011, 0b111 }, // LRDIMM
};
fapi2::buffer<uint64_t> l_data;
uint8_t l_rlo = 0;
uint8_t l_wlo = 0;
uint8_t l_dram_gen[MAX_DIMM_PER_PORT] = {0};
uint8_t l_dimm_type[MAX_DIMM_PER_PORT] = {0};
uint8_t l_type_index = 0;
uint8_t l_gen_index = 0;
FAPI_TRY( mss::vpd_mr_dphy_rlo(i_target, l_rlo) );
FAPI_TRY( mss::vpd_mr_dphy_wlo(i_target, l_wlo) );
FAPI_TRY( mss::eff_dram_gen(i_target, &(l_dram_gen[0])) );
FAPI_TRY( mss::eff_dimm_type(i_target, &(l_dimm_type[0])) );
// There's no way to configure the PHY for more than one value. However, we don't know if there's
// a DIMM in one slot, the other or double drop. So we do a little gyration here to make sure
// we have one of the two values (and assume effective config caught a bad config)
l_type_index = l_dimm_type[0] | l_dimm_type[1];
l_gen_index = l_dram_gen[0] | l_dram_gen[1];
// FOR NIMBUS PHY (as the protocol choice above is) BRS
FAPI_TRY( mss::getScom(i_target, MCA_DDRPHY_PC_CONFIG1_P0, l_data) );
l_data.insertFromRight<TT::MEMORY_TYPE, TT::MEMORY_TYPE_LEN>(memory_type[l_type_index][l_gen_index]);
l_data.insertFromRight<TT::WRITE_LATENCY_OFFSET, TT::WRITE_LATENCY_OFFSET_LEN>(l_wlo);
// Always set this bit. It forces the PHY to use A12 when figuring out latency. This makes sense in
// all cases as A12 is 0 for non-3DS in MR0.
l_data.setBit<TT::DDR4_LATENCY_SW>();
// If we are 2N mode we add one to the RLO (see also Centaur initfile)
l_data.insertFromRight<TT::READ_LATENCY_OFFSET, TT::READ_LATENCY_OFFSET_LEN>(
mss::two_n_mode_helper(i_target) ? l_rlo + 1 : l_rlo);
FAPI_TRY( write_config1(i_target, l_data) );
fapi_try_exit:
return fapi2::current_err;
}
} // close namespace pc
} // close namespace mss
<commit_msg>Add c_str generic API and update makefiles<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/memory/lib/phy/phy_cntrl.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file phy_cntrl.C
/// @brief Subroutines for the PHY PC registers
///
// *HWP HWP Owner: Brian Silver <[email protected]>
// *HWP HWP Backup: Andre Marin <[email protected]>
// *HWP Team: Memory
// *HWP Level: 2
// *HWP Consumed by: FSP:HB
#include <fapi2.H>
#include <lib/phy/phy_cntrl.H>
#include <lib/utils/scom.H>
#include <c_str.H>
#include <lib/utils/index.H>
#include <lib/mss_attribute_accessors.H>
using fapi2::TARGET_TYPE_MCA;
namespace mss
{
// Definition of the PHY PC MR shadow registers
// indexed by [rank_pair][MR index]
const std::vector< std::vector<uint64_t> > pcTraits<TARGET_TYPE_MCA>::PC_MR_SHADOW_REGS =
{
{
MCA_DDRPHY_PC_MR0_PRI_RP0_P0,
MCA_DDRPHY_PC_MR1_PRI_RP0_P0,
MCA_DDRPHY_PC_MR2_PRI_RP0_P0,
MCA_DDRPHY_PC_MR3_PRI_RP0_P0,
MCA_DDRPHY_PC_MR0_SEC_RP0_P0,
MCA_DDRPHY_PC_MR1_SEC_RP0_P0,
MCA_DDRPHY_PC_MR2_SEC_RP0_P0,
},
{
MCA_DDRPHY_PC_MR0_PRI_RP1_P0,
MCA_DDRPHY_PC_MR1_PRI_RP1_P0,
MCA_DDRPHY_PC_MR2_PRI_RP1_P0,
MCA_DDRPHY_PC_MR3_PRI_RP1_P0,
MCA_DDRPHY_PC_MR0_SEC_RP1_P0,
MCA_DDRPHY_PC_MR1_SEC_RP1_P0,
MCA_DDRPHY_PC_MR2_SEC_RP1_P0,
},
{
MCA_DDRPHY_PC_MR0_PRI_RP2_P0,
MCA_DDRPHY_PC_MR1_PRI_RP2_P0,
MCA_DDRPHY_PC_MR2_PRI_RP2_P0,
MCA_DDRPHY_PC_MR3_PRI_RP2_P0,
MCA_DDRPHY_PC_MR0_SEC_RP2_P0,
MCA_DDRPHY_PC_MR1_SEC_RP2_P0,
MCA_DDRPHY_PC_MR2_SEC_RP2_P0,
},
{
MCA_DDRPHY_PC_MR0_PRI_RP3_P0,
MCA_DDRPHY_PC_MR1_PRI_RP3_P0,
MCA_DDRPHY_PC_MR2_PRI_RP3_P0,
MCA_DDRPHY_PC_MR3_PRI_RP3_P0,
MCA_DDRPHY_PC_MR0_SEC_RP3_P0,
MCA_DDRPHY_PC_MR1_SEC_RP3_P0,
MCA_DDRPHY_PC_MR2_SEC_RP3_P0,
},
};
namespace pc
{
///
/// @brief Reset the PC CONFIG0 register
/// @param[in] i_target the target (MCA or MBA?)
/// @return FAPI2_RC_SUCCESS if and only if ok
///
template<>
fapi2::ReturnCode reset_config0(const fapi2::Target<TARGET_TYPE_MCA>& i_target)
{
typedef pcTraits<TARGET_TYPE_MCA> TT;
fapi2::buffer<uint64_t> l_data;
l_data.setBit<TT::DDR4_CMD_SIG_REDUCTION>();
l_data.setBit<TT::DDR4_VLEVEL_BANK_GROUP>();
FAPI_TRY( write_config0(i_target, l_data) );
fapi_try_exit:
return fapi2::current_err;
}
///
/// @brief Reset the PC CONFIG1 register
/// @param[in] i_target <the target (MCA or MBA?)
/// @return FAPI2_RC_SUCCESS if and only if ok
///
template<>
fapi2::ReturnCode reset_config1(const fapi2::Target<TARGET_TYPE_MCA>& i_target)
{
typedef pcTraits<TARGET_TYPE_MCA> TT;
// Static table of PHY config values for MEMORY_TYPE.
// [EMPTY, RDIMM, CDIMM, or LRDIMM][EMPTY, DDR3 or DDR4]
constexpr uint64_t memory_type[4][3] =
{
{ 0, 0, 0 }, // Empty, never really used.
{ 0, 0b001, 0b101 }, // RDIMM
{ 0, 0b000, 0b000 }, // CDIMM bits, UDIMM enum (placeholder, never used on Nimbus)
{ 0, 0b011, 0b111 }, // LRDIMM
};
fapi2::buffer<uint64_t> l_data;
uint8_t l_rlo = 0;
uint8_t l_wlo = 0;
uint8_t l_dram_gen[MAX_DIMM_PER_PORT] = {0};
uint8_t l_dimm_type[MAX_DIMM_PER_PORT] = {0};
uint8_t l_type_index = 0;
uint8_t l_gen_index = 0;
FAPI_TRY( mss::vpd_mr_dphy_rlo(i_target, l_rlo) );
FAPI_TRY( mss::vpd_mr_dphy_wlo(i_target, l_wlo) );
FAPI_TRY( mss::eff_dram_gen(i_target, &(l_dram_gen[0])) );
FAPI_TRY( mss::eff_dimm_type(i_target, &(l_dimm_type[0])) );
// There's no way to configure the PHY for more than one value. However, we don't know if there's
// a DIMM in one slot, the other or double drop. So we do a little gyration here to make sure
// we have one of the two values (and assume effective config caught a bad config)
l_type_index = l_dimm_type[0] | l_dimm_type[1];
l_gen_index = l_dram_gen[0] | l_dram_gen[1];
// FOR NIMBUS PHY (as the protocol choice above is) BRS
FAPI_TRY( mss::getScom(i_target, MCA_DDRPHY_PC_CONFIG1_P0, l_data) );
l_data.insertFromRight<TT::MEMORY_TYPE, TT::MEMORY_TYPE_LEN>(memory_type[l_type_index][l_gen_index]);
l_data.insertFromRight<TT::WRITE_LATENCY_OFFSET, TT::WRITE_LATENCY_OFFSET_LEN>(l_wlo);
// Always set this bit. It forces the PHY to use A12 when figuring out latency. This makes sense in
// all cases as A12 is 0 for non-3DS in MR0.
l_data.setBit<TT::DDR4_LATENCY_SW>();
// If we are 2N mode we add one to the RLO (see also Centaur initfile)
l_data.insertFromRight<TT::READ_LATENCY_OFFSET, TT::READ_LATENCY_OFFSET_LEN>(
mss::two_n_mode_helper(i_target) ? l_rlo + 1 : l_rlo);
FAPI_TRY( write_config1(i_target, l_data) );
fapi_try_exit:
return fapi2::current_err;
}
} // close namespace pc
} // close namespace mss
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/memory/p9_mss_eff_config.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_mss_eff_config.C
/// @brief Command and Control for the memory subsystem - populate attributes
///
// *HWP HWP Owner: Andre Marin <[email protected]>
// *HWP HWP Backup: Brian Silver <[email protected]>
// *HWP Team: Memory
// *HWP Level: 2
// *HWP Consumed by: FSP:HB
#include <p9_mss_eff_config.H>
// std
#include <vector>
// fapi2
#include <fapi2.H>
// mss lib
#include <generic/memory/lib/spd/common/ddr4/spd_decoder_ddr4.H>
#include <lib/spd/spd_factory.H>
#include <generic/memory/lib/utils/pos.H>
#include <lib/utils/checker.H>
#include <generic/memory/lib/utils/find.H>
#include <lib/shared/mss_kind.H>
#include <lib/dimm/eff_dimm.H>
#include <lib/eff_config/plug_rules.H>
///
/// @brief Configure the attributes for each controller
/// @param[in] i_target the controller (e.g., MCS)
/// @param[in] i_decode_spd_only options to set VPD and SPD attrs only
/// @return FAPI2_RC_SUCCESS iff ok
///
fapi2::ReturnCode p9_mss_eff_config( const fapi2::Target<fapi2::TARGET_TYPE_MCS>& i_target,
const bool i_decode_spd_only )
{
fapi2::ReturnCode l_rc;
std::vector< std::shared_ptr<mss::spd::decoder> > l_factory_caches;
// Caches
FAPI_TRY( mss::spd::populate_decoder_caches(i_target, l_factory_caches) );
// Need to check dead load before we get the VPD.
// MR and MT VPD depends on DIMM ranks and freaks out if it recieves 0 ranks from DIMM 0 and 1 or more ranks for DIMM 1
FAPI_TRY( mss::plug_rule::check_dead_load (i_target) );
FAPI_TRY( mss::plug_rule::empty_slot_zero (i_target) );
// We need to decode the VPD. We don't do this in the ctor as we need
// the rank information and for that we need the SPD caches (which we get when we populate the cache.)
// However, we need to do the VPD decode before the others so that they might
// be able to use VPD information to make decisions about setting up eff attributes.
if( !i_decode_spd_only )
{
// Always set VPD attributes unless we enable the SPD_ONLY flag
// Enables skipping VPD decoder when a valid VPD template isn't available
FAPI_TRY( mss::eff_dimm::decode_vpd(i_target),
"Unable to decode VPD for %s", mss::c_str(i_target) );
}
for( const auto& l_cache : l_factory_caches )
{
std::shared_ptr<mss::eff_dimm> l_eff_dimm;
FAPI_TRY( mss::eff_dimm::eff_dimm_factory( l_cache, l_eff_dimm));
FAPI_TRY( l_eff_dimm->dram_mfg_id() );
FAPI_TRY( l_eff_dimm->dram_width() );
FAPI_TRY( l_eff_dimm->dram_density() );
FAPI_TRY( l_eff_dimm->ranks_per_dimm() );
FAPI_TRY( l_eff_dimm->prim_die_count() );
FAPI_TRY( l_eff_dimm->primary_stack_type() );
FAPI_TRY( l_eff_dimm->dimm_size() );
FAPI_TRY( l_eff_dimm->hybrid_memory_type() );
FAPI_TRY( l_eff_dimm->dram_trefi() );
FAPI_TRY( l_eff_dimm->dram_trfc() );
FAPI_TRY( l_eff_dimm->dram_trfc_dlr() );
FAPI_TRY( l_eff_dimm->rcd_mirror_mode() );
FAPI_TRY( l_eff_dimm->dram_bank_bits() );
FAPI_TRY( l_eff_dimm->dram_row_bits() );
FAPI_TRY( l_eff_dimm->dram_dqs_time() );
FAPI_TRY( l_eff_dimm->dram_tccd_l() );
FAPI_TRY( l_eff_dimm->dimm_rc00() );
FAPI_TRY( l_eff_dimm->dimm_rc01() );
FAPI_TRY( l_eff_dimm->dimm_rc02() );
FAPI_TRY( l_eff_dimm->dimm_rc03() );
FAPI_TRY( l_eff_dimm->dimm_rc04() );
FAPI_TRY( l_eff_dimm->dimm_rc05() );
FAPI_TRY( l_eff_dimm->dimm_rc06_07() );
FAPI_TRY( l_eff_dimm->dimm_rc08() );
FAPI_TRY( l_eff_dimm->dimm_rc09() );
FAPI_TRY( l_eff_dimm->dimm_rc0a() );
FAPI_TRY( l_eff_dimm->dimm_rc0b() );
FAPI_TRY( l_eff_dimm->dimm_rc0c() );
FAPI_TRY( l_eff_dimm->dimm_rc0d() );
FAPI_TRY( l_eff_dimm->dimm_rc0e() );
FAPI_TRY( l_eff_dimm->dimm_rc0f() );
FAPI_TRY( l_eff_dimm->dimm_rc1x() );
FAPI_TRY( l_eff_dimm->dimm_rc2x() );
FAPI_TRY( l_eff_dimm->dimm_rc3x() );
FAPI_TRY( l_eff_dimm->dimm_rc4x() );
FAPI_TRY( l_eff_dimm->dimm_rc5x() );
FAPI_TRY( l_eff_dimm->dimm_rc6x() );
FAPI_TRY( l_eff_dimm->dimm_rc7x() );
FAPI_TRY( l_eff_dimm->dimm_rc8x() );
FAPI_TRY( l_eff_dimm->dimm_rc9x() );
FAPI_TRY( l_eff_dimm->dimm_rcax() );
FAPI_TRY( l_eff_dimm->dimm_rcbx() );
FAPI_TRY( l_eff_dimm->dram_twr() );
FAPI_TRY( l_eff_dimm->read_burst_type() );
FAPI_TRY( l_eff_dimm->dram_tm() );
FAPI_TRY( l_eff_dimm->dram_cwl() );
FAPI_TRY( l_eff_dimm->dram_lpasr() );
FAPI_TRY( l_eff_dimm->dll_enable() );
FAPI_TRY( l_eff_dimm->dll_reset() );
FAPI_TRY( l_eff_dimm->write_level_enable() );
FAPI_TRY( l_eff_dimm->output_buffer() );
FAPI_TRY( l_eff_dimm->vref_dq_train_value() );
FAPI_TRY( l_eff_dimm->vref_dq_train_range() );
FAPI_TRY( l_eff_dimm->vref_dq_train_enable() );
FAPI_TRY( l_eff_dimm->ca_parity_latency() );
FAPI_TRY( l_eff_dimm->ca_parity_error_status() );
FAPI_TRY( l_eff_dimm->ca_parity() );
FAPI_TRY( l_eff_dimm->crc_error_clear() );
FAPI_TRY( l_eff_dimm->odt_input_buffer() );
FAPI_TRY( l_eff_dimm->post_package_repair() );
FAPI_TRY( l_eff_dimm->read_preamble_train() );
FAPI_TRY( l_eff_dimm->read_preamble() );
FAPI_TRY( l_eff_dimm->write_preamble() );
FAPI_TRY( l_eff_dimm->self_refresh_abort() );
FAPI_TRY( l_eff_dimm->cs_to_cmd_addr_latency() );
FAPI_TRY( l_eff_dimm->internal_vref_monitor() );
FAPI_TRY( l_eff_dimm->max_powerdown_mode() );
FAPI_TRY( l_eff_dimm->mpr_read_format() );
FAPI_TRY( l_eff_dimm->temp_readout() );
FAPI_TRY( l_eff_dimm->crc_wr_latency() );
FAPI_TRY( l_eff_dimm->per_dram_addressability() );
FAPI_TRY( l_eff_dimm->geardown_mode() );
FAPI_TRY( l_eff_dimm->mpr_page() );
FAPI_TRY( l_eff_dimm->mpr_mode() );
FAPI_TRY( l_eff_dimm->write_crc() );
FAPI_TRY( l_eff_dimm->zqcal_interval() );
FAPI_TRY( l_eff_dimm->memcal_interval() );
FAPI_TRY( l_eff_dimm->dram_trp() );
FAPI_TRY( l_eff_dimm->dram_trcd() );
FAPI_TRY( l_eff_dimm->dram_trc() );
FAPI_TRY( l_eff_dimm->dram_twtr_l() );
FAPI_TRY( l_eff_dimm->dram_twtr_s() );
FAPI_TRY( l_eff_dimm->dram_trrd_s() );
FAPI_TRY( l_eff_dimm->dram_trrd_l() );
FAPI_TRY( l_eff_dimm->dram_trrd_dlr() );
FAPI_TRY( l_eff_dimm->dram_tfaw() );
FAPI_TRY( l_eff_dimm->dram_tfaw_dlr() );
FAPI_TRY( l_eff_dimm->dram_tras() );
FAPI_TRY( l_eff_dimm->dram_trtp() );
FAPI_TRY( l_eff_dimm->read_dbi() );
FAPI_TRY( l_eff_dimm->write_dbi() );
FAPI_TRY( l_eff_dimm->additive_latency() );
FAPI_TRY( l_eff_dimm->data_mask() );
FAPI_TRY( l_eff_dimm->dimm_bc00());
FAPI_TRY( l_eff_dimm->dimm_bc01());
FAPI_TRY( l_eff_dimm->dimm_bc02());
FAPI_TRY( l_eff_dimm->dimm_bc03());
FAPI_TRY( l_eff_dimm->dimm_bc04());
FAPI_TRY( l_eff_dimm->dimm_bc05());
FAPI_TRY( l_eff_dimm->dimm_bc07());
FAPI_TRY( l_eff_dimm->dimm_bc08());
FAPI_TRY( l_eff_dimm->dimm_bc09());
FAPI_TRY( l_eff_dimm->dimm_bc0a());
FAPI_TRY( l_eff_dimm->dimm_bc0b());
FAPI_TRY( l_eff_dimm->dimm_bc0c());
FAPI_TRY( l_eff_dimm->dimm_bc0d());
FAPI_TRY( l_eff_dimm->dimm_bc0e());
FAPI_TRY( l_eff_dimm->dimm_bc0f());
FAPI_TRY( l_eff_dimm->dram_rtt_nom () );
FAPI_TRY( l_eff_dimm->dram_rtt_wr () );
FAPI_TRY( l_eff_dimm->dram_rtt_park() );
FAPI_TRY( l_eff_dimm->phy_seq_refresh() );
// Sets up the calibration steps
FAPI_TRY( l_eff_dimm->cal_step_enable() );
FAPI_TRY( l_eff_dimm->rdvref_enable_bit() );
//Let's do some checking
FAPI_TRY( mss::check::temp_refresh_mode());
}// dimm
// Check plug rules. We check the MCS, and this will iterate down to children as needed.
FAPI_TRY( mss::plug_rule::enforce_plug_rules(i_target) );
fapi_try_exit:
return fapi2::current_err;
}
<commit_msg>Add in RCD attributes for DD2 debug<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/memory/p9_mss_eff_config.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_mss_eff_config.C
/// @brief Command and Control for the memory subsystem - populate attributes
///
// *HWP HWP Owner: Andre Marin <[email protected]>
// *HWP HWP Backup: Brian Silver <[email protected]>
// *HWP Team: Memory
// *HWP Level: 2
// *HWP Consumed by: FSP:HB
#include <p9_mss_eff_config.H>
// std
#include <vector>
// fapi2
#include <fapi2.H>
// mss lib
#include <generic/memory/lib/spd/common/ddr4/spd_decoder_ddr4.H>
#include <lib/spd/spd_factory.H>
#include <generic/memory/lib/utils/pos.H>
#include <lib/utils/checker.H>
#include <generic/memory/lib/utils/find.H>
#include <lib/shared/mss_kind.H>
#include <lib/dimm/eff_dimm.H>
#include <lib/eff_config/plug_rules.H>
///
/// @brief Configure the attributes for each controller
/// @param[in] i_target the controller (e.g., MCS)
/// @param[in] i_decode_spd_only options to set VPD and SPD attrs only
/// @return FAPI2_RC_SUCCESS iff ok
///
fapi2::ReturnCode p9_mss_eff_config( const fapi2::Target<fapi2::TARGET_TYPE_MCS>& i_target,
const bool i_decode_spd_only )
{
fapi2::ReturnCode l_rc;
std::vector< std::shared_ptr<mss::spd::decoder> > l_factory_caches;
// Caches
FAPI_TRY( mss::spd::populate_decoder_caches(i_target, l_factory_caches) );
// Need to check dead load before we get the VPD.
// MR and MT VPD depends on DIMM ranks and freaks out if it recieves 0 ranks from DIMM 0 and 1 or more ranks for DIMM 1
FAPI_TRY( mss::plug_rule::check_dead_load (i_target) );
FAPI_TRY( mss::plug_rule::empty_slot_zero (i_target) );
// We need to decode the VPD. We don't do this in the ctor as we need
// the rank information and for that we need the SPD caches (which we get when we populate the cache.)
// However, we need to do the VPD decode before the others so that they might
// be able to use VPD information to make decisions about setting up eff attributes.
if( !i_decode_spd_only )
{
// Always set VPD attributes unless we enable the SPD_ONLY flag
// Enables skipping VPD decoder when a valid VPD template isn't available
FAPI_TRY( mss::eff_dimm::decode_vpd(i_target),
"Unable to decode VPD for %s", mss::c_str(i_target) );
}
for( const auto& l_cache : l_factory_caches )
{
std::shared_ptr<mss::eff_dimm> l_eff_dimm;
FAPI_TRY( mss::eff_dimm::eff_dimm_factory( l_cache, l_eff_dimm));
FAPI_INF("%s Running eff_config", mss::c_str(l_cache->iv_target) );
FAPI_TRY( l_eff_dimm->rcd_mfg_id() );
FAPI_TRY( l_eff_dimm->register_type() );
FAPI_TRY( l_eff_dimm->register_rev() );
FAPI_TRY( l_eff_dimm->dram_mfg_id() );
FAPI_TRY( l_eff_dimm->dram_width() );
FAPI_TRY( l_eff_dimm->dram_density() );
FAPI_TRY( l_eff_dimm->ranks_per_dimm() );
FAPI_TRY( l_eff_dimm->prim_die_count() );
FAPI_TRY( l_eff_dimm->primary_stack_type() );
FAPI_TRY( l_eff_dimm->dimm_size() );
FAPI_TRY( l_eff_dimm->hybrid_memory_type() );
FAPI_TRY( l_eff_dimm->dram_trefi() );
FAPI_TRY( l_eff_dimm->dram_trfc() );
FAPI_TRY( l_eff_dimm->dram_trfc_dlr() );
FAPI_TRY( l_eff_dimm->rcd_mirror_mode() );
FAPI_TRY( l_eff_dimm->dram_bank_bits() );
FAPI_TRY( l_eff_dimm->dram_row_bits() );
FAPI_TRY( l_eff_dimm->dram_dqs_time() );
FAPI_TRY( l_eff_dimm->dram_tccd_l() );
FAPI_TRY( l_eff_dimm->dimm_rc00() );
FAPI_TRY( l_eff_dimm->dimm_rc01() );
FAPI_TRY( l_eff_dimm->dimm_rc02() );
FAPI_TRY( l_eff_dimm->dimm_rc03() );
FAPI_TRY( l_eff_dimm->dimm_rc04() );
FAPI_TRY( l_eff_dimm->dimm_rc05() );
FAPI_TRY( l_eff_dimm->dimm_rc06_07() );
FAPI_TRY( l_eff_dimm->dimm_rc08() );
FAPI_TRY( l_eff_dimm->dimm_rc09() );
FAPI_TRY( l_eff_dimm->dimm_rc0a() );
FAPI_TRY( l_eff_dimm->dimm_rc0b() );
FAPI_TRY( l_eff_dimm->dimm_rc0c() );
FAPI_TRY( l_eff_dimm->dimm_rc0d() );
FAPI_TRY( l_eff_dimm->dimm_rc0e() );
FAPI_TRY( l_eff_dimm->dimm_rc0f() );
FAPI_TRY( l_eff_dimm->dimm_rc1x() );
FAPI_TRY( l_eff_dimm->dimm_rc2x() );
FAPI_TRY( l_eff_dimm->dimm_rc3x() );
FAPI_TRY( l_eff_dimm->dimm_rc4x() );
FAPI_TRY( l_eff_dimm->dimm_rc5x() );
FAPI_TRY( l_eff_dimm->dimm_rc6x() );
FAPI_TRY( l_eff_dimm->dimm_rc7x() );
FAPI_TRY( l_eff_dimm->dimm_rc8x() );
FAPI_TRY( l_eff_dimm->dimm_rc9x() );
FAPI_TRY( l_eff_dimm->dimm_rcax() );
FAPI_TRY( l_eff_dimm->dimm_rcbx() );
FAPI_TRY( l_eff_dimm->dram_twr() );
FAPI_TRY( l_eff_dimm->read_burst_type() );
FAPI_TRY( l_eff_dimm->dram_tm() );
FAPI_TRY( l_eff_dimm->dram_cwl() );
FAPI_TRY( l_eff_dimm->dram_lpasr() );
FAPI_TRY( l_eff_dimm->dll_enable() );
FAPI_TRY( l_eff_dimm->dll_reset() );
FAPI_TRY( l_eff_dimm->write_level_enable() );
FAPI_TRY( l_eff_dimm->output_buffer() );
FAPI_TRY( l_eff_dimm->vref_dq_train_value() );
FAPI_TRY( l_eff_dimm->vref_dq_train_range() );
FAPI_TRY( l_eff_dimm->vref_dq_train_enable() );
FAPI_TRY( l_eff_dimm->ca_parity_latency() );
FAPI_TRY( l_eff_dimm->ca_parity_error_status() );
FAPI_TRY( l_eff_dimm->ca_parity() );
FAPI_TRY( l_eff_dimm->crc_error_clear() );
FAPI_TRY( l_eff_dimm->odt_input_buffer() );
FAPI_TRY( l_eff_dimm->post_package_repair() );
FAPI_TRY( l_eff_dimm->read_preamble_train() );
FAPI_TRY( l_eff_dimm->read_preamble() );
FAPI_TRY( l_eff_dimm->write_preamble() );
FAPI_TRY( l_eff_dimm->self_refresh_abort() );
FAPI_TRY( l_eff_dimm->cs_to_cmd_addr_latency() );
FAPI_TRY( l_eff_dimm->internal_vref_monitor() );
FAPI_TRY( l_eff_dimm->max_powerdown_mode() );
FAPI_TRY( l_eff_dimm->mpr_read_format() );
FAPI_TRY( l_eff_dimm->temp_readout() );
FAPI_TRY( l_eff_dimm->crc_wr_latency() );
FAPI_TRY( l_eff_dimm->per_dram_addressability() );
FAPI_TRY( l_eff_dimm->geardown_mode() );
FAPI_TRY( l_eff_dimm->mpr_page() );
FAPI_TRY( l_eff_dimm->mpr_mode() );
FAPI_TRY( l_eff_dimm->write_crc() );
FAPI_TRY( l_eff_dimm->zqcal_interval() );
FAPI_TRY( l_eff_dimm->memcal_interval() );
FAPI_TRY( l_eff_dimm->dram_trp() );
FAPI_TRY( l_eff_dimm->dram_trcd() );
FAPI_TRY( l_eff_dimm->dram_trc() );
FAPI_TRY( l_eff_dimm->dram_twtr_l() );
FAPI_TRY( l_eff_dimm->dram_twtr_s() );
FAPI_TRY( l_eff_dimm->dram_trrd_s() );
FAPI_TRY( l_eff_dimm->dram_trrd_l() );
FAPI_TRY( l_eff_dimm->dram_trrd_dlr() );
FAPI_TRY( l_eff_dimm->dram_tfaw() );
FAPI_TRY( l_eff_dimm->dram_tfaw_dlr() );
FAPI_TRY( l_eff_dimm->dram_tras() );
FAPI_TRY( l_eff_dimm->dram_trtp() );
FAPI_TRY( l_eff_dimm->read_dbi() );
FAPI_TRY( l_eff_dimm->write_dbi() );
FAPI_TRY( l_eff_dimm->additive_latency() );
FAPI_TRY( l_eff_dimm->data_mask() );
FAPI_TRY( l_eff_dimm->dimm_bc00());
FAPI_TRY( l_eff_dimm->dimm_bc01());
FAPI_TRY( l_eff_dimm->dimm_bc02());
FAPI_TRY( l_eff_dimm->dimm_bc03());
FAPI_TRY( l_eff_dimm->dimm_bc04());
FAPI_TRY( l_eff_dimm->dimm_bc05());
FAPI_TRY( l_eff_dimm->dimm_bc07());
FAPI_TRY( l_eff_dimm->dimm_bc08());
FAPI_TRY( l_eff_dimm->dimm_bc09());
FAPI_TRY( l_eff_dimm->dimm_bc0a());
FAPI_TRY( l_eff_dimm->dimm_bc0b());
FAPI_TRY( l_eff_dimm->dimm_bc0c());
FAPI_TRY( l_eff_dimm->dimm_bc0d());
FAPI_TRY( l_eff_dimm->dimm_bc0e());
FAPI_TRY( l_eff_dimm->dimm_bc0f());
FAPI_TRY( l_eff_dimm->dram_rtt_nom () );
FAPI_TRY( l_eff_dimm->dram_rtt_wr () );
FAPI_TRY( l_eff_dimm->dram_rtt_park() );
FAPI_TRY( l_eff_dimm->phy_seq_refresh() );
// Sets up the calibration steps
FAPI_TRY( l_eff_dimm->cal_step_enable() );
FAPI_TRY( l_eff_dimm->rdvref_enable_bit() );
//Let's do some checking
FAPI_TRY( mss::check::temp_refresh_mode());
}// dimm
// Check plug rules. We check the MCS, and this will iterate down to children as needed.
FAPI_TRY( mss::plug_rule::enforce_plug_rules(i_target) );
fapi_try_exit:
return fapi2::current_err;
}
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/pm/p9_update_ec_eq_state.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_update_ec_eq_state.H
/// @brief Update the "permanent" multicast groups reflect any additional
/// deconfigured by Hostboot
///
// *HWP HWP Owner: Amit Kumar <[email protected]>
// *HWP Backup HWP Owner: Greg Still <[email protected]>
// *HWP FW Owner: Sangeetha T S <[email protected]>
// *HWP Team: PM
// *HWP Level: 1
// *HWP Consumed by: SBE
///
///
///
/// High-level procedure flow:
/// @verbatim
/// Update the "permanent" multicast groups reflect any additional
/// deconfiguration by Hostboot
/// Use the functional state to find all good cores
/// Write the good core and quad mask into OCC CCSR and QCSR respectively
/// These become the "master record " of the enabled cores/quad in
/// the system for runtime
/// @endverbatim
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "p9_update_ec_eq_state.H"
// -----------------------------------------------------------------------------
// Function prototypes
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// Function definitions
// -----------------------------------------------------------------------------
// See .H for documentation
fapi2::ReturnCode p9_update_ec_eq_state(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target)
{
FAPI_IMP("p9_update_ec_eq_state start");
FAPI_INF("p9_update_ec_eq_state end");
return fapi2::current_err;
} // END p9_update_ec_eq_state
<commit_msg>p9_update_ec_eq_state Level 2<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/pm/p9_update_ec_eq_state.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_update_ec_eq_state.H
/// @brief Update the "permanent" multicast groups reflect any additional
/// deconfigured by Hostboot
///
// *HWP HWP Owner: Amit Kumar <[email protected]>
// *HWP Backup HWP Owner: Greg Still <[email protected]>
// *HWP FW Owner: Sangeetha T S <[email protected]>
// *HWP Team: PM
// *HWP Level: 2
// *HWP Consumed by: SBE
///
///
///
/// High-level procedure flow:
/// @verbatim
/// - Update the "permanent" multicast groups reflect any additional
/// deconfiguration by Hostboot.
/// - MC group 0 (using MC register #1) - All good chiplets (deal with EC
// and EQ chiplets)
/// - MC group 1 (using EC MC register @2) - All good cores (EC only)
/// - Use the functional state to find all good cores
/// -Write the good core and quad mask into OCC CCSR and QCSR respectively
/// These become the "master record " of the enabled cores/quad in
/// the system for runtime
/// @endverbatim
// -----------------------------------------------------------------------------
// Includes
// -----------------------------------------------------------------------------
#include "p9_update_ec_eq_state.H"
// -----------------------------------------------------------------------------
// Function prototypes
// -----------------------------------------------------------------------------
static fapi2::ReturnCode update_ec_config(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target);
static fapi2::ReturnCode update_eq_config(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target);
// -----------------------------------------------------------------------------
// Constants
// -----------------------------------------------------------------------------
static const uint8_t CORE_CHIPLET_START = 0x20;
static const uint8_t CORE_CHIPLET_COUNT = 24;
// See .H for documentation
fapi2::ReturnCode p9_update_ec_eq_state(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target)
{
FAPI_IMP("> p9_update_ec_eq_state");
FAPI_TRY(update_ec_config(i_target),
"Error update_core_config detected");
FAPI_TRY(update_eq_config(i_target),
"Error update_cache_config detected");
fapi_try_exit:
FAPI_INF("< p9_update_ec_eq_state");
return fapi2::current_err;
} // END p9_update_ec_eq_state
/// @brief Update multicast groups and the CCSR for cores
///
/// @param[in] i_target Reference to TARGET_TYPE_PROC_CHIP target
/// @return FAPI2_RC_SUCCESS if success, else error code.
static fapi2::ReturnCode update_ec_config(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target)
{
FAPI_INF("> update_core_config...");
uint8_t l_present_core_unit_pos;
uint8_t l_functional_core_unit_pos;
fapi2::buffer<uint64_t> l_core_config = 0;
auto l_core_present_vector =
i_target.getChildren<fapi2::TARGET_TYPE_CORE>
(fapi2::TARGET_STATE_PRESENT);
auto l_core_functional_vector =
i_target.getChildren<fapi2::TARGET_TYPE_CORE>
(fapi2::TARGET_STATE_FUNCTIONAL);
FAPI_INF(" Number of present cores = %d; Number of functional cores = %d",
l_core_present_vector.size(),
l_core_functional_vector.size());
// For each present core, set multicast groups and the CCSR
for (auto core_present_it : l_core_present_vector)
{
bool b_core_functional = false;
FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_CHIP_UNIT_POS,
core_present_it,
l_present_core_unit_pos));
FAPI_DBG(" Checking if present EC %d is functional",
l_present_core_unit_pos);
for (auto core_functional_it : l_core_functional_vector)
{
FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_CHIP_UNIT_POS,
core_functional_it,
l_functional_core_unit_pos));
FAPI_DBG(" Functional EC %d",
l_functional_core_unit_pos);
if (l_functional_core_unit_pos == l_present_core_unit_pos)
{
// Set this core into the multicast groups. These should already
// be set but we won't assume anything
// Setting into ALL chiplets group (multicast group 0) using
// MULTICAST_GROUP_1 register
FAPI_INF(" Setting EC %d into MC group 0 (All chiplets)",
l_present_core_unit_pos);
FAPI_TRY(fapi2::putScom(core_functional_it, C_MULTICAST_GROUP_1,
p9UpdateECEQ::MCGR0_CNFG_SETTINGS));
// Setting into good core group (multicast group 1) using
// MULTICAST_GROUP_2 register in the EC chiplets
FAPI_INF(" Setting EC %d into MC group 1 (All core chiplets)",
l_present_core_unit_pos);
FAPI_TRY(fapi2::putScom(core_functional_it, C_MULTICAST_GROUP_2,
p9UpdateECEQ::MCGR1_CNFG_SETTINGS));
// Set the appropriate bit in the Core Configuration Status
// Register buffer
FAPI_INF(" Setting EC %d as good in value to be written to CCSR",
l_present_core_unit_pos);
l_core_config.setBit(l_present_core_unit_pos);
b_core_functional = true;
break;
}
}
// If not functional, clear the core chiplet out of all multicast groups
// As the chiplet is not functional, it can only addressed with the chip
// target, not a core target
if (!b_core_functional)
{
// Clearing from the ALL chiplets group (multicast group 0) using
// MULTICAST_GROUP_1 register
FAPI_INF(" Removing EC %d from MC group 0 (All chiplets)",
l_present_core_unit_pos);
uint32_t address = C_MULTICAST_GROUP_1 +
0x01000000 * l_present_core_unit_pos;
FAPI_TRY(fapi2::putScom(i_target, address,
p9UpdateECEQ::MCGR_CLEAR_CNFG_SETTINGS));
// Clearing from the good cores (multicast group 1) using
// MULTICAST_GROUP_2 register
FAPI_INF(" Removing EC %d from MC group 1 (All core chiplets)",
l_present_core_unit_pos);
address = C_MULTICAST_GROUP_2 +
0x01000000 * l_present_core_unit_pos;
FAPI_TRY(fapi2::putScom(i_target, address,
p9UpdateECEQ::MCGR_CLEAR_CNFG_SETTINGS));
// The Core Configuration Status Register buffer bit is already clear
}
}
// Write the recalculated OCC Core Configuration Status Register
FAPI_INF(" Writing OCC CCSR");
FAPI_TRY(fapi2::putScom(i_target, PU_OCB_OCI_CCSR_SCOM2, l_core_config),
"Error writing to CCSR");
fapi_try_exit:
FAPI_INF("< update_core_config...");
return fapi2::current_err;
}
/// @brief Update multicast groups and the QCSR for caches
///
/// @param[in] i_target Reference to TARGET_TYPE_PROC_CHIP target
/// @return FAPI2_RC_SUCCESS if success, else error code.
static fapi2::ReturnCode update_eq_config(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target)
{
FAPI_INF("> update_cache_config...");
uint8_t l_present_eq_unit_pos;
uint8_t l_present_ex_unit_pos;
uint8_t l_functional_eq_unit_pos;
uint8_t l_functional_ex_unit_pos;
fapi2::buffer<uint64_t> l_ex_config = 0;
auto l_eq_present_vector =
i_target.getChildren<fapi2::TARGET_TYPE_EQ>
(fapi2::TARGET_STATE_PRESENT);
auto l_eq_functional_vector =
i_target.getChildren<fapi2::TARGET_TYPE_EQ>
(fapi2::TARGET_STATE_FUNCTIONAL);
auto l_ex_present_vector =
i_target.getChildren<fapi2::TARGET_TYPE_EX>
(fapi2::TARGET_STATE_PRESENT);
auto l_ex_functional_vector =
i_target.getChildren<fapi2::TARGET_TYPE_EX>
(fapi2::TARGET_STATE_FUNCTIONAL);
FAPI_INF(" Number of present cache chiplets = %d; Number of functional cache chiplets = %d",
l_eq_present_vector.size(),
l_eq_functional_vector.size());
FAPI_INF(" Number of functional EX regions = %d",
l_ex_functional_vector.size());
// For each functinal EQ, set the multicast groups to match (including
// removal of the non-functional ones from all groups)
for (auto eq_present_it : l_eq_present_vector)
{
bool b_eq_functional = false;
FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_CHIP_UNIT_POS,
eq_present_it,
l_present_eq_unit_pos));
FAPI_DBG(" Checking if present EQ %d is functional)",
l_present_eq_unit_pos);
for (auto eq_functional_it : l_eq_functional_vector)
{
FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_CHIP_UNIT_POS,
eq_functional_it,
l_functional_eq_unit_pos));
if (l_functional_eq_unit_pos == l_present_eq_unit_pos)
{
// Setting into ALL chiplets group (multicast group 0) using
// MULTICAST_GROUP_1 register
FAPI_INF(" Setting EQ %d into MC group 0 (All chiplets)",
l_functional_eq_unit_pos);
FAPI_TRY(fapi2::putScom(eq_functional_it, EQ_MULTICAST_GROUP_1,
p9UpdateECEQ::MCGR0_CNFG_SETTINGS));
b_eq_functional = true;
}
}
// If not functional, clear the eq chiplet out of all multicast groups
// As the chiplet is not functional, it can only addressed with the chip
// target, not an EQ target
if (!b_eq_functional)
{
// Clearing from the ALL chiplets group (multicast group 0) using
// MULTICAST_GROUP_1 register
FAPI_INF(" Remove EQ %d from MC group 0 (All chiplets)",
l_present_eq_unit_pos);
uint32_t address = EQ_MULTICAST_GROUP_1 +
0x01000000 * l_present_eq_unit_pos;
FAPI_DBG(" address = 0x%X", address);
FAPI_TRY(fapi2::putScom(i_target, address,
p9UpdateECEQ::MCGR_CLEAR_CNFG_SETTINGS));
}
}
// For each present EX, set the QCSR
// This is done last so that hardware is accurate in the event of errors.
for (auto ex_present_it : l_ex_present_vector)
{
FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_CHIP_UNIT_POS,
ex_present_it,
l_present_ex_unit_pos));
for (auto ex_functional_it : l_ex_functional_vector)
{
FAPI_TRY(FAPI_ATTR_GET( fapi2::ATTR_CHIP_UNIT_POS,
ex_functional_it,
l_functional_ex_unit_pos));
if (l_functional_ex_unit_pos == l_present_ex_unit_pos)
{
// Set the bit in the buffer to written to the hardware
FAPI_INF(" Setting EX %d as good in value to be written to QCSR",
l_present_ex_unit_pos);
l_ex_config.setBit(l_present_ex_unit_pos);
}
}
}
// Write the recalculated OCC Quad Configuration Status Register
FAPI_INF(" Writing OCC QCSR");
FAPI_TRY(fapi2::putScom(i_target, PU_OCB_OCI_QCSR_SCOM2, l_ex_config),
"Error writing to CCSR");
fapi_try_exit:
FAPI_INF("< update_cache_config");
return fapi2::current_err;
} // END p9_update_ec_eq_state
<|endoftext|> |
<commit_before>#ifndef AMGCL_COARSENING_SMOOTHED_AGGREGATION_HPP
#define AMGCL_COARSENING_SMOOTHED_AGGREGATION_HPP
/*
The MIT License
Copyright (c) 2012-2018 Denis Demidov <[email protected]>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/**
* \file amgcl/coarsening/smoothed_aggregation.hpp
* \author Denis Demidov <[email protected]>
* \brief Smoothed aggregation coarsening scheme.
*/
#ifdef _OPENMP
# include <omp.h>
#endif
#include <boost/tuple/tuple.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#include <amgcl/backend/builtin.hpp>
#include <amgcl/coarsening/detail/galerkin.hpp>
#include <amgcl/coarsening/pointwise_aggregates.hpp>
#include <amgcl/coarsening/tentative_prolongation.hpp>
#include <amgcl/util.hpp>
namespace amgcl {
namespace coarsening {
/// Smoothed aggregation coarsening.
/**
* \ingroup coarsening
* \sa \cite Vanek1996
*/
template <class Backend>
struct smoothed_aggregation {
typedef pointwise_aggregates Aggregates;
/// Coarsening parameters
struct params {
/// Aggregation parameters.
Aggregates::params aggr;
/// Near nullspace parameters.
nullspace_params nullspace;
/// Relaxation factor.
/**
* Used as a scaling for the damping factor omega.
* When estimate_spectral_radius is set, then
* omega = relax * (4/3) / rho.
* Otherwise
* omega = relax * (2/3).
*
* Piecewise constant prolongation \f$\tilde P\f$ from non-smoothed
* aggregation is improved by a smoothing to get the final prolongation
* matrix \f$P\f$. Simple Jacobi smoother is used here, giving the
* prolongation matrix
* \f[P = \left( I - \omega D^{-1} A^F \right) \tilde P.\f]
* Here \f$A^F = (a_{ij}^F)\f$ is the filtered matrix given by
* \f[
* a_{ij}^F =
* \begin{cases}
* a_{ij} \quad \text{if} \; j \in N_i\\
* 0 \quad \text{otherwise}
* \end{cases}, \quad \text{if}\; i \neq j,
* \quad a_{ii}^F = a_{ii} - \sum\limits_{j=1,j\neq i}^n
* \left(a_{ij} - a_{ij}^F \right),
* \f]
* where \f$N_i\f$ is the set of variables, strongly coupled to
* variable \f$i\f$, and \f$D\f$ denotes the diagonal of \f$A^F\f$.
*/
float relax;
// Use power iterations to estimate the matrix spectral radius.
// This usually improves convergence rate and results in faster solves,
// but costs some time during setup.
bool estimate_spectral_radius;
// Number of power iterations to apply for the spectral radius
// estimation.
int power_iters;
params() : relax(1.0f), estimate_spectral_radius(true), power_iters(5) { }
params(const boost::property_tree::ptree &p)
: AMGCL_PARAMS_IMPORT_CHILD(p, aggr),
AMGCL_PARAMS_IMPORT_CHILD(p, nullspace),
AMGCL_PARAMS_IMPORT_VALUE(p, relax),
AMGCL_PARAMS_IMPORT_VALUE(p, estimate_spectral_radius),
AMGCL_PARAMS_IMPORT_VALUE(p, power_iters)
{
AMGCL_PARAMS_CHECK(p, (aggr)(nullspace)(relax)(estimate_spectral_radius)(power_iters));
}
void get(boost::property_tree::ptree &p, const std::string &path) const {
AMGCL_PARAMS_EXPORT_CHILD(p, path, aggr);
AMGCL_PARAMS_EXPORT_CHILD(p, path, nullspace);
AMGCL_PARAMS_EXPORT_VALUE(p, path, relax);
AMGCL_PARAMS_EXPORT_VALUE(p, path, estimate_spectral_radius);
AMGCL_PARAMS_EXPORT_VALUE(p, path, power_iters);
}
} prm;
smoothed_aggregation(const params &prm = params()) : prm(prm) {}
/// \copydoc amgcl::coarsening::aggregation::transfer_operators
template <class Matrix>
boost::tuple< boost::shared_ptr<Matrix>, boost::shared_ptr<Matrix> >
transfer_operators(const Matrix &A) {
typedef typename backend::value_type<Matrix>::type value_type;
typedef typename math::scalar_of<value_type>::type scalar_type;
const size_t n = rows(A);
AMGCL_TIC("aggregates");
Aggregates aggr(A, prm.aggr, prm.nullspace.cols);
prm.aggr.eps_strong *= 0.5;
AMGCL_TOC("aggregates");
AMGCL_TIC("interpolation");
boost::shared_ptr<Matrix> P_tent = tentative_prolongation<Matrix>(
n, aggr.count, aggr.id, prm.nullspace, prm.aggr.block_size
);
boost::shared_ptr<Matrix> P = boost::make_shared<Matrix>();
P->set_size(rows(*P_tent), cols(*P_tent), true);
scalar_type omega = prm.relax;
if (prm.estimate_spectral_radius) {
omega *= static_cast<scalar_type>(4.0/3) / spectral_radius(A, prm.power_iters);
} else {
omega *= static_cast<scalar_type>(2.0/3);
}
#pragma omp parallel
{
std::vector<ptrdiff_t> marker(P->ncols, -1);
// Count number of entries in P.
#pragma omp for
for(ptrdiff_t i = 0; i < static_cast<ptrdiff_t>(n); ++i) {
for(ptrdiff_t ja = A.ptr[i], ea = A.ptr[i+1]; ja < ea; ++ja) {
ptrdiff_t ca = A.col[ja];
// Skip weak off-diagonal connections.
if (ca != i && !aggr.strong_connection[ja])
continue;
for(ptrdiff_t jp = P_tent->ptr[ca], ep = P_tent->ptr[ca+1]; jp < ep; ++jp) {
ptrdiff_t cp = P_tent->col[jp];
if (marker[cp] != i) {
marker[cp] = i;
++( P->ptr[i + 1] );
}
}
}
}
}
P->scan_row_sizes();
P->set_nonzeros();
#pragma omp parallel
{
std::vector<ptrdiff_t> marker(P->ncols, -1);
// Fill the interpolation matrix.
#pragma omp for
for(ptrdiff_t i = 0; i < static_cast<ptrdiff_t>(n); ++i) {
// Diagonal of the filtered matrix is the original matrix
// diagonal minus its weak connections.
value_type dia = math::zero<value_type>();
for(ptrdiff_t j = A.ptr[i], e = A.ptr[i+1]; j < e; ++j) {
if (A.col[j] == i || !aggr.strong_connection[j])
dia += A.val[j];
}
dia = -omega * math::inverse(dia);
ptrdiff_t row_beg = P->ptr[i];
ptrdiff_t row_end = row_beg;
for(ptrdiff_t ja = A.ptr[i], ea = A.ptr[i + 1]; ja < ea; ++ja) {
ptrdiff_t ca = A.col[ja];
// Skip weak off-diagonal connections.
if (ca != i && !aggr.strong_connection[ja]) continue;
value_type va = (ca == i)
? static_cast<value_type>(static_cast<scalar_type>(1 - omega) * math::identity<value_type>())
: dia * A.val[ja]);
for(ptrdiff_t jp = P_tent->ptr[ca], ep = P_tent->ptr[ca+1]; jp < ep; ++jp) {
ptrdiff_t cp = P_tent->col[jp];
value_type vp = P_tent->val[jp];
if (marker[cp] < row_beg) {
marker[cp] = row_end;
P->col[row_end] = cp;
P->val[row_end] = va * vp;
++row_end;
} else {
P->val[ marker[cp] ] += va * vp;
}
}
}
}
}
AMGCL_TOC("interpolation");
if (prm.nullspace.cols > 0)
prm.aggr.block_size = prm.nullspace.cols;
return boost::make_tuple(P, transpose(*P));
}
/// \copydoc amgcl::coarsening::aggregation::coarse_operator
template <class Matrix>
boost::shared_ptr<Matrix>
coarse_operator(const Matrix &A, const Matrix &P, const Matrix &R) const {
return detail::galerkin(A, P, R);
}
// Uses power iteration to estimate spectral readius of the matrix,
// scaled by its inverse diagonal.
template <class Matrix>
static
typename math::scalar_of<typename backend::value_type<Matrix>::type>::type
spectral_radius(const Matrix &A, int power_iters)
{
typedef typename backend::value_type<Matrix>::type value_type;
typedef typename math::rhs_of<value_type>::type rhs_type;
typedef typename math::scalar_of<value_type>::type scalar_type;
const ptrdiff_t n = backend::rows(A);
backend::numa_vector<value_type> D(n, false);
backend::numa_vector<rhs_type> b0(n, false), b1(n, false);
// Fill the initial vector with random values.
// Also extract the inverted matrix diagonal values.
scalar_type b0_norm = 0;
#pragma omp parallel
{
#ifdef _OPENMP
int tid = omp_get_thread_num();
#else
int tid = 0;
#endif
boost::random::mt11213b rng(tid);
boost::random::uniform_real_distribution<scalar_type> rnd(-1, 1);
scalar_type loc_norm = 0;
#pragma omp for nowait
for(ptrdiff_t i = 0; i < n; ++i) {
rhs_type v = math::constant<rhs_type>(rnd(rng));
b0[i] = v;
loc_norm += math::norm(math::inner_product(v,v));
for(ptrdiff_t j = A.ptr[i], e = A.ptr[i+1]; j < e; ++j) {
if (A.col[j] == i) {
D[i] = math::inverse(A.val[j]);
break;
}
}
}
#pragma omp critical
b0_norm += loc_norm;
}
// Normalize b0
b0_norm = 1 / sqrt(b0_norm);
#pragma omp parallel for
for(ptrdiff_t i = 0; i < n; ++i) {
b0[i] = b0_norm * b0[i];
}
scalar_type radius = 1;
for(int iter = 0; iter < power_iters;) {
// b1 = (D * A) * b0
// b1_norm = ||b1||
// radius = <b1,b0>
scalar_type b1_norm = 0;
radius = 0;
#pragma omp parallel
{
scalar_type loc_norm = 0;
scalar_type loc_radi = 0;
#pragma omp for nowait
for(ptrdiff_t i = 0; i < n; ++i) {
rhs_type s = math::zero<rhs_type>();
for(ptrdiff_t j = A.ptr[i], e = A.ptr[i+1]; j < e; ++j) {
s += A.val[j] * b0[A.col[j]];
}
s = D[i] * s;
loc_norm += math::norm(math::inner_product(s, s));
loc_radi += math::norm(math::inner_product(s, b0[i]));
b1[i] = s;
}
#pragma omp critical
{
b1_norm += loc_norm;
radius += loc_radi;
}
}
if (++iter < power_iters) {
// b0 = b1 / b1_norm
b1_norm = 1 / sqrt(b1_norm);
#pragma omp parallel for
for(ptrdiff_t i = 0; i < n; ++i) {
b0[i] = b1_norm * b1[i];
}
}
}
return radius < 0 ? static_cast<scalar_type>(2) : radius;
}
};
} // namespace coarsening
} // namespace amgcl
#endif
<commit_msg>Missing paren<commit_after>#ifndef AMGCL_COARSENING_SMOOTHED_AGGREGATION_HPP
#define AMGCL_COARSENING_SMOOTHED_AGGREGATION_HPP
/*
The MIT License
Copyright (c) 2012-2018 Denis Demidov <[email protected]>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/**
* \file amgcl/coarsening/smoothed_aggregation.hpp
* \author Denis Demidov <[email protected]>
* \brief Smoothed aggregation coarsening scheme.
*/
#ifdef _OPENMP
# include <omp.h>
#endif
#include <boost/tuple/tuple.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#include <amgcl/backend/builtin.hpp>
#include <amgcl/coarsening/detail/galerkin.hpp>
#include <amgcl/coarsening/pointwise_aggregates.hpp>
#include <amgcl/coarsening/tentative_prolongation.hpp>
#include <amgcl/util.hpp>
namespace amgcl {
namespace coarsening {
/// Smoothed aggregation coarsening.
/**
* \ingroup coarsening
* \sa \cite Vanek1996
*/
template <class Backend>
struct smoothed_aggregation {
typedef pointwise_aggregates Aggregates;
/// Coarsening parameters
struct params {
/// Aggregation parameters.
Aggregates::params aggr;
/// Near nullspace parameters.
nullspace_params nullspace;
/// Relaxation factor.
/**
* Used as a scaling for the damping factor omega.
* When estimate_spectral_radius is set, then
* omega = relax * (4/3) / rho.
* Otherwise
* omega = relax * (2/3).
*
* Piecewise constant prolongation \f$\tilde P\f$ from non-smoothed
* aggregation is improved by a smoothing to get the final prolongation
* matrix \f$P\f$. Simple Jacobi smoother is used here, giving the
* prolongation matrix
* \f[P = \left( I - \omega D^{-1} A^F \right) \tilde P.\f]
* Here \f$A^F = (a_{ij}^F)\f$ is the filtered matrix given by
* \f[
* a_{ij}^F =
* \begin{cases}
* a_{ij} \quad \text{if} \; j \in N_i\\
* 0 \quad \text{otherwise}
* \end{cases}, \quad \text{if}\; i \neq j,
* \quad a_{ii}^F = a_{ii} - \sum\limits_{j=1,j\neq i}^n
* \left(a_{ij} - a_{ij}^F \right),
* \f]
* where \f$N_i\f$ is the set of variables, strongly coupled to
* variable \f$i\f$, and \f$D\f$ denotes the diagonal of \f$A^F\f$.
*/
float relax;
// Use power iterations to estimate the matrix spectral radius.
// This usually improves convergence rate and results in faster solves,
// but costs some time during setup.
bool estimate_spectral_radius;
// Number of power iterations to apply for the spectral radius
// estimation.
int power_iters;
params() : relax(1.0f), estimate_spectral_radius(true), power_iters(5) { }
params(const boost::property_tree::ptree &p)
: AMGCL_PARAMS_IMPORT_CHILD(p, aggr),
AMGCL_PARAMS_IMPORT_CHILD(p, nullspace),
AMGCL_PARAMS_IMPORT_VALUE(p, relax),
AMGCL_PARAMS_IMPORT_VALUE(p, estimate_spectral_radius),
AMGCL_PARAMS_IMPORT_VALUE(p, power_iters)
{
AMGCL_PARAMS_CHECK(p, (aggr)(nullspace)(relax)(estimate_spectral_radius)(power_iters));
}
void get(boost::property_tree::ptree &p, const std::string &path) const {
AMGCL_PARAMS_EXPORT_CHILD(p, path, aggr);
AMGCL_PARAMS_EXPORT_CHILD(p, path, nullspace);
AMGCL_PARAMS_EXPORT_VALUE(p, path, relax);
AMGCL_PARAMS_EXPORT_VALUE(p, path, estimate_spectral_radius);
AMGCL_PARAMS_EXPORT_VALUE(p, path, power_iters);
}
} prm;
smoothed_aggregation(const params &prm = params()) : prm(prm) {}
/// \copydoc amgcl::coarsening::aggregation::transfer_operators
template <class Matrix>
boost::tuple< boost::shared_ptr<Matrix>, boost::shared_ptr<Matrix> >
transfer_operators(const Matrix &A) {
typedef typename backend::value_type<Matrix>::type value_type;
typedef typename math::scalar_of<value_type>::type scalar_type;
const size_t n = rows(A);
AMGCL_TIC("aggregates");
Aggregates aggr(A, prm.aggr, prm.nullspace.cols);
prm.aggr.eps_strong *= 0.5;
AMGCL_TOC("aggregates");
AMGCL_TIC("interpolation");
boost::shared_ptr<Matrix> P_tent = tentative_prolongation<Matrix>(
n, aggr.count, aggr.id, prm.nullspace, prm.aggr.block_size
);
boost::shared_ptr<Matrix> P = boost::make_shared<Matrix>();
P->set_size(rows(*P_tent), cols(*P_tent), true);
scalar_type omega = prm.relax;
if (prm.estimate_spectral_radius) {
omega *= static_cast<scalar_type>(4.0/3) / spectral_radius(A, prm.power_iters);
} else {
omega *= static_cast<scalar_type>(2.0/3);
}
#pragma omp parallel
{
std::vector<ptrdiff_t> marker(P->ncols, -1);
// Count number of entries in P.
#pragma omp for
for(ptrdiff_t i = 0; i < static_cast<ptrdiff_t>(n); ++i) {
for(ptrdiff_t ja = A.ptr[i], ea = A.ptr[i+1]; ja < ea; ++ja) {
ptrdiff_t ca = A.col[ja];
// Skip weak off-diagonal connections.
if (ca != i && !aggr.strong_connection[ja])
continue;
for(ptrdiff_t jp = P_tent->ptr[ca], ep = P_tent->ptr[ca+1]; jp < ep; ++jp) {
ptrdiff_t cp = P_tent->col[jp];
if (marker[cp] != i) {
marker[cp] = i;
++( P->ptr[i + 1] );
}
}
}
}
}
P->scan_row_sizes();
P->set_nonzeros();
#pragma omp parallel
{
std::vector<ptrdiff_t> marker(P->ncols, -1);
// Fill the interpolation matrix.
#pragma omp for
for(ptrdiff_t i = 0; i < static_cast<ptrdiff_t>(n); ++i) {
// Diagonal of the filtered matrix is the original matrix
// diagonal minus its weak connections.
value_type dia = math::zero<value_type>();
for(ptrdiff_t j = A.ptr[i], e = A.ptr[i+1]; j < e; ++j) {
if (A.col[j] == i || !aggr.strong_connection[j])
dia += A.val[j];
}
dia = -omega * math::inverse(dia);
ptrdiff_t row_beg = P->ptr[i];
ptrdiff_t row_end = row_beg;
for(ptrdiff_t ja = A.ptr[i], ea = A.ptr[i + 1]; ja < ea; ++ja) {
ptrdiff_t ca = A.col[ja];
// Skip weak off-diagonal connections.
if (ca != i && !aggr.strong_connection[ja]) continue;
value_type va = (ca == i)
? static_cast<value_type>(static_cast<scalar_type>(1 - omega) * math::identity<value_type>())
: dia * A.val[ja];
for(ptrdiff_t jp = P_tent->ptr[ca], ep = P_tent->ptr[ca+1]; jp < ep; ++jp) {
ptrdiff_t cp = P_tent->col[jp];
value_type vp = P_tent->val[jp];
if (marker[cp] < row_beg) {
marker[cp] = row_end;
P->col[row_end] = cp;
P->val[row_end] = va * vp;
++row_end;
} else {
P->val[ marker[cp] ] += va * vp;
}
}
}
}
}
AMGCL_TOC("interpolation");
if (prm.nullspace.cols > 0)
prm.aggr.block_size = prm.nullspace.cols;
return boost::make_tuple(P, transpose(*P));
}
/// \copydoc amgcl::coarsening::aggregation::coarse_operator
template <class Matrix>
boost::shared_ptr<Matrix>
coarse_operator(const Matrix &A, const Matrix &P, const Matrix &R) const {
return detail::galerkin(A, P, R);
}
// Uses power iteration to estimate spectral readius of the matrix,
// scaled by its inverse diagonal.
template <class Matrix>
static
typename math::scalar_of<typename backend::value_type<Matrix>::type>::type
spectral_radius(const Matrix &A, int power_iters)
{
typedef typename backend::value_type<Matrix>::type value_type;
typedef typename math::rhs_of<value_type>::type rhs_type;
typedef typename math::scalar_of<value_type>::type scalar_type;
const ptrdiff_t n = backend::rows(A);
backend::numa_vector<value_type> D(n, false);
backend::numa_vector<rhs_type> b0(n, false), b1(n, false);
// Fill the initial vector with random values.
// Also extract the inverted matrix diagonal values.
scalar_type b0_norm = 0;
#pragma omp parallel
{
#ifdef _OPENMP
int tid = omp_get_thread_num();
#else
int tid = 0;
#endif
boost::random::mt11213b rng(tid);
boost::random::uniform_real_distribution<scalar_type> rnd(-1, 1);
scalar_type loc_norm = 0;
#pragma omp for nowait
for(ptrdiff_t i = 0; i < n; ++i) {
rhs_type v = math::constant<rhs_type>(rnd(rng));
b0[i] = v;
loc_norm += math::norm(math::inner_product(v,v));
for(ptrdiff_t j = A.ptr[i], e = A.ptr[i+1]; j < e; ++j) {
if (A.col[j] == i) {
D[i] = math::inverse(A.val[j]);
break;
}
}
}
#pragma omp critical
b0_norm += loc_norm;
}
// Normalize b0
b0_norm = 1 / sqrt(b0_norm);
#pragma omp parallel for
for(ptrdiff_t i = 0; i < n; ++i) {
b0[i] = b0_norm * b0[i];
}
scalar_type radius = 1;
for(int iter = 0; iter < power_iters;) {
// b1 = (D * A) * b0
// b1_norm = ||b1||
// radius = <b1,b0>
scalar_type b1_norm = 0;
radius = 0;
#pragma omp parallel
{
scalar_type loc_norm = 0;
scalar_type loc_radi = 0;
#pragma omp for nowait
for(ptrdiff_t i = 0; i < n; ++i) {
rhs_type s = math::zero<rhs_type>();
for(ptrdiff_t j = A.ptr[i], e = A.ptr[i+1]; j < e; ++j) {
s += A.val[j] * b0[A.col[j]];
}
s = D[i] * s;
loc_norm += math::norm(math::inner_product(s, s));
loc_radi += math::norm(math::inner_product(s, b0[i]));
b1[i] = s;
}
#pragma omp critical
{
b1_norm += loc_norm;
radius += loc_radi;
}
}
if (++iter < power_iters) {
// b0 = b1 / b1_norm
b1_norm = 1 / sqrt(b1_norm);
#pragma omp parallel for
for(ptrdiff_t i = 0; i < n; ++i) {
b0[i] = b1_norm * b1[i];
}
}
}
return radius < 0 ? static_cast<scalar_type>(2) : radius;
}
};
} // namespace coarsening
} // namespace amgcl
#endif
<|endoftext|> |
<commit_before>// Licensed GNU LGPL v2.1 or later: http://www.gnu.org/licenses/lgpl.html
IGNORE:
struct DUMMY { // dummy class for auto indentation
interface_scope:Object:
BSE_USE_RESULT
::Aida::IfaceEventConnection on (const ::std::string &type, ::Aida::EventHandlerF handler) { return this->ImplicitBase::__attach__ (type, handler); }
BSE_USE_RESULT
::Aida::IfaceEventConnection on (const ::std::string &type, ::std::function<void()> vfunc) { return this->ImplicitBase::__attach__ (type, [vfunc] (const ::Aida::Event&) { vfunc(); }); }
void off (::Aida::IfaceEventConnection &hcon) { hcon.disconnect(); }
void off (::Aida::IfaceEventConnection *hcon) { hcon->disconnect(); *hcon = ::Aida::IfaceEventConnection(); }
// as<BseObjectPtr>()
template<class BseObjectPtr, typename ::std::enable_if<std::is_pointer<BseObjectPtr>::value, bool>::type = true>
BseObjectPtr as ()
{
static_assert (std::is_pointer<BseObjectPtr>::value, "'BseObject*' required");
typedef typename std::remove_pointer<BseObjectPtr>::type BseObjectT;
static_assert (std::is_base_of<GObject, BseObjectT>::value, "'BseObject*' required");
return (BseObjectPtr) this->as_bse_object();
}
// DERIVES_shared_ptr (uses void_t to prevent errors for T without shared_ptr's typedefs)
template<class T, typename = void> struct DERIVES_shared_ptr : std::false_type {};
template<class T> struct DERIVES_shared_ptr<T, Bse::void_t< typename T::element_type > > :
std::is_base_of< std::shared_ptr<typename T::element_type>, T > {};
// as<shared_ptr<T>>()
template<class ObjectImplP, typename ::std::enable_if<DERIVES_shared_ptr<ObjectImplP>::value, bool>::type = true>
ObjectImplP as ()
{
typedef typename ObjectImplP::element_type ObjectImplT;
static_assert (std::is_base_of<Aida::ImplicitBase, ObjectImplT>::value, "");
ObjectImplT *impl = dynamic_cast<ObjectImplT*> (this);
return impl ? Bse::shared_ptr_cast<ObjectImplT> (impl) : NULL;
}
protected:
virtual BseObject* as_bse_object() = 0;
IGNORE: // close last _scope
}; // DUMMY
<commit_msg>BSE: bseapi-inserts.hh: on(): use ObjectImpl->__attach__() for connecting<commit_after>// Licensed GNU LGPL v2.1 or later: http://www.gnu.org/licenses/lgpl.html
IGNORE:
struct DUMMY { // dummy class for auto indentation
interface_scope:Object:
BSE_USE_RESULT
::Aida::IfaceEventConnection on (const ::std::string &type, ::Aida::EventHandlerF handler) { return this->__attach__ (type, handler); }
BSE_USE_RESULT
::Aida::IfaceEventConnection on (const ::std::string &type, ::std::function<void()> vfunc) { return this->__attach__ (type, [vfunc] (const ::Aida::Event&) { vfunc(); }); }
void off (::Aida::IfaceEventConnection &hcon) { hcon.disconnect(); }
void off (::Aida::IfaceEventConnection *hcon) { hcon->disconnect(); *hcon = ::Aida::IfaceEventConnection(); }
// as<BseObjectPtr>()
template<class BseObjectPtr, typename ::std::enable_if<std::is_pointer<BseObjectPtr>::value, bool>::type = true>
BseObjectPtr as ()
{
static_assert (std::is_pointer<BseObjectPtr>::value, "'BseObject*' required");
typedef typename std::remove_pointer<BseObjectPtr>::type BseObjectT;
static_assert (std::is_base_of<GObject, BseObjectT>::value, "'BseObject*' required");
return (BseObjectPtr) this->as_bse_object();
}
// DERIVES_shared_ptr (uses void_t to prevent errors for T without shared_ptr's typedefs)
template<class T, typename = void> struct DERIVES_shared_ptr : std::false_type {};
template<class T> struct DERIVES_shared_ptr<T, Bse::void_t< typename T::element_type > > :
std::is_base_of< std::shared_ptr<typename T::element_type>, T > {};
// as<shared_ptr<T>>()
template<class ObjectImplP, typename ::std::enable_if<DERIVES_shared_ptr<ObjectImplP>::value, bool>::type = true>
ObjectImplP as ()
{
typedef typename ObjectImplP::element_type ObjectImplT;
static_assert (std::is_base_of<Aida::ImplicitBase, ObjectImplT>::value, "");
ObjectImplT *impl = dynamic_cast<ObjectImplT*> (this);
return impl ? Bse::shared_ptr_cast<ObjectImplT> (impl) : NULL;
}
protected:
virtual BseObject* as_bse_object() = 0;
IGNORE: // close last _scope
}; // DUMMY
<|endoftext|> |
<commit_before>/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "modules/prediction/predictor/sequence/sequence_predictor.h"
#include <utility>
#include <cmath>
#include <limits>
#include <memory>
#include "modules/common/adapters/proto/adapter_config.pb.h"
#include "modules/prediction/common/prediction_map.h"
#include "modules/prediction/common/road_graph.h"
#include "modules/prediction/common/prediction_gflags.h"
#include "modules/prediction/container/container_manager.h"
#include "modules/prediction/container/obstacles/obstacles_container.h"
#include "modules/prediction/container/pose/pose_container.h"
namespace apollo {
namespace prediction {
using ::apollo::common::adapter::AdapterConfig;
using ::apollo::hdmap::LaneInfo;
void SequencePredictor::Predict(Obstacle* obstacle) {
Clear();
CHECK_NOTNULL(obstacle);
CHECK_GT(obstacle->history_size(), 0);
}
void SequencePredictor::Clear() {
Predictor::Clear();
adc_lane_id_.clear();
adc_lane_s_ = 0.0;
}
std::string SequencePredictor::ToString(const LaneSequence& sequence) {
std::string str_lane_sequence = "";
if (sequence.lane_segment_size() > 0) {
str_lane_sequence += sequence.lane_segment(0).lane_id();
}
for (int i = 1; i < sequence.lane_segment_size(); ++i) {
str_lane_sequence += ("->" + sequence.lane_segment(i).lane_id());
}
return str_lane_sequence;
}
void SequencePredictor::FilterLaneSequences(
const LaneGraph& lane_graph,
const std::string& lane_id,
std::vector<bool>* enable_lane_sequence) {
int num_lane_sequence = lane_graph.lane_sequence_size();
std::vector<LaneChangeType> lane_change_type(
num_lane_sequence, LaneChangeType::INVALID);
std::pair<int, double> change(-1, -1.0);
std::pair<int, double> all(-1, -1.0);
// Get ADC status
GetADC();
for (int i = 0; i < num_lane_sequence; ++i) {
const LaneSequence& sequence = lane_graph.lane_sequence(i);
lane_change_type[i] = GetLaneChangeType(lane_id, sequence);
if (lane_change_type[i] == LaneChangeType::INVALID) {
continue;
}
double probability = sequence.probability();
if (LaneSequenceWithMaxProb(
lane_change_type[i], probability, all.second)) {
all.first = i;
all.second = probability;
}
if (LaneChangeWithMaxProb(
lane_change_type[i], probability, change.second)) {
change.first = i;
change.second = probability;
}
}
for (int i = 0; i < num_lane_sequence; ++i) {
const LaneSequence& sequence = lane_graph.lane_sequence(i);
// The obstacle has interference with ADC within a small distance
if (GetLaneChangeDistanceWithADC(sequence) < FLAGS_lane_change_dist) {
(*enable_lane_sequence)[i] = false;
continue;
}
double probability = sequence.probability();
if (probability < FLAGS_lane_sequence_threshold && i != all.first) {
(*enable_lane_sequence)[i] = false;
} else if (change.first >= 0 && change.first < num_lane_sequence &&
(lane_change_type[i] == LaneChangeType::LEFT ||
lane_change_type[i] == LaneChangeType::RIGHT) &&
lane_change_type[i] != lane_change_type[change.first]) {
(*enable_lane_sequence)[i] = false;
}
}
}
void SequencePredictor::GetADC() {
ObstaclesContainer* container = dynamic_cast<ObstaclesContainer*>(
ContainerManager::instance()->GetContainer(
AdapterConfig::PERCEPTION_OBSTACLES));
if (container == nullptr) {
AERROR << "Unavailable obstacle container";
return;
}
Obstacle* adc = container->GetObstacle(PoseContainer::ID);
if (adc != nullptr) {
const Feature& feature = adc->latest_feature();
if (feature.has_lane() && feature.lane().has_lane_feature()) {
adc_lane_id_ = feature.lane().lane_feature().lane_id();
adc_lane_s_ = feature.lane().lane_feature().lane_s();
}
if (feature.has_position()) {
adc_position_[0] = feature.position().x();
adc_position_[1] = feature.position().y();
}
}
}
SequencePredictor::LaneChangeType SequencePredictor::GetLaneChangeType(
const std::string& lane_id, const LaneSequence& lane_sequence) {
PredictionMap* map = PredictionMap::instance();
std::string lane_change_id = lane_sequence.lane_segment(0).lane_id();
if (lane_id == lane_change_id) {
return LaneChangeType::STRAIGHT;
} else {
if (map->IsLeftNeighborLane(map->LaneById(lane_change_id),
map->LaneById(lane_id))) {
return LaneChangeType::LEFT;
} else if (map->IsRightNeighborLane(map->LaneById(lane_change_id),
map->LaneById(lane_id))) {
return LaneChangeType::RIGHT;
}
}
return LaneChangeType::INVALID;
}
double SequencePredictor::GetLaneChangeDistanceWithADC(
const LaneSequence& lane_sequence) {
if (adc_lane_id_.empty() || lane_sequence.lane_segment_size() <= 0) {
return std::numeric_limits<double>::max();
}
PredictionMap* map = PredictionMap::instance();
std::string obstacle_lane_id = lane_sequence.lane_segment(0).lane_id();
double obstacle_lane_s = lane_sequence.lane_segment(0).start_s();
if (SameLaneSequence(obstacle_lane_id, obstacle_lane_s)) {
return std::numeric_limits<double>::max();
}
double lane_s = 0.0;
double lane_l = 0.0;
if (map->GetProjection(adc_position_, map->LaneById(obstacle_lane_id),
&lane_s, &lane_l)) {
return std::fabs(lane_s - obstacle_lane_s);
}
return std::numeric_limits<double>::max();
}
bool SequencePredictor::SameLaneSequence(const std::string& lane_id,
double lane_s) {
PredictionMap* map = PredictionMap::instance();
std::shared_ptr<const LaneInfo> obstacle_lane = map->LaneById(lane_id);
std::shared_ptr<const LaneInfo> adc_lane = map->LaneById(adc_lane_id_);
if (obstacle_lane != nullptr && adc_lane != nullptr) {
RoadGraph obstacle_road_graph(lane_s, FLAGS_lane_change_dist,
obstacle_lane);
LaneGraph obstacle_lane_graph;
obstacle_road_graph.BuildLaneGraph(&obstacle_lane_graph);
RoadGraph adc_road_graph(adc_lane_s_, FLAGS_lane_change_dist, adc_lane);
LaneGraph adc_lane_graph;
adc_road_graph.BuildLaneGraph(&adc_lane_graph);
return obstacle_road_graph.IsOnLaneGraph(adc_lane, obstacle_lane_graph) ||
adc_road_graph.IsOnLaneGraph(obstacle_lane, adc_lane_graph);
}
return false;
}
bool SequencePredictor::LaneSequenceWithMaxProb(const LaneChangeType& type,
const double& probability,
const double& max_prob) {
if (probability > max_prob) {
return true;
} else {
double prob_diff = std::abs(probability - max_prob);
if (prob_diff <= std::numeric_limits<double>::epsilon() &&
type == LaneChangeType::STRAIGHT) {
return true;
}
}
return false;
}
bool SequencePredictor::LaneChangeWithMaxProb(const LaneChangeType& type,
const double& probability,
const double& max_prob) {
if (type == LaneChangeType::LEFT || type == LaneChangeType::RIGHT) {
if (probability > max_prob) {
return true;
}
}
return false;
}
} // namespace prediction
} // namespace apollo
<commit_msg>Prediction: fix the problem of nearby obstacles no prediction trajectories (#826)<commit_after>/******************************************************************************
* Copyright 2017 The Apollo Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#include "modules/prediction/predictor/sequence/sequence_predictor.h"
#include <utility>
#include <cmath>
#include <limits>
#include <memory>
#include "modules/common/adapters/proto/adapter_config.pb.h"
#include "modules/prediction/common/prediction_map.h"
#include "modules/prediction/common/road_graph.h"
#include "modules/prediction/common/prediction_gflags.h"
#include "modules/prediction/container/container_manager.h"
#include "modules/prediction/container/obstacles/obstacles_container.h"
#include "modules/prediction/container/pose/pose_container.h"
namespace apollo {
namespace prediction {
using ::apollo::common::adapter::AdapterConfig;
using ::apollo::hdmap::LaneInfo;
void SequencePredictor::Predict(Obstacle* obstacle) {
Clear();
CHECK_NOTNULL(obstacle);
CHECK_GT(obstacle->history_size(), 0);
}
void SequencePredictor::Clear() {
Predictor::Clear();
adc_lane_id_.clear();
adc_lane_s_ = 0.0;
}
std::string SequencePredictor::ToString(const LaneSequence& sequence) {
std::string str_lane_sequence = "";
if (sequence.lane_segment_size() > 0) {
str_lane_sequence += sequence.lane_segment(0).lane_id();
}
for (int i = 1; i < sequence.lane_segment_size(); ++i) {
str_lane_sequence += ("->" + sequence.lane_segment(i).lane_id());
}
return str_lane_sequence;
}
void SequencePredictor::FilterLaneSequences(
const LaneGraph& lane_graph,
const std::string& lane_id,
std::vector<bool>* enable_lane_sequence) {
int num_lane_sequence = lane_graph.lane_sequence_size();
std::vector<LaneChangeType> lane_change_type(
num_lane_sequence, LaneChangeType::INVALID);
std::pair<int, double> change(-1, -1.0);
std::pair<int, double> all(-1, -1.0);
// Get ADC status
GetADC();
for (int i = 0; i < num_lane_sequence; ++i) {
const LaneSequence& sequence = lane_graph.lane_sequence(i);
lane_change_type[i] = GetLaneChangeType(lane_id, sequence);
if (lane_change_type[i] == LaneChangeType::INVALID) {
continue;
}
double probability = sequence.probability();
if (LaneSequenceWithMaxProb(
lane_change_type[i], probability, all.second)) {
all.first = i;
all.second = probability;
}
if (LaneChangeWithMaxProb(
lane_change_type[i], probability, change.second)) {
change.first = i;
change.second = probability;
}
}
for (int i = 0; i < num_lane_sequence; ++i) {
const LaneSequence& sequence = lane_graph.lane_sequence(i);
// The obstacle has interference with ADC within a small distance
if (GetLaneChangeDistanceWithADC(sequence) < FLAGS_lane_change_dist &&
(lane_change_type[i] == LaneChangeType::LEFT ||
lane_change_type[i] == LaneChangeType::RIGHT)) {
(*enable_lane_sequence)[i] = false;
continue;
}
double probability = sequence.probability();
if (probability < FLAGS_lane_sequence_threshold && i != all.first) {
(*enable_lane_sequence)[i] = false;
} else if (change.first >= 0 && change.first < num_lane_sequence &&
(lane_change_type[i] == LaneChangeType::LEFT ||
lane_change_type[i] == LaneChangeType::RIGHT) &&
lane_change_type[i] != lane_change_type[change.first]) {
(*enable_lane_sequence)[i] = false;
}
}
}
void SequencePredictor::GetADC() {
ObstaclesContainer* container = dynamic_cast<ObstaclesContainer*>(
ContainerManager::instance()->GetContainer(
AdapterConfig::PERCEPTION_OBSTACLES));
if (container == nullptr) {
AERROR << "Unavailable obstacle container";
return;
}
Obstacle* adc = container->GetObstacle(PoseContainer::ID);
if (adc != nullptr) {
const Feature& feature = adc->latest_feature();
if (feature.has_lane() && feature.lane().has_lane_feature()) {
adc_lane_id_ = feature.lane().lane_feature().lane_id();
adc_lane_s_ = feature.lane().lane_feature().lane_s();
}
if (feature.has_position()) {
adc_position_[0] = feature.position().x();
adc_position_[1] = feature.position().y();
}
}
}
SequencePredictor::LaneChangeType SequencePredictor::GetLaneChangeType(
const std::string& lane_id, const LaneSequence& lane_sequence) {
PredictionMap* map = PredictionMap::instance();
std::string lane_change_id = lane_sequence.lane_segment(0).lane_id();
if (lane_id == lane_change_id) {
return LaneChangeType::STRAIGHT;
} else {
if (map->IsLeftNeighborLane(map->LaneById(lane_change_id),
map->LaneById(lane_id))) {
return LaneChangeType::LEFT;
} else if (map->IsRightNeighborLane(map->LaneById(lane_change_id),
map->LaneById(lane_id))) {
return LaneChangeType::RIGHT;
}
}
return LaneChangeType::INVALID;
}
double SequencePredictor::GetLaneChangeDistanceWithADC(
const LaneSequence& lane_sequence) {
if (adc_lane_id_.empty() || lane_sequence.lane_segment_size() <= 0) {
return std::numeric_limits<double>::max();
}
PredictionMap* map = PredictionMap::instance();
std::string obstacle_lane_id = lane_sequence.lane_segment(0).lane_id();
double obstacle_lane_s = lane_sequence.lane_segment(0).start_s();
if (SameLaneSequence(obstacle_lane_id, obstacle_lane_s)) {
return std::numeric_limits<double>::max();
}
double lane_s = 0.0;
double lane_l = 0.0;
if (map->GetProjection(adc_position_, map->LaneById(obstacle_lane_id),
&lane_s, &lane_l)) {
return std::fabs(lane_s - obstacle_lane_s);
}
return std::numeric_limits<double>::max();
}
bool SequencePredictor::SameLaneSequence(const std::string& lane_id,
double lane_s) {
PredictionMap* map = PredictionMap::instance();
std::shared_ptr<const LaneInfo> obstacle_lane = map->LaneById(lane_id);
std::shared_ptr<const LaneInfo> adc_lane = map->LaneById(adc_lane_id_);
if (obstacle_lane != nullptr && adc_lane != nullptr) {
RoadGraph obstacle_road_graph(lane_s, FLAGS_lane_change_dist,
obstacle_lane);
LaneGraph obstacle_lane_graph;
obstacle_road_graph.BuildLaneGraph(&obstacle_lane_graph);
RoadGraph adc_road_graph(adc_lane_s_, FLAGS_lane_change_dist, adc_lane);
LaneGraph adc_lane_graph;
adc_road_graph.BuildLaneGraph(&adc_lane_graph);
return obstacle_road_graph.IsOnLaneGraph(adc_lane, obstacle_lane_graph) ||
adc_road_graph.IsOnLaneGraph(obstacle_lane, adc_lane_graph);
}
return false;
}
bool SequencePredictor::LaneSequenceWithMaxProb(const LaneChangeType& type,
const double& probability,
const double& max_prob) {
if (probability > max_prob) {
return true;
} else {
double prob_diff = std::abs(probability - max_prob);
if (prob_diff <= std::numeric_limits<double>::epsilon() &&
type == LaneChangeType::STRAIGHT) {
return true;
}
}
return false;
}
bool SequencePredictor::LaneChangeWithMaxProb(const LaneChangeType& type,
const double& probability,
const double& max_prob) {
if (type == LaneChangeType::LEFT || type == LaneChangeType::RIGHT) {
if (probability > max_prob) {
return true;
}
}
return false;
}
} // namespace prediction
} // namespace apollo
<|endoftext|> |
<commit_before>/* bzflag
* Copyright (c) 1993 - 2009 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named COPYING that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
// interface header
#include "TimeKeeper.h"
// system implementation headers
#include <time.h>
#include <string>
#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef __BEOS__
# include <OS.h>
#endif
#if !defined(_WIN32)
# include <sys/time.h>
# include <sys/types.h>
static int64_t lastTime = 0;
# ifdef HAVE_SCHED_H
# include <sched.h>
# endif
#else // !defined(_WIN32)
# include <mmsystem.h>
static unsigned long int lastTime = 0;
static LARGE_INTEGER qpcLastTime;
static LONGLONG qpcFrequency = 0;
static LONGLONG qpcLastCalibration;
static DWORD timeLastCalibration;
#endif // !defined(_WIN32)
// common implementation headers
#include "TextUtils.h"
#include "bzfio.h"
static TimeKeeper currentTime;
static TimeKeeper tickTime;
static TimeKeeper sunExplodeTime;
static TimeKeeper sunGenesisTime;
static TimeKeeper nullTime;
static TimeKeeper startTime = TimeKeeper::getCurrent();
#if !defined(_WIN32)
static inline int64_t getEpochMicroseconds()
{
struct timeval nowTime;
gettimeofday(&nowTime, NULL);
return (int64_t(nowTime.tv_sec) * int64_t(1000000))
+ int64_t(nowTime.tv_usec);
}
#endif
const TimeKeeper& TimeKeeper::getCurrent(void)
{
// if not first call then update current time, else use default initial time
#if !defined(_WIN32)
if (lastTime == 0) {
// time starts at 0 seconds from the first call to getCurrent()
lastTime = getEpochMicroseconds();
}
else {
const int64_t nowTime = getEpochMicroseconds();
int64_t diff = (nowTime - lastTime);
if (diff < 0) {
logDebugMessage(1, "WARNING: went back in time %li microseconds\n",
(long int)diff);
diff = 0; // eh, how'd we go back in time?
}
currentTime += double(diff) * 1.0e-6;;
lastTime = nowTime;
}
#else /* !defined(_WIN32) */
if (qpcFrequency != 0) {
// main timer is qpc
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
LONGLONG diff = now.QuadPart - qpcLastTime.QuadPart;
LONGLONG clkSpent = now.QuadPart - qpcLastCalibration;
qpcLastTime = now;
if (clkSpent > qpcFrequency) {
// Recalibrate Frequency
DWORD tgt = timeGetTime();
DWORD deltaTgt = tgt - timeLastCalibration;
timeLastCalibration = tgt;
qpcLastCalibration = now.QuadPart;
if (deltaTgt > 0) {
LONGLONG oldqpcfreq = qpcFrequency;
qpcFrequency = (clkSpent * 1000) / deltaTgt;
if (qpcFrequency != oldqpcfreq)
logDebugMessage(4, "Recalibrated QPC frequency. Old: %f ; New: %f\n",
(double)oldqpcfreq, (double)qpcFrequency);
}
}
currentTime += (double) diff / (double) qpcFrequency;
} else if (lastTime != 0) {
unsigned long int now = (unsigned long int)timeGetTime();
unsigned long int diff;
if (now < lastTime) {
// eh, how'd we go back in time?
diff = 0;
} else {
diff = now - lastTime;
}
currentTime += 1.0e-3 * (double)diff;
lastTime = now;
} else {
static bool sane = true;
// should only get into here once on app start
if (!sane) {
logDebugMessage(1,"Sanity check failure in TimeKeeper::getCurrent()\n");
}
sane = false;
// make sure we're at our best timer resolution possible
timeBeginPeriod(1);
LARGE_INTEGER freq;
if (QueryPerformanceFrequency(&freq)) {
QueryPerformanceCounter(&qpcLastTime);
qpcFrequency = freq.QuadPart;
logDebugMessage(4,"Actual reported QPC Frequency: %f\n", (double)qpcFrequency);
qpcLastCalibration = qpcLastTime.QuadPart;
timeLastCalibration = timeGetTime();
} else {
logDebugMessage(1,"QueryPerformanceFrequency failed with error %d\n", GetLastError());
lastTime = (unsigned long int)timeGetTime();
}
}
#endif /* !defined(_WIN32) */
return currentTime;
}
const TimeKeeper& TimeKeeper::getStartTime(void) // const
{
return startTime;
}
const TimeKeeper& TimeKeeper::getTick(void) // const
{
return tickTime;
}
void TimeKeeper::setTick(void)
{
tickTime = getCurrent();
}
const TimeKeeper& TimeKeeper::getSunExplodeTime(void)
{
sunExplodeTime.seconds = 10000.0 * 365 * 24 * 60 * 60;
return sunExplodeTime;
}
const TimeKeeper& TimeKeeper::getSunGenesisTime(void)
{
sunGenesisTime.seconds = -10000.0 * 365 * 24 * 60 * 60;
return sunGenesisTime;
}
const TimeKeeper& TimeKeeper::getNullTime(void)
{
nullTime.seconds = 0;
return nullTime;
}
const char *TimeKeeper::timestamp(void) // const
{
static char buffer[256]; // static, so that it doesn't vanish
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
strncpy (buffer, TextUtils::format("%04d-%02d-%02d %02d:%02d:%02d",
now->tm_year, now->tm_mon, now->tm_mday,
now->tm_hour, now->tm_min, now->tm_sec).c_str(), 256);
buffer[255] = '\0'; // safety
return buffer;
}
/** returns a short string of the local time */
//static
std::string TimeKeeper::shortTimeStamp(void) {
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
std::string result( TextUtils::format("%02d:%02d", now->tm_hour, now->tm_min) );
return result;
}
void TimeKeeper::localTime(int *year, int *month, int* day,
int* hour, int* min, int* sec, bool* dst) // const
{
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
if (year) { *year = now->tm_year; }
if (month) { *month = now->tm_mon; }
if (day) { *day = now->tm_mday; }
if (hour) { *hour = now->tm_hour; }
if (min) { *min = now->tm_min; }
if (sec) { *sec = now->tm_sec; }
if (dst) { *dst = (now->tm_isdst != 0); }
}
void TimeKeeper::localTimeDOW(int *year, int *month, int* day, int* wday,
int* hour, int* min, int* sec, bool* dst) // const
{
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
if (year) { *year = now->tm_year; }
if (month) { *month = now->tm_mon; }
if (day) { *day = now->tm_mday; }
if (wday) { *wday = now->tm_wday; }
if (hour) { *hour = now->tm_hour; }
if (min) { *min = now->tm_min; }
if (sec) { *sec = now->tm_sec; }
if (dst) { *dst = (now->tm_isdst != 0); }
}
void TimeKeeper::UTCTime(int *year, int *month, int* day, int* wday,
int* hour, int* min, int* sec, bool* dst) // const
{
time_t tnow = time(0);
struct tm *now = gmtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
if (year) { *year = now->tm_year; }
if (month) { *month = now->tm_mon; }
if (day) { *day = now->tm_mday; }
if (wday) { *wday = now->tm_wday; }
if (hour) { *hour = now->tm_hour; }
if (min) { *min = now->tm_min; }
if (sec) { *sec = now->tm_sec; }
if (dst) { *dst = (now->tm_isdst != 0); }
}
// function for converting a float time (e.g. difference of two TimeKeepers)
// into an array of ints
void TimeKeeper::convertTime(double raw, long int convertedTimes[]) // const
{
long int day, hour, min, sec, remainder;
static const int secondsInDay = 86400;
sec = (long int)raw;
day = sec / secondsInDay;
remainder = sec - (day * secondsInDay);
hour = remainder / 3600;
remainder = sec - ((hour * 3600) + (day * secondsInDay));
min = remainder / 60;
remainder = sec - ((hour * 3600) + (day * secondsInDay) + (min * 60));
sec = remainder;
convertedTimes[0] = day;
convertedTimes[1] = hour;
convertedTimes[2] = min;
convertedTimes[3] = sec;
return;
}
// function for printing an array of ints representing a time
// as a human-readable string
const std::string TimeKeeper::printTime(long int timeValue[])
{
std::string valueNames;
char temp[20];
if (timeValue[0] > 0) {
snprintf(temp, 20, "%ld day%s", timeValue[0], timeValue[0] == 1 ? "" : "s");
valueNames.append(temp);
}
if (timeValue[1] > 0) {
if (timeValue[0] > 0) {
valueNames.append(", ");
}
snprintf(temp, 20, "%ld hour%s", timeValue[1], timeValue[1] == 1 ? "" : "s");
valueNames.append(temp);
}
if (timeValue[2] > 0) {
if ((timeValue[1] > 0) || (timeValue[0] > 0)) {
valueNames.append(", ");
}
snprintf(temp, 20, "%ld min%s", timeValue[2], timeValue[2] == 1 ? "" : "s");
valueNames.append(temp);
}
if (timeValue[3] > 0) {
if ((timeValue[2] > 0) || (timeValue[1] > 0) || (timeValue[0] > 0)) {
valueNames.append(", ");
}
snprintf(temp, 20, "%ld sec%s", timeValue[3], timeValue[3] == 1 ? "" : "s");
valueNames.append(temp);
}
return valueNames;
}
// function for printing a float time difference as a human-readable string
const std::string TimeKeeper::printTime(double diff)
{
long int temp[4];
convertTime(diff, temp);
return printTime(temp);
}
void TimeKeeper::sleep(double seconds)
{
if (seconds <= 0.0) {
return;
}
#ifdef HAVE_USLEEP
usleep((unsigned int)(1.0e6 * seconds));
return;
#endif
#if defined(HAVE_SLEEP) && !defined(__APPLE__)
// equivalent to _sleep() on win32 (not sleep(3))
Sleep((DWORD)(seconds * 1000.0));
return;
#endif
#ifdef HAVE_SNOOZE
snooze((bigtime_t)(1.0e6 * seconds));
return;
#endif
#ifdef HAVE_SELECT
struct timeval tv;
tv.tv_sec = (long)seconds;
tv.tv_usec = (long)(1.0e6 * (seconds - tv.tv_sec));
select(0, NULL, NULL, NULL, &tv);
return;
#endif
#ifdef HAVE_WAITFORSINGLEOBJECT
HANDLE dummyEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
WaitForSingleObject(dummyEvent, (DWORD)(1000.0 * seconds));
CloseHandle(dummyEvent);
return;
#endif
// fall-back case is fugly manual timekeeping
TimeKeeper now = TimeKeeper::getCurrent();
while ((TimeKeeper::getCurrent() - now) < seconds) {
continue;
}
return;
}
void TimeKeeper::setProcessorAffinity(int processor)
{
#ifdef HAVE_SCHED_SETAFFINITY
/* linuxy fix for time travel */
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(processor, &mask);
sched_setaffinity(0, sizeof(mask), &mask);
#elif defined(WIN32)
/* windowsy fix for time travel */
HANDLE hThread = GetCurrentThread();
DWORD_PTR dwMask = 1 << processor;
DWORD_PTR dwProcs = 0;
GetProcessAffinityMask(NULL, NULL, &dwProcs);
if (dwMask < dwProcs) {
logDebugMessage(1, "Unable to set process affinity mask (specified processor does not exist).\n");
return;
}
SetThreadAffinityMask(hThread, dwMask);
#else
logDebugMessage(1, "Unable to set processor affinity to %d - function not implemented on this platform.\n", processor);
#endif
}
// Local Variables: ***
// mode: C++ ***
// tab-width: 8 ***
// c-basic-offset: 2 ***
// indent-tabs-mode: t ***
// End: ***
// ex: shiftwidth=2 tabstop=8
<commit_msg>* changed a debug message level<commit_after>/* bzflag
* Copyright (c) 1993 - 2009 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named COPYING that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
// interface header
#include "TimeKeeper.h"
// system implementation headers
#include <time.h>
#include <string>
#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef __BEOS__
# include <OS.h>
#endif
#if !defined(_WIN32)
# include <sys/time.h>
# include <sys/types.h>
static int64_t lastTime = 0;
# ifdef HAVE_SCHED_H
# include <sched.h>
# endif
#else // !defined(_WIN32)
# include <mmsystem.h>
static unsigned long int lastTime = 0;
static LARGE_INTEGER qpcLastTime;
static LONGLONG qpcFrequency = 0;
static LONGLONG qpcLastCalibration;
static DWORD timeLastCalibration;
#endif // !defined(_WIN32)
// common implementation headers
#include "TextUtils.h"
#include "bzfio.h"
static TimeKeeper currentTime;
static TimeKeeper tickTime;
static TimeKeeper sunExplodeTime;
static TimeKeeper sunGenesisTime;
static TimeKeeper nullTime;
static TimeKeeper startTime = TimeKeeper::getCurrent();
#if !defined(_WIN32)
static inline int64_t getEpochMicroseconds()
{
struct timeval nowTime;
gettimeofday(&nowTime, NULL);
return (int64_t(nowTime.tv_sec) * int64_t(1000000))
+ int64_t(nowTime.tv_usec);
}
#endif
const TimeKeeper& TimeKeeper::getCurrent(void)
{
// if not first call then update current time, else use default initial time
#if !defined(_WIN32)
if (lastTime == 0) {
// time starts at 0 seconds from the first call to getCurrent()
lastTime = getEpochMicroseconds();
}
else {
const int64_t nowTime = getEpochMicroseconds();
int64_t diff = (nowTime - lastTime);
if (diff < 0) {
logDebugMessage(5, "WARNING: went back in time %li microseconds\n",
(long int)diff);
diff = 0; // eh, how'd we go back in time?
}
currentTime += double(diff) * 1.0e-6;;
lastTime = nowTime;
}
#else /* !defined(_WIN32) */
if (qpcFrequency != 0) {
// main timer is qpc
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
LONGLONG diff = now.QuadPart - qpcLastTime.QuadPart;
LONGLONG clkSpent = now.QuadPart - qpcLastCalibration;
qpcLastTime = now;
if (clkSpent > qpcFrequency) {
// Recalibrate Frequency
DWORD tgt = timeGetTime();
DWORD deltaTgt = tgt - timeLastCalibration;
timeLastCalibration = tgt;
qpcLastCalibration = now.QuadPart;
if (deltaTgt > 0) {
LONGLONG oldqpcfreq = qpcFrequency;
qpcFrequency = (clkSpent * 1000) / deltaTgt;
if (qpcFrequency != oldqpcfreq)
logDebugMessage(4, "Recalibrated QPC frequency. Old: %f ; New: %f\n",
(double)oldqpcfreq, (double)qpcFrequency);
}
}
currentTime += (double) diff / (double) qpcFrequency;
} else if (lastTime != 0) {
unsigned long int now = (unsigned long int)timeGetTime();
unsigned long int diff;
if (now < lastTime) {
// eh, how'd we go back in time?
diff = 0;
} else {
diff = now - lastTime;
}
currentTime += 1.0e-3 * (double)diff;
lastTime = now;
} else {
static bool sane = true;
// should only get into here once on app start
if (!sane) {
logDebugMessage(1,"Sanity check failure in TimeKeeper::getCurrent()\n");
}
sane = false;
// make sure we're at our best timer resolution possible
timeBeginPeriod(1);
LARGE_INTEGER freq;
if (QueryPerformanceFrequency(&freq)) {
QueryPerformanceCounter(&qpcLastTime);
qpcFrequency = freq.QuadPart;
logDebugMessage(4,"Actual reported QPC Frequency: %f\n", (double)qpcFrequency);
qpcLastCalibration = qpcLastTime.QuadPart;
timeLastCalibration = timeGetTime();
} else {
logDebugMessage(1,"QueryPerformanceFrequency failed with error %d\n", GetLastError());
lastTime = (unsigned long int)timeGetTime();
}
}
#endif /* !defined(_WIN32) */
return currentTime;
}
const TimeKeeper& TimeKeeper::getStartTime(void) // const
{
return startTime;
}
const TimeKeeper& TimeKeeper::getTick(void) // const
{
return tickTime;
}
void TimeKeeper::setTick(void)
{
tickTime = getCurrent();
}
const TimeKeeper& TimeKeeper::getSunExplodeTime(void)
{
sunExplodeTime.seconds = 10000.0 * 365 * 24 * 60 * 60;
return sunExplodeTime;
}
const TimeKeeper& TimeKeeper::getSunGenesisTime(void)
{
sunGenesisTime.seconds = -10000.0 * 365 * 24 * 60 * 60;
return sunGenesisTime;
}
const TimeKeeper& TimeKeeper::getNullTime(void)
{
nullTime.seconds = 0;
return nullTime;
}
const char *TimeKeeper::timestamp(void) // const
{
static char buffer[256]; // static, so that it doesn't vanish
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
strncpy (buffer, TextUtils::format("%04d-%02d-%02d %02d:%02d:%02d",
now->tm_year, now->tm_mon, now->tm_mday,
now->tm_hour, now->tm_min, now->tm_sec).c_str(), 256);
buffer[255] = '\0'; // safety
return buffer;
}
/** returns a short string of the local time */
//static
std::string TimeKeeper::shortTimeStamp(void) {
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
std::string result( TextUtils::format("%02d:%02d", now->tm_hour, now->tm_min) );
return result;
}
void TimeKeeper::localTime(int *year, int *month, int* day,
int* hour, int* min, int* sec, bool* dst) // const
{
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
if (year) { *year = now->tm_year; }
if (month) { *month = now->tm_mon; }
if (day) { *day = now->tm_mday; }
if (hour) { *hour = now->tm_hour; }
if (min) { *min = now->tm_min; }
if (sec) { *sec = now->tm_sec; }
if (dst) { *dst = (now->tm_isdst != 0); }
}
void TimeKeeper::localTimeDOW(int *year, int *month, int* day, int* wday,
int* hour, int* min, int* sec, bool* dst) // const
{
time_t tnow = time(0);
struct tm *now = localtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
if (year) { *year = now->tm_year; }
if (month) { *month = now->tm_mon; }
if (day) { *day = now->tm_mday; }
if (wday) { *wday = now->tm_wday; }
if (hour) { *hour = now->tm_hour; }
if (min) { *min = now->tm_min; }
if (sec) { *sec = now->tm_sec; }
if (dst) { *dst = (now->tm_isdst != 0); }
}
void TimeKeeper::UTCTime(int *year, int *month, int* day, int* wday,
int* hour, int* min, int* sec, bool* dst) // const
{
time_t tnow = time(0);
struct tm *now = gmtime(&tnow);
now->tm_year += 1900;
++now->tm_mon;
if (year) { *year = now->tm_year; }
if (month) { *month = now->tm_mon; }
if (day) { *day = now->tm_mday; }
if (wday) { *wday = now->tm_wday; }
if (hour) { *hour = now->tm_hour; }
if (min) { *min = now->tm_min; }
if (sec) { *sec = now->tm_sec; }
if (dst) { *dst = (now->tm_isdst != 0); }
}
// function for converting a float time (e.g. difference of two TimeKeepers)
// into an array of ints
void TimeKeeper::convertTime(double raw, long int convertedTimes[]) // const
{
long int day, hour, min, sec, remainder;
static const int secondsInDay = 86400;
sec = (long int)raw;
day = sec / secondsInDay;
remainder = sec - (day * secondsInDay);
hour = remainder / 3600;
remainder = sec - ((hour * 3600) + (day * secondsInDay));
min = remainder / 60;
remainder = sec - ((hour * 3600) + (day * secondsInDay) + (min * 60));
sec = remainder;
convertedTimes[0] = day;
convertedTimes[1] = hour;
convertedTimes[2] = min;
convertedTimes[3] = sec;
return;
}
// function for printing an array of ints representing a time
// as a human-readable string
const std::string TimeKeeper::printTime(long int timeValue[])
{
std::string valueNames;
char temp[20];
if (timeValue[0] > 0) {
snprintf(temp, 20, "%ld day%s", timeValue[0], timeValue[0] == 1 ? "" : "s");
valueNames.append(temp);
}
if (timeValue[1] > 0) {
if (timeValue[0] > 0) {
valueNames.append(", ");
}
snprintf(temp, 20, "%ld hour%s", timeValue[1], timeValue[1] == 1 ? "" : "s");
valueNames.append(temp);
}
if (timeValue[2] > 0) {
if ((timeValue[1] > 0) || (timeValue[0] > 0)) {
valueNames.append(", ");
}
snprintf(temp, 20, "%ld min%s", timeValue[2], timeValue[2] == 1 ? "" : "s");
valueNames.append(temp);
}
if (timeValue[3] > 0) {
if ((timeValue[2] > 0) || (timeValue[1] > 0) || (timeValue[0] > 0)) {
valueNames.append(", ");
}
snprintf(temp, 20, "%ld sec%s", timeValue[3], timeValue[3] == 1 ? "" : "s");
valueNames.append(temp);
}
return valueNames;
}
// function for printing a float time difference as a human-readable string
const std::string TimeKeeper::printTime(double diff)
{
long int temp[4];
convertTime(diff, temp);
return printTime(temp);
}
void TimeKeeper::sleep(double seconds)
{
if (seconds <= 0.0) {
return;
}
#ifdef HAVE_USLEEP
usleep((unsigned int)(1.0e6 * seconds));
return;
#endif
#if defined(HAVE_SLEEP) && !defined(__APPLE__)
// equivalent to _sleep() on win32 (not sleep(3))
Sleep((DWORD)(seconds * 1000.0));
return;
#endif
#ifdef HAVE_SNOOZE
snooze((bigtime_t)(1.0e6 * seconds));
return;
#endif
#ifdef HAVE_SELECT
struct timeval tv;
tv.tv_sec = (long)seconds;
tv.tv_usec = (long)(1.0e6 * (seconds - tv.tv_sec));
select(0, NULL, NULL, NULL, &tv);
return;
#endif
#ifdef HAVE_WAITFORSINGLEOBJECT
HANDLE dummyEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
WaitForSingleObject(dummyEvent, (DWORD)(1000.0 * seconds));
CloseHandle(dummyEvent);
return;
#endif
// fall-back case is fugly manual timekeeping
TimeKeeper now = TimeKeeper::getCurrent();
while ((TimeKeeper::getCurrent() - now) < seconds) {
continue;
}
return;
}
void TimeKeeper::setProcessorAffinity(int processor)
{
#ifdef HAVE_SCHED_SETAFFINITY
/* linuxy fix for time travel */
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(processor, &mask);
sched_setaffinity(0, sizeof(mask), &mask);
#elif defined(WIN32)
/* windowsy fix for time travel */
HANDLE hThread = GetCurrentThread();
DWORD_PTR dwMask = 1 << processor;
DWORD_PTR dwProcs = 0;
GetProcessAffinityMask(NULL, NULL, &dwProcs);
if (dwMask < dwProcs) {
logDebugMessage(1, "Unable to set process affinity mask (specified processor does not exist).\n");
return;
}
SetThreadAffinityMask(hThread, dwMask);
#else
logDebugMessage(1, "Unable to set processor affinity to %d - function not implemented on this platform.\n", processor);
#endif
}
// Local Variables: ***
// mode: C++ ***
// tab-width: 8 ***
// c-basic-offset: 2 ***
// indent-tabs-mode: t ***
// End: ***
// ex: shiftwidth=2 tabstop=8
<|endoftext|> |
<commit_before>/* bzflag
* Copyright (c) 1993 - 2005 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named COPYING that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
#ifdef _MSC_VER
#pragma warning( 4: 4786)
#define _WINSOCK2API_
#endif
// bzflag common header
#include "common.h"
// class interface header
#include "URLManager.h"
// system headers
#ifdef _WIN32
#include <winsock.h>
#endif
#ifdef HAVE_CURL
#include <curl/curl.h>
#endif
#include <iostream>
// common implementation headers
#include "bzfio.h"
#include "StateDatabase.h"
template <>
URLManager* Singleton<URLManager>::_instance = (URLManager*)0;
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb, void *stream);
#endif // HAVE_CURL
bool URLManager::getURL(const std::string URL, std::string &data)
{
clearInternal();
if (!beginGet(URL))
return false;
char* newData = (char*)malloc(theLen + 1);
memcpy(newData, theData, theLen);
newData[theLen] = 0;
data = newData;
free(newData);
return true;
}
bool URLManager::getURL(const std::string URL, void **data, unsigned int& size)
{
clearInternal();
if (!beginGet(URL))
return false;
*data = malloc(theLen);
memcpy(*data, theData, theLen);
size = theLen;
return true;
}
void URLManager::freeURLData(void *data)
{
free(data);
}
URLManager::URLManager()
{
easyHandle = NULL;
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode curlResult;
#if LIBCURL_VERSION_NUM >= 0x070a00
if ((curlResult = curl_global_init(CURL_GLOBAL_NOTHING)))
DEBUG1("Unexpected error from libcurl; Error: %d\n", curlResult);
#endif
easyHandle = curl_easy_init();
if (!easyHandle) {
DEBUG1("Something wrong with CURL\n");
return;
}
CURLcode result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_WRITEFUNCTION, writeFunction);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n", result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_FILE, this);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n", result);
#endif
}
URLManager::~URLManager()
{
clearInternal();
#ifdef HAVE_CURL
if (easyHandle)
curl_easy_cleanup((CURL*)easyHandle);
#if LIBCURL_VERSION_NUM >= 0x070a00
curl_global_cleanup();
#endif
#endif
}
void URLManager::collectData(char* ptr, int len)
{
unsigned char *newData = (unsigned char*)malloc(theLen + len);
if (theData)
memcpy(newData, theData, theLen);
memcpy(&(newData[theLen]), ptr, len);
theLen += len;
free(theData);
theData = newData;
}
void URLManager::clearInternal()
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
}
#ifdef HAVE_CURL
bool URLManager::beginGet(const std::string URL)
#else
bool URLManager::beginGet(const std::string)
#endif
{
#ifdef HAVE_CURL
CURLcode result = CURLE_OK;
if (!easyHandle) {
return false;
}
float timeout = 15;
if (BZDB.isSet("httpTimeout"))
timeout = BZDB.eval("httpTimeout");
#if LIBCURL_VERSION_NUM >= 0x070a00
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_NOSIGNAL, true);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
}
#endif
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_TIMEOUT, timeout);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, URL.c_str());
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
}
// FIXME: This could block for a _long_ time.
result = curl_easy_perform((CURL*)easyHandle);
if (result == (CURLcode)CURLOPT_ERRORBUFFER) {
DEBUG1("Error: server reported: %d\n", result);
return false;
} else if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, NULL);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
return false;
}
if (!theData)
return false;
return true;
#else
return false;
#endif // HAVE_CURL
}
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb, void *stream)
{
int len = size * nmemb;
((URLManager*)stream)->collectData((char*)ptr, len);
return len;
}
#endif // HAVE_CURL
// Local Variables: ***
// mode:C++ ***
// tab-width: 8 ***
// c-basic-offset: 2 ***
// indent-tabs-mode: t ***
// End: ***
// ex: shiftwidth=2 tabstop=8
<commit_msg>better not declare if your not going to use it<commit_after>/* bzflag
* Copyright (c) 1993 - 2005 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named COPYING that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
#ifdef _MSC_VER
#pragma warning( 4: 4786)
#define _WINSOCK2API_
#endif
// bzflag common header
#include "common.h"
// class interface header
#include "URLManager.h"
// system headers
#ifdef _WIN32
#include <winsock.h>
#endif
#ifdef HAVE_CURL
#include <curl/curl.h>
#endif
#include <iostream>
// common implementation headers
#include "bzfio.h"
#include "StateDatabase.h"
template <>
URLManager* Singleton<URLManager>::_instance = (URLManager*)0;
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb, void *stream);
#endif // HAVE_CURL
bool URLManager::getURL(const std::string URL, std::string &data)
{
clearInternal();
if (!beginGet(URL))
return false;
char* newData = (char*)malloc(theLen + 1);
memcpy(newData, theData, theLen);
newData[theLen] = 0;
data = newData;
free(newData);
return true;
}
bool URLManager::getURL(const std::string URL, void **data, unsigned int& size)
{
clearInternal();
if (!beginGet(URL))
return false;
*data = malloc(theLen);
memcpy(*data, theData, theLen);
size = theLen;
return true;
}
void URLManager::freeURLData(void *data)
{
free(data);
}
URLManager::URLManager()
{
easyHandle = NULL;
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
#if LIBCURL_VERSION_NUM >= 0x070a00
CURLcode curlResult;
if ((curlResult = curl_global_init(CURL_GLOBAL_NOTHING)))
DEBUG1("Unexpected error from libcurl; Error: %d\n", curlResult);
#endif
easyHandle = curl_easy_init();
if (!easyHandle) {
DEBUG1("Something wrong with CURL\n");
return;
}
CURLcode result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_WRITEFUNCTION, writeFunction);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n", result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_FILE, this);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n", result);
#endif
}
URLManager::~URLManager()
{
clearInternal();
#ifdef HAVE_CURL
if (easyHandle)
curl_easy_cleanup((CURL*)easyHandle);
#if LIBCURL_VERSION_NUM >= 0x070a00
curl_global_cleanup();
#endif
#endif
}
void URLManager::collectData(char* ptr, int len)
{
unsigned char *newData = (unsigned char*)malloc(theLen + len);
if (theData)
memcpy(newData, theData, theLen);
memcpy(&(newData[theLen]), ptr, len);
theLen += len;
free(theData);
theData = newData;
}
void URLManager::clearInternal()
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
}
#ifdef HAVE_CURL
bool URLManager::beginGet(const std::string URL)
#else
bool URLManager::beginGet(const std::string)
#endif
{
#ifdef HAVE_CURL
CURLcode result = CURLE_OK;
if (!easyHandle) {
return false;
}
float timeout = 15;
if (BZDB.isSet("httpTimeout"))
timeout = BZDB.eval("httpTimeout");
#if LIBCURL_VERSION_NUM >= 0x070a00
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_NOSIGNAL, true);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
}
#endif
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_TIMEOUT, timeout);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, URL.c_str());
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
}
// FIXME: This could block for a _long_ time.
result = curl_easy_perform((CURL*)easyHandle);
if (result == (CURLcode)CURLOPT_ERRORBUFFER) {
DEBUG1("Error: server reported: %d\n", result);
return false;
} else if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, NULL);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n", result);
return false;
}
if (!theData)
return false;
return true;
#else
return false;
#endif // HAVE_CURL
}
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb, void *stream)
{
int len = size * nmemb;
((URLManager*)stream)->collectData((char*)ptr, len);
return len;
}
#endif // HAVE_CURL
// Local Variables: ***
// mode:C++ ***
// tab-width: 8 ***
// c-basic-offset: 2 ***
// indent-tabs-mode: t ***
// End: ***
// ex: shiftwidth=2 tabstop=8
<|endoftext|> |
<commit_before>/* bzflag
* Copyright (c) 1993 - 2004 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named COPYING that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
// bzflag common header
#include "common.h"
#include "URLManager.h"
#include <iostream>
#include "bzfio.h"
#ifdef _MSC_VER
#pragma warning( 4: 4786)
#define _WINSOCK2API_
#endif
#ifdef HAVE_CURL
#include <curl/curl.h>
#endif
template <>
URLManager* Singleton<URLManager>::_instance = (URLManager*)0;
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb, void *stream);
#endif // HAVE_CURL
#ifdef HAVE_CURL
bool URLManager::getURL ( const std::string URL, std::string &data )
#else
bool URLManager::getURL ( const std::string, std::string&)
#endif // HAVE_CURL
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode result;
if (!easyHandle) {
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_TIMEOUT, 5);
if (result)
DEBUG1("Something wrong with CURL; Error: %d",result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, URL.c_str());
if (result) {
DEBUG1("Something wrong with CURL; Error: %d",result);
return false;
}
result = curl_easy_perform((CURL*)easyHandle);
if (result == (CURLcode)CURLOPT_ERRORBUFFER) {
DEBUG1("Error: server reported: %d",result);
return false;
}else if (result) {
DEBUG1("Something wrong with CURL; Error: %d",result);
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, NULL);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d",result);
return false;
}
if (!theData)
return false;
char * newData = (char*)malloc(theLen + 1);
memcpy(newData,theData,theLen);
newData[theLen] = 0;
data = newData;
free(newData);
return true;
#endif
return false;
}
#ifdef HAVE_CURL
bool URLManager::getURL ( const std::string URL, void **data, unsigned int& size )
#else
bool URLManager::getURL (const std::string, void **, unsigned int&)
#endif // HAVE_CURL
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode result;
if (!easyHandle) {
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_TIMEOUT, 60);
if (result)
DEBUG1("Something wrong with CURL; Error: %d",result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, URL.c_str());
if (result) {
DEBUG1("Something wrong with CURL; Error: %d",result);
}
result = curl_easy_perform((CURL*)easyHandle);
if (result == (CURLcode)CURLOPT_ERRORBUFFER) {
DEBUG1("Error: server reported: %d",result);
return false;
}else if (result) {
DEBUG1("Something wrong with CURL; Error: %d",result);
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, NULL);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d",result);
return false;
}
if (!theData)
return false;
*data = malloc(theLen);
memcpy(*data,theData,theLen);
size = theLen;
return true;
#endif
return false;
}
void URLManager::freeURLData ( void *data )
{
free(data);
}
URLManager::URLManager()
{
easyHandle = NULL;
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode curlResult;
if ((curlResult = curl_global_init(CURL_GLOBAL_NOTHING)))
DEBUG1("Unexpected error from libcurl; Error: %d",curlResult);
easyHandle = curl_easy_init();
if (!easyHandle) {
DEBUG1("Something wrong with CURL");
return;
}
CURLcode result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_WRITEFUNCTION, writeFunction);
if (result)
DEBUG1("Something wrong with CURL; Error: %d",result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_FILE, this);
if (result)
DEBUG1("Something wrong with CURL; Error: %d",result);
#endif
}
URLManager::~URLManager()
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
if (easyHandle)
curl_easy_cleanup((CURL*)easyHandle);
curl_global_cleanup();
#endif
}
void URLManager::collectData(char* ptr, int len)
{
unsigned char *newData = (unsigned char*)malloc(theLen + len);
if (theData)
memcpy(newData,theData,theLen);
memcpy(&(newData[theLen]),ptr,len);
theLen+= len;
free(theData);
theData = newData;
}
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb,void *stream)
{
int len = size * nmemb;
((URLManager *)stream)->collectData((char *)ptr, len);
return len;
}
#endif // HAVE_CURL
<commit_msg>Newlines on DEBUG messages<commit_after>/* bzflag
* Copyright (c) 1993 - 2004 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named COPYING that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
// bzflag common header
#include "common.h"
#include "URLManager.h"
#include <iostream>
#include "bzfio.h"
#ifdef _MSC_VER
#pragma warning( 4: 4786)
#define _WINSOCK2API_
#endif
#ifdef HAVE_CURL
#include <curl/curl.h>
#endif
template <>
URLManager* Singleton<URLManager>::_instance = (URLManager*)0;
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb, void *stream);
#endif // HAVE_CURL
#ifdef HAVE_CURL
bool URLManager::getURL ( const std::string URL, std::string &data )
#else
bool URLManager::getURL ( const std::string, std::string&)
#endif // HAVE_CURL
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode result;
if (!easyHandle) {
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_TIMEOUT, 5);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n",result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, URL.c_str());
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n",result);
return false;
}
result = curl_easy_perform((CURL*)easyHandle);
if (result == (CURLcode)CURLOPT_ERRORBUFFER) {
DEBUG1("Error: server reported: %d\n",result);
return false;
} else if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n",result);
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, NULL);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n",result);
return false;
}
if (!theData)
return false;
char * newData = (char*)malloc(theLen + 1);
memcpy(newData,theData,theLen);
newData[theLen] = 0;
data = newData;
free(newData);
return true;
#endif
return false;
}
#ifdef HAVE_CURL
bool URLManager::getURL ( const std::string URL, void **data, unsigned int& size )
#else
bool URLManager::getURL (const std::string, void **, unsigned int&)
#endif // HAVE_CURL
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode result;
if (!easyHandle) {
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_TIMEOUT, 60);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n",result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, URL.c_str());
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n",result);
}
result = curl_easy_perform((CURL*)easyHandle);
if (result == (CURLcode)CURLOPT_ERRORBUFFER) {
DEBUG1("Error: server reported: %d\n",result);
return false;
} else if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n",result);
return false;
}
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_URL, NULL);
if (result) {
DEBUG1("Something wrong with CURL; Error: %d\n",result);
return false;
}
if (!theData)
return false;
*data = malloc(theLen);
memcpy(*data,theData,theLen);
size = theLen;
return true;
#endif
return false;
}
void URLManager::freeURLData ( void *data )
{
free(data);
}
URLManager::URLManager()
{
easyHandle = NULL;
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
CURLcode curlResult;
if ((curlResult = curl_global_init(CURL_GLOBAL_NOTHING)))
DEBUG1("Unexpected error from libcurl; Error: %d\n",curlResult);
easyHandle = curl_easy_init();
if (!easyHandle) {
DEBUG1("Something wrong with CURL\n");
return;
}
CURLcode result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_WRITEFUNCTION, writeFunction);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n",result);
result = curl_easy_setopt((CURL*)easyHandle, CURLOPT_FILE, this);
if (result)
DEBUG1("Something wrong with CURL; Error: %d\n",result);
#endif
}
URLManager::~URLManager()
{
if (theData)
free (theData);
theData = NULL;
theLen = 0;
#ifdef HAVE_CURL
if (easyHandle)
curl_easy_cleanup((CURL*)easyHandle);
curl_global_cleanup();
#endif
}
void URLManager::collectData(char* ptr, int len)
{
unsigned char *newData = (unsigned char*)malloc(theLen + len);
if (theData)
memcpy(newData,theData,theLen);
memcpy(&(newData[theLen]),ptr,len);
theLen+= len;
free(theData);
theData = newData;
}
#ifdef HAVE_CURL
static size_t writeFunction(void *ptr, size_t size, size_t nmemb,void *stream)
{
int len = size * nmemb;
((URLManager *)stream)->collectData((char *)ptr, len);
return len;
}
#endif // HAVE_CURL
<|endoftext|> |
<commit_before>// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
#include "stdafx.h"
#include "AutoNetServerImpl.hpp"
#include "at_exit.h"
#include "autowiring.h"
#include "demangle.h"
#include "ObjectTraits.h"
#include "EventRegistry.h"
#include "TypeRegistry.h"
#include <iostream>
#include FUTURE_HEADER
using std::placeholders::_1;
using std::placeholders::_2;
using json11::Json;
AutoNetServerImpl::AutoNetServerImpl(void) :
m_Port(8000)
{
// Configure websocketpp
m_Server.init_asio();
m_Server.set_access_channels(websocketpp::log::alevel::none);
m_Server.set_error_channels(websocketpp::log::elevel::none);
// Register handlers
m_Server.set_open_handler(std::bind(&AutoNetServerImpl::OnOpen, this, ::_1));
m_Server.set_close_handler(std::bind(&AutoNetServerImpl::OnClose, this, ::_1));
m_Server.set_message_handler(std::bind(&AutoNetServerImpl::OnMessage, this, ::_1, ::_2));
// Generate list of all types from type registry
for(auto type = g_pFirstTypeEntry; type; type = type->pFlink)
if(type->CanInject())
m_AllTypes[autowiring::demangle(type->ti)] = [type]{ type->Inject(); };
// Generate list of all events from event registry
for(auto event = g_pFirstEventEntry; event; event = event->pFlink)
m_EventTypes.insert(event->NewTypeIdentifier());
}
AutoNetServerImpl::~AutoNetServerImpl()
{
}
AutoNetServer* NewAutoNetServerImpl(void) {
return new AutoNetServerImpl;
}
// CoreThread overrides
void AutoNetServerImpl::Run(void){
std::cout << "Starting Autonet server..." << std::endl;
m_Server.listen(m_Port);
m_Server.start_accept();
// blocks until the server finishes
auto websocket = std::async(std::launch::async, [this]{
m_Server.run();
});
PollThreadUtilization(std::chrono::milliseconds(1000));
CoreThread::Run();
}
void AutoNetServerImpl::OnStop(void) {
if (m_Server.is_listening())
m_Server.stop_listening();
for (auto& conn : m_Subscribers) {
m_Server.close(conn, websocketpp::close::status::normal, "closed");
}
}
// Server Handler functions
void AutoNetServerImpl::OnOpen(websocketpp::connection_hdl hdl) {
*this += [this, hdl] {
SendMessage(hdl, "opened");
};
}
void AutoNetServerImpl::OnClose(websocketpp::connection_hdl hdl) {
*this += [this, hdl] {
this->m_Subscribers.erase(hdl);
};
}
void AutoNetServerImpl::OnMessage(websocketpp::connection_hdl hdl, message_ptr p_message) {
// Parse string from client
std::string err;
Json msg = Json::parse(p_message->get_payload(), err);
if(!err.empty()) {
std::cout << "Parse error: " << err << std::endl;
SendMessage(hdl, "invalidMessage", "Couldn't parse message");
return;
}
std::string msgType = msg["type"].string_value();
Json::array msgArgs = msg["args"].array_items();
*this += [this, hdl, msgType, msgArgs] {
if(msgType == "subscribe") HandleSubscribe(hdl);
else if(msgType == "unsubscribe") HandleUnsubscribe(hdl);
else if(msgType == "terminateContext") HandleTerminateContext(msgArgs[0].int_value());
else if(msgType == "injectContextMember") HandleInjectContextMember(msgArgs[0].int_value(), msgArgs[1].string_value());
else if(msgType == "resumeFromBreakpoint") HandleResumeFromBreakpoint(msgArgs[0].string_value());
else
SendMessage(hdl, "invalidMessage", "Message type not recognized");
};
}
void AutoNetServerImpl::Breakpoint(std::string name){
std::unique_lock<std::mutex> lk(m_mutex);
m_breakpoints.insert(name);
*this += [this, name]{
BroadcastMessage("breakpoint", name);
};
m_breakpoint_cv.wait(lk, [this, name]{
return !m_breakpoints.count(name);
});
}
// Update Functions
void AutoNetServerImpl::NewContext(CoreContext& newCtxt){
auto ctxt = newCtxt.shared_from_this();
*this += [this, ctxt] {
Json::object context{
{"name", autowiring::demangle(ctxt->GetSigilType())}
};
if(ctxt->GetParentContext()){
context["parent"] = ResolveContextID(ctxt->GetParentContext().get());
}
BroadcastMessage("newContext", ResolveContextID(ctxt.get()), context);
};
}
void AutoNetServerImpl::ExpiredContext(CoreContext& oldCtxt){
int id = ResolveContextID(&oldCtxt);
*this += [this, id] {
BroadcastMessage("expiredContext", id);
};
}
void AutoNetServerImpl::NewObject(CoreContext& ctxt, const ObjectTraits& object){
int contextID = ResolveContextID(&ctxt);
*this += [this, object, contextID]{
Json::object objData;
Json::object types;
// Add object data
objData["name"] = autowiring::demangle(typeid(*object.pObject));
{
Json::array slots;
for(auto slot = object.stump.pHead; slot; slot = slot->pFlink) {
slots.push_back(Json::object{
{"name", autowiring::demangle(slot->type)},
{"autoRequired", slot->autoRequired},
{"offset", int(slot->slotOffset)}
});
}
objData["slots"] = slots;
}
// Add type information
auto member = object.pContextMember;
if(member) {
types["contextMember"] = true;
}
auto runnable = object.pCoreRunnable;
if(runnable) {
types["coreRunnable"] = true;
}
auto thread = object.pBasicThread;
if(thread) {
// Create slot in map
m_Threads[thread->GetSelf<BasicThread>()];
types["thread"] = Json::object{
{"kernal", 0.0},
{"user", 0.0}
};
}
// Check if type implements an AutoFilter
if (!object.subscriber.empty()) {
Json::object args;
for (auto pArg = object.subscriber.GetAutoFilterInput(); *pArg; ++pArg) {
args[autowiring::demangle(pArg->ti)] = Json::object{
{"isInput", pArg->is_input || bool(pArg->tshift)},
{"isOutput", pArg->is_output}
};
}
types["autoFilter"] = args;
}
// Check if type receives any events
{
Json::array listenerTypes;
for(const auto& event : m_EventTypes) {
if(event->IsSameAs(object.pObject.get()))
listenerTypes.push_back(autowiring::demangle(event->Type()));
}
if(!listenerTypes.empty())
types["eventReceiver"] = listenerTypes;
}
auto filter = object.pFilter;
if(filter) {
types["exceptionFilter"] = true;
}
auto bolt = object.pBoltBase;
if(bolt) {
Json::array sigils;
for(auto cur = bolt->GetContextSigils(); *cur; cur++){
sigils.push_back(autowiring::demangle(**cur));
}
types["bolt"] = sigils;
}
BroadcastMessage("newObject", contextID, types, objData);
};
}
void AutoNetServerImpl::EventFired(CoreContext& context, const std::type_info& info){
int contextID = ResolveContextID(&context);
std::string name = autowiring::demangle(info);
*this += [this, contextID, name] {
BroadcastMessage("eventFired", contextID, Json::object{{"name", name}});
};
}
void AutoNetServerImpl::HandleSubscribe(websocketpp::connection_hdl hdl) {
m_Subscribers.insert(hdl);
Json::array types;
for(const auto& type : m_AllTypes) {
types.push_back(type.first);
}
SendMessage(hdl, "subscribed", types);
GetContext()->BuildCurrentState();
// Send breakpoint message
for(const auto& breakpoint : m_breakpoints) {
SendMessage(hdl, "breakpoint", breakpoint);
}
}
void AutoNetServerImpl::HandleUnsubscribe(websocketpp::connection_hdl hdl) {
this->m_Subscribers.erase(hdl);
SendMessage(hdl, "unsubscribed");
}
void AutoNetServerImpl::HandleTerminateContext(int contextID) {
ResolveContextID(contextID)->SignalShutdown();
}
void AutoNetServerImpl::HandleInjectContextMember(int contextID, std::string typeName) {
std::shared_ptr<CoreContext> ctxt = ResolveContextID(contextID)->shared_from_this();
if(m_AllTypes.find(typeName) != m_AllTypes.end()) {
CurrentContextPusher pshr(ctxt);
m_AllTypes[typeName]();
}
else {
// Type doesn't exist
assert(false);
}
}
void AutoNetServerImpl::HandleResumeFromBreakpoint(std::string name){
std::unique_lock<std::mutex> lk(m_mutex);
m_breakpoints.erase(name);
m_breakpoint_cv.notify_all();
}
//helper functions
int AutoNetServerImpl::ResolveContextID(CoreContext* ctxt) {
static int counter = 0;
if(m_ContextIDs.find(ctxt) == m_ContextIDs.end()){
m_ContextIDs[ctxt] = counter;
m_ContextPtrs[counter] = ctxt;
return counter++;
}
else {
return m_ContextIDs[ctxt];
}
}
CoreContext* AutoNetServerImpl::ResolveContextID(int id) {
return m_ContextPtrs.at(id);
}
void AutoNetServerImpl::PollThreadUtilization(std::chrono::milliseconds period){
*this += period, [this, period] {
for(auto q = m_Threads.begin(); q != m_Threads.end();) {
std::shared_ptr<BasicThread> thread = q->first.lock();
if(!thread) {
m_Threads.erase(q++);
continue;
}
std::chrono::milliseconds runtimeKM, runtimeUM;
thread->GetThreadTimes(runtimeKM, runtimeUM);
// Determine the amount of time this thread has run since the last time we
// asked it for its runtime.
std::chrono::duration<double> deltaRuntimeKM = runtimeKM - q->second.m_lastRuntimeKM;
std::chrono::duration<double> deltaRuntimeUM = runtimeUM - q->second.m_lastRuntimeUM;
// Update timing values:
q->second.m_lastRuntimeKM = runtimeKM;
q->second.m_lastRuntimeUM = runtimeUM;
// Broadcast current thread utilization
int contextID = ResolveContextID(thread->GetContext().get());
std::string name = autowiring::demangle(typeid(*thread.get()));
std::chrono::duration<double> periodDbl = period;
double kmPercent = 100.0 * (deltaRuntimeKM.count() / periodDbl.count());
double umPercent = 100.0 * (deltaRuntimeUM.count() / periodDbl.count());
// Make sure user + kernel percent < 100.0
umPercent = std::min(umPercent, 99.9 - kmPercent);
if(kmPercent >= 0.0 && umPercent >= 0.0) {
BroadcastMessage("threadUtilization", contextID, name, kmPercent, umPercent);
}
// Next!
q++;
}
// Poll again after "period" milliseconds
PollThreadUtilization(period);
};
}
<commit_msg>Fixing warning in MSVC<commit_after>// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
#include "stdafx.h"
#include "AutoNetServerImpl.hpp"
#include "at_exit.h"
#include "autowiring.h"
#include "demangle.h"
#include "ObjectTraits.h"
#include "EventRegistry.h"
#include "TypeRegistry.h"
#include <iostream>
#include FUTURE_HEADER
using std::placeholders::_1;
using std::placeholders::_2;
using json11::Json;
AutoNetServerImpl::AutoNetServerImpl(void) :
m_Port(8000)
{
// Configure websocketpp
m_Server.init_asio();
m_Server.set_access_channels(websocketpp::log::alevel::none);
m_Server.set_error_channels(websocketpp::log::elevel::none);
// Register handlers
m_Server.set_open_handler(std::bind(&AutoNetServerImpl::OnOpen, this, ::_1));
m_Server.set_close_handler(std::bind(&AutoNetServerImpl::OnClose, this, ::_1));
m_Server.set_message_handler(std::bind(&AutoNetServerImpl::OnMessage, this, ::_1, ::_2));
// Generate list of all types from type registry
for(auto type = g_pFirstTypeEntry; type; type = type->pFlink)
if(type->CanInject())
m_AllTypes[autowiring::demangle(type->ti)] = [type]{ type->Inject(); };
// Generate list of all events from event registry
for(auto event = g_pFirstEventEntry; event; event = event->pFlink)
m_EventTypes.insert(event->NewTypeIdentifier());
}
AutoNetServerImpl::~AutoNetServerImpl()
{
}
AutoNetServer* NewAutoNetServerImpl(void) {
return new AutoNetServerImpl;
}
// CoreThread overrides
void AutoNetServerImpl::Run(void){
std::cout << "Starting Autonet server..." << std::endl;
m_Server.listen(m_Port);
m_Server.start_accept();
// blocks until the server finishes
auto websocket = std::async(std::launch::async, [this]{
m_Server.run();
});
PollThreadUtilization(std::chrono::milliseconds(1000));
CoreThread::Run();
}
void AutoNetServerImpl::OnStop(void) {
if (m_Server.is_listening())
m_Server.stop_listening();
for (auto& conn : m_Subscribers) {
m_Server.close(conn, websocketpp::close::status::normal, "closed");
}
}
// Server Handler functions
void AutoNetServerImpl::OnOpen(websocketpp::connection_hdl hdl) {
*this += [this, hdl] {
SendMessage(hdl, "opened");
};
}
void AutoNetServerImpl::OnClose(websocketpp::connection_hdl hdl) {
*this += [this, hdl] {
this->m_Subscribers.erase(hdl);
};
}
void AutoNetServerImpl::OnMessage(websocketpp::connection_hdl hdl, message_ptr p_message) {
// Parse string from client
std::string err;
Json msg = Json::parse(p_message->get_payload(), err);
if(!err.empty()) {
std::cout << "Parse error: " << err << std::endl;
SendMessage(hdl, "invalidMessage", "Couldn't parse message");
return;
}
std::string msgType = msg["type"].string_value();
Json::array msgArgs = msg["args"].array_items();
*this += [this, hdl, msgType, msgArgs] {
if(msgType == "subscribe") HandleSubscribe(hdl);
else if(msgType == "unsubscribe") HandleUnsubscribe(hdl);
else if(msgType == "terminateContext") HandleTerminateContext(msgArgs[0].int_value());
else if(msgType == "injectContextMember") HandleInjectContextMember(msgArgs[0].int_value(), msgArgs[1].string_value());
else if(msgType == "resumeFromBreakpoint") HandleResumeFromBreakpoint(msgArgs[0].string_value());
else
SendMessage(hdl, "invalidMessage", "Message type not recognized");
};
}
void AutoNetServerImpl::Breakpoint(std::string name){
std::unique_lock<std::mutex> lk(m_mutex);
m_breakpoints.insert(name);
*this += [this, name]{
BroadcastMessage("breakpoint", name);
};
m_breakpoint_cv.wait(lk, [this, name]{
return !m_breakpoints.count(name);
});
}
// Update Functions
void AutoNetServerImpl::NewContext(CoreContext& newCtxt){
auto ctxt = newCtxt.shared_from_this();
*this += [this, ctxt] {
Json::object context{
{"name", autowiring::demangle(ctxt->GetSigilType())}
};
if(ctxt->GetParentContext()){
context["parent"] = ResolveContextID(ctxt->GetParentContext().get());
}
BroadcastMessage("newContext", ResolveContextID(ctxt.get()), context);
};
}
void AutoNetServerImpl::ExpiredContext(CoreContext& oldCtxt){
int id = ResolveContextID(&oldCtxt);
*this += [this, id] {
BroadcastMessage("expiredContext", id);
};
}
void AutoNetServerImpl::NewObject(CoreContext& ctxt, const ObjectTraits& object){
int contextID = ResolveContextID(&ctxt);
*this += [this, object, contextID]{
Json::object objData;
Json::object types;
// Add object data
objData["name"] = autowiring::demangle(typeid(*object.pObject));
{
Json::array slots;
for(auto slot = object.stump.pHead; slot; slot = slot->pFlink) {
slots.push_back(Json::object{
{"name", autowiring::demangle(slot->type)},
{"autoRequired", slot->autoRequired},
{"offset", int(slot->slotOffset)}
});
}
objData["slots"] = slots;
}
// Add type information
auto member = object.pContextMember;
if(member) {
types["contextMember"] = true;
}
auto runnable = object.pCoreRunnable;
if(runnable) {
types["coreRunnable"] = true;
}
auto thread = object.pBasicThread;
if(thread) {
// Create slot in map
m_Threads[thread->GetSelf<BasicThread>()];
types["thread"] = Json::object{
{"kernal", 0.0},
{"user", 0.0}
};
}
// Check if type implements an AutoFilter
if (!object.subscriber.empty()) {
Json::object args;
for (auto pArg = object.subscriber.GetAutoFilterInput(); *pArg; ++pArg) {
args[autowiring::demangle(pArg->ti)] = Json::object{
{"isInput", pArg->is_input || pArg->tshift},
{"isOutput", pArg->is_output}
};
}
types["autoFilter"] = args;
}
// Check if type receives any events
{
Json::array listenerTypes;
for(const auto& event : m_EventTypes) {
if(event->IsSameAs(object.pObject.get()))
listenerTypes.push_back(autowiring::demangle(event->Type()));
}
if(!listenerTypes.empty())
types["eventReceiver"] = listenerTypes;
}
auto filter = object.pFilter;
if(filter) {
types["exceptionFilter"] = true;
}
auto bolt = object.pBoltBase;
if(bolt) {
Json::array sigils;
for(auto cur = bolt->GetContextSigils(); *cur; cur++){
sigils.push_back(autowiring::demangle(**cur));
}
types["bolt"] = sigils;
}
BroadcastMessage("newObject", contextID, types, objData);
};
}
void AutoNetServerImpl::EventFired(CoreContext& context, const std::type_info& info){
int contextID = ResolveContextID(&context);
std::string name = autowiring::demangle(info);
*this += [this, contextID, name] {
BroadcastMessage("eventFired", contextID, Json::object{{"name", name}});
};
}
void AutoNetServerImpl::HandleSubscribe(websocketpp::connection_hdl hdl) {
m_Subscribers.insert(hdl);
Json::array types;
for(const auto& type : m_AllTypes) {
types.push_back(type.first);
}
SendMessage(hdl, "subscribed", types);
GetContext()->BuildCurrentState();
// Send breakpoint message
for(const auto& breakpoint : m_breakpoints) {
SendMessage(hdl, "breakpoint", breakpoint);
}
}
void AutoNetServerImpl::HandleUnsubscribe(websocketpp::connection_hdl hdl) {
this->m_Subscribers.erase(hdl);
SendMessage(hdl, "unsubscribed");
}
void AutoNetServerImpl::HandleTerminateContext(int contextID) {
ResolveContextID(contextID)->SignalShutdown();
}
void AutoNetServerImpl::HandleInjectContextMember(int contextID, std::string typeName) {
std::shared_ptr<CoreContext> ctxt = ResolveContextID(contextID)->shared_from_this();
if(m_AllTypes.find(typeName) != m_AllTypes.end()) {
CurrentContextPusher pshr(ctxt);
m_AllTypes[typeName]();
}
else {
// Type doesn't exist
assert(false);
}
}
void AutoNetServerImpl::HandleResumeFromBreakpoint(std::string name){
std::unique_lock<std::mutex> lk(m_mutex);
m_breakpoints.erase(name);
m_breakpoint_cv.notify_all();
}
//helper functions
int AutoNetServerImpl::ResolveContextID(CoreContext* ctxt) {
static int counter = 0;
if(m_ContextIDs.find(ctxt) == m_ContextIDs.end()){
m_ContextIDs[ctxt] = counter;
m_ContextPtrs[counter] = ctxt;
return counter++;
}
else {
return m_ContextIDs[ctxt];
}
}
CoreContext* AutoNetServerImpl::ResolveContextID(int id) {
return m_ContextPtrs.at(id);
}
void AutoNetServerImpl::PollThreadUtilization(std::chrono::milliseconds period){
*this += period, [this, period] {
for(auto q = m_Threads.begin(); q != m_Threads.end();) {
std::shared_ptr<BasicThread> thread = q->first.lock();
if(!thread) {
m_Threads.erase(q++);
continue;
}
std::chrono::milliseconds runtimeKM, runtimeUM;
thread->GetThreadTimes(runtimeKM, runtimeUM);
// Determine the amount of time this thread has run since the last time we
// asked it for its runtime.
std::chrono::duration<double> deltaRuntimeKM = runtimeKM - q->second.m_lastRuntimeKM;
std::chrono::duration<double> deltaRuntimeUM = runtimeUM - q->second.m_lastRuntimeUM;
// Update timing values:
q->second.m_lastRuntimeKM = runtimeKM;
q->second.m_lastRuntimeUM = runtimeUM;
// Broadcast current thread utilization
int contextID = ResolveContextID(thread->GetContext().get());
std::string name = autowiring::demangle(typeid(*thread.get()));
std::chrono::duration<double> periodDbl = period;
double kmPercent = 100.0 * (deltaRuntimeKM.count() / periodDbl.count());
double umPercent = 100.0 * (deltaRuntimeUM.count() / periodDbl.count());
// Make sure user + kernel percent < 100.0
umPercent = std::min(umPercent, 99.9 - kmPercent);
if(kmPercent >= 0.0 && umPercent >= 0.0) {
BroadcastMessage("threadUtilization", contextID, name, kmPercent, umPercent);
}
// Next!
q++;
}
// Poll again after "period" milliseconds
PollThreadUtilization(period);
};
}
<|endoftext|> |
<commit_before>/*
OpenDeck MIDI platform firmware
Copyright (C) 2015-2018 Igor Petrovic
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Board.h"
#include "Variables.h"
volatile uint8_t digitalInBuffer[NUMBER_OF_BUTTON_COLUMNS];
volatile uint8_t digitalInBuffer_copy[NUMBER_OF_BUTTON_COLUMNS];
volatile uint8_t activeInColumn;
bool Board::digitalInputDataAvailable()
{
return (activeInColumn == NUMBER_OF_BUTTON_COLUMNS);
}
void Board::continueDigitalInReadout()
{
activeInColumn = 0;
}
<commit_msg>remove unused array<commit_after>/*
OpenDeck MIDI platform firmware
Copyright (C) 2015-2018 Igor Petrovic
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Board.h"
#include "Variables.h"
volatile uint8_t digitalInBuffer[NUMBER_OF_BUTTON_COLUMNS];
volatile uint8_t activeInColumn;
bool Board::digitalInputDataAvailable()
{
return (activeInColumn == NUMBER_OF_BUTTON_COLUMNS);
}
void Board::continueDigitalInReadout()
{
activeInColumn = 0;
}
<|endoftext|> |
<commit_before>////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Jan Steemann
////////////////////////////////////////////////////////////////////////////////
#include "RocksDBTransactionState.h"
#include "Aql/QueryCache.h"
#include "Basics/Exceptions.h"
#include "Cache/CacheManagerFeature.h"
#include "Cache/Manager.h"
#include "Cache/Transaction.h"
#include "Logger/Logger.h"
#include "RestServer/TransactionManagerFeature.h"
#include "RocksDBEngine/RocksDBCollection.h"
#include "RocksDBEngine/RocksDBCommon.h"
#include "RocksDBEngine/RocksDBCounterManager.h"
#include "RocksDBEngine/RocksDBEngine.h"
#include "RocksDBEngine/RocksDBTransactionCollection.h"
#include "StorageEngine/EngineSelectorFeature.h"
#include "StorageEngine/StorageEngine.h"
#include "StorageEngine/TransactionCollection.h"
#include "Transaction/Methods.h"
#include "VocBase/LogicalCollection.h"
#include "VocBase/TransactionManager.h"
#include "VocBase/modes.h"
#include "VocBase/ticks.h"
#include <rocksdb/db.h>
#include <rocksdb/options.h>
#include <rocksdb/status.h>
#include <rocksdb/utilities/optimistic_transaction_db.h>
#include <rocksdb/utilities/transaction.h>
using namespace arangodb;
struct RocksDBTransactionData final : public TransactionData {};
RocksDBSavePoint::RocksDBSavePoint(rocksdb::Transaction* trx)
: _trx(trx), _committed(false) {
_trx->SetSavePoint();
}
RocksDBSavePoint::~RocksDBSavePoint() {
if (!_committed) {
rollback();
}
}
void RocksDBSavePoint::commit() {
_committed = true; // this will prevent the rollback
}
void RocksDBSavePoint::rollback() {
_trx->RollbackToSavePoint();
_committed = true; // in order to not roll back again by accident
}
/// @brief transaction type
RocksDBTransactionState::RocksDBTransactionState(TRI_vocbase_t* vocbase)
: TransactionState(vocbase),
_rocksReadOptions(),
_cacheTx(nullptr),
_operationSize(0),
_numInserts(0),
_numUpdates(0),
_numRemoves(0) {}
/// @brief free a transaction container
RocksDBTransactionState::~RocksDBTransactionState() {}
/// @brief start a transaction
Result RocksDBTransactionState::beginTransaction(transaction::Hints hints) {
LOG_TRX(this, _nestingLevel) << "beginning " << AccessMode::typeString(_type)
<< " transaction";
if (_nestingLevel == 0) {
TRI_ASSERT(_status == transaction::Status::CREATED);
// get a new id
_id = TRI_NewTickServer();
// register a protector
auto data =
std::make_unique<RocksDBTransactionData>(); // intentionally empty
TransactionManagerFeature::MANAGER->registerTransaction(_id,
std::move(data));
TRI_ASSERT(_rocksTransaction == nullptr);
TRI_ASSERT(_cacheTx == nullptr);
// start cache transaction
_cacheTx = CacheManagerFeature::MANAGER->beginTransaction(isReadOnlyTransaction());
// start rocks transaction
StorageEngine* engine = EngineSelectorFeature::ENGINE;
rocksdb::TransactionDB* db = static_cast<RocksDBEngine*>(engine)->db();
_rocksTransaction.reset(db->BeginTransaction(
_rocksWriteOptions, rocksdb::TransactionOptions()));
_rocksTransaction->SetSnapshot();
_rocksReadOptions.snapshot = _rocksTransaction->GetSnapshot();
} else {
TRI_ASSERT(_status == transaction::Status::RUNNING);
}
Result result = useCollections(_nestingLevel);
if (result.ok()) {
// all valid
if (_nestingLevel == 0) {
updateStatus(transaction::Status::RUNNING);
}
} else {
// something is wrong
if (_nestingLevel == 0) {
updateStatus(transaction::Status::ABORTED);
}
// free what we have got so far
unuseCollections(_nestingLevel);
}
return result;
}
/// @brief commit a transaction
Result RocksDBTransactionState::commitTransaction(
transaction::Methods* activeTrx) {
LOG_TRX(this, _nestingLevel) << "committing " << AccessMode::typeString(_type)
<< " transaction";
TRI_ASSERT(_status == transaction::Status::RUNNING);
arangodb::Result result;
if (_nestingLevel == 0) {
if (_rocksTransaction != nullptr) {
// set wait for sync flag if required
if (waitForSync()) {
_rocksWriteOptions.sync = true;
}
result = rocksutils::convertStatus(_rocksTransaction->Commit());
if (!result.ok()) {
// TODO: translate status
abortTransaction(activeTrx);
return result;
}
rocksdb::Snapshot const* snap = this->_rocksReadOptions.snapshot;
for (auto& trxCollection : _collections) {
RocksDBTransactionCollection* collection = static_cast<RocksDBTransactionCollection*>(trxCollection);
int64_t adjustment = collection->numInserts() - collection->numRemoves();
RocksDBCollection *coll = static_cast<RocksDBCollection*>(trxCollection->collection()->getPhysical());
coll->adjustNumberDocuments(adjustment);
if (collection->numInserts() != 0 || collection->numRemoves() != 0) {
RocksDBEngine* engine = static_cast<RocksDBEngine*>(EngineSelectorFeature::ENGINE);
engine->counterManager()->updateCounter(coll->objectId(), snap, coll->numberDocuments());
}
}
_rocksTransaction.reset();
if (_cacheTx != nullptr) {
CacheManagerFeature::MANAGER->endTransaction(_cacheTx);
_cacheTx = nullptr;
}
}
updateStatus(transaction::Status::COMMITTED);
// if a write query, clear the query cache for the participating collections
if (AccessMode::isWriteOrExclusive(_type) && !_collections.empty() &&
arangodb::aql::QueryCache::instance()->mayBeActive()) {
clearQueryCache();
}
}
unuseCollections(_nestingLevel);
return result;
}
/// @brief abort and rollback a transaction
Result RocksDBTransactionState::abortTransaction(
transaction::Methods* activeTrx) {
LOG_TRX(this, _nestingLevel) << "aborting " << AccessMode::typeString(_type)
<< " transaction";
TRI_ASSERT(_status == transaction::Status::RUNNING);
Result result;
if (_nestingLevel == 0) {
if (_rocksTransaction != nullptr) {
rocksdb::Status status = _rocksTransaction->Rollback();
result = rocksutils::convertStatus(status);
_rocksTransaction.reset();
}
if (_cacheTx != nullptr) {
CacheManagerFeature::MANAGER->endTransaction(_cacheTx);
_cacheTx = nullptr;
}
updateStatus(transaction::Status::ABORTED);
if (hasOperations()) {
// must clean up the query cache because the transaction
// may have queried something via AQL that is now rolled back
clearQueryCache();
}
}
unuseCollections(_nestingLevel);
return result;
}
/// @brief add an operation for a transaction collection
void RocksDBTransactionState::addOperation(TRI_voc_cid_t cid,
TRI_voc_document_operation_e operationType,
uint64_t operationSize) {
auto collection = static_cast<RocksDBTransactionCollection*>(findCollection(cid));
if (collection == nullptr) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "collection not found in transaction state");
}
collection->addOperation(operationType, operationSize);
switch (operationType) {
case TRI_VOC_DOCUMENT_OPERATION_UNKNOWN:
break;
case TRI_VOC_DOCUMENT_OPERATION_INSERT:
++_numInserts;
break;
case TRI_VOC_DOCUMENT_OPERATION_UPDATE:
case TRI_VOC_DOCUMENT_OPERATION_REPLACE:
++_numUpdates;
break;
case TRI_VOC_DOCUMENT_OPERATION_REMOVE:
++_numRemoves;
break;
}
_operationSize += operationSize;
}
<commit_msg>fix memleak<commit_after>////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Jan Steemann
////////////////////////////////////////////////////////////////////////////////
#include "RocksDBTransactionState.h"
#include "Aql/QueryCache.h"
#include "Basics/Exceptions.h"
#include "Cache/CacheManagerFeature.h"
#include "Cache/Manager.h"
#include "Cache/Transaction.h"
#include "Logger/Logger.h"
#include "RestServer/TransactionManagerFeature.h"
#include "RocksDBEngine/RocksDBCollection.h"
#include "RocksDBEngine/RocksDBCommon.h"
#include "RocksDBEngine/RocksDBCounterManager.h"
#include "RocksDBEngine/RocksDBEngine.h"
#include "RocksDBEngine/RocksDBTransactionCollection.h"
#include "StorageEngine/EngineSelectorFeature.h"
#include "StorageEngine/StorageEngine.h"
#include "StorageEngine/TransactionCollection.h"
#include "Transaction/Methods.h"
#include "VocBase/LogicalCollection.h"
#include "VocBase/TransactionManager.h"
#include "VocBase/modes.h"
#include "VocBase/ticks.h"
#include <rocksdb/db.h>
#include <rocksdb/options.h>
#include <rocksdb/status.h>
#include <rocksdb/utilities/optimistic_transaction_db.h>
#include <rocksdb/utilities/transaction.h>
using namespace arangodb;
struct RocksDBTransactionData final : public TransactionData {};
RocksDBSavePoint::RocksDBSavePoint(rocksdb::Transaction* trx)
: _trx(trx), _committed(false) {
_trx->SetSavePoint();
}
RocksDBSavePoint::~RocksDBSavePoint() {
if (!_committed) {
rollback();
}
}
void RocksDBSavePoint::commit() {
_committed = true; // this will prevent the rollback
}
void RocksDBSavePoint::rollback() {
_trx->RollbackToSavePoint();
_committed = true; // in order to not roll back again by accident
}
/// @brief transaction type
RocksDBTransactionState::RocksDBTransactionState(TRI_vocbase_t* vocbase)
: TransactionState(vocbase),
_rocksReadOptions(),
_cacheTx(nullptr),
_operationSize(0),
_numInserts(0),
_numUpdates(0),
_numRemoves(0) {}
/// @brief free a transaction container
RocksDBTransactionState::~RocksDBTransactionState() {
if (_cacheTx != nullptr) {
// note: endTransaction() will delete _cacheTrx!
CacheManagerFeature::MANAGER->endTransaction(_cacheTx);
_cacheTx = nullptr;
}
}
/// @brief start a transaction
Result RocksDBTransactionState::beginTransaction(transaction::Hints hints) {
LOG_TRX(this, _nestingLevel) << "beginning " << AccessMode::typeString(_type)
<< " transaction";
if (_nestingLevel == 0) {
TRI_ASSERT(_status == transaction::Status::CREATED);
// get a new id
_id = TRI_NewTickServer();
// register a protector
auto data =
std::make_unique<RocksDBTransactionData>(); // intentionally empty
TransactionManagerFeature::MANAGER->registerTransaction(_id,
std::move(data));
TRI_ASSERT(_rocksTransaction == nullptr);
TRI_ASSERT(_cacheTx == nullptr);
// start cache transaction
_cacheTx = CacheManagerFeature::MANAGER->beginTransaction(isReadOnlyTransaction());
// start rocks transaction
StorageEngine* engine = EngineSelectorFeature::ENGINE;
rocksdb::TransactionDB* db = static_cast<RocksDBEngine*>(engine)->db();
_rocksTransaction.reset(db->BeginTransaction(
_rocksWriteOptions, rocksdb::TransactionOptions()));
_rocksTransaction->SetSnapshot();
_rocksReadOptions.snapshot = _rocksTransaction->GetSnapshot();
} else {
TRI_ASSERT(_status == transaction::Status::RUNNING);
}
Result result = useCollections(_nestingLevel);
if (result.ok()) {
// all valid
if (_nestingLevel == 0) {
updateStatus(transaction::Status::RUNNING);
}
} else {
// something is wrong
if (_nestingLevel == 0) {
updateStatus(transaction::Status::ABORTED);
}
// free what we have got so far
unuseCollections(_nestingLevel);
}
return result;
}
/// @brief commit a transaction
Result RocksDBTransactionState::commitTransaction(
transaction::Methods* activeTrx) {
LOG_TRX(this, _nestingLevel) << "committing " << AccessMode::typeString(_type)
<< " transaction";
TRI_ASSERT(_status == transaction::Status::RUNNING);
arangodb::Result result;
if (_nestingLevel == 0) {
if (_cacheTx != nullptr) {
// note: endTransaction() will delete _cacheTrx!
CacheManagerFeature::MANAGER->endTransaction(_cacheTx);
_cacheTx = nullptr;
}
if (_rocksTransaction != nullptr) {
// set wait for sync flag if required
if (waitForSync()) {
_rocksWriteOptions.sync = true;
}
result = rocksutils::convertStatus(_rocksTransaction->Commit());
if (!result.ok()) {
// TODO: translate status
abortTransaction(activeTrx);
return result;
}
rocksdb::Snapshot const* snap = this->_rocksReadOptions.snapshot;
for (auto& trxCollection : _collections) {
RocksDBTransactionCollection* collection = static_cast<RocksDBTransactionCollection*>(trxCollection);
int64_t adjustment = collection->numInserts() - collection->numRemoves();
RocksDBCollection *coll = static_cast<RocksDBCollection*>(trxCollection->collection()->getPhysical());
coll->adjustNumberDocuments(adjustment);
if (collection->numInserts() != 0 || collection->numRemoves() != 0) {
RocksDBEngine* engine = static_cast<RocksDBEngine*>(EngineSelectorFeature::ENGINE);
engine->counterManager()->updateCounter(coll->objectId(), snap, coll->numberDocuments());
}
}
_rocksTransaction.reset();
}
updateStatus(transaction::Status::COMMITTED);
// if a write query, clear the query cache for the participating collections
if (AccessMode::isWriteOrExclusive(_type) && !_collections.empty() &&
arangodb::aql::QueryCache::instance()->mayBeActive()) {
clearQueryCache();
}
}
unuseCollections(_nestingLevel);
return result;
}
/// @brief abort and rollback a transaction
Result RocksDBTransactionState::abortTransaction(
transaction::Methods* activeTrx) {
LOG_TRX(this, _nestingLevel) << "aborting " << AccessMode::typeString(_type)
<< " transaction";
TRI_ASSERT(_status == transaction::Status::RUNNING);
Result result;
if (_nestingLevel == 0) {
if (_cacheTx != nullptr) {
// note: endTransaction() will delete _cacheTrx!
CacheManagerFeature::MANAGER->endTransaction(_cacheTx);
_cacheTx = nullptr;
}
if (_rocksTransaction != nullptr) {
rocksdb::Status status = _rocksTransaction->Rollback();
result = rocksutils::convertStatus(status);
_rocksTransaction.reset();
}
updateStatus(transaction::Status::ABORTED);
if (hasOperations()) {
// must clean up the query cache because the transaction
// may have queried something via AQL that is now rolled back
clearQueryCache();
}
}
unuseCollections(_nestingLevel);
return result;
}
/// @brief add an operation for a transaction collection
void RocksDBTransactionState::addOperation(TRI_voc_cid_t cid,
TRI_voc_document_operation_e operationType,
uint64_t operationSize) {
auto collection = static_cast<RocksDBTransactionCollection*>(findCollection(cid));
if (collection == nullptr) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "collection not found in transaction state");
}
collection->addOperation(operationType, operationSize);
switch (operationType) {
case TRI_VOC_DOCUMENT_OPERATION_UNKNOWN:
break;
case TRI_VOC_DOCUMENT_OPERATION_INSERT:
++_numInserts;
break;
case TRI_VOC_DOCUMENT_OPERATION_UPDATE:
case TRI_VOC_DOCUMENT_OPERATION_REPLACE:
++_numUpdates;
break;
case TRI_VOC_DOCUMENT_OPERATION_REMOVE:
++_numRemoves;
break;
}
_operationSize += operationSize;
}
<|endoftext|> |
<commit_before>//===----------------------------------------------------------------------===//
//
// Peloton
//
// packet_manager_test.cpp
//
// Identification: test/wire/packet_manager_test.cpp
//
// Copyright (c) 2016-17, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "common/harness.h"
#include "gtest/gtest.h"
#include "common/logger.h"
#include "wire/libevent_server.h"
#include <pqxx/pqxx>
#define NUM_THREADS 1
namespace peloton {
namespace test {
//===--------------------------------------------------------------------===//
// Packet Manager Tests
//===--------------------------------------------------------------------===//
class PacketManagerTests : public PelotonTest {};
static void *LaunchServer(peloton::wire::LibeventServer libeventserver) {
try {
// Setup
// peloton::PelotonInit::Initialize();
// LOG_INFO("Server initialized\n");
// Launch server
// peloton::wire::LibeventServer libeventserver;
libeventserver.StartServer();
// Teardown
// Todo: Peloton cannot shut down normally, will try to fix this soon
// peloton::PelotonInit::Shutdown();
// LOG_INFO("Peloton has shut down\n");
} catch (peloton::ConnectionException exception) {
// Nothing to do here!
LOG_INFO("There is exception in thread");
}
return NULL;
}
static void *SimpleQueryTest(void *) {
try {
pqxx::connection C(
"host=127.0.0.1 port=15721 user=postgres sslmode=disable");
LOG_INFO("Connected to %s", C.dbname());
pqxx::work W(C);
// create table and insert some data
W.exec("DROP TABLE IF EXISTS employee;");
W.exec("CREATE TABLE employee(id INT, name VARCHAR(100));");
W.exec("INSERT INTO employee VALUES (1, 'Han LI');");
W.exec("INSERT INTO employee VALUES (2, 'Shaokun ZOU');");
W.exec("INSERT INTO employee VALUES (3, 'Yilei CHU');");
pqxx::result R = W.exec("SELECT name FROM employee where id=1;");
EXPECT_EQ(R.size(), 1);
LOG_INFO("Found %lu employees", R.size());
W.commit();
} catch (const std::exception &e) {
LOG_INFO("Exception occurred");
}
LOG_INFO("Client has closed");
return NULL;
}
TEST_F(PacketManagerTests, SimpleQueryTest) {
peloton::PelotonInit::Initialize();
LOG_INFO("Server initialized");
peloton::wire::LibeventServer libeventserver;
std::thread serverThread(LaunchServer, libeventserver);
while (!libeventserver.is_started) {
sleep(1);
}
SimpleQueryTest(NULL);
libeventserver.CloseServer();
serverThread.join();
LOG_INFO("Thread has joined");
peloton::PelotonInit::Shutdown();
LOG_INFO("Peloton has shut down\n");
}
} // End test namespace
} // End peloton namespace
<commit_msg>Add prepared statement test<commit_after>//===----------------------------------------------------------------------===//
//
// Peloton
//
// packet_manager_test.cpp
//
// Identification: test/wire/packet_manager_test.cpp
//
// Copyright (c) 2016-17, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "common/harness.h"
#include "gtest/gtest.h"
#include "common/logger.h"
#include "wire/libevent_server.h"
#include <pqxx/pqxx> /* libpqxx is used to instantiate C++ client */
#define NUM_THREADS 1
namespace peloton {
namespace test {
//===--------------------------------------------------------------------===//
// Packet Manager Tests
//===--------------------------------------------------------------------===//
class PacketManagerTests : public PelotonTest {};
static void *LaunchServer(peloton::wire::LibeventServer libeventserver) {
try {
libeventserver.StartServer();
} catch (peloton::ConnectionException exception) {
LOG_INFO("[LaunchServer] exception in thread");
}
return NULL;
}
/**
* Simple select query test
*/
static void *SimpleQueryTest(void *) {
try {
pqxx::connection C(
"host=127.0.0.1 port=15721 user=postgres sslmode=disable");
LOG_INFO("[SimpleQueryTest] Connected to %s", C.dbname());
pqxx::work W(C);
// create table and insert some data
W.exec("DROP TABLE IF EXISTS employee;");
W.exec("CREATE TABLE employee(id INT, name VARCHAR(100));");
W.exec("INSERT INTO employee VALUES (1, 'Han LI');");
W.exec("INSERT INTO employee VALUES (2, 'Shaokun ZOU');");
W.exec("INSERT INTO employee VALUES (3, 'Yilei CHU');");
pqxx::result R = W.exec("SELECT name FROM employee where id=1;");
EXPECT_EQ(R.size(), 1);
LOG_INFO("[SimpleQueryTest] Found %lu employees", R.size());
W.commit();
} catch (const std::exception &e) {
LOG_INFO("[SimpleQueryTest] Exception occurred");
}
LOG_INFO("[SimpleQueryTest] Client has closed");
return NULL;
}
/**
* named prepare statement test
*/
static void *PrepareStatementTest(void *) {
try {
pqxx::connection C(
"host=127.0.0.1 port=15721 user=postgres sslmode=disable");
LOG_INFO("[PrepareStatementTest] Connected to %s", C.dbname());
pqxx::work W(C);
// create table and insert some data
W.exec("DROP TABLE IF EXISTS employee;");
W.exec("CREATE TABLE employee(id INT, name VARCHAR(100));");
W.exec("INSERT INTO employee VALUES (1, 'Han LI');");
W.exec("INSERT INTO employee VALUES (2, 'Shaokun ZOU');");
W.exec("INSERT INTO employee VALUES (3, 'Yilei CHU');");
// test prepare statement
C.prepare("searchstmt","SELECT name FROM employee WHERE id=1;");
// invocation as in variable binding
pqxx::result R = W.prepared("searchstmt").exec();
W.commit();
LOG_INFO("Prepare statement search result:%lu",R.size());
} catch (const std::exception &e) {
LOG_INFO("[PrepareStatementTest] Exception occurred");
}
LOG_INFO("[PrepareStatementTest] Client has closed");
return NULL;
}
/**
* Use std::thread to initiate peloton server and pqxx client in separate threads
* Simple query test to guarantee both sides run correctly
* Callback method to close server after client finishes
*/
TEST_F(PacketManagerTests, SimpleQueryTest) {
peloton::PelotonInit::Initialize();
LOG_INFO("Server initialized");
peloton::wire::LibeventServer libeventserver;
std::thread serverThread(LaunchServer, libeventserver);
while (!libeventserver.is_started) {
sleep(1);
}
/* server & client running correctly */
SimpleQueryTest(NULL);
/* TODO: monitor packet_manager's status when receiving prepare statement from client */
PrepareStatementTest(NULL);
libeventserver.CloseServer();
serverThread.join();
LOG_INFO("Thread has joined");
peloton::PelotonInit::Shutdown();
LOG_INFO("Peloton has shut down\n");
}
//TEST_F(PacketManagerTests, PrepareStatementTest) {
// peloton::PelotonInit::Initialize();
// LOG_INFO("Server initialized");
// peloton::wire::LibeventServer libeventserver;
// std::thread serverThread(LaunchServer, libeventserver);
// while (!libeventserver.is_started) {
// sleep(1);
// }
//
// PrepareStatementTest(NULL);
//// SimpleQueryTest(NULL);
//
// libeventserver.CloseServer();
// serverThread.join();
// LOG_INFO("Thread has joined");
// peloton::PelotonInit::Shutdown();
// LOG_INFO("Peloton has shut down\n");
//}
} // End test namespace
} // End peloton namespace
<|endoftext|> |
<commit_before>/**
* AES
* (C) 1999-2009 Jack Lloyd
*
* Distributed under the terms of the Botan license
*/
#include <botan/aes_intel.h>
#include <wmmintrin.h>
namespace Botan {
namespace {
__m128i aes_128_key_expansion(__m128i key, __m128i key_with_rcon)
{
key_with_rcon = _mm_shuffle_epi32(key_with_rcon, 0xff);
__m128i T = _mm_slli_si128 (key, 0x4);
key = _mm_xor_si128 (key, T);
T = _mm_slli_si128 (T, 0x4);
key = _mm_xor_si128 (key, T);
T = _mm_slli_si128 (T, 0x4);
key = _mm_xor_si128 (key, T);
key = _mm_xor_si128 (key, key_with_rcon);
return key;
}
}
/**
* AES Encryption
*/
void AES_128_Intel::encrypt_n(const byte in[], byte out[], u32bit blocks) const
{
const __m128i* in_mm = (const __m128i*)in;
__m128i* out_mm = (__m128i*)out;
const __m128i* key_mm = (const __m128i*)&EK[0];
__m128i K0 = _mm_loadu_si128(key_mm);
__m128i K1 = _mm_loadu_si128(key_mm + 1);
__m128i K2 = _mm_loadu_si128(key_mm + 2);
__m128i K3 = _mm_loadu_si128(key_mm + 3);
__m128i K4 = _mm_loadu_si128(key_mm + 4);
__m128i K5 = _mm_loadu_si128(key_mm + 5);
__m128i K6 = _mm_loadu_si128(key_mm + 6);
__m128i K7 = _mm_loadu_si128(key_mm + 7);
__m128i K8 = _mm_loadu_si128(key_mm + 8);
__m128i K9 = _mm_loadu_si128(key_mm + 9);
__m128i K10 = _mm_loadu_si128(key_mm + 10);
for(u32bit i = 0; i != blocks; ++i)
{
__m128i B = _mm_loadu_si128(in_mm + i);
B = _mm_xor_si128(B, K0);
B = _mm_aesenc_si128(B, K1);
B = _mm_aesenc_si128(B, K2);
B = _mm_aesenc_si128(B, K3);
B = _mm_aesenc_si128(B, K4);
B = _mm_aesenc_si128(B, K5);
B = _mm_aesenc_si128(B, K6);
B = _mm_aesenc_si128(B, K7);
B = _mm_aesenc_si128(B, K8);
B = _mm_aesenc_si128(B, K9);
B = _mm_aesenclast_si128(B, K10);
_mm_storeu_si128(out_mm + i, B);
in += BLOCK_SIZE;
out += BLOCK_SIZE;
}
}
/**
* AES Decryption
*/
void AES_128_Intel::decrypt_n(const byte in[], byte out[], u32bit blocks) const
{
const __m128i* in_mm = (const __m128i*)in;
__m128i* out_mm = (__m128i*)out;
const __m128i* key_mm = (const __m128i*)&DK[0];
__m128i K0 = _mm_loadu_si128(key_mm);
__m128i K1 = _mm_loadu_si128(key_mm + 1);
__m128i K2 = _mm_loadu_si128(key_mm + 2);
__m128i K3 = _mm_loadu_si128(key_mm + 3);
__m128i K4 = _mm_loadu_si128(key_mm + 4);
__m128i K5 = _mm_loadu_si128(key_mm + 5);
__m128i K6 = _mm_loadu_si128(key_mm + 6);
__m128i K7 = _mm_loadu_si128(key_mm + 7);
__m128i K8 = _mm_loadu_si128(key_mm + 8);
__m128i K9 = _mm_loadu_si128(key_mm + 9);
__m128i K10 = _mm_loadu_si128(key_mm + 10);
for(u32bit i = 0; i != blocks; ++i)
{
__m128i B = _mm_loadu_si128(in_mm + i);
B = _mm_xor_si128(B, K0);
B = _mm_aesdec_si128(B, K1);
B = _mm_aesdec_si128(B, K2);
B = _mm_aesdec_si128(B, K3);
B = _mm_aesdec_si128(B, K4);
B = _mm_aesdec_si128(B, K5);
B = _mm_aesdec_si128(B, K6);
B = _mm_aesdec_si128(B, K7);
B = _mm_aesdec_si128(B, K8);
B = _mm_aesdec_si128(B, K9);
B = _mm_aesdeclast_si128(B, K10);
_mm_storeu_si128(out_mm + i, B);
in += BLOCK_SIZE;
out += BLOCK_SIZE;
}
}
/**
* AES Key Schedule
*/
void AES_128_Intel::key_schedule(const byte key[], u32bit)
{
#define AES_128_key_exp_with_rcon(K, RCON) \
aes_128_key_expansion(K, _mm_aeskeygenassist_si128(K, RCON));
__m128i K0 = _mm_loadu_si128((const __m128i*)key);
__m128i K1 = AES_128_key_exp_with_rcon(K0, 0x01);
__m128i K2 = AES_128_key_exp_with_rcon(K1, 0x02);
__m128i K3 = AES_128_key_exp_with_rcon(K2, 0x04);
__m128i K4 = AES_128_key_exp_with_rcon(K3, 0x08);
__m128i K5 = AES_128_key_exp_with_rcon(K4, 0x10);
__m128i K6 = AES_128_key_exp_with_rcon(K5, 0x20);
__m128i K7 = AES_128_key_exp_with_rcon(K6, 0x40);
__m128i K8 = AES_128_key_exp_with_rcon(K7, 0x80);
__m128i K9 = AES_128_key_exp_with_rcon(K8, 0x1B);
__m128i K10 = AES_128_key_exp_with_rcon(K9, 0x36);
__m128i* EK_mm = (__m128i*)&EK[0];
_mm_storeu_si128(EK_mm , K0);
_mm_storeu_si128(EK_mm + 1, K1);
_mm_storeu_si128(EK_mm + 2, K2);
_mm_storeu_si128(EK_mm + 3, K3);
_mm_storeu_si128(EK_mm + 4, K4);
_mm_storeu_si128(EK_mm + 5, K5);
_mm_storeu_si128(EK_mm + 6, K6);
_mm_storeu_si128(EK_mm + 7, K7);
_mm_storeu_si128(EK_mm + 8, K8);
_mm_storeu_si128(EK_mm + 9, K9);
_mm_storeu_si128(EK_mm + 10, K10);
// Now generate decryption keys
__m128i* DK_mm = (__m128i*)&DK[0];
_mm_storeu_si128(DK_mm , K10);
_mm_storeu_si128(DK_mm + 1, _mm_aesimc_si128(K9));
_mm_storeu_si128(DK_mm + 2, _mm_aesimc_si128(K8));
_mm_storeu_si128(DK_mm + 3, _mm_aesimc_si128(K7));
_mm_storeu_si128(DK_mm + 4, _mm_aesimc_si128(K6));
_mm_storeu_si128(DK_mm + 5, _mm_aesimc_si128(K5));
_mm_storeu_si128(DK_mm + 6, _mm_aesimc_si128(K4));
_mm_storeu_si128(DK_mm + 7, _mm_aesimc_si128(K3));
_mm_storeu_si128(DK_mm + 8, _mm_aesimc_si128(K2));
_mm_storeu_si128(DK_mm + 9, _mm_aesimc_si128(K1));
_mm_storeu_si128(DK_mm + 10, K0);
}
/**
* Clear memory of sensitive data
*/
void AES_128_Intel::clear()
{
EK.clear();
DK.clear();
}
}
<commit_msg>Clean up aes_128_key_expansion<commit_after>/**
* AES
* (C) 1999-2009 Jack Lloyd
*
* Distributed under the terms of the Botan license
*/
#include <botan/aes_intel.h>
#include <wmmintrin.h>
namespace Botan {
namespace {
__m128i aes_128_key_expansion(__m128i key, __m128i key_with_rcon)
{
key_with_rcon = _mm_shuffle_epi32(key_with_rcon, _MM_SHUFFLE(3,3,3,3));
key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
return _mm_xor_si128(key, key_with_rcon);
}
}
/**
* AES Encryption
*/
void AES_128_Intel::encrypt_n(const byte in[], byte out[], u32bit blocks) const
{
const __m128i* in_mm = (const __m128i*)in;
__m128i* out_mm = (__m128i*)out;
const __m128i* key_mm = (const __m128i*)&EK[0];
__m128i K0 = _mm_loadu_si128(key_mm);
__m128i K1 = _mm_loadu_si128(key_mm + 1);
__m128i K2 = _mm_loadu_si128(key_mm + 2);
__m128i K3 = _mm_loadu_si128(key_mm + 3);
__m128i K4 = _mm_loadu_si128(key_mm + 4);
__m128i K5 = _mm_loadu_si128(key_mm + 5);
__m128i K6 = _mm_loadu_si128(key_mm + 6);
__m128i K7 = _mm_loadu_si128(key_mm + 7);
__m128i K8 = _mm_loadu_si128(key_mm + 8);
__m128i K9 = _mm_loadu_si128(key_mm + 9);
__m128i K10 = _mm_loadu_si128(key_mm + 10);
for(u32bit i = 0; i != blocks; ++i)
{
__m128i B = _mm_loadu_si128(in_mm + i);
B = _mm_xor_si128(B, K0);
B = _mm_aesenc_si128(B, K1);
B = _mm_aesenc_si128(B, K2);
B = _mm_aesenc_si128(B, K3);
B = _mm_aesenc_si128(B, K4);
B = _mm_aesenc_si128(B, K5);
B = _mm_aesenc_si128(B, K6);
B = _mm_aesenc_si128(B, K7);
B = _mm_aesenc_si128(B, K8);
B = _mm_aesenc_si128(B, K9);
B = _mm_aesenclast_si128(B, K10);
_mm_storeu_si128(out_mm + i, B);
in += BLOCK_SIZE;
out += BLOCK_SIZE;
}
}
/**
* AES Decryption
*/
void AES_128_Intel::decrypt_n(const byte in[], byte out[], u32bit blocks) const
{
const __m128i* in_mm = (const __m128i*)in;
__m128i* out_mm = (__m128i*)out;
const __m128i* key_mm = (const __m128i*)&DK[0];
__m128i K0 = _mm_loadu_si128(key_mm);
__m128i K1 = _mm_loadu_si128(key_mm + 1);
__m128i K2 = _mm_loadu_si128(key_mm + 2);
__m128i K3 = _mm_loadu_si128(key_mm + 3);
__m128i K4 = _mm_loadu_si128(key_mm + 4);
__m128i K5 = _mm_loadu_si128(key_mm + 5);
__m128i K6 = _mm_loadu_si128(key_mm + 6);
__m128i K7 = _mm_loadu_si128(key_mm + 7);
__m128i K8 = _mm_loadu_si128(key_mm + 8);
__m128i K9 = _mm_loadu_si128(key_mm + 9);
__m128i K10 = _mm_loadu_si128(key_mm + 10);
for(u32bit i = 0; i != blocks; ++i)
{
__m128i B = _mm_loadu_si128(in_mm + i);
B = _mm_xor_si128(B, K0);
B = _mm_aesdec_si128(B, K1);
B = _mm_aesdec_si128(B, K2);
B = _mm_aesdec_si128(B, K3);
B = _mm_aesdec_si128(B, K4);
B = _mm_aesdec_si128(B, K5);
B = _mm_aesdec_si128(B, K6);
B = _mm_aesdec_si128(B, K7);
B = _mm_aesdec_si128(B, K8);
B = _mm_aesdec_si128(B, K9);
B = _mm_aesdeclast_si128(B, K10);
_mm_storeu_si128(out_mm + i, B);
in += BLOCK_SIZE;
out += BLOCK_SIZE;
}
}
/**
* AES Key Schedule
*/
void AES_128_Intel::key_schedule(const byte key[], u32bit length)
{
#define AES_128_key_exp(K, RCON) \
aes_128_key_expansion(K, _mm_aeskeygenassist_si128(K, RCON))
__m128i K0 = _mm_loadu_si128((const __m128i*)key);
__m128i K1 = AES_128_key_exp(K0, 0x01);
__m128i K2 = AES_128_key_exp(K1, 0x02);
__m128i K3 = AES_128_key_exp(K2, 0x04);
__m128i K4 = AES_128_key_exp(K3, 0x08);
__m128i K5 = AES_128_key_exp(K4, 0x10);
__m128i K6 = AES_128_key_exp(K5, 0x20);
__m128i K7 = AES_128_key_exp(K6, 0x40);
__m128i K8 = AES_128_key_exp(K7, 0x80);
__m128i K9 = AES_128_key_exp(K8, 0x1B);
__m128i K10 = AES_128_key_exp(K9, 0x36);
__m128i* EK_mm = (__m128i*)&EK[0];
_mm_storeu_si128(EK_mm , K0);
_mm_storeu_si128(EK_mm + 1, K1);
_mm_storeu_si128(EK_mm + 2, K2);
_mm_storeu_si128(EK_mm + 3, K3);
_mm_storeu_si128(EK_mm + 4, K4);
_mm_storeu_si128(EK_mm + 5, K5);
_mm_storeu_si128(EK_mm + 6, K6);
_mm_storeu_si128(EK_mm + 7, K7);
_mm_storeu_si128(EK_mm + 8, K8);
_mm_storeu_si128(EK_mm + 9, K9);
_mm_storeu_si128(EK_mm + 10, K10);
// Now generate decryption keys
__m128i* DK_mm = (__m128i*)&DK[0];
_mm_storeu_si128(DK_mm , K10);
_mm_storeu_si128(DK_mm + 1, _mm_aesimc_si128(K9));
_mm_storeu_si128(DK_mm + 2, _mm_aesimc_si128(K8));
_mm_storeu_si128(DK_mm + 3, _mm_aesimc_si128(K7));
_mm_storeu_si128(DK_mm + 4, _mm_aesimc_si128(K6));
_mm_storeu_si128(DK_mm + 5, _mm_aesimc_si128(K5));
_mm_storeu_si128(DK_mm + 6, _mm_aesimc_si128(K4));
_mm_storeu_si128(DK_mm + 7, _mm_aesimc_si128(K3));
_mm_storeu_si128(DK_mm + 8, _mm_aesimc_si128(K2));
_mm_storeu_si128(DK_mm + 9, _mm_aesimc_si128(K1));
_mm_storeu_si128(DK_mm + 10, K0);
}
/**
* Clear memory of sensitive data
*/
void AES_128_Intel::clear()
{
EK.clear();
DK.clear();
}
}
<|endoftext|> |
<commit_before>/* bzflag
* Copyright (c) 1993 - 2004 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named LICENSE that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
// Provide BZFS with a list server connection
/* class header */
#include "ListServerConnection.h"
/* implementation headers */
#include <string.h>
#include <math.h>
#include "bzfio.h"
#include "version.h"
#include "TextUtils.h"
#include "protocol.h"
extern Address serverAddress;
extern PingPacket getTeamCounts();
ListServerLink::ListServerLink(std::string listServerURL, std::string publicizedAddress, std::string publicizedTitle)
{
// parse url
std::string protocol, hostname, pathname;
int port = 80;
bool useDefault = false;
// use default if it can't be parsed
if (!BzfNetwork::parseURL(listServerURL, protocol, hostname, port, pathname))
useDefault = true;
// use default if wrong protocol or invalid port
if ((protocol != "http") || (port < 1) || (port > 65535))
useDefault = true;
// use default if bad address
Address address = Address::getHostAddress(hostname.c_str());
if (address.isAny())
useDefault = true;
// parse default list server URL if we need to; assume default works
if (useDefault) {
BzfNetwork::parseURL(DefaultListServerURL, protocol, hostname, port, pathname);
DEBUG1("Provided list server URL (%s) is invalid. Using default of %s.", listServerURL.c_str(), DefaultListServerURL);
}
// add to list
this->address = address;
this->port = port;
this->pathname = pathname;
this->hostname = hostname;
this->linkSocket = NotConnected;
this->publicizeAddress = publicizedAddress;
this->publicizeDescription = publicizedTitle;
this->publicizeServer = true; //if this c'tor is called, it's safe to publicize
// schedule initial ADD message
queueMessage(ListServerLink::ADD);
}
ListServerLink::ListServerLink()
{
// does not create a usable link, so checks should be placed
// in all public member functions to ensure that nothing tries
// to happen if publicizeServer is false
this->linkSocket = NotConnected;
this->publicizeServer = false;
}
ListServerLink::~ListServerLink()
{
// now tell the list server that we're going away. this can
// take some time but we don't want to wait too long. we do
// our own multiplexing loop and wait for a maximum of 3 seconds
// total.
// if we aren't supposed to be publicizing, skip the whole thing
// and don't waste 3 seconds.
if (!publicizeServer)
return;
queueMessage(ListServerLink::REMOVE);
TimeKeeper start = TimeKeeper::getCurrent();
do {
// compute timeout
float waitTime = 3.0f - (TimeKeeper::getCurrent() - start);
if (waitTime <= 0.0f)
break;
if (!isConnected()) //queueMessage should have connected us
break;
// check for list server socket connection
int fdMax = -1;
fd_set write_set;
fd_set read_set;
FD_ZERO(&write_set);
FD_ZERO(&read_set);
if (phase == ListServerLink::CONNECTING)
_FD_SET(linkSocket, &write_set);
else
_FD_SET(linkSocket, &read_set);
fdMax = linkSocket;
// wait for socket to connect or timeout
struct timeval timeout;
timeout.tv_sec = long(floorf(waitTime));
timeout.tv_usec = long(1.0e+6f * (waitTime - floorf(waitTime)));
int nfound = select(fdMax + 1, (fd_set*)&read_set, (fd_set*)&write_set,
0, &timeout);
if (nfound == 0)
// Time has gone, close and go
break;
// check for connection to list server
if (FD_ISSET(linkSocket, &write_set))
sendQueuedMessages();
else if (FD_ISSET(linkSocket, &read_set))
read();
} while (true);
// stop list server communication
closeLink();
}
void ListServerLink::closeLink()
{
if (isConnected()) {
close(linkSocket);
DEBUG4("Closing List Server\n");
linkSocket = NotConnected;
}
}
void ListServerLink::read()
{
if (isConnected()) {
char buf[256];
recv(linkSocket, buf, sizeof(buf), 0);
closeLink();
if (nextMessageType != ListServerLink::NONE)
// There was a pending request arrived after we write:
// we should redo all the stuff
openLink();
}
}
void ListServerLink::openLink()
{
// start opening connection if not already doing so
if (!isConnected()) {
linkSocket = socket(AF_INET, SOCK_STREAM, 0);
DEBUG4("Opening List Server\n");
if (!isConnected()) {
return;
}
// set to non-blocking for connect
if (BzfNetwork::setNonBlocking(linkSocket) < 0) {
closeLink();
return;
}
// Make our connection come from our serverAddress in case we have
// multiple/masked IPs so the list server can verify us.
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr = serverAddress;
// assign the address to the socket
if (bind(linkSocket, (CNCTType*)&addr, sizeof(addr)) < 0) {
closeLink();
return;
}
// connect. this should fail with EINPROGRESS but check for
// success just in case.
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr = address;
if (connect(linkSocket, (CNCTType*)&addr, sizeof(addr)) < 0) {
#if defined(_WIN32)
#undef EINPROGRESS
#define EINPROGRESS EWOULDBLOCK
#endif
if (getErrno() != EINPROGRESS) {
nerror("connecting to list server");
// TODO should try to lookup dns name again, but we don't have it anymore
closeLink();
} else {
phase = CONNECTING;
}
} else {
// shouldn't arrive here. Just in case, clean
closeLink();
}
}
}
void ListServerLink::queueMessage(MessageType type)
{
// ignore if the server is not public
if (!publicizeServer) return;
// Open network connection only if closed
if (!isConnected()) openLink();
// record next message to send.
nextMessageType = type;
}
void ListServerLink::sendQueuedMessages()
{
if (!isConnected())
return;
if (nextMessageType == ListServerLink::ADD) {
DEBUG3("Queuing ADD message to list server\n");
addMe(getTeamCounts(), publicizeAddress, url_encode(publicizeDescription));
lastAddTime = TimeKeeper::getCurrent();
} else if (nextMessageType == ListServerLink::REMOVE) {
DEBUG3("Queuing REMOVE message to list server\n");
removeMe(publicizeAddress);
}
}
void ListServerLink::addMe(PingPacket pingInfo,
std::string publicizedAddress,
std::string publicizedTitle)
{
std::string msg;
// encode ping reply as ascii hex digits plus NULL
char gameInfo[PingPacketHexPackedSize + 1];
pingInfo.packHex(gameInfo);
// send ADD message (must send blank line)
msg = string_util::format("GET %s?action=ADD&nameport=%s&version=%s&gameinfo=%s&title=%s HTTP/1.1\r\n"
"Host: %s\r\nCache-Control: no-cache\r\n\r\n",
pathname.c_str(), publicizedAddress.c_str(),
getServerVersion(), gameInfo,
publicizedTitle.c_str(),
hostname.c_str());
sendMessage(msg);
}
void ListServerLink::removeMe(std::string publicizedAddress)
{
std::string msg;
// send REMOVE (must send blank line)
msg = string_util::format("GET %s?action=REMOVE&nameport=%s HTTP/1.1\r\n"
"Host: %s\r\nCache-Control: no-cache\r\n\r\n",
pathname.c_str(),
publicizedAddress.c_str(),
hostname.c_str());
sendMessage(msg);
}
void ListServerLink::sendMessage(std::string message)
{
const int bufsize = 4096;
char msg[bufsize];
strncpy(msg, message.c_str(), (message.length() > bufsize) ? bufsize : message.length());
if (strlen(msg) > 0) {
DEBUG3("%s\n",msg);
if (send(linkSocket, msg, strlen(msg), 0) == -1) {
perror("List server send failed");
DEBUG3("Unable to send to the list server!\n");
closeLink();
} else {
nextMessageType = ListServerLink::NONE;
phase = ListServerLink::WRITTEN;
}
} else {
closeLink();
}
}<commit_msg>serve up a newline and fries with that<commit_after>/* bzflag
* Copyright (c) 1993 - 2004 Tim Riker
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the license found in the file
* named LICENSE that should have accompanied this file.
*
* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
// Provide BZFS with a list server connection
/* class header */
#include "ListServerConnection.h"
/* implementation headers */
#include <string.h>
#include <math.h>
#include "bzfio.h"
#include "version.h"
#include "TextUtils.h"
#include "protocol.h"
extern Address serverAddress;
extern PingPacket getTeamCounts();
ListServerLink::ListServerLink(std::string listServerURL, std::string publicizedAddress, std::string publicizedTitle)
{
// parse url
std::string protocol, hostname, pathname;
int port = 80;
bool useDefault = false;
// use default if it can't be parsed
if (!BzfNetwork::parseURL(listServerURL, protocol, hostname, port, pathname))
useDefault = true;
// use default if wrong protocol or invalid port
if ((protocol != "http") || (port < 1) || (port > 65535))
useDefault = true;
// use default if bad address
Address address = Address::getHostAddress(hostname.c_str());
if (address.isAny())
useDefault = true;
// parse default list server URL if we need to; assume default works
if (useDefault) {
BzfNetwork::parseURL(DefaultListServerURL, protocol, hostname, port, pathname);
DEBUG1("Provided list server URL (%s) is invalid. Using default of %s.", listServerURL.c_str(), DefaultListServerURL);
}
// add to list
this->address = address;
this->port = port;
this->pathname = pathname;
this->hostname = hostname;
this->linkSocket = NotConnected;
this->publicizeAddress = publicizedAddress;
this->publicizeDescription = publicizedTitle;
this->publicizeServer = true; //if this c'tor is called, it's safe to publicize
// schedule initial ADD message
queueMessage(ListServerLink::ADD);
}
ListServerLink::ListServerLink()
{
// does not create a usable link, so checks should be placed
// in all public member functions to ensure that nothing tries
// to happen if publicizeServer is false
this->linkSocket = NotConnected;
this->publicizeServer = false;
}
ListServerLink::~ListServerLink()
{
// now tell the list server that we're going away. this can
// take some time but we don't want to wait too long. we do
// our own multiplexing loop and wait for a maximum of 3 seconds
// total.
// if we aren't supposed to be publicizing, skip the whole thing
// and don't waste 3 seconds.
if (!publicizeServer)
return;
queueMessage(ListServerLink::REMOVE);
TimeKeeper start = TimeKeeper::getCurrent();
do {
// compute timeout
float waitTime = 3.0f - (TimeKeeper::getCurrent() - start);
if (waitTime <= 0.0f)
break;
if (!isConnected()) //queueMessage should have connected us
break;
// check for list server socket connection
int fdMax = -1;
fd_set write_set;
fd_set read_set;
FD_ZERO(&write_set);
FD_ZERO(&read_set);
if (phase == ListServerLink::CONNECTING)
_FD_SET(linkSocket, &write_set);
else
_FD_SET(linkSocket, &read_set);
fdMax = linkSocket;
// wait for socket to connect or timeout
struct timeval timeout;
timeout.tv_sec = long(floorf(waitTime));
timeout.tv_usec = long(1.0e+6f * (waitTime - floorf(waitTime)));
int nfound = select(fdMax + 1, (fd_set*)&read_set, (fd_set*)&write_set,
0, &timeout);
if (nfound == 0)
// Time has gone, close and go
break;
// check for connection to list server
if (FD_ISSET(linkSocket, &write_set))
sendQueuedMessages();
else if (FD_ISSET(linkSocket, &read_set))
read();
} while (true);
// stop list server communication
closeLink();
}
void ListServerLink::closeLink()
{
if (isConnected()) {
close(linkSocket);
DEBUG4("Closing List Server\n");
linkSocket = NotConnected;
}
}
void ListServerLink::read()
{
if (isConnected()) {
char buf[256];
recv(linkSocket, buf, sizeof(buf), 0);
closeLink();
if (nextMessageType != ListServerLink::NONE)
// There was a pending request arrived after we write:
// we should redo all the stuff
openLink();
}
}
void ListServerLink::openLink()
{
// start opening connection if not already doing so
if (!isConnected()) {
linkSocket = socket(AF_INET, SOCK_STREAM, 0);
DEBUG4("Opening List Server\n");
if (!isConnected()) {
return;
}
// set to non-blocking for connect
if (BzfNetwork::setNonBlocking(linkSocket) < 0) {
closeLink();
return;
}
// Make our connection come from our serverAddress in case we have
// multiple/masked IPs so the list server can verify us.
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr = serverAddress;
// assign the address to the socket
if (bind(linkSocket, (CNCTType*)&addr, sizeof(addr)) < 0) {
closeLink();
return;
}
// connect. this should fail with EINPROGRESS but check for
// success just in case.
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr = address;
if (connect(linkSocket, (CNCTType*)&addr, sizeof(addr)) < 0) {
#if defined(_WIN32)
#undef EINPROGRESS
#define EINPROGRESS EWOULDBLOCK
#endif
if (getErrno() != EINPROGRESS) {
nerror("connecting to list server");
// TODO should try to lookup dns name again, but we don't have it anymore
closeLink();
} else {
phase = CONNECTING;
}
} else {
// shouldn't arrive here. Just in case, clean
closeLink();
}
}
}
void ListServerLink::queueMessage(MessageType type)
{
// ignore if the server is not public
if (!publicizeServer) return;
// Open network connection only if closed
if (!isConnected()) openLink();
// record next message to send.
nextMessageType = type;
}
void ListServerLink::sendQueuedMessages()
{
if (!isConnected())
return;
if (nextMessageType == ListServerLink::ADD) {
DEBUG3("Queuing ADD message to list server\n");
addMe(getTeamCounts(), publicizeAddress, url_encode(publicizeDescription));
lastAddTime = TimeKeeper::getCurrent();
} else if (nextMessageType == ListServerLink::REMOVE) {
DEBUG3("Queuing REMOVE message to list server\n");
removeMe(publicizeAddress);
}
}
void ListServerLink::addMe(PingPacket pingInfo,
std::string publicizedAddress,
std::string publicizedTitle)
{
std::string msg;
// encode ping reply as ascii hex digits plus NULL
char gameInfo[PingPacketHexPackedSize + 1];
pingInfo.packHex(gameInfo);
// send ADD message (must send blank line)
msg = string_util::format("GET %s?action=ADD&nameport=%s&version=%s&gameinfo=%s&title=%s HTTP/1.1\r\n"
"Host: %s\r\nCache-Control: no-cache\r\n\r\n",
pathname.c_str(), publicizedAddress.c_str(),
getServerVersion(), gameInfo,
publicizedTitle.c_str(),
hostname.c_str());
sendMessage(msg);
}
void ListServerLink::removeMe(std::string publicizedAddress)
{
std::string msg;
// send REMOVE (must send blank line)
msg = string_util::format("GET %s?action=REMOVE&nameport=%s HTTP/1.1\r\n"
"Host: %s\r\nCache-Control: no-cache\r\n\r\n",
pathname.c_str(),
publicizedAddress.c_str(),
hostname.c_str());
sendMessage(msg);
}
void ListServerLink::sendMessage(std::string message)
{
const int bufsize = 4096;
char msg[bufsize];
strncpy(msg, message.c_str(), (message.length() > bufsize) ? bufsize : message.length());
if (strlen(msg) > 0) {
DEBUG3("%s\n",msg);
if (send(linkSocket, msg, strlen(msg), 0) == -1) {
perror("List server send failed");
DEBUG3("Unable to send to the list server!\n");
closeLink();
} else {
nextMessageType = ListServerLink::NONE;
phase = ListServerLink::WRITTEN;
}
} else {
closeLink();
}
}
<|endoftext|> |
<commit_before>#include <string>
#include <vector>
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/StringRef.h>
#include <llvm/Support/raw_ostream.h>
#include "../driver/driver.h"
#include "../driver/repl.h"
#include "../support/utility.h"
using namespace delta;
static std::vector<std::string> removeFileArgs(std::vector<llvm::StringRef>& args) {
std::vector<std::string> files;
for (auto arg = args.begin(); arg != args.end();) {
if (!arg->startswith("-")) {
files.push_back(*arg);
arg = args.erase(arg);
} else {
++arg;
}
}
return files;
}
static void printHelp() {
llvm::outs() <<
"OVERVIEW: Delta compiler\n"
"\n"
"USAGE: delta [options] <inputs>\n"
"\n"
"OPTIONS:\n"
" -c - Compile only, generating an .o file; don't link\n"
" -emit-assembly - Emit assembly code\n"
" -fPIC - Emit position-independent code\n"
" -help - Display this help\n"
" -I<directory> - Add a search path for module and C header import\n"
" -parse - Perform parsing\n"
" -print-ast - Print the abstract syntax tree to stdout\n"
" -print-ir - Print the generated LLVM IR to stdout\n"
" -typecheck - Perform parsing and type checking\n";
}
int main(int argc, const char** argv) {
--argc;
++argv;
if (argc == 0) {
return replMain();
}
llvm::StringRef command = argv[0];
try {
if (command == "build") {
std::vector<llvm::StringRef> args(argv + 1, argv + argc);
return buildPackage(".", args, /* run */ false);
} else if (command == "run") {
std::vector<llvm::StringRef> args(argv + 1, argv + argc);
auto files = removeFileArgs(args);
if (files.empty()) {
return buildPackage(".", args, /* run */ true);
} else {
return buildExecutable(files, /* manifest */ nullptr, args, /* run */ true);
}
} else {
std::vector<llvm::StringRef> args(argv, argv + argc);
if (checkFlag("-help", args) || checkFlag("--help", args) || checkFlag("-h", args)) {
printHelp();
return 0;
}
auto files = removeFileArgs(args);
return buildExecutable(files, /* manifest */ nullptr, args, /* run */ false);
}
} catch (const CompileError& error) {
error.print();
return 1;
}
}
<commit_msg>Make "delta build <files>" behave like "delta <files>"<commit_after>#include <string>
#include <vector>
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/StringRef.h>
#include <llvm/Support/raw_ostream.h>
#include "../driver/driver.h"
#include "../driver/repl.h"
#include "../support/utility.h"
using namespace delta;
static void printHelp() {
llvm::outs() <<
"OVERVIEW: Delta compiler\n"
"\n"
"USAGE: delta [options] <inputs>\n"
"\n"
"OPTIONS:\n"
" -c - Compile only, generating an .o file; don't link\n"
" -emit-assembly - Emit assembly code\n"
" -fPIC - Emit position-independent code\n"
" -help - Display this help\n"
" -I<directory> - Add a search path for module and C header import\n"
" -parse - Perform parsing\n"
" -print-ast - Print the abstract syntax tree to stdout\n"
" -print-ir - Print the generated LLVM IR to stdout\n"
" -typecheck - Perform parsing and type checking\n";
}
int main(int argc, const char** argv) {
--argc;
++argv;
if (argc == 0) {
return replMain();
}
llvm::StringRef command = argv[0];
bool build = command == "build";
bool run = command == "run";
if (build || run) {
--argc;
++argv;
}
std::vector<std::string> inputs;
std::vector<llvm::StringRef> args;
for (int i = 0; i < argc; ++i) {
llvm::StringRef arg = argv[i];
if (arg == "help" || arg == "-help" || arg == "--help" || arg == "-h") {
printHelp();
return 0;
} else if (arg.startswith("-")) {
args.push_back(arg);
} else {
inputs.push_back(arg);
}
}
try {
if (inputs.empty()) {
return buildPackage(".", args, run);
} else {
return buildExecutable(inputs, nullptr, args, run);
}
} catch (const CompileError& error) {
error.print();
return 1;
}
}
<|endoftext|> |
<commit_before>#include "dsa/message.h"
#include "gtest/gtest.h"
using namespace dsa;
class InvokeRequestMessageExt : public InvokeRequestMessage {
public:
InvokeRequestMessageExt() : InvokeRequestMessage() {}
bool check_static_headers(uint8_t *expected_values, size_t size) {
uint8_t buf[1024];
static_headers.write(buf);
return (memcmp(expected_values, buf, size) == 0);
}
};
class InvokeResponseMessageExt : public InvokeResponseMessage {
public:
InvokeResponseMessageExt() : InvokeResponseMessage() {}
bool check_static_headers(uint8_t *expected_values, size_t size) {
uint8_t buf[1024];
static_headers.write(buf);
return (memcmp(expected_values, buf, size) == 0);
}
};
TEST(MessageTest, InvokeRequest__Constructor_01) {
// public methods
// InvokeRequestMessage();
InvokeRequestMessage request;
EXPECT_EQ(15, request.size());
EXPECT_EQ(0, request.get_sequence_id());
EXPECT_EQ(0, request.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, request.type());
EXPECT_EQ(true, request.is_request());
EXPECT_EQ(0, request.request_id());
EXPECT_EQ(false, request.get_priority());
EXPECT_EQ("", request.get_target_path());
EXPECT_EQ("", request.get_permission_token());
EXPECT_EQ(false, request.get_no_stream());
EXPECT_EQ(0, request.get_alias_count());
}
TEST(MessageTest, InvokeRequest__Constructor_02) {
// InvokeRequestMessage(const InvokeRequestMessage&);
const InvokeRequestMessage src__request;
InvokeRequestMessage target__request(src__request);
EXPECT_EQ(15, target__request.size());
EXPECT_EQ(0, target__request.get_sequence_id());
EXPECT_EQ(0, target__request.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, target__request.type());
EXPECT_EQ(true, target__request.is_request());
EXPECT_EQ(0, target__request.request_id());
EXPECT_EQ(false, target__request.get_priority());
EXPECT_EQ("", target__request.get_target_path());
EXPECT_EQ("", target__request.get_permission_token());
EXPECT_EQ(false, target__request.get_no_stream());
EXPECT_EQ(0, target__request.get_alias_count());
std::string target_path("path/to/abc");
target__request.set_target_path(target_path);
EXPECT_EQ("", src__request.get_target_path());
EXPECT_EQ(target_path, target__request.get_target_path());
}
TEST(MessageTest, InvokeRequest__Constructor_03) {
// InvokeRequestMessage(const uint8_t* data, size_t size);
const uint8_t data[] = {0xf, 0x0, 0x0, 0x0, 0xf, 0x0, 0x3, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
size_t data_size = sizeof(data) / sizeof(uint8_t);
InvokeRequestMessage request(data, data_size);
EXPECT_EQ(15, request.size());
EXPECT_EQ(0, request.get_sequence_id());
EXPECT_EQ(0, request.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, request.type());
EXPECT_EQ(true, request.is_request());
EXPECT_EQ(0, request.request_id());
EXPECT_EQ(false, request.get_priority());
EXPECT_EQ("", request.get_target_path());
EXPECT_EQ("", request.get_permission_token());
EXPECT_EQ(false, request.get_no_stream());
EXPECT_EQ(0, request.get_alias_count());
uint8_t buf[1024];
request.size();
request.write(buf);
}
TEST(MessageTest, InvokeRequest__Constructor_04) {
// InvokeRequestMessage(const uint8_t* data, size_t size);
InvokeRequestMessage request;
request.set_target_path("/request");
InvokeRequestMessage other = request;
EXPECT_EQ("/request", other.get_target_path());
other.set_target_path("/other");
EXPECT_EQ("/request", request.get_target_path());
EXPECT_EQ("/other", other.get_target_path());
EXPECT_EQ(24, other.size());
EXPECT_EQ(0, other.get_sequence_id());
EXPECT_EQ(0, other.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, other.type());
EXPECT_EQ(true, other.is_request());
EXPECT_EQ(0, other.request_id());
EXPECT_EQ(false, other.get_priority());
EXPECT_EQ("/other", other.get_target_path());
EXPECT_EQ("", other.get_permission_token());
EXPECT_EQ(false, other.get_no_stream());
EXPECT_EQ(0, other.get_alias_count());
}
TEST(MessageTest, InvokeRequest__get_invoke_options) {
// InvokeOptions get_invoke_options() const;
InvokeRequestMessage request;
InvokeOptions options = request.get_invoke_options();
EXPECT_EQ(1, sizeof(options));
}
TEST(MessageTest, InvokeRequest__update_static_header) {
// void update_static_header();
InvokeRequestMessageExt request;
request.size();
uint8_t expect_values[] = {0xf, 0x0, 0x0, 0x0, 0xf, 0x0};
EXPECT_EQ(true,
request.check_static_headers(
expect_values, sizeof(expect_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeRequest__priority) {
InvokeRequestMessage request;
EXPECT_EQ(false, request.get_priority());
request.set_priority(true);
EXPECT_EQ(true, request.get_priority());
}
TEST(MessageTest, InvokeRequest__target_path) {
InvokeRequestMessage request;
EXPECT_EQ("", request.get_target_path());
request.set_target_path("path/to/node");
EXPECT_EQ("path/to/node", request.get_target_path());
}
TEST(MessageTest, InvokeRequest__permission_token) {
// TODO: to be implemented
InvokeRequestMessage request;
EXPECT_EQ("", request.get_permission_token());
request.set_permission_token("permission-token");
EXPECT_EQ("permission-token", request.get_permission_token());
}
TEST(MessageTest, InvokeRequest__no_stream) {
InvokeRequestMessage request;
EXPECT_EQ(false, request.get_no_stream());
request.set_no_stream(true);
EXPECT_EQ(true, request.get_no_stream());
}
TEST(MessageTest, InvokeRequest__write) {
InvokeRequestMessage request;
request.set_target_path("path/to/dsa");
request.set_no_stream(true);
request.size();
uint8_t buf[1024];
request.write(buf);
uint8_t expected_values[] = {0x1e, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x3, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80,
0x0b, 0x0, 0x70, 0x61, 0x74, 0x68, 0x2f, 0x74,
0x6f, 0x2f, 0x64, 0x73, 0x61, 0x11};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeRequest__dynamic_structure) {
InvokeRequestMessage request;
request.set_sequence_id(1234);
request.set_page_id(4321);
request.set_alias_count(11);
request.set_priority(true);
request.set_no_stream(true);
// request.set_max_permission(); // TODO : TBI
request.set_permission_token("ptoken");
request.set_target_path("/target/path");
request.size();
uint8_t buf[1024];
request.write(buf);
uint8_t expected_values[] = {
0x30, 0x0, 0x0, 0x0, 0x30, 0x0, 0x03, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x10, 0x02, 0xe1, 0x10, 0x0, 0x0, 0x08, 0x0b, 0x80,
0x0c, 0x0, 0x2f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x2f, 0x70, 0x61,
0x74, 0x68, 0x60, 0x06, 0x0, 0x70, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x11};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeResponse__Constructor) {
InvokeResponseMessage response;
EXPECT_EQ(15, response.size());
EXPECT_EQ(0, response.get_sequence_id());
EXPECT_EQ(0, response.get_page_id());
EXPECT_EQ(MessageType::InvokeResponse, response.type());
EXPECT_EQ(false, response.is_request());
EXPECT_EQ(0, response.request_id());
}
TEST(MessageTest, InvokeResponse__source_path) {
InvokeResponseMessage response;
EXPECT_EQ("", response.get_source_path());
response.set_source_path("/source/path");
EXPECT_EQ("/source/path", response.get_source_path());
}
TEST(MessageTest, InvokeResponse__status) {
InvokeResponseMessage response;
static const MessageStatus message_status_all[]{
MessageStatus::Ok,
MessageStatus::Initializing,
MessageStatus::Refreshed,
MessageStatus::NotAvailable,
MessageStatus::Closed,
MessageStatus::Disconnected,
MessageStatus::PermissionDenied,
MessageStatus::InvalidMessage,
MessageStatus::InvalidParameter,
MessageStatus::Busy,
MessageStatus::AliasLoop,
MessageStatus::ConnectionError,
};
for (const auto status : message_status_all) {
response.set_status(status);
EXPECT_EQ(status, response.get_status());
}
}
TEST(MessageTest, InvokeResponse__write) {
InvokeResponseMessage response;
response.set_source_path("source/path"); // no effect
response.set_status(MessageStatus::Busy);
response.size();
uint8_t buf[1024];
response.write(buf);
uint8_t expected_values[] = {0x11, 0x0, 0x0, 0x0, 0x11, 0x0, 0x83, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeResponse__dynamic_structure) {
InvokeResponseMessage response;
response.set_status(MessageStatus::Closed);
response.set_sequence_id(1234);
response.set_page_id(4321);
// response.skippable(true); // TODO: TBI
response.set_source_path("/source/path"); // no effect
response.size();
uint8_t buf[1024];
response.write(buf);
uint8_t expected_values[] = {0x1b, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x83, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x10, 0x01, 0xd2, 0x04, 0x0, 0x0, 0x02, 0xe1,
0x10, 0x0, 0x0};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
<commit_msg>fix issue with sequence_id<commit_after>#include "dsa/message.h"
#include "gtest/gtest.h"
using namespace dsa;
class InvokeRequestMessageExt : public InvokeRequestMessage {
public:
InvokeRequestMessageExt() : InvokeRequestMessage() {}
bool check_static_headers(uint8_t *expected_values, size_t size) {
uint8_t buf[1024];
static_headers.write(buf);
return (memcmp(expected_values, buf, size) == 0);
}
};
class InvokeResponseMessageExt : public InvokeResponseMessage {
public:
InvokeResponseMessageExt() : InvokeResponseMessage() {}
bool check_static_headers(uint8_t *expected_values, size_t size) {
uint8_t buf[1024];
static_headers.write(buf);
return (memcmp(expected_values, buf, size) == 0);
}
};
TEST(MessageTest, InvokeRequest__Constructor_01) {
// public methods
// InvokeRequestMessage();
InvokeRequestMessage request;
EXPECT_EQ(15, request.size());
EXPECT_EQ(0, request.get_sequence_id());
EXPECT_EQ(0, request.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, request.type());
EXPECT_EQ(true, request.is_request());
EXPECT_EQ(0, request.request_id());
EXPECT_EQ(false, request.get_priority());
EXPECT_EQ("", request.get_target_path());
EXPECT_EQ("", request.get_permission_token());
EXPECT_EQ(false, request.get_no_stream());
EXPECT_EQ(0, request.get_alias_count());
}
TEST(MessageTest, InvokeRequest__Constructor_02) {
// InvokeRequestMessage(const InvokeRequestMessage&);
const InvokeRequestMessage src__request;
InvokeRequestMessage target__request(src__request);
EXPECT_EQ(15, target__request.size());
EXPECT_EQ(0, target__request.get_sequence_id());
EXPECT_EQ(0, target__request.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, target__request.type());
EXPECT_EQ(true, target__request.is_request());
EXPECT_EQ(0, target__request.request_id());
EXPECT_EQ(false, target__request.get_priority());
EXPECT_EQ("", target__request.get_target_path());
EXPECT_EQ("", target__request.get_permission_token());
EXPECT_EQ(false, target__request.get_no_stream());
EXPECT_EQ(0, target__request.get_alias_count());
std::string target_path("path/to/abc");
target__request.set_target_path(target_path);
EXPECT_EQ("", src__request.get_target_path());
EXPECT_EQ(target_path, target__request.get_target_path());
}
TEST(MessageTest, InvokeRequest__Constructor_03) {
// InvokeRequestMessage(const uint8_t* data, size_t size);
const uint8_t data[] = {0xf, 0x0, 0x0, 0x0, 0xf, 0x0, 0x3, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
size_t data_size = sizeof(data) / sizeof(uint8_t);
InvokeRequestMessage request(data, data_size);
EXPECT_EQ(15, request.size());
EXPECT_EQ(0, request.get_sequence_id());
EXPECT_EQ(0, request.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, request.type());
EXPECT_EQ(true, request.is_request());
EXPECT_EQ(0, request.request_id());
EXPECT_EQ(false, request.get_priority());
EXPECT_EQ("", request.get_target_path());
EXPECT_EQ("", request.get_permission_token());
EXPECT_EQ(false, request.get_no_stream());
EXPECT_EQ(0, request.get_alias_count());
uint8_t buf[1024];
request.size();
request.write(buf);
}
TEST(MessageTest, InvokeRequest__Constructor_04) {
// InvokeRequestMessage(const uint8_t* data, size_t size);
InvokeRequestMessage request;
request.set_target_path("/request");
InvokeRequestMessage other = request;
EXPECT_EQ("/request", other.get_target_path());
other.set_target_path("/other");
EXPECT_EQ("/request", request.get_target_path());
EXPECT_EQ("/other", other.get_target_path());
EXPECT_EQ(24, other.size());
EXPECT_EQ(0, other.get_sequence_id());
EXPECT_EQ(0, other.get_page_id());
EXPECT_EQ(MessageType::InvokeRequest, other.type());
EXPECT_EQ(true, other.is_request());
EXPECT_EQ(0, other.request_id());
EXPECT_EQ(false, other.get_priority());
EXPECT_EQ("/other", other.get_target_path());
EXPECT_EQ("", other.get_permission_token());
EXPECT_EQ(false, other.get_no_stream());
EXPECT_EQ(0, other.get_alias_count());
}
TEST(MessageTest, InvokeRequest__get_invoke_options) {
// InvokeOptions get_invoke_options() const;
InvokeRequestMessage request;
InvokeOptions options = request.get_invoke_options();
EXPECT_EQ(1, sizeof(options));
}
TEST(MessageTest, InvokeRequest__update_static_header) {
// void update_static_header();
InvokeRequestMessageExt request;
request.size();
uint8_t expect_values[] = {0xf, 0x0, 0x0, 0x0, 0xf, 0x0};
EXPECT_EQ(true,
request.check_static_headers(
expect_values, sizeof(expect_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeRequest__priority) {
InvokeRequestMessage request;
EXPECT_EQ(false, request.get_priority());
request.set_priority(true);
EXPECT_EQ(true, request.get_priority());
}
TEST(MessageTest, InvokeRequest__target_path) {
InvokeRequestMessage request;
EXPECT_EQ("", request.get_target_path());
request.set_target_path("path/to/node");
EXPECT_EQ("path/to/node", request.get_target_path());
}
TEST(MessageTest, InvokeRequest__permission_token) {
// TODO: to be implemented
InvokeRequestMessage request;
EXPECT_EQ("", request.get_permission_token());
request.set_permission_token("permission-token");
EXPECT_EQ("permission-token", request.get_permission_token());
}
TEST(MessageTest, InvokeRequest__no_stream) {
InvokeRequestMessage request;
EXPECT_EQ(false, request.get_no_stream());
request.set_no_stream(true);
EXPECT_EQ(true, request.get_no_stream());
}
TEST(MessageTest, InvokeRequest__write) {
InvokeRequestMessage request;
request.set_target_path("path/to/dsa");
request.set_no_stream(true);
request.size();
uint8_t buf[1024];
request.write(buf);
uint8_t expected_values[] = {0x1e, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x3, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80,
0x0b, 0x0, 0x70, 0x61, 0x74, 0x68, 0x2f, 0x74,
0x6f, 0x2f, 0x64, 0x73, 0x61, 0x11};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeRequest__dynamic_structure) {
InvokeRequestMessage request;
request.set_sequence_id(1234);
request.set_page_id(4321);
request.set_alias_count(11);
request.set_priority(true);
request.set_no_stream(true);
// request.set_max_permission(); // TODO : TBI
request.set_permission_token("ptoken");
request.set_target_path("/target/path");
request.size();
uint8_t buf[1024];
request.write(buf);
uint8_t expected_values[] = {
0x35, 0x0, 0x0, 0x0, 0x35, 0x0, 0x03, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x10, 0x1, 0xd2, 0x04, 0x0, 0x0, 0x02,
0xe1, 0x10, 0x0, 0x0, 0x08, 0x0b, 0x80, 0x0c, 0x0, 0x2f, 0x74,
0x61, 0x72, 0x67, 0x65, 0x74, 0x2f, 0x70, 0x61, 0x74, 0x68, 0x60,
0x06, 0x0, 0x70, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x11};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeResponse__Constructor) {
InvokeResponseMessage response;
EXPECT_EQ(15, response.size());
EXPECT_EQ(0, response.get_sequence_id());
EXPECT_EQ(0, response.get_page_id());
EXPECT_EQ(MessageType::InvokeResponse, response.type());
EXPECT_EQ(false, response.is_request());
EXPECT_EQ(0, response.request_id());
}
TEST(MessageTest, InvokeResponse__source_path) {
InvokeResponseMessage response;
EXPECT_EQ("", response.get_source_path());
response.set_source_path("/source/path");
EXPECT_EQ("/source/path", response.get_source_path());
}
TEST(MessageTest, InvokeResponse__status) {
InvokeResponseMessage response;
static const MessageStatus message_status_all[]{
MessageStatus::Ok,
MessageStatus::Initializing,
MessageStatus::Refreshed,
MessageStatus::NotAvailable,
MessageStatus::Closed,
MessageStatus::Disconnected,
MessageStatus::PermissionDenied,
MessageStatus::InvalidMessage,
MessageStatus::InvalidParameter,
MessageStatus::Busy,
MessageStatus::AliasLoop,
MessageStatus::ConnectionError,
};
for (const auto status : message_status_all) {
response.set_status(status);
EXPECT_EQ(status, response.get_status());
}
}
TEST(MessageTest, InvokeResponse__write) {
InvokeResponseMessage response;
response.set_source_path("source/path"); // no effect
response.set_status(MessageStatus::Busy);
response.size();
uint8_t buf[1024];
response.write(buf);
uint8_t expected_values[] = {0x11, 0x0, 0x0, 0x0, 0x11, 0x0, 0x83, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
TEST(MessageTest, InvokeResponse__dynamic_structure) {
InvokeResponseMessage response;
response.set_status(MessageStatus::Closed);
response.set_sequence_id(1234);
response.set_page_id(4321);
// response.skippable(true); // TODO: TBI
response.set_source_path("/source/path"); // no effect
response.size();
uint8_t buf[1024];
response.write(buf);
uint8_t expected_values[] = {0x1b, 0x0, 0x0, 0x0, 0x1b, 0x0, 0x83,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x10, 0x01, 0xd2, 0x04, 0x0,
0x0, 0x02, 0xe1, 0x10, 0x0, 0x0};
EXPECT_EQ(0, memcmp(expected_values, buf,
sizeof(expected_values) / sizeof(uint8_t)));
}
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/nest/p9_adu_setup.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
//------------------------------------------------------------------------------------
//
/// @file p9_adu_setup.H
/// @brief Setup the adu to do reads/writes
//
// *HWP HWP Owner: Christina Graves [email protected]
// *HWP FW Owner: Thi Tran [email protected]
// *HWP Team: Nest
// *HWP Level: 1
// *HWP Consumed by:
//-----------------------------------------------------------------------------------
// *! ADDITIONAL COMMENTS:
// *!
// *! The purpose of this procedure is to setup the ADU to do reads/writes
// *! and to return the number of granules (number of 8B reads/writes) that
// *! can be done before setup needs to be called again
// *!
// *! Successful operation assumes that:
// *!
// *! High-level procedure flow:
// *!
// *!
//------------------------------------------------------------------------------------
#ifndef _P9_ADU_SETUP_H_
#define _P9_ADU_SETUP_H_
//-----------------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------------
#include <fapi2.H>
#include <p9_adu_constants.H>
//-----------------------------------------------------------------------------------
// Structure definitions
//-----------------------------------------------------------------------------------
//function pointer typedef definition for HWP call support
typedef fapi2::ReturnCode
(*p9_adu_setup_FP_t) (const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>&,
const uint64_t,
const bool,
const uint32_t,
uint32_t&);
//-----------------------------------------------------------------------------------
// Constant definitions
//-----------------------------------------------------------------------------------
extern "C" {
//-----------------------------------------------------------------------------------
// Function prototype
//-----------------------------------------------------------------------------------
/// @brief setup for reads/writes from the ADU
/// @param[in] i_target => P9 chip target
/// @param[in] i_address => base real address for read/write operation (expected to be 8B aligned)
/// @param[in] i_rnw => if the operation is read not write (1 for read, 0 for write)
/// @param[in] i_flags => other information that is needed - the flags are:
/// -bit 0-cache inhibited - use cache-inhibited ttype?
/// (true = ci, false = dma partial)
/// -bit 1-autoinc - utilize ADU HW auto-increment function
/// -bit 2-lock pick - pick ADU lock (if required)
/// -bit 3-leave dirty - in the case of a fail with lock held,
/// do not reset ADU & do not release lock
/// -bit 4-fastmode - check status only at the end of read/write stream
/// -bit 5-itag - collect itag with each 8B read/write
/// -bit 6:13-size - transaction size
/// -bit 14:32-lock tries - number of ADU lock acquisitions to attempt
/// before giving up or attempting lock pick
/// @param[out] o_numGranules => number of 8B granules that can be read/written before setup needs to be called again
//
/// @return FAPI_RC_SUCCESS if the setup completes successfully,
//
fapi2::ReturnCode p9_adu_setup(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
const uint64_t i_address,
const bool i_rnw,
const uint32_t i_flags,
uint32_t& o_numGranules);
} //extern "C"
#endif //_P9_ADU_SETUP_H_
<commit_msg>Changes in ecc data fixing so reading and writing works<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/nest/p9_adu_setup.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
//------------------------------------------------------------------------------------
//
/// @file p9_adu_setup.H
/// @brief Setup the adu to do reads/writes
//
// *HWP HWP Owner: Christina Graves [email protected]
// *HWP FW Owner: Thi Tran [email protected]
// *HWP Team: Nest
// *HWP Level: 1
// *HWP Consumed by:
//-----------------------------------------------------------------------------------
// *! ADDITIONAL COMMENTS:
// *!
// *! The purpose of this procedure is to setup the ADU to do reads/writes
// *! and to return the number of granules (number of 8B reads/writes) that
// *! can be done before setup needs to be called again
// *!
// *! Successful operation assumes that:
// *!
// *! High-level procedure flow:
// *!
// *!
//------------------------------------------------------------------------------------
#ifndef _P9_ADU_SETUP_H_
#define _P9_ADU_SETUP_H_
//-----------------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------------
#include <fapi2.H>
#include <p9_adu_constants.H>
//-----------------------------------------------------------------------------------
// Structure definitions
//-----------------------------------------------------------------------------------
//function pointer typedef definition for HWP call support
typedef fapi2::ReturnCode
(*p9_adu_setup_FP_t) (const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>&,
const uint64_t,
const bool,
const uint32_t,
uint32_t&);
//-----------------------------------------------------------------------------------
// Constant definitions
//-----------------------------------------------------------------------------------
extern "C" {
//-----------------------------------------------------------------------------------
// Function prototype
//-----------------------------------------------------------------------------------
/// @brief setup for reads/writes from the ADU
/// @param[in] i_target => P9 chip target
/// @param[in] i_address => base real address for read/write operation (expected to be 8B aligned)
/// @param[in] i_rnw => if the operation is read not write (1 for read, 0 for write)
/// @param[in] i_flags => other information that is needed - see the p9_adu_constants adu_flags enums for bit definitions
/// Note: To construct the flag you can use p9_ADU_oper_flag class
/// @param[out] o_numGranules => number of 8B granules that can be read/written before setup needs to be called again
//
/// @return FAPI_RC_SUCCESS if the setup completes successfully,
//
fapi2::ReturnCode p9_adu_setup(
const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
const uint64_t i_address,
const bool i_rnw,
const uint32_t i_flags,
uint32_t& o_numGranules);
} //extern "C"
#endif //_P9_ADU_SETUP_H_
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/perv/p9_start_cbs.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2016 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
//------------------------------------------------------------------------------
/// @file p9_start_cbs.C
///
/// @brief Start CBS : Trigger CBS
//------------------------------------------------------------------------------
// *HWP HW Owner : Abhishek Agarwal <[email protected]>
// *HWP HW Backup Owner : Srinivas V Naga <[email protected]>
// *HWP FW Owner : sunil kumar <[email protected]>
// *HWP Team : Perv
// *HWP Level : 2
// *HWP Consumed by : SE:HB
//------------------------------------------------------------------------------
//## auto_generated
#include "p9_start_cbs.H"
//## auto_generated
#include "p9_const_common.H"
#include <p9_perv_scom_addresses.H>
#include <p9_perv_scom_addresses_fld.H>
#include <p9_perv_scom_addresses_fixes.H>
#include <p9_perv_scom_addresses_fld_fixes.H>
enum P9_START_CBS_Private_Constants
{
P9_CFAM_CBS_POLL_COUNT = 20, // Observed Number of times CBS read for CBS_INTERNAL_STATE_VECTOR
CBS_IDLE_VALUE = 0x002, // Read the value of CBS_CS_INTERNAL_STATE_VECTOR
P9_CBS_IDLE_HW_NS_DELAY = 640000, // unit is nano seconds [min : 64k x (1/100MHz) = 64k x 10(-8) = 640 us
// max : 64k x (1/50MHz) = 128k x 10(-8) = 1280 us]
P9_CBS_IDLE_SIM_CYCLE_DELAY = 7500000 // unit is sim cycles,to match the poll count change( 250000 * 30 )
};
fapi2::ReturnCode p9_start_cbs(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>
& i_target_chip,
const bool i_sbe_start)
{
fapi2::buffer<uint32_t> l_read_reg ;
bool l_read_vdn_pgood_status = false;
bool l_sbe_start_value = false;
bool l_fsi2pib_status = false;
fapi2::buffer<uint32_t> l_data32;
fapi2::buffer<uint32_t> l_data32_cbs_cs;
int l_timeout = 0;
FAPI_INF("p9_start_cbs: Entering ...");
l_sbe_start_value = !i_sbe_start;
FAPI_DBG("Configuring Prevent SBE start option");
FAPI_IMP("SBE start value : %d", l_sbe_start_value);
//Setting CBS_CS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
//CFAM.CBS_CS.CBS_CS_PREVENT_SBE_START = l_sbe_start_value
l_data32_cbs_cs.writeBit<3>(l_sbe_start_value);
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
FAPI_DBG("check for VDN_PGOOD");
//Getting PERV_CBS_ENVSTAT register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_ENVSTAT_FSI,
l_data32));
l_read_vdn_pgood_status =
l_data32.getBit<PERV_CBS_ENVSTAT_C4_VDN_GPOOD>(); //l_read_vdn_pgood_status = PERV_CBS_ENVSTAT.PERV_CBS_ENVSTAT_C4_VDN_GPOOD
FAPI_ASSERT(l_read_vdn_pgood_status,
fapi2::VDN_PGOOD_NOT_SET()
.set_MASTER_CHIP(i_target_chip)
.set_CBS_ENVSTAT_READ(l_data32),
"ERROR:VDN_PGOOD OFF, CBS_ENVSTAT BIT 2 NOT SET");
FAPI_DBG("Resetting CFAM Boot Sequencer (CBS) to flush value");
//Setting CBS_CS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
l_data32_cbs_cs.clearBit<0>(); //CFAM.CBS_CS.CBS_CS_START_BOOT_SEQUENCER = 0
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
FAPI_DBG("Triggering CFAM Boot Sequencer (CBS) to start");
//Setting CBS_CS register value
l_data32_cbs_cs.setBit<0>(); //CFAM.CBS_CS.CBS_CS_START_BOOT_SEQUENCER = 1
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
FAPI_DBG("Check cbs_cs_internal_state_vector");
l_timeout = P9_CFAM_CBS_POLL_COUNT;
//UNTIL CBS_CS.CBS_CS_INTERNAL_STATE_VECTOR == CBS_IDLE_VALUE
while (l_timeout != 0)
{
//Getting CBS_CS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
uint32_t l_poll_data = 0; //uint32_t l_poll_data = CFAM.CBS_CS.CBS_CS_INTERNAL_STATE_VECTOR
l_data32_cbs_cs.extractToRight<16, 16>(l_poll_data);
if (l_poll_data == CBS_IDLE_VALUE)
{
break;
}
fapi2::delay(P9_CBS_IDLE_HW_NS_DELAY, P9_CBS_IDLE_SIM_CYCLE_DELAY);
--l_timeout;
}
FAPI_DBG("Loop Count :%d", l_timeout);
FAPI_ASSERT(l_timeout > 0,
fapi2::CBS_NOT_IN_IDLE_STATE()
.set_MASTER_CHIP_TARGET(i_target_chip)
.set_MASTER_CHIP(i_target_chip)
.set_CBS_CS_READ(l_data32_cbs_cs)
.set_CBS_CS_IDLE_VALUE(CBS_IDLE_VALUE)
.set_LOOP_COUNT(l_timeout)
.set_HW_DELAY(P9_CBS_IDLE_HW_NS_DELAY),
"ERROR: CBS HAS NOT REACHED IDLE STATE VALUE 0x002 ");
FAPI_DBG("check for VDD status");
//Getting FSI2PIB_STATUS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_FSI2PIB_STATUS_FSI,
l_data32));
//l_fsi2pib_status = CFAM.FSI2PIB_STATUS.VDD_NEST_OBSERVE
l_fsi2pib_status = l_data32.getBit<PERV_FSI2PIB_STATUS_VDD_NEST_OBSERVE>();
FAPI_ASSERT(l_fsi2pib_status,
fapi2::VDD_NEST_OBSERVE_NOT_SET()
.set_MASTER_CHIP(i_target_chip)
.set_FSI2PIB_STATUS_READ(l_data32),
"ERROR:VDD OFF, FSI2PIB BIT 16 NOT SET");
FAPI_INF("p9_start_cbs: Exiting ...");
fapi_try_exit:
return fapi2::current_err;
}
<commit_msg>Clearing SB MSG register before cbs start<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/perv/p9_start_cbs.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2016 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
//------------------------------------------------------------------------------
/// @file p9_start_cbs.C
///
/// @brief Start CBS : Trigger CBS
//------------------------------------------------------------------------------
// *HWP HW Owner : Abhishek Agarwal <[email protected]>
// *HWP HW Backup Owner : Srinivas V Naga <[email protected]>
// *HWP FW Owner : sunil kumar <[email protected]>
// *HWP Team : Perv
// *HWP Level : 2
// *HWP Consumed by : SE:HB
//------------------------------------------------------------------------------
//## auto_generated
#include "p9_start_cbs.H"
//## auto_generated
#include "p9_const_common.H"
#include <p9_perv_scom_addresses.H>
#include <p9_perv_scom_addresses_fld.H>
#include <p9_perv_scom_addresses_fixes.H>
#include <p9_perv_scom_addresses_fld_fixes.H>
enum P9_START_CBS_Private_Constants
{
P9_CFAM_CBS_POLL_COUNT = 20, // Observed Number of times CBS read for CBS_INTERNAL_STATE_VECTOR
CBS_IDLE_VALUE = 0x002, // Read the value of CBS_CS_INTERNAL_STATE_VECTOR
P9_CBS_IDLE_HW_NS_DELAY = 640000, // unit is nano seconds [min : 64k x (1/100MHz) = 64k x 10(-8) = 640 us
// max : 64k x (1/50MHz) = 128k x 10(-8) = 1280 us]
P9_CBS_IDLE_SIM_CYCLE_DELAY = 7500000 // unit is sim cycles,to match the poll count change( 250000 * 30 )
};
fapi2::ReturnCode p9_start_cbs(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>
& i_target_chip,
const bool i_sbe_start)
{
fapi2::buffer<uint32_t> l_read_reg ;
bool l_read_vdn_pgood_status = false;
bool l_sbe_start_value = false;
bool l_fsi2pib_status = false;
fapi2::buffer<uint32_t> l_data32;
fapi2::buffer<uint32_t> l_data32_cbs_cs;
int l_timeout = 0;
FAPI_INF("p9_start_cbs: Entering ...");
FAPI_DBG("Clearing Selfboot message register before every boot ");
// buffer is init value is 0
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_SB_MSG_FSI, l_data32));
l_sbe_start_value = !i_sbe_start;
FAPI_DBG("Configuring Prevent SBE start option");
FAPI_IMP("SBE start value : %d", l_sbe_start_value);
//Setting CBS_CS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
//CFAM.CBS_CS.CBS_CS_PREVENT_SBE_START = l_sbe_start_value
l_data32_cbs_cs.writeBit<3>(l_sbe_start_value);
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
FAPI_DBG("check for VDN_PGOOD");
//Getting PERV_CBS_ENVSTAT register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_ENVSTAT_FSI,
l_data32));
l_read_vdn_pgood_status =
l_data32.getBit<PERV_CBS_ENVSTAT_C4_VDN_GPOOD>(); //l_read_vdn_pgood_status = PERV_CBS_ENVSTAT.PERV_CBS_ENVSTAT_C4_VDN_GPOOD
FAPI_ASSERT(l_read_vdn_pgood_status,
fapi2::VDN_PGOOD_NOT_SET()
.set_MASTER_CHIP(i_target_chip)
.set_CBS_ENVSTAT_READ(l_data32),
"ERROR:VDN_PGOOD OFF, CBS_ENVSTAT BIT 2 NOT SET");
FAPI_DBG("Resetting CFAM Boot Sequencer (CBS) to flush value");
//Setting CBS_CS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
l_data32_cbs_cs.clearBit<0>(); //CFAM.CBS_CS.CBS_CS_START_BOOT_SEQUENCER = 0
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
FAPI_DBG("Triggering CFAM Boot Sequencer (CBS) to start");
//Setting CBS_CS register value
l_data32_cbs_cs.setBit<0>(); //CFAM.CBS_CS.CBS_CS_START_BOOT_SEQUENCER = 1
FAPI_TRY(fapi2::putCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
FAPI_DBG("Check cbs_cs_internal_state_vector");
l_timeout = P9_CFAM_CBS_POLL_COUNT;
//UNTIL CBS_CS.CBS_CS_INTERNAL_STATE_VECTOR == CBS_IDLE_VALUE
while (l_timeout != 0)
{
//Getting CBS_CS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_CBS_CS_FSI,
l_data32_cbs_cs));
uint32_t l_poll_data = 0; //uint32_t l_poll_data = CFAM.CBS_CS.CBS_CS_INTERNAL_STATE_VECTOR
l_data32_cbs_cs.extractToRight<16, 16>(l_poll_data);
if (l_poll_data == CBS_IDLE_VALUE)
{
break;
}
fapi2::delay(P9_CBS_IDLE_HW_NS_DELAY, P9_CBS_IDLE_SIM_CYCLE_DELAY);
--l_timeout;
}
FAPI_DBG("Loop Count :%d", l_timeout);
FAPI_ASSERT(l_timeout > 0,
fapi2::CBS_NOT_IN_IDLE_STATE()
.set_MASTER_CHIP_TARGET(i_target_chip)
.set_MASTER_CHIP(i_target_chip)
.set_CBS_CS_READ(l_data32_cbs_cs)
.set_CBS_CS_IDLE_VALUE(CBS_IDLE_VALUE)
.set_LOOP_COUNT(l_timeout)
.set_HW_DELAY(P9_CBS_IDLE_HW_NS_DELAY),
"ERROR: CBS HAS NOT REACHED IDLE STATE VALUE 0x002 ");
FAPI_DBG("check for VDD status");
//Getting FSI2PIB_STATUS register value
FAPI_TRY(fapi2::getCfamRegister(i_target_chip, PERV_FSI2PIB_STATUS_FSI,
l_data32));
//l_fsi2pib_status = CFAM.FSI2PIB_STATUS.VDD_NEST_OBSERVE
l_fsi2pib_status = l_data32.getBit<PERV_FSI2PIB_STATUS_VDD_NEST_OBSERVE>();
FAPI_ASSERT(l_fsi2pib_status,
fapi2::VDD_NEST_OBSERVE_NOT_SET()
.set_MASTER_CHIP(i_target_chip)
.set_FSI2PIB_STATUS_READ(l_data32),
"ERROR:VDD OFF, FSI2PIB BIT 16 NOT SET");
FAPI_INF("p9_start_cbs: Exiting ...");
fapi_try_exit:
return fapi2::current_err;
}
<|endoftext|> |
<commit_before>#pragma once
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include "BigInt.hpp"
#include "types.hpp"
namespace Ethereum{namespace Connector{
template<typename T>
std::string hex(const T &);
template<typename T>
T unhex(const char *);
template<>
uint32_t unhex<uint32_t>(const char *);
#if __HAS_INT64__
template<>
uint64_t unhex<uint64_t>(const char *);
#endif
template<>
BigInt unhex<BigInt>(const char *);
}}
#include "hex.ipp"
<commit_msg>relative includes<commit_after>#pragma once
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include "../BigInt.hpp"
#include "types.hpp"
namespace Ethereum{namespace Connector{
template<typename T>
std::string hex(const T &);
template<typename T>
T unhex(const char *);
template<>
uint32_t unhex<uint32_t>(const char *);
#if __HAS_INT64__
template<>
uint64_t unhex<uint64_t>(const char *);
#endif
template<>
BigInt unhex<BigInt>(const char *);
}}
#include "hex.ipp"
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: bmpsum.cxx,v $
*
* $Revision: 1.8 $
*
* last change: $Author: hr $ $Date: 2006-06-19 20:07:37 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#include <stdio.h>
#include <signal.h>
#include <vector>
#include <set>
#include <map>
#include <rtl/crc.h>
#include <tools/stream.hxx>
#include <tools/fsys.hxx>
#include <vcl/svapp.hxx>
#include <vcl/bitmap.hxx>
#include <vcl/bmpacc.hxx>
#include <vcl/pngread.hxx>
#include "solar.hrc"
#include "filedlg.hxx"
#define EXIT_NOERROR 0x00000000
#define EXIT_INVALIDFILE 0x00000001
#define EXIT_COMMONERROR 0x80000000
// ----------
// - BmpSum -
// ----------
class BmpSum
{
private:
sal_uInt32 cExitCode;
BOOL GetCommandOption( const ::std::vector< String >& rArgs, const String& rSwitch, String& rSwitchParam );
BOOL GetCommandOptions( const ::std::vector< String >& rArgs, const String& rSwitch, ::std::vector< String >& rSwitchParams );
void SetExitCode( BYTE cExit )
{
if( ( EXIT_NOERROR == cExitCode ) || ( cExit != EXIT_NOERROR ) )
cExitCode = cExit;
}
void ShowUsage();
void Message( const String& rText, BYTE cExitCode );
sal_uInt64 GetCRC( Bitmap& rBmp );
void ProcessFile( const String& rBmpFileName );
void ProcessFileList( const String& rInFileList, const String& rOutFileList, const String& rOutPath );
public:
BmpSum();
~BmpSum();
int Start( const ::std::vector< String >& rArgs );
};
// -----------------------------------------------------------------------------
BmpSum::BmpSum()
{
}
// -----------------------------------------------------------------------------
BmpSum::~BmpSum()
{
}
// -----------------------------------------------------------------------
BOOL BmpSum::GetCommandOption( const ::std::vector< String >& rArgs, const String& rSwitch, String& rParam )
{
BOOL bRet = FALSE;
for( int i = 0, nCount = rArgs.size(); ( i < nCount ) && !bRet; i++ )
{
String aTestStr( '-' );
for( int n = 0; ( n < 2 ) && !bRet; n++ )
{
aTestStr += rSwitch;
if( aTestStr.CompareIgnoreCaseToAscii( rArgs[ i ] ) == COMPARE_EQUAL )
{
bRet = TRUE;
if( i < ( nCount - 1 ) )
rParam = rArgs[ i + 1 ];
else
rParam = String();
}
if( 0 == n )
aTestStr = '/';
}
}
return bRet;
}
// -----------------------------------------------------------------------
BOOL BmpSum::GetCommandOptions( const ::std::vector< String >& rArgs, const String& rSwitch, ::std::vector< String >& rParams )
{
BOOL bRet = FALSE;
for( int i = 0, nCount = rArgs.size(); ( i < nCount ); i++ )
{
String aTestStr( '-' );
for( int n = 0; ( n < 2 ) && !bRet; n++ )
{
aTestStr += rSwitch;
if( aTestStr.CompareIgnoreCaseToAscii( rArgs[ i ] ) == COMPARE_EQUAL )
{
if( i < ( nCount - 1 ) )
rParams.push_back( rArgs[ i + 1 ] );
else
rParams.push_back( String() );
break;
}
if( 0 == n )
aTestStr = '/';
}
}
return( rParams.size() > 0 );
}
// -----------------------------------------------------------------------
void BmpSum::Message( const String& rText, BYTE nExitCode )
{
if( EXIT_NOERROR != nExitCode )
SetExitCode( nExitCode );
ByteString aText( rText, RTL_TEXTENCODING_UTF8 );
aText.Append( "\r\n" );
fprintf( stderr, aText.GetBuffer() );
}
// -----------------------------------------------------------------------------
void BmpSum::ShowUsage()
{
Message( String( RTL_CONSTASCII_USTRINGPARAM( "Usage:" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum bmp_inputfile" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum -i input_filelist -o output_filelist [-p path_for_copied_bitmaps]" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( "Options:" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( "Examples:" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum /home/test.bmp" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum -i /home/inlist.txt -o /home/outlist.txt" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum -i /home/inlist.txt -o /home/outlist.txt -p /home/outpath" ) ), EXIT_NOERROR );
}
// -----------------------------------------------------------------------------
int BmpSum::Start( const ::std::vector< String >& rArgs )
{
cExitCode = EXIT_NOERROR;
if( rArgs.size() >= 1 )
{
String aInFileList, aOutFileList, aOutPath;
if( GetCommandOption( rArgs, 'i', aInFileList ) &&
GetCommandOption( rArgs, 'o', aOutFileList ) )
{
GetCommandOption( rArgs, 'p', aOutPath );
ProcessFileList( aInFileList, aOutFileList, aOutPath );
}
else
{
ProcessFile( rArgs[ 0 ] );
}
}
else
{
ShowUsage();
cExitCode = EXIT_COMMONERROR;
}
return cExitCode;
}
// -----------------------------------------------------------------------------
sal_uInt64 BmpSum::GetCRC( Bitmap& rBmp )
{
BitmapReadAccess* pRAcc = rBmp.AcquireReadAccess();
sal_uInt64 nRet = 0;
sal_uInt32 nCrc = 0;
if( pRAcc && pRAcc->Width() && pRAcc->Height() )
{
SVBT32 aBT32;
for( long nY = 0; nY < pRAcc->Height(); ++nY )
{
for( long nX = 0; nX < pRAcc->Width(); ++nX )
{
const BitmapColor aCol( pRAcc->GetColor( nY, nX ) );
UInt32ToSVBT32( aCol.GetRed(), aBT32 );
nCrc = rtl_crc32( nCrc, aBT32, 4 );
UInt32ToSVBT32( aCol.GetGreen(), aBT32 );
nCrc = rtl_crc32( nCrc, aBT32, 4 );
UInt32ToSVBT32( aCol.GetBlue(), aBT32 );
nCrc = rtl_crc32( nCrc, aBT32, 4 );
}
}
nRet = ( ( (sal_uInt64) pRAcc->Width() ) << 48 ) |
( ( (sal_uInt64) pRAcc->Height() ) << 32 ) |
( (sal_uInt64) nCrc );
}
rBmp.ReleaseAccess( pRAcc );
return nRet;
}
// -----------------------------------------------------------------------------
void BmpSum::ProcessFile( const String& rBmpFileName )
{
SvFileStream aIStm( rBmpFileName, STREAM_READ );
if( aIStm.IsOpen() )
{
Bitmap aBmp;
aIStm >> aBmp;
if( !aBmp.IsEmpty() )
{
#ifdef WNT
fprintf( stdout, "%I64u\r\n", GetCRC( aBmp ) );
#else
fprintf( stdout, "%llu\r\n", GetCRC( aBmp ) );
#endif
}
else
{
aIStm.ResetError();
aIStm.Seek( 0 );
::vcl::PNGReader aPngReader( aIStm );
aBmp = aPngReader.Read().GetBitmap();
if( !aBmp.IsEmpty() )
{
#ifdef WNT
fprintf( stdout, "%I64u\r\n", GetCRC( aBmp ) );
#else
fprintf( stdout, "%llu\r\n", GetCRC( aBmp ) );
#endif
}
else
Message( String( RTL_CONSTASCII_USTRINGPARAM( "file not valid" ) ), EXIT_INVALIDFILE );
}
}
}
// -----------------------------------------------------------------------------
void BmpSum::ProcessFileList( const String& rInFileList,
const String& rOutFileList,
const String& rOutPath )
{
SvFileStream aIStm( rInFileList, STREAM_READ );
SvFileStream aOStm( rOutFileList, STREAM_WRITE | STREAM_TRUNC );
const DirEntry aBaseDir( rOutPath );
if( rOutPath.Len() )
aBaseDir.MakeDir();
if( aIStm.IsOpen() && aOStm.IsOpen() )
{
ByteString aReadLine;
::std::set< ByteString > aFileNameSet;
while( aIStm.ReadLine( aReadLine ) )
{
if( aReadLine.Len() )
aFileNameSet.insert( aReadLine );
if( aReadLine.Search( "enus" ) != STRING_NOTFOUND )
{
static const char* aLanguages[] =
{
"chinsim",
"chintrad",
"dtch",
"enus",
"fren",
"hebrew"
"ital",
"japn",
"korean",
"pol",
"poln",
"port",
"russ",
"span",
"turk"
};
for( sal_uInt32 n = 0; n < 14; ++n )
{
ByteString aLangPath( aReadLine );
aLangPath.SearchAndReplace( "enus", aLanguages[ n ] );
DirEntry aTestFile( aLangPath );
if( aTestFile.Exists() )
aFileNameSet.insert( aLangPath );
}
}
aReadLine.Erase();
}
aIStm.Close();
::std::set< ByteString >::iterator aIter( aFileNameSet.begin() );
::std::map< sal_uInt64, ::std::vector< ByteString > > aFileNameMap;
while( aIter != aFileNameSet.end() )
{
ByteString aStr( *aIter++ );
SvFileStream aBmpStm( String( aStr.GetBuffer(), RTL_TEXTENCODING_ASCII_US ), STREAM_READ );
sal_uInt64 nCRC = 0;
if( aBmpStm.IsOpen() )
{
Bitmap aBmp;
aBmpStm >> aBmp;
if( !aBmp.IsEmpty() )
nCRC = GetCRC( aBmp );
else
{
aBmpStm.ResetError();
aBmpStm.Seek( 0 );
::vcl::PNGReader aPngReader( aBmpStm );
aBmp = aPngReader.Read().GetBitmap();
if( !aBmp.IsEmpty() )
nCRC = GetCRC( aBmp );
else
fprintf( stderr, "%s could not be opened\n", aStr.GetBuffer() );
}
aBmpStm.Close();
}
if( nCRC )
{
::std::map< sal_uInt64, ::std::vector< ByteString > >::iterator aFound( aFileNameMap.find( nCRC ) );
if( aFound != aFileNameMap.end() )
(*aFound).second.push_back( aStr );
else
{
::std::vector< ByteString > aVector( 1, aStr );
aFileNameMap[ nCRC ] = aVector;
}
}
else
{
::std::vector< ByteString > aVector( 1, aStr );
aFileNameMap[ nCRC ] = aVector;
}
}
::std::map< sal_uInt64, ::std::vector< ByteString > >::iterator aMapIter( aFileNameMap.begin() );
sal_uInt32 nFileCount = 0;
while( aMapIter != aFileNameMap.end() )
{
::std::pair< const sal_uInt64, ::std::vector< ByteString > > aPair( *aMapIter++ );
::std::vector< ByteString > aFileNameVector( aPair.second );
// write new entries
for( sal_uInt32 i = 0; i < aFileNameVector.size(); ++i )
{
ByteString aStr( ByteString::CreateFromInt64( aPair.first ) );
ByteString aFileName( aFileNameVector[ i ] );
DirEntry aSrcFile( aFileName );
aStr += '\t';
aStr += aFileName;
aOStm.WriteLine( aStr );
// copy bitmap
if( rOutPath.Len() )
{
if( aFileName.Search( ":\\" ) != STRING_NOTFOUND )
aFileName.Erase( 0, aFileName.Search( ":\\" ) + 2 );
aFileName.SearchAndReplaceAll( '\\', '/' );
sal_uInt16 nTokenCount = aFileName.GetTokenCount( '/' );
DirEntry aNewDir( aBaseDir );
for( sal_uInt16 n = 0; ( n < nTokenCount - 1 ); n++ )
{
aNewDir += DirEntry( aFileName.GetToken( n, '/' ) );
aNewDir.MakeDir();
}
aNewDir += DirEntry( aFileName.GetToken( nTokenCount - 1, '/' ) );
aSrcFile.CopyTo( aNewDir, FSYS_ACTION_COPYFILE );
}
}
++nFileCount;
}
fprintf( stdout, "unique file count: %u", nFileCount );
}
}
// --------
// - Main -
// --------
int main( int nArgCount, char* ppArgs[] )
{
::std::vector< String > aArgs;
BmpSum aBmpSum;
InitVCL( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >() );
for( int i = 1; i < nArgCount; i++ )
aArgs.push_back( String( ppArgs[ i ], RTL_TEXTENCODING_ASCII_US ) );
return aBmpSum.Start( aArgs );
}
<commit_msg>INTEGRATION: CWS warningfixes02 (1.8.12); FILE MERGED 2006/06/30 12:20:40 sb 1.8.12.1: #i66577# Made the code compile (warning-free) on a unxlngi6.pro GCC 4.1.1 Linux box.<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: bmpsum.cxx,v $
*
* $Revision: 1.9 $
*
* last change: $Author: kz $ $Date: 2006-07-19 17:03:49 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#include <stdio.h>
#include <signal.h>
#include <vector>
#include <set>
#include <map>
#include <rtl/crc.h>
#include <tools/stream.hxx>
#include <tools/fsys.hxx>
#include <vcl/svapp.hxx>
#include <vcl/bitmap.hxx>
#include <vcl/bmpacc.hxx>
#include <vcl/pngread.hxx>
#include "solar.hrc"
#include "filedlg.hxx"
#define EXIT_NOERROR 0x00000000
#define EXIT_INVALIDFILE 0x00000001
#define EXIT_COMMONERROR 0x80000000
// ----------
// - BmpSum -
// ----------
class BmpSum
{
private:
sal_uInt32 cExitCode;
BOOL GetCommandOption( const ::std::vector< String >& rArgs, const String& rSwitch, String& rSwitchParam );
BOOL GetCommandOptions( const ::std::vector< String >& rArgs, const String& rSwitch, ::std::vector< String >& rSwitchParams );
void SetExitCode( BYTE cExit )
{
if( ( EXIT_NOERROR == cExitCode ) || ( cExit != EXIT_NOERROR ) )
cExitCode = cExit;
}
void ShowUsage();
void Message( const String& rText, BYTE cExitCode );
sal_uInt64 GetCRC( Bitmap& rBmp );
void ProcessFile( const String& rBmpFileName );
void ProcessFileList( const String& rInFileList, const String& rOutFileList, const String& rOutPath );
public:
BmpSum();
~BmpSum();
int Start( const ::std::vector< String >& rArgs );
};
// -----------------------------------------------------------------------------
BmpSum::BmpSum()
{
}
// -----------------------------------------------------------------------------
BmpSum::~BmpSum()
{
}
// -----------------------------------------------------------------------
BOOL BmpSum::GetCommandOption( const ::std::vector< String >& rArgs, const String& rSwitch, String& rParam )
{
BOOL bRet = FALSE;
for( int i = 0, nCount = rArgs.size(); ( i < nCount ) && !bRet; i++ )
{
String aTestStr( '-' );
for( int n = 0; ( n < 2 ) && !bRet; n++ )
{
aTestStr += rSwitch;
if( aTestStr.CompareIgnoreCaseToAscii( rArgs[ i ] ) == COMPARE_EQUAL )
{
bRet = TRUE;
if( i < ( nCount - 1 ) )
rParam = rArgs[ i + 1 ];
else
rParam = String();
}
if( 0 == n )
aTestStr = '/';
}
}
return bRet;
}
// -----------------------------------------------------------------------
BOOL BmpSum::GetCommandOptions( const ::std::vector< String >& rArgs, const String& rSwitch, ::std::vector< String >& rParams )
{
BOOL bRet = FALSE;
for( int i = 0, nCount = rArgs.size(); ( i < nCount ); i++ )
{
String aTestStr( '-' );
for( int n = 0; ( n < 2 ) && !bRet; n++ )
{
aTestStr += rSwitch;
if( aTestStr.CompareIgnoreCaseToAscii( rArgs[ i ] ) == COMPARE_EQUAL )
{
if( i < ( nCount - 1 ) )
rParams.push_back( rArgs[ i + 1 ] );
else
rParams.push_back( String() );
break;
}
if( 0 == n )
aTestStr = '/';
}
}
return( rParams.size() > 0 );
}
// -----------------------------------------------------------------------
void BmpSum::Message( const String& rText, BYTE nExitCode )
{
if( EXIT_NOERROR != nExitCode )
SetExitCode( nExitCode );
ByteString aText( rText, RTL_TEXTENCODING_UTF8 );
aText.Append( "\r\n" );
fprintf( stderr, aText.GetBuffer() );
}
// -----------------------------------------------------------------------------
void BmpSum::ShowUsage()
{
Message( String( RTL_CONSTASCII_USTRINGPARAM( "Usage:" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum bmp_inputfile" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum -i input_filelist -o output_filelist [-p path_for_copied_bitmaps]" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( "Options:" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( "Examples:" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum /home/test.bmp" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum -i /home/inlist.txt -o /home/outlist.txt" ) ), EXIT_NOERROR );
Message( String( RTL_CONSTASCII_USTRINGPARAM( " bmpsum -i /home/inlist.txt -o /home/outlist.txt -p /home/outpath" ) ), EXIT_NOERROR );
}
// -----------------------------------------------------------------------------
int BmpSum::Start( const ::std::vector< String >& rArgs )
{
cExitCode = EXIT_NOERROR;
if( rArgs.size() >= 1 )
{
String aInFileList, aOutFileList, aOutPath;
if( GetCommandOption( rArgs, 'i', aInFileList ) &&
GetCommandOption( rArgs, 'o', aOutFileList ) )
{
GetCommandOption( rArgs, 'p', aOutPath );
ProcessFileList( aInFileList, aOutFileList, aOutPath );
}
else
{
ProcessFile( rArgs[ 0 ] );
}
}
else
{
ShowUsage();
cExitCode = EXIT_COMMONERROR;
}
return cExitCode;
}
// -----------------------------------------------------------------------------
sal_uInt64 BmpSum::GetCRC( Bitmap& rBmp )
{
BitmapReadAccess* pRAcc = rBmp.AcquireReadAccess();
sal_uInt64 nRet = 0;
sal_uInt32 nCrc = 0;
if( pRAcc && pRAcc->Width() && pRAcc->Height() )
{
SVBT32 aBT32;
for( long nY = 0; nY < pRAcc->Height(); ++nY )
{
for( long nX = 0; nX < pRAcc->Width(); ++nX )
{
const BitmapColor aCol( pRAcc->GetColor( nY, nX ) );
UInt32ToSVBT32( aCol.GetRed(), aBT32 );
nCrc = rtl_crc32( nCrc, aBT32, 4 );
UInt32ToSVBT32( aCol.GetGreen(), aBT32 );
nCrc = rtl_crc32( nCrc, aBT32, 4 );
UInt32ToSVBT32( aCol.GetBlue(), aBT32 );
nCrc = rtl_crc32( nCrc, aBT32, 4 );
}
}
nRet = ( ( (sal_uInt64) pRAcc->Width() ) << 48 ) |
( ( (sal_uInt64) pRAcc->Height() ) << 32 ) |
( (sal_uInt64) nCrc );
}
rBmp.ReleaseAccess( pRAcc );
return nRet;
}
// -----------------------------------------------------------------------------
void BmpSum::ProcessFile( const String& rBmpFileName )
{
SvFileStream aIStm( rBmpFileName, STREAM_READ );
if( aIStm.IsOpen() )
{
Bitmap aBmp;
aIStm >> aBmp;
if( !aBmp.IsEmpty() )
{
#ifdef WNT
fprintf( stdout, "%I64u\r\n", GetCRC( aBmp ) );
#else
fprintf( stdout, "%llu\r\n", GetCRC( aBmp ) );
#endif
}
else
{
aIStm.ResetError();
aIStm.Seek( 0 );
::vcl::PNGReader aPngReader( aIStm );
aBmp = aPngReader.Read().GetBitmap();
if( !aBmp.IsEmpty() )
{
#ifdef WNT
fprintf( stdout, "%I64u\r\n", GetCRC( aBmp ) );
#else
fprintf( stdout, "%llu\r\n", GetCRC( aBmp ) );
#endif
}
else
Message( String( RTL_CONSTASCII_USTRINGPARAM( "file not valid" ) ), EXIT_INVALIDFILE );
}
}
}
// -----------------------------------------------------------------------------
void BmpSum::ProcessFileList( const String& rInFileList,
const String& rOutFileList,
const String& rOutPath )
{
SvFileStream aIStm( rInFileList, STREAM_READ );
SvFileStream aOStm( rOutFileList, STREAM_WRITE | STREAM_TRUNC );
const DirEntry aBaseDir( rOutPath );
if( rOutPath.Len() )
aBaseDir.MakeDir();
if( aIStm.IsOpen() && aOStm.IsOpen() )
{
ByteString aReadLine;
::std::set< ByteString > aFileNameSet;
while( aIStm.ReadLine( aReadLine ) )
{
if( aReadLine.Len() )
aFileNameSet.insert( aReadLine );
if( aReadLine.Search( "enus" ) != STRING_NOTFOUND )
{
static const char* aLanguages[] =
{
"chinsim",
"chintrad",
"dtch",
"enus",
"fren",
"hebrew"
"ital",
"japn",
"korean",
"pol",
"poln",
"port",
"russ",
"span",
"turk"
};
for( sal_uInt32 n = 0; n < 14; ++n )
{
ByteString aLangPath( aReadLine );
aLangPath.SearchAndReplace( "enus", aLanguages[ n ] );
DirEntry aTestFile( aLangPath );
if( aTestFile.Exists() )
aFileNameSet.insert( aLangPath );
}
}
aReadLine.Erase();
}
aIStm.Close();
::std::set< ByteString >::iterator aIter( aFileNameSet.begin() );
::std::map< sal_uInt64, ::std::vector< ByteString > > aFileNameMap;
while( aIter != aFileNameSet.end() )
{
ByteString aStr( *aIter++ );
SvFileStream aBmpStm( String( aStr.GetBuffer(), RTL_TEXTENCODING_ASCII_US ), STREAM_READ );
sal_uInt64 nCRC = 0;
if( aBmpStm.IsOpen() )
{
Bitmap aBmp;
aBmpStm >> aBmp;
if( !aBmp.IsEmpty() )
nCRC = GetCRC( aBmp );
else
{
aBmpStm.ResetError();
aBmpStm.Seek( 0 );
::vcl::PNGReader aPngReader( aBmpStm );
aBmp = aPngReader.Read().GetBitmap();
if( !aBmp.IsEmpty() )
nCRC = GetCRC( aBmp );
else
fprintf( stderr, "%s could not be opened\n", aStr.GetBuffer() );
}
aBmpStm.Close();
}
if( nCRC )
{
::std::map< sal_uInt64, ::std::vector< ByteString > >::iterator aFound( aFileNameMap.find( nCRC ) );
if( aFound != aFileNameMap.end() )
(*aFound).second.push_back( aStr );
else
{
::std::vector< ByteString > aVector( 1, aStr );
aFileNameMap[ nCRC ] = aVector;
}
}
else
{
::std::vector< ByteString > aVector( 1, aStr );
aFileNameMap[ nCRC ] = aVector;
}
}
::std::map< sal_uInt64, ::std::vector< ByteString > >::iterator aMapIter( aFileNameMap.begin() );
sal_uInt32 nFileCount = 0;
while( aMapIter != aFileNameMap.end() )
{
::std::pair< const sal_uInt64, ::std::vector< ByteString > > aPair( *aMapIter++ );
::std::vector< ByteString > aFileNameVector( aPair.second );
// write new entries
for( sal_uInt32 i = 0; i < aFileNameVector.size(); ++i )
{
ByteString aStr( ByteString::CreateFromInt64( aPair.first ) );
ByteString aFileName( aFileNameVector[ i ] );
DirEntry aSrcFile( aFileName );
aStr += '\t';
aStr += aFileName;
aOStm.WriteLine( aStr );
// copy bitmap
if( rOutPath.Len() )
{
if( aFileName.Search( ":\\" ) != STRING_NOTFOUND )
aFileName.Erase( 0, aFileName.Search( ":\\" ) + 2 );
aFileName.SearchAndReplaceAll( '\\', '/' );
sal_uInt16 nTokenCount = aFileName.GetTokenCount( '/' );
DirEntry aNewDir( aBaseDir );
for( sal_uInt16 n = 0; ( n < nTokenCount - 1 ); n++ )
{
aNewDir += DirEntry( aFileName.GetToken( n, '/' ) );
aNewDir.MakeDir();
}
aNewDir += DirEntry( aFileName.GetToken( nTokenCount - 1, '/' ) );
aSrcFile.CopyTo( aNewDir, FSYS_ACTION_COPYFILE );
}
}
++nFileCount;
}
fprintf(
stdout, "unique file count: %lu",
sal::static_int_cast< unsigned long >(nFileCount) );
}
}
// --------
// - Main -
// --------
int main( int nArgCount, char* ppArgs[] )
{
::std::vector< String > aArgs;
BmpSum aBmpSum;
InitVCL( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >() );
for( int i = 1; i < nArgCount; i++ )
aArgs.push_back( String( ppArgs[ i ], RTL_TEXTENCODING_ASCII_US ) );
return aBmpSum.Start( aArgs );
}
<|endoftext|> |
<commit_before>#include <stdio.h>
#include <udis86.h>
#include <disassembly.hh>
static int next_byte(ud_t *ud);
class Disassembly : public IDisassembly
{
public:
friend int next_byte(ud_t *);
Disassembly()
{
ud_init(&m_ud);
ud_set_user_opaque_data(&m_ud, (void *)this);
ud_set_input_hook(&m_ud, next_byte);
ud_set_mode(&m_ud, 32);
m_data = NULL;
m_dataSize = 0;
m_count = 0;
}
bool execute(IDisassembly::IInstructionListener *listener,
uint8_t *data, size_t size)
{
if (!listener)
return false;
if (!data || size == 0)
return false;
m_data = data;
m_dataSize = size;
m_count = 0;
while (ud_disassemble(&m_ud)) {
bool mem = (m_ud.operand[0].type == UD_OP_MEM ||
m_ud.operand[1].type == UD_OP_MEM ||
m_ud.operand[2].type == UD_OP_MEM);
bool call = m_ud.mnemonic == UD_Icall;
bool branch = m_ud.mnemonic == UD_Ijo ||
m_ud.mnemonic == UD_Ijno ||
m_ud.mnemonic == UD_Ijb ||
m_ud.mnemonic == UD_Ijae ||
m_ud.mnemonic == UD_Ijz ||
m_ud.mnemonic == UD_Ijnz ||
m_ud.mnemonic == UD_Ijbe ||
m_ud.mnemonic == UD_Ija ||
m_ud.mnemonic == UD_Ijs ||
m_ud.mnemonic == UD_Ijns ||
m_ud.mnemonic == UD_Ijp ||
m_ud.mnemonic == UD_Ijnp ||
m_ud.mnemonic == UD_Ijl ||
m_ud.mnemonic == UD_Ijge ||
m_ud.mnemonic == UD_Ijle ||
m_ud.mnemonic == UD_Ijg ||
m_ud.mnemonic == UD_Ijcxz ||
m_ud.mnemonic == UD_Ijecxz ||
m_ud.mnemonic == UD_Ijrcxz ||
m_ud.mnemonic == UD_Ijmp;
if (mem)
listener->onMemoryReference(ud_insn_off(&m_ud), false);
if (call)
listener->onCall(ud_insn_off(&m_ud));
if (branch)
listener->onBranch(ud_insn_off(&m_ud));
}
return true;
}
private:
int nextUdByte()
{
if (m_count == m_dataSize)
return UD_EOI;
return m_data[m_count++];
}
ud_t m_ud;
uint8_t *m_data;
size_t m_dataSize;
size_t m_count;
};
static int next_byte(ud_t *ud)
{
Disassembly *p = (Disassembly *)ud_get_user_opaque_data(ud);
return p->nextUdByte();
}
IDisassembly &IDisassembly::getInstance()
{
static Disassembly *instance;
if (!instance)
instance = new Disassembly();
return *instance;
}
<commit_msg>disassembly: Set the input hook for each run<commit_after>#include <stdio.h>
#include <udis86.h>
#include <disassembly.hh>
static int next_byte(ud_t *ud);
class Disassembly : public IDisassembly
{
public:
friend int next_byte(ud_t *);
Disassembly()
{
ud_init(&m_ud);
ud_set_user_opaque_data(&m_ud, (void *)this);
ud_set_mode(&m_ud, 32);
m_data = NULL;
m_dataSize = 0;
m_count = 0;
}
bool execute(IDisassembly::IInstructionListener *listener,
uint8_t *data, size_t size)
{
if (!listener)
return false;
if (!data || size == 0)
return false;
m_data = data;
m_dataSize = size;
m_count = 0;
ud_set_input_hook(&m_ud, next_byte);
while (ud_disassemble(&m_ud)) {
bool mem = (m_ud.operand[0].type == UD_OP_MEM ||
m_ud.operand[1].type == UD_OP_MEM ||
m_ud.operand[2].type == UD_OP_MEM);
bool call = m_ud.mnemonic == UD_Icall;
bool branch = m_ud.mnemonic == UD_Ijo ||
m_ud.mnemonic == UD_Ijno ||
m_ud.mnemonic == UD_Ijb ||
m_ud.mnemonic == UD_Ijae ||
m_ud.mnemonic == UD_Ijz ||
m_ud.mnemonic == UD_Ijnz ||
m_ud.mnemonic == UD_Ijbe ||
m_ud.mnemonic == UD_Ija ||
m_ud.mnemonic == UD_Ijs ||
m_ud.mnemonic == UD_Ijns ||
m_ud.mnemonic == UD_Ijp ||
m_ud.mnemonic == UD_Ijnp ||
m_ud.mnemonic == UD_Ijl ||
m_ud.mnemonic == UD_Ijge ||
m_ud.mnemonic == UD_Ijle ||
m_ud.mnemonic == UD_Ijg ||
m_ud.mnemonic == UD_Ijcxz ||
m_ud.mnemonic == UD_Ijecxz ||
m_ud.mnemonic == UD_Ijrcxz ||
m_ud.mnemonic == UD_Ijmp;
if (mem)
listener->onMemoryReference(ud_insn_off(&m_ud), false);
if (call)
listener->onCall(ud_insn_off(&m_ud));
if (branch)
listener->onBranch(ud_insn_off(&m_ud));
}
return true;
}
private:
int nextUdByte()
{
if (m_count == m_dataSize)
return UD_EOI;
return m_data[m_count++];
}
ud_t m_ud;
uint8_t *m_data;
size_t m_dataSize;
size_t m_count;
};
static int next_byte(ud_t *ud)
{
Disassembly *p = (Disassembly *)ud_get_user_opaque_data(ud);
return p->nextUdByte();
}
IDisassembly &IDisassembly::getInstance()
{
static Disassembly *instance;
if (!instance)
instance = new Disassembly();
return *instance;
}
<|endoftext|> |
<commit_before>
#ifndef SVTOOLS_COLLATORRESSOURCE_HXX
#define SVTOOLS_COLLATORRESSOURCE_HXX
#ifndef INCLUDED_SVTDLLAPI_H
#include "svtools/svtdllapi.h"
#endif
#ifndef _STRING_HXX
#include <tools/string.hxx>
#endif
class CollatorRessourceData;
class SVT_DLLPUBLIC CollatorRessource
{
private:
CollatorRessourceData *mp_Data;
public:
CollatorRessource ();
~CollatorRessource ();
const String& GetTranslation (const String& r_Algorithm);
};
#endif /* SVTOOLS_COLLATORRESSOURCE_HXX */
<commit_msg>INTEGRATION: CWS changefileheader (1.3.546); FILE MERGED 2008/04/01 15:44:18 thb 1.3.546.2: #i85898# Stripping all external header guards 2008/04/01 12:43:05 thb 1.3.546.1: #i85898# Stripping all external header guards<commit_after>
#ifndef SVTOOLS_COLLATORRESSOURCE_HXX
#define SVTOOLS_COLLATORRESSOURCE_HXX
#include "svtools/svtdllapi.h"
#include <tools/string.hxx>
class CollatorRessourceData;
class SVT_DLLPUBLIC CollatorRessource
{
private:
CollatorRessourceData *mp_Data;
public:
CollatorRessource ();
~CollatorRessource ();
const String& GetTranslation (const String& r_Algorithm);
};
#endif /* SVTOOLS_COLLATORRESSOURCE_HXX */
<|endoftext|> |
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: stmenu.hxx,v $
*
* $Revision: 1.3 $
*
* last change: $Author: hr $ $Date: 2007-06-27 13:24:53 $
*
* 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
*
* Initial Contributer was Fabalabs Software GmbH, Jakob Lechner
*
* 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
*
************************************************************************/
// SMARTTAGS
#ifndef _STMENU_HXX
#define _STMENU_HXX
#ifndef _MENU_HXX //autogen
#include <vcl/menu.hxx>
#endif
#include <vector>
#ifndef _COM_SUN_STAR_SMARTTAGS_XSMARTTAGACTION_HPP_
#include <com/sun/star/smarttags/XSmartTagAction.hpp>
#endif
#ifndef _COM_SUN_STAR_SMARTTAGS_XSTRINGKEYMAP_HPP_
#include <com/sun/star/container/XStringKeyMap.hpp>
#endif
#ifndef _COM_SUN_STAR_TEXT_XTEXTRANGE_HPP_
#include <com/sun/star/text/XTextRange.hpp>
#endif
class SwView;
/** Class: SwSmartTagPopup
This class contains the implementation of the smarttag popup
menu that is opened if a user clicks on an underlined word.
The menu is built in the constructor and the actions for each
menu entry are invoked in the excute-method.
*/
class SwSmartTagPopup : public PopupMenu
{
SwView* mpSwView;
com::sun::star::uno::Reference< com::sun::star::text::XTextRange > mxTextRange;
struct InvokeAction
{
com::sun::star::uno::Reference< com::sun::star::smarttags::XSmartTagAction > mxAction;
com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > mxSmartTagProperties;
sal_uInt32 mnActionID;
InvokeAction( com::sun::star::uno::Reference< com::sun::star::smarttags::XSmartTagAction > xAction,
com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xSmartTagProperties,
sal_uInt32 nActionID ) : mxAction( xAction ), mxSmartTagProperties( xSmartTagProperties ), mnActionID( nActionID ) {}
};
std::vector< InvokeAction > maInvokeActions;
public:
SwSmartTagPopup( SwView* _pSwView,
::com::sun::star::uno::Sequence< rtl::OUString >& rSmartTagTypes,
::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::container::XStringKeyMap > >& rStringKeyMaps,
::com::sun::star::uno::Reference< com::sun::star::text::XTextRange > xTextRange );
sal_uInt16 Execute( Window* pWin, const Rectangle& rPopupPos );
};
#endif
<commit_msg>INTEGRATION: CWS swwarnings (1.2.102); FILE MERGED 2007/08/24 10:55:15 tl 1.2.102.3: #i69287# warning-free code 2007/08/20 15:53:18 tl 1.2.102.2: RESYNC: (1.2-1.3); FILE MERGED 2007/03/05 12:45:49 tl 1.2.102.1: #i69287# warning-free code<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: stmenu.hxx,v $
*
* $Revision: 1.4 $
*
* last change: $Author: hr $ $Date: 2007-09-27 12:10:13 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* Initial Contributer was Fabalabs Software GmbH, Jakob Lechner
*
* 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
*
************************************************************************/
// SMARTTAGS
#ifndef _STMENU_HXX
#define _STMENU_HXX
#ifndef _MENU_HXX //autogen
#include <vcl/menu.hxx>
#endif
#include <vector>
#ifndef _COM_SUN_STAR_SMARTTAGS_XSMARTTAGACTION_HPP_
#include <com/sun/star/smarttags/XSmartTagAction.hpp>
#endif
#ifndef _COM_SUN_STAR_SMARTTAGS_XSTRINGKEYMAP_HPP_
#include <com/sun/star/container/XStringKeyMap.hpp>
#endif
#ifndef _COM_SUN_STAR_TEXT_XTEXTRANGE_HPP_
#include <com/sun/star/text/XTextRange.hpp>
#endif
class SwView;
/** Class: SwSmartTagPopup
This class contains the implementation of the smarttag popup
menu that is opened if a user clicks on an underlined word.
The menu is built in the constructor and the actions for each
menu entry are invoked in the excute-method.
*/
class SwSmartTagPopup : public PopupMenu
{
SwView* mpSwView;
com::sun::star::uno::Reference< com::sun::star::text::XTextRange > mxTextRange;
struct InvokeAction
{
com::sun::star::uno::Reference< com::sun::star::smarttags::XSmartTagAction > mxAction;
com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > mxSmartTagProperties;
sal_uInt32 mnActionID;
InvokeAction( com::sun::star::uno::Reference< com::sun::star::smarttags::XSmartTagAction > xAction,
com::sun::star::uno::Reference< com::sun::star::container::XStringKeyMap > xSmartTagProperties,
sal_uInt32 nActionID ) : mxAction( xAction ), mxSmartTagProperties( xSmartTagProperties ), mnActionID( nActionID ) {}
};
std::vector< InvokeAction > maInvokeActions;
protected:
using PopupMenu::Execute;
public:
SwSmartTagPopup( SwView* _pSwView,
::com::sun::star::uno::Sequence< rtl::OUString >& rSmartTagTypes,
::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::container::XStringKeyMap > >& rStringKeyMaps,
::com::sun::star::uno::Reference< com::sun::star::text::XTextRange > xTextRange );
sal_uInt16 Execute( const Rectangle& rPopupPos, Window* pWin );
};
#endif
<|endoftext|> |
<commit_before>#include "../include/image.h"
#include "../include/glinclude.h"
#include "../include/math.h"
#include <math.h>
#include <stdlib.h>
#include "../include/renderer.h"
// TAREA: Declarar funciones de stb_image.c
extern "C" {
unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp);
void stbi_image_free(void *retval_from_stbi_load);
}
Image::Image(const String &filename, uint16 hframes, uint16 vframes) {
this->filename = filename;
this->hframes = hframes;
this->vframes = vframes;
width = 0;
height = 0;
handlex = 0;
handley = 0;
gltex = 0;
lastU = 1.0;
lastV = 1.0;
int width32 = 0;
int height32 = 0;
int *ptrComp = NULL;
uint8 *buffer = stbi_load(filename.ToCString(), &width32, &height32, ptrComp, 4);
width = static_cast<uint16>(width32);
height = static_cast<uint16>(height32);
//PO2 -> Power of 2
double widthPO2 = pow(2, ceil(Log2(width)));
double heightPO2 = pow(2, ceil(Log2(height)));
if (widthPO2 != width || heightPO2 != height) {
lastU = static_cast<double>(width / widthPO2);
lastV = static_cast<double>(height / heightPO2);
widthPO2 = static_cast<uint16>(widthPO2);
heightPO2 = static_cast<uint16>(heightPO2);
//allocating memory for new buffer
uint8 *bufferPO2 = (uint8 *)malloc(widthPO2 * heightPO2 * 4); // * 4 because each pixel needs 32 bits
uint8 * const origBufferPO2pos = bufferPO2; //ptr to keep reference to the bufferPO2
//setting pixels to white -> as texture has transparent pixels, check everything is working properly
memset(bufferPO2, 255, widthPO2 * heightPO2 * 4);
for (unsigned int h = 0; h < height; h++) {
memcpy(bufferPO2, buffer, width * 4);
bufferPO2 += static_cast<int>(widthPO2) * 4;
buffer += (width * 4);
}
bufferPO2 = origBufferPO2pos;
//bufferPO2 -= static_cast<int>(widthPO2) * height * 4;
//call to genImage, creating texture in VRAM
this->gltex = Renderer::Instance().GenImage(bufferPO2, widthPO2, heightPO2);
//now, the texture is in VRAM so we no longer need it in RAM
stbi_image_free(bufferPO2);
}
else {
// Generamos la textura
if ( buffer ) {
this->gltex = Renderer::Instance().GenImage(buffer, width, height);
stbi_image_free(buffer);
}
}
}
Image::~Image() {
if (gltex != 0) Renderer::Instance().DeleteImage(this->gltex);
}
void Image::Bind() const {
Renderer::Instance().BindImage(this->gltex);
}
<commit_msg>Refactor<commit_after>#include "../include/image.h"
#include "../include/glinclude.h"
#include "../include/math.h"
#include <math.h>
#include <stdlib.h>
#include "../include/renderer.h"
// TAREA: Declarar funciones de stb_image.c
extern "C" {
unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp);
void stbi_image_free(void *retval_from_stbi_load);
}
Image::Image(const String &filename, uint16 hframes, uint16 vframes) {
this->filename = filename;
this->hframes = hframes;
this->vframes = vframes;
width = 0;
height = 0;
handlex = 0;
handley = 0;
gltex = 0;
lastU = 1.0;
lastV = 1.0;
int width32 = 0;
int height32 = 0;
int *ptrComp = NULL;
uint8 *buffer = stbi_load(filename.ToCString(), &width32, &height32, ptrComp, 4);
width = static_cast<uint16>(width32);
height = static_cast<uint16>(height32);
//PO2 -> Power of 2
double widthPO2 = pow(2, ceil(Log2(width)));
double heightPO2 = pow(2, ceil(Log2(height)));
if (widthPO2 != width || heightPO2 != height) {
lastU = static_cast<double>(width / widthPO2);
lastV = static_cast<double>(height / heightPO2);
widthPO2 = static_cast<uint16>(widthPO2);
heightPO2 = static_cast<uint16>(heightPO2);
//allocating memory for new buffer
uint8 *bufferPO2 = (uint8 *)malloc(widthPO2 * heightPO2 * 4); // * 4 because each pixel needs 32 bits
uint8 * const origBufferPO2pos = bufferPO2; //ptr to keep reference to the bufferPO2
//setting pixels to white -> as texture has transparent pixels, check everything is working properly
memset(bufferPO2, 255, widthPO2 * heightPO2 * 4);
for (unsigned int h = 0; h < height; h++) {
memcpy(bufferPO2, buffer, width * 4);
bufferPO2 += static_cast<int>(widthPO2) * 4;
buffer += (width * 4);
}
bufferPO2 = origBufferPO2pos;
//bufferPO2 -= static_cast<int>(widthPO2) * height * 4;
//call to genImage, creating texture in VRAM
this->gltex = Renderer::Instance().GenImage(bufferPO2, widthPO2, heightPO2);
//now, the texture is in VRAM so we no longer need it in RAM
stbi_image_free(bufferPO2);
} else {
// Generamos la textura
if ( buffer ) {
this->gltex = Renderer::Instance().GenImage(buffer, width, height);
stbi_image_free(buffer);
}
}
}
Image::~Image() {
if (gltex != 0) Renderer::Instance().DeleteImage(this->gltex);
}
void Image::Bind() const {
Renderer::Instance().BindImage(this->gltex);
}
<|endoftext|> |
<commit_before>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/nest/p9_l2_flush.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_l2_flush.H
/// @brief Flush the P9 L2 cache (FAPI)
///
/// *HWP HWP Owner : Benjamin Gass <[email protected]>
/// *HWP FW Owner : Bilicon Patil <[email protected]>
/// *HWP Team : Quad
/// *HWP Consumed by : FSP
/// *HWP Level : 2
///
/// Procedure Additional Comments:
///
/// High-level procedure flow:
/// o Poll Purge Engine Command Register to confirm that purge engine
/// is idle before starting (fail if self-imposed timeout occurs)
/// o Write Purge Engine Command Register to kick off complete/requested
/// cache flush operation
/// o Poll Purge Engine Command Register to wait for completion of
/// flush (fail if self-imposed timeout occurs) & check for errors
///
/// Successful operations assumes that:
/// o System clocks are running
/// o While not strictly required, to guarantee a completely empty cache
/// at the end of the procedure execution, instructions should be
/// stopped on the core underneath the L2 being flushed before the flush
/// is executed
///
#ifndef _P9_L2_FLUSH_H_
#define _P9_L2_FLUSH_H_
//------------------------------------------------------------------------------
// Includes
//------------------------------------------------------------------------------
#include <fapi2.H>
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
namespace p9core
{
// This structure specifies the data needed in case when there
// is request for specific L2 purges
struct purgeData_t
{
uint8_t iv_cmdType: 4;
uint8_t iv_cmdMem: 3;
uint8_t iv_cmdBank: 1;
uint8_t iv_cmdCGC: 8;
purgeData_t(): iv_cmdType(0),
iv_cmdMem(0),
iv_cmdBank(0),
iv_cmdCGC(0) {}
};
} // end of p9core namespace
//------------------------------------------------------------------------------
// Structure definitions
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Function prototypes
//------------------------------------------------------------------------------
typedef fapi2::ReturnCode (*p9_l2_flush_FP_t)
(const fapi2::Target < fapi2::TARGET_TYPE_EX >& i_target,
const p9core::purgeData_t& i_purgeData);
extern "C"
{
///
/// @brief p9_l2_flush HWP to flush entire content of L2 cache via purge engine
/// @param[in] i_target Ex target
/// @param[in] i_purgeData Specifies a particular purge type
/// @return: FAPI2_RC_SUCCESS if purge operation completes successfully,
/// RC_P9_L2_FLUSH_UNKNOWN_PLATFORM
/// if executed on unsupported platform,
/// RC_P9_L2_FLUSH_PURGE_REQ_OUTSTANDING
/// if called when existing L2 purge is in progress,
/// RC_P9_L2_FLUSH_CMD_TIMEOUT
/// if purge operation does not complete in expected time,
/// RC_P9_L2_FLUSH_CMD_ERROR
/// if purge operation reports error,
/// else FAPI getscom/putscom return code for failing operation
///
fapi2::ReturnCode p9_l2_flush(const fapi2::Target < fapi2::TARGET_TYPE_EX >
& i_target,
const p9core::purgeData_t& i_purgeData);
} // end of extern C
#endif // _P9_L2_FLUSH_H_
<commit_msg>L3 Update - p9_l2/l3_flush.C<commit_after>/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/nest/p9_l2_flush.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* 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. */
/* */
/* IBM_PROLOG_END_TAG */
///
/// @file p9_l2_flush.H
/// @brief Flush the P9 L2 cache (FAPI)
///
/// *HWP HWP Owner : Benjamin Gass <[email protected]>
/// *HWP FW Owner : Thi Tran <[email protected]>
/// *HWP Team : Quad
/// *HWP Consumed by : FSP and SBE
/// *HWP Level : 3
///
/// Procedure Additional Comments:
///
/// High-level procedure flow:
/// o Poll Purge Engine Command Register to confirm that purge engine
/// is idle before starting (fail if self-imposed timeout occurs)
/// o Write Purge Engine Command Register to kick off complete/requested
/// cache flush operation
/// o Poll Purge Engine Command Register to wait for completion of
/// flush (fail if self-imposed timeout occurs) & check for errors
///
/// Successful operations assumes that:
/// o System clocks are running
/// o While not strictly required, to guarantee a completely empty cache
/// at the end of the procedure execution, instructions should be
/// stopped on the core underneath the L2 being flushed before the flush
/// is executed
///
#ifndef _P9_L2_FLUSH_H_
#define _P9_L2_FLUSH_H_
//------------------------------------------------------------------------------
// Includes
//------------------------------------------------------------------------------
#include <fapi2.H>
//------------------------------------------------------------------------------
// Structure definitions
//------------------------------------------------------------------------------
namespace p9core
{
// This structure specifies the data needed in case when there
// is request for specific L2 purges
struct purgeData_t
{
uint8_t iv_cmdType: 4;
uint8_t iv_cmdMem: 3;
uint8_t iv_cmdBank: 1;
uint8_t iv_cmdCGC: 8;
purgeData_t(): iv_cmdType(0),
iv_cmdMem(0),
iv_cmdBank(0),
iv_cmdCGC(0) {}
};
} // end of p9core namespace
//------------------------------------------------------------------------------
// Function prototypes
//------------------------------------------------------------------------------
typedef fapi2::ReturnCode (*p9_l2_flush_FP_t)
(const fapi2::Target < fapi2::TARGET_TYPE_EX >& i_target,
const p9core::purgeData_t& i_purgeData);
extern "C"
{
///
/// @brief Flush entire content of L2 cache via purge engine
/// @param[in] i_target EX target
/// @param[in] i_purgeData Specifies a particular purge type
/// @return: FAPI2_RC_SUCCESS if purge operation completes successfully,
/// RC_P9_L2_FLUSH_PURGE_REQ_OUTSTANDING
/// if called when existing L2 purge is in progress,
/// RC_P9_L2_FLUSH_CMD_TIMEOUT
/// if purge operation does not complete in expected time,
/// RC_P9_L2_FLUSH_CMD_ERROR
/// if purge operation reports error,
/// else FAPI getscom/putscom return code for failing operation
///
fapi2::ReturnCode p9_l2_flush(const fapi2::Target < fapi2::TARGET_TYPE_EX >
& i_target,
const p9core::purgeData_t& i_purgeData);
} // end of extern C
#endif // _P9_L2_FLUSH_H_
<|endoftext|> |
<commit_before>#include "combiner_gridcompare_hist.h"
/// SYSTEM
#include <pluginlib/class_list_macros.h>
#include <QComboBox>
PLUGINLIB_EXPORT_CLASS(csapex::GridCompareHist, csapex::BoxedObject)
using namespace csapex;
using namespace cv_grid;
GridCompareHist::GridCompareHist() :
GridCompare(State::Ptr(new State)),
container_hist_sliders_(NULL)
{
private_state_gch_ = dynamic_cast<State*>(state_.get());
assert(private_state_gch_);
}
GridCompareHist::GridCompareHist(GridCompare::State::Ptr state) :
GridCompare(state),
container_hist_sliders_(NULL)
{
private_state_gch_ = dynamic_cast<State*>(state_.get());
assert(private_state_gch_);
}
cv::Mat GridCompareHist::combine(const cv::Mat img1, const cv::Mat mask1, const cv::Mat img2, const cv::Mat mask2)
{
if(!img1.empty() && !img2.empty()) {
/// PREPARE
if(img1.channels() != img2.channels())
throw std::runtime_error("Channel count is not matching!");
// if(img1.rows != img2.rows || img1.cols != img2.cols)
// throw std::runtime_error("Dimension is not matching!");
if(private_state_gch_->channel_count != img1.channels()) {
private_state_gch_->channel_count = img1.channels();
private_state_gch_->bins.clear();
private_state_gch_->eps.clear();
Q_EMIT modelChanged();
}
updateSliderMaxima(img1.cols, img1.rows);
/// COMPUTE
if(hist_sliders_.size() == private_state_gch_->channel_count) {
state_buffer_gch_ = *private_state_gch_;
GridHist g1, g2;
prepareGrid(g1, img1, mask1, state_buffer_gch_.grid_width, state_buffer_gch_.grid_width);
prepareGrid(g2, img2, mask2, state_buffer_gch_.grid_width, state_buffer_gch_.grid_width);
cv::Mat out;
render_grid(g1, g2, cv::Size(10,10), out);
return out;
}
}
return cv::Mat();
}
void GridCompareHist::updateDynamicGui(QBoxLayout *layout)
{
QVBoxLayout *internal_layout;
if(container_hist_sliders_ != NULL) {
container_hist_sliders_->deleteLater();
}
internal_layout = new QVBoxLayout;
for(int i = 0 ; i < private_state_gch_->channel_count ; i++) {
std::stringstream ch;
ch << i + 1;
int default_bin = 32;
double default_eps = 0.0;
if(private_state_gch_->bins.size() < private_state_gch_->channel_count ) {
private_state_gch_->bins.push_back(default_bin);
private_state_gch_->eps.push_back(default_eps);
} else {
default_bin = private_state_gch_->bins[i];
default_eps = private_state_gch_->eps[i];
}
QSlider *bins = QtHelper::makeSlider(internal_layout, "Ch." + ch.str() + " bins", default_bin, 1, 1000);
QDoubleSlider *eps = QtHelper::makeDoubleSlider(internal_layout, "Ch." + ch.str() + " eps", default_eps, 0.0, 255.0, 0.01);
addHistSliders(bins, eps);
}
container_hist_sliders_ = QtHelper::wrapLayout(internal_layout);
layout->addWidget(container_hist_sliders_);
}
void GridCompareHist::updateState(int value)
{
if(state_mutex_.tryLock()) {
private_state_gch_->combo_index = combo_compare_->currentIndex();
private_state_gch_->grid_width = slide_width_->value();
private_state_gch_->grid_height = slide_height_->value();
state_mutex_.unlock();
}
}
void GridCompareHist::fill(QBoxLayout *layout)
{
GridCompare::fill(layout);
combo_compare_ = new QComboBox();
combo_compare_->addItem("Correlation");
combo_compare_->addItem("Chi-Square");
combo_compare_->addItem("Intersection");
combo_compare_->addItem("Hellinger");
combo_compare_->addItem("Squared Distances");
int index = combo_compare_->findText("Correlation");
index_to_compare_.insert(intPair(index, CV_COMP_CORREL));
index = combo_compare_->findText("Chi-Square");
index_to_compare_.insert(intPair(index, CV_COMP_CHISQR));
index = combo_compare_->findText("Intersection");
index_to_compare_.insert(intPair(index, CV_COMP_INTERSECT));
index = combo_compare_->findText("Hellinger");
index_to_compare_.insert(intPair(index, CV_COMP_BHATTACHARYYA));
index = combo_compare_->findText("Squared Distances");
index_to_compare_.insert(intPair(index, AttrHistogram::CV_COMP_SQRD));
layout->addWidget(combo_compare_);
private_state_gch_->combo_index = combo_compare_->currentIndex();
connect(combo_compare_, SIGNAL(currentIndexChanged(int)), this, SLOT(updateState(int)));
connect(slide_height_, SIGNAL(valueChanged(int)), this, SLOT(updateState(int)));
connect(slide_width_, SIGNAL(valueChanged(int)), this, SLOT(updateState(int)));
}
void GridCompareHist::prepareGrid(GridHist &g, const cv::Mat &img, const cv::Mat &mask, const int width, const int height)
{
AttrHistogram::Params p;
prepareHistParams(p.bins, p.ranges, p.eps);
p.method = index_to_compare_[private_state_gch_->combo_index];
p.image = img;
cv_grid::prepare_grid<AttrHistogram>(g, height, width, p, mask, 1.0);
}
void GridCompareHist::addHistSliders(QSlider *bins, QDoubleSlider *eps)
{
HistSliderPair p;
p.first = bins;
p.second = eps;
hist_sliders_.push_back(p);
}
void GridCompareHist::prepareHistParams(cv::Mat &bins, cv::Mat &ranges, cv::Scalar &eps)
{
bins = cv::Mat_<int>(private_state_gch_->channel_count, 1);
ranges = cv::Mat_<float>(private_state_gch_->channel_count * 2 ,1);
for(int i = 0 ; i < private_state_gch_->channel_count ; i++) {
HistSliderPair p = hist_sliders_[i];
bins.at<int>(i) = p.first->value();
ranges.at<float>(2 * i) = 0.f;
ranges.at<float>(2 * i + 1) = 256.f;
eps[i] = p.second->doubleValue();
/// MEMENTO
private_state_gch_->bins[i] = p.first->value();
private_state_gch_->eps[i] = p.second->doubleValue();
}
}
/// MEMENTO ------------------------------------------------------------------------------------
void GridCompareHist::setState(Memento::Ptr memento)
{
state_.reset(new State);
State::Ptr s = boost::dynamic_pointer_cast<State>(memento);
assert(s.get());
*boost::dynamic_pointer_cast<State>(state_) = *s;
assert(state_.get());
private_state_gch_ = boost::dynamic_pointer_cast<State>(state_).get();
assert(private_state_gch_);
state_mutex_.lock();
slide_height_->setValue(private_state_gch_->grid_height);
slide_width_->setValue(private_state_gch_->grid_width);
combo_compare_->setCurrentIndex(private_state_gch_->combo_index);
state_mutex_.unlock();
Q_EMIT modelChanged();
}
void GridCompareHist::State::readYaml(const YAML::Node &node)
{
GridCompare::State::readYaml(node);
node["compare"] >> combo_index;
const YAML::Node &_bins = node["bins"];
for(YAML::Iterator it = _bins.begin() ; it != _bins.end() ; it++) {
int bin_val;
*it >> bin_val;
bins.push_back(bin_val);
}
const YAML::Node &_eps = node["eps"];
for(YAML::Iterator it = _eps.begin() ; it != _eps.end() ; it++) {
double eps_val;
*it >> eps_val;
eps.push_back(eps_val);
}
}
GridCompareHist::State::State() :
GridCompare::State(),
combo_index(0)
{
}
Memento::Ptr GridCompareHist::getState() const
{
State::Ptr memento(new State);
*memento = *boost::dynamic_pointer_cast<State>(state_);
return memento;
}
void GridCompareHist::State::writeYaml(YAML::Emitter &out) const
{
GridCompare::State::writeYaml(out);
out << YAML::Key << "compare" << YAML::Value << combo_index;
out << YAML::Key << "bins" << YAML::Value << YAML::BeginSeq;
for(std::vector<int>::const_iterator it = bins.begin() ; it != bins.end() ; it++) {
out << *it;
}
out << YAML::EndSeq;
out << YAML::Key << "eps" << YAML::Value << YAML::BeginSeq;
for(std::vector<double>::const_iterator it = eps.begin() ; it != eps.end() ; it++) {
out << *it;
}
out << YAML::EndSeq;
}
<commit_msg>fixes and rotated template header<commit_after>#include "combiner_gridcompare_hist.h"
/// SYSTEM
#include <pluginlib/class_list_macros.h>
#include <QComboBox>
PLUGINLIB_EXPORT_CLASS(csapex::GridCompareHist, csapex::BoxedObject)
using namespace csapex;
using namespace cv_grid;
GridCompareHist::GridCompareHist() :
GridCompare(State::Ptr(new State)),
container_hist_sliders_(NULL)
{
private_state_gch_ = dynamic_cast<State*>(state_.get());
assert(private_state_gch_);
}
GridCompareHist::GridCompareHist(GridCompare::State::Ptr state) :
GridCompare(state),
container_hist_sliders_(NULL)
{
private_state_gch_ = dynamic_cast<State*>(state_.get());
assert(private_state_gch_);
}
cv::Mat GridCompareHist::combine(const cv::Mat img1, const cv::Mat mask1, const cv::Mat img2, const cv::Mat mask2)
{
if(!img1.empty() && !img2.empty()) {
/// PREPARE
if(img1.channels() != img2.channels())
throw std::runtime_error("Channel count is not matching!");
// if(img1.rows != img2.rows || img1.cols != img2.cols)
// throw std::runtime_error("Dimension is not matching!");
if(private_state_gch_->channel_count != img1.channels()) {
private_state_gch_->channel_count = img1.channels();
private_state_gch_->bins.clear();
private_state_gch_->eps.clear();
Q_EMIT modelChanged();
}
updateSliderMaxima(img1.cols, img1.rows);
/// COMPUTE
if(hist_sliders_.size() == private_state_gch_->channel_count) {
state_buffer_gch_ = *private_state_gch_;
GridHist g1, g2;
prepareGrid(g1, img1, mask1, state_buffer_gch_.grid_width, state_buffer_gch_.grid_height);
prepareGrid(g2, img2, mask2, state_buffer_gch_.grid_width, state_buffer_gch_.grid_height);
cv::Mat out;
render_grid(g1, g2, cv::Size(10,10), out);
return out;
}
}
return cv::Mat();
}
void GridCompareHist::updateDynamicGui(QBoxLayout *layout)
{
QVBoxLayout *internal_layout;
if(container_hist_sliders_ != NULL) {
container_hist_sliders_->deleteLater();
}
internal_layout = new QVBoxLayout;
for(int i = 0 ; i < private_state_gch_->channel_count ; i++) {
std::stringstream ch;
ch << i + 1;
int default_bin = 32;
double default_eps = 0.0;
if(private_state_gch_->bins.size() < private_state_gch_->channel_count ) {
private_state_gch_->bins.push_back(default_bin);
private_state_gch_->eps.push_back(default_eps);
} else {
default_bin = private_state_gch_->bins[i];
default_eps = private_state_gch_->eps[i];
}
QSlider *bins = QtHelper::makeSlider(internal_layout, "Ch." + ch.str() + " bins", default_bin, 1, 1000);
QDoubleSlider *eps = QtHelper::makeDoubleSlider(internal_layout, "Ch." + ch.str() + " eps", default_eps, 0.0, 255.0, 0.01);
addHistSliders(bins, eps);
}
container_hist_sliders_ = QtHelper::wrapLayout(internal_layout);
layout->addWidget(container_hist_sliders_);
}
void GridCompareHist::updateState(int value)
{
if(state_mutex_.tryLock()) {
private_state_gch_->combo_index = combo_compare_->currentIndex();
private_state_gch_->grid_width = slide_width_->value();
private_state_gch_->grid_height = slide_height_->value();
state_mutex_.unlock();
}
}
void GridCompareHist::fill(QBoxLayout *layout)
{
GridCompare::fill(layout);
combo_compare_ = new QComboBox();
combo_compare_->addItem("Correlation");
combo_compare_->addItem("Chi-Square");
combo_compare_->addItem("Intersection");
combo_compare_->addItem("Hellinger");
combo_compare_->addItem("Squared Distances");
int index = combo_compare_->findText("Correlation");
index_to_compare_.insert(intPair(index, CV_COMP_CORREL));
index = combo_compare_->findText("Chi-Square");
index_to_compare_.insert(intPair(index, CV_COMP_CHISQR));
index = combo_compare_->findText("Intersection");
index_to_compare_.insert(intPair(index, CV_COMP_INTERSECT));
index = combo_compare_->findText("Hellinger");
index_to_compare_.insert(intPair(index, CV_COMP_BHATTACHARYYA));
index = combo_compare_->findText("Squared Distances");
index_to_compare_.insert(intPair(index, AttrHistogram::CV_COMP_SQRD));
layout->addWidget(combo_compare_);
private_state_gch_->combo_index = combo_compare_->currentIndex();
connect(combo_compare_, SIGNAL(currentIndexChanged(int)), this, SLOT(updateState(int)));
connect(slide_height_, SIGNAL(valueChanged(int)), this, SLOT(updateState(int)));
connect(slide_width_, SIGNAL(valueChanged(int)), this, SLOT(updateState(int)));
}
void GridCompareHist::prepareGrid(GridHist &g, const cv::Mat &img, const cv::Mat &mask, const int width, const int height)
{
AttrHistogram::Params p;
prepareHistParams(p.bins, p.ranges, p.eps);
p.method = index_to_compare_[private_state_gch_->combo_index];
p.image = img;
cv_grid::prepare_grid<AttrHistogram>(g, height, width, p, mask, 1.0);
}
void GridCompareHist::addHistSliders(QSlider *bins, QDoubleSlider *eps)
{
HistSliderPair p;
p.first = bins;
p.second = eps;
hist_sliders_.push_back(p);
}
void GridCompareHist::prepareHistParams(cv::Mat &bins, cv::Mat &ranges, cv::Scalar &eps)
{
bins = cv::Mat_<int>(private_state_gch_->channel_count, 1);
ranges = cv::Mat_<float>(private_state_gch_->channel_count * 2 ,1);
for(int i = 0 ; i < private_state_gch_->channel_count ; i++) {
HistSliderPair p = hist_sliders_[i];
bins.at<int>(i) = p.first->value();
ranges.at<float>(2 * i) = 0.f;
ranges.at<float>(2 * i + 1) = 256.f;
eps[i] = p.second->doubleValue();
/// MEMENTO
private_state_gch_->bins[i] = p.first->value();
private_state_gch_->eps[i] = p.second->doubleValue();
}
}
/// MEMENTO ------------------------------------------------------------------------------------
void GridCompareHist::setState(Memento::Ptr memento)
{
state_.reset(new State);
State::Ptr s = boost::dynamic_pointer_cast<State>(memento);
assert(s.get());
*boost::dynamic_pointer_cast<State>(state_) = *s;
assert(state_.get());
private_state_gch_ = boost::dynamic_pointer_cast<State>(state_).get();
assert(private_state_gch_);
state_mutex_.lock();
slide_height_->setValue(private_state_gch_->grid_height);
slide_width_->setValue(private_state_gch_->grid_width);
combo_compare_->setCurrentIndex(private_state_gch_->combo_index);
state_mutex_.unlock();
Q_EMIT modelChanged();
}
void GridCompareHist::State::readYaml(const YAML::Node &node)
{
GridCompare::State::readYaml(node);
node["compare"] >> combo_index;
const YAML::Node &_bins = node["bins"];
for(YAML::Iterator it = _bins.begin() ; it != _bins.end() ; it++) {
int bin_val;
*it >> bin_val;
bins.push_back(bin_val);
}
const YAML::Node &_eps = node["eps"];
for(YAML::Iterator it = _eps.begin() ; it != _eps.end() ; it++) {
double eps_val;
*it >> eps_val;
eps.push_back(eps_val);
}
}
GridCompareHist::State::State() :
GridCompare::State(),
combo_index(0)
{
}
Memento::Ptr GridCompareHist::getState() const
{
State::Ptr memento(new State);
*memento = *boost::dynamic_pointer_cast<State>(state_);
return memento;
}
void GridCompareHist::State::writeYaml(YAML::Emitter &out) const
{
GridCompare::State::writeYaml(out);
out << YAML::Key << "compare" << YAML::Value << combo_index;
out << YAML::Key << "bins" << YAML::Value << YAML::BeginSeq;
for(std::vector<int>::const_iterator it = bins.begin() ; it != bins.end() ; it++) {
out << *it;
}
out << YAML::EndSeq;
out << YAML::Key << "eps" << YAML::Value << YAML::BeginSeq;
for(std::vector<double>::const_iterator it = eps.begin() ; it != eps.end() ; it++) {
out << *it;
}
out << YAML::EndSeq;
}
<|endoftext|> |
<commit_before>//
// This file is part of the Marble Virtual Globe.
//
// This program is free software licensed under the GNU LGPL. You can
// find a copy of this license in LICENSE.txt in the top directory of
// the source code.
//
// Copyright 2012 Shou Ya <[email protected]>
// Copyright 2012 Dennis Nienhüser <[email protected]>
//
#include "KmlGroundOverlayWriter.h"
#include "GeoDataGroundOverlay.h"
#include "GeoDataTypes.h"
#include "GeoWriter.h"
#include "KmlElementDictionary.h"
namespace Marble
{
static GeoTagWriterRegistrar s_writerLookAt(
GeoTagWriter::QualifiedName( GeoDataTypes::GeoDataGroundOverlayType,
kml::kmlTag_nameSpace22 ),
new KmlGroundOverlayWriter );
KmlGroundOverlayWriter::KmlGroundOverlayWriter() : KmlOverlayTagWriter( kml::kmlTag_GroundOverlay )
{
// nothing to do
}
bool KmlGroundOverlayWriter::writeMid(const GeoNode *node, GeoWriter &writer) const
{
const GeoDataGroundOverlay *ground_overlay =
static_cast<const GeoDataGroundOverlay*>( node );
writer.writeTextElement( kml::kmlTag_altitude,
QString::number(ground_overlay->altitude()) );
writer.writeTextElement( kml::kmlTag_altitudeMode,
altitudeModeToString(ground_overlay->altitudeMode()) );
if ( !ground_overlay->latLonBox().isEmpty() ) {
writeElement( &ground_overlay->latLonBox(), writer );
}
if ( ground_overlay->latLonQuad().isValid() ) {
writeElement( &ground_overlay->latLonQuad(), writer );
}
return true;
}
QString KmlGroundOverlayWriter::altitudeModeToString(AltitudeMode mode)
{
switch (mode) {
case ClampToGround:
return "ClampToGround";
case RelativeToGround:
return "RelativeToGround";
case Absolute:
return "Absolute";
}
return "";
}
}
<commit_msg>Fix capitalization according to kml spec.<commit_after>//
// This file is part of the Marble Virtual Globe.
//
// This program is free software licensed under the GNU LGPL. You can
// find a copy of this license in LICENSE.txt in the top directory of
// the source code.
//
// Copyright 2012 Shou Ya <[email protected]>
// Copyright 2012 Dennis Nienhüser <[email protected]>
//
#include "KmlGroundOverlayWriter.h"
#include "GeoDataGroundOverlay.h"
#include "GeoDataTypes.h"
#include "GeoWriter.h"
#include "KmlElementDictionary.h"
namespace Marble
{
static GeoTagWriterRegistrar s_writerLookAt(
GeoTagWriter::QualifiedName( GeoDataTypes::GeoDataGroundOverlayType,
kml::kmlTag_nameSpace22 ),
new KmlGroundOverlayWriter );
KmlGroundOverlayWriter::KmlGroundOverlayWriter() : KmlOverlayTagWriter( kml::kmlTag_GroundOverlay )
{
// nothing to do
}
bool KmlGroundOverlayWriter::writeMid(const GeoNode *node, GeoWriter &writer) const
{
const GeoDataGroundOverlay *ground_overlay =
static_cast<const GeoDataGroundOverlay*>( node );
writer.writeTextElement( kml::kmlTag_altitude,
QString::number(ground_overlay->altitude()) );
writer.writeTextElement( kml::kmlTag_altitudeMode,
altitudeModeToString(ground_overlay->altitudeMode()) );
if ( !ground_overlay->latLonBox().isEmpty() ) {
writeElement( &ground_overlay->latLonBox(), writer );
}
if ( ground_overlay->latLonQuad().isValid() ) {
writeElement( &ground_overlay->latLonQuad(), writer );
}
return true;
}
QString KmlGroundOverlayWriter::altitudeModeToString(AltitudeMode mode)
{
switch (mode) {
case ClampToGround:
return "clampToGround";
case RelativeToGround:
return "relativeToGround";
case Absolute:
return "absolute";
}
return "";
}
}
<|endoftext|> |
<commit_before>//
// C++ Implementation: BuiltinFuncs
//
// Description:
//
//
// Author: Carmelo Piccione <[email protected]>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//
/* Loads all builtin functions */
/* Loads a builtin function */
#include "BuiltinFuncs.hpp"
#include <string>
#include <iostream>
#include "fatal.h"
std::map<std::string, Func*> BuiltinFuncs::builtin_func_tree;
int BuiltinFuncs::load_builtin_func(const std::string & name, float (*func_ptr)(float*), int num_args) {
Func * func;
int retval;
/* Create new function */
func = new Func(name, func_ptr, num_args);
if (func == 0)
return PROJECTM_OUTOFMEM_ERROR;
retval = insert_func( func );
return retval;
}
Func * BuiltinFuncs::find_func(const std::string & name) {
std::map<std::string, Func*>::iterator pos = builtin_func_tree.find(name);
// Case: function not found, return null
if (pos == builtin_func_tree.end())
return 0;
// Case: function found, return a pointer to it
return pos->second;
}
int BuiltinFuncs::load_all_builtin_func() {
if (load_builtin_func("int", FuncWrappers::int_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("abs", FuncWrappers::abs_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sin", FuncWrappers::sin_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("cos", FuncWrappers::cos_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("tan", FuncWrappers::tan_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("asin", FuncWrappers::asin_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("acos", FuncWrappers::acos_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("atan", FuncWrappers::atan_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sqr", FuncWrappers::sqr_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sqrt", FuncWrappers::sqrt_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("pow", FuncWrappers::pow_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("exp", FuncWrappers::exp_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("log", FuncWrappers::log_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("log10", FuncWrappers::log10_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sign", FuncWrappers::sign_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("min", FuncWrappers::min_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("max", FuncWrappers::max_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sigmoid", FuncWrappers::sigmoid_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("atan2", FuncWrappers::atan2_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("rand", FuncWrappers::rand_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("band", FuncWrappers::band_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("bor", FuncWrappers::bor_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("bnot", FuncWrappers::bnot_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("if", FuncWrappers::if_wrapper, 3) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("equal", FuncWrappers::equal_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("above", FuncWrappers::above_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("below", FuncWrappers::below_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("nchoosek", FuncWrappers::nchoosek_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("fact", FuncWrappers::fact_wrapper, 1) < 0)
return PROJECTM_ERROR;
return PROJECTM_SUCCESS;
}
volatile bool BuiltinFuncs::initialized = false;
/* Initialize the builtin function database.
Should only be necessary once */
int BuiltinFuncs::init_builtin_func_db() {
int retval;
if (initialized) {
return 0;
} else
initialized = true;
retval = load_all_builtin_func();
return retval;
}
/* Destroy the builtin function database.
Generally, do this on projectm exit */
int BuiltinFuncs::destroy_builtin_func_db() {
traverse<TraverseFunctors::Delete<Func> >(builtin_func_tree);
builtin_func_tree.clear();
initialized = false;
return PROJECTM_SUCCESS;
}
/* Insert a function into the database */
int BuiltinFuncs::insert_func( Func *func ) {
assert(func);
if (func == 0) {
std::cerr << "Received a null function object, ignoring...." << std::endl;
return PROJECTM_ERROR;
}
std::cout << "inserting function " << func->getName() << std::endl;
const std::pair<std::string, Func*> pair = std::make_pair(std::string(func->getName()), func);
assert(pair.second);
const std::pair<std::map<std::string, Func*>::iterator, bool> inserteePair =
builtin_func_tree.insert(pair);
if (!inserteePair.second) {
std::cerr << "Failed to insert builtin function \"" << func->getName() << "\" into collection! Bailing..." << std::endl;
abort();
}
return PROJECTM_SUCCESS;
}
<commit_msg>removed debugging<commit_after>//
// C++ Implementation: BuiltinFuncs
//
// Description:
//
//
// Author: Carmelo Piccione <[email protected]>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//
/* Loads all builtin functions */
/* Loads a builtin function */
#include "BuiltinFuncs.hpp"
#include <string>
#include <iostream>
#include "fatal.h"
std::map<std::string, Func*> BuiltinFuncs::builtin_func_tree;
int BuiltinFuncs::load_builtin_func(const std::string & name, float (*func_ptr)(float*), int num_args) {
Func * func;
int retval;
/* Create new function */
func = new Func(name, func_ptr, num_args);
if (func == 0)
return PROJECTM_OUTOFMEM_ERROR;
retval = insert_func( func );
return retval;
}
Func * BuiltinFuncs::find_func(const std::string & name) {
std::map<std::string, Func*>::iterator pos = builtin_func_tree.find(name);
// Case: function not found, return null
if (pos == builtin_func_tree.end())
return 0;
// Case: function found, return a pointer to it
return pos->second;
}
int BuiltinFuncs::load_all_builtin_func() {
if (load_builtin_func("int", FuncWrappers::int_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("abs", FuncWrappers::abs_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sin", FuncWrappers::sin_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("cos", FuncWrappers::cos_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("tan", FuncWrappers::tan_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("asin", FuncWrappers::asin_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("acos", FuncWrappers::acos_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("atan", FuncWrappers::atan_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sqr", FuncWrappers::sqr_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sqrt", FuncWrappers::sqrt_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("pow", FuncWrappers::pow_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("exp", FuncWrappers::exp_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("log", FuncWrappers::log_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("log10", FuncWrappers::log10_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sign", FuncWrappers::sign_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("min", FuncWrappers::min_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("max", FuncWrappers::max_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("sigmoid", FuncWrappers::sigmoid_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("atan2", FuncWrappers::atan2_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("rand", FuncWrappers::rand_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("band", FuncWrappers::band_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("bor", FuncWrappers::bor_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("bnot", FuncWrappers::bnot_wrapper, 1) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("if", FuncWrappers::if_wrapper, 3) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("equal", FuncWrappers::equal_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("above", FuncWrappers::above_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("below", FuncWrappers::below_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("nchoosek", FuncWrappers::nchoosek_wrapper, 2) < 0)
return PROJECTM_ERROR;
if (load_builtin_func("fact", FuncWrappers::fact_wrapper, 1) < 0)
return PROJECTM_ERROR;
return PROJECTM_SUCCESS;
}
volatile bool BuiltinFuncs::initialized = false;
/* Initialize the builtin function database.
Should only be necessary once */
int BuiltinFuncs::init_builtin_func_db() {
int retval;
if (initialized) {
return 0;
} else
initialized = true;
retval = load_all_builtin_func();
return retval;
}
/* Destroy the builtin function database.
Generally, do this on projectm exit */
int BuiltinFuncs::destroy_builtin_func_db() {
traverse<TraverseFunctors::Delete<Func> >(builtin_func_tree);
builtin_func_tree.clear();
initialized = false;
return PROJECTM_SUCCESS;
}
/* Insert a function into the database */
int BuiltinFuncs::insert_func( Func *func ) {
assert(func);
if (func == 0) {
std::cerr << "Received a null function object, ignoring...." << std::endl;
return PROJECTM_ERROR;
}
// //std::cout << "inserting function " << func->getName() << std::endl;
const std::pair<std::string, Func*> pair = std::make_pair(std::string(func->getName()), func);
assert(pair.second);
const std::pair<std::map<std::string, Func*>::iterator, bool> inserteePair =
builtin_func_tree.insert(pair);
if (!inserteePair.second) {
std::cerr << "Failed to insert builtin function \"" << func->getName() << "\" into collection! Bailing..." << std::endl;
abort();
}
return PROJECTM_SUCCESS;
}
<|endoftext|> |
<commit_before>#include <GLFW/glfw3.h>
#include "GLFWSystem.hpp"
#include "kengine.hpp"
#include "data/InputBufferComponent.hpp"
#include "data/GLFWWindowComponent.hpp"
#include "data/WindowComponent.hpp"
#include "functions/OnTerminate.hpp"
#include "functions/OnMouseCaptured.hpp"
#include "functions/Execute.hpp"
#include "imgui.h"
#include "with.hpp"
namespace kengine::glfw {
namespace Input {
static InputBufferComponent * g_buffer;
static void onKey(GLFWwindow * window, int key, int scancode, int action, int mods) noexcept {
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureKeyboard))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
g_buffer->keys.push_back(InputBufferComponent::KeyEvent{ id, key, true });
else if (action == GLFW_RELEASE)
g_buffer->keys.push_back(InputBufferComponent::KeyEvent{ id, key, false });
}
static putils::Point2f lastPos{ FLT_MAX, FLT_MAX };
static void onClick(GLFWwindow * window, int button, int action, int mods) noexcept {
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureMouse))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
g_buffer->clicks.push_back(InputBufferComponent::ClickEvent{ id, lastPos, button, true });
else if (action == GLFW_RELEASE)
g_buffer->clicks.push_back(InputBufferComponent::ClickEvent{ id, lastPos, button, false });
}
static void onMouseMove(GLFWwindow * window, double xpos, double ypos) noexcept {
if (lastPos.x == FLT_MAX) {
lastPos.x = (float)xpos;
lastPos.y = (float)ypos;
}
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureMouse))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
InputBufferComponent::MouseMoveEvent info;
info.window = id;
info.pos = { (float)xpos, (float)ypos };
info.rel = { (float)xpos - lastPos.x, (float)ypos - lastPos.y };
lastPos = info.pos;
g_buffer->moves.push_back(info);
}
static void onScroll(GLFWwindow * window, double xoffset, double yoffset) noexcept {
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureMouse))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
g_buffer->scrolls.push_back(InputBufferComponent::MouseScrollEvent{ id, (float)xoffset, (float)yoffset, lastPos });
}
}
struct impl {
static void init(Entity & e) noexcept {
e += functions::Execute{ glfw::impl::execute };
e += functions::OnEntityCreated{ glfw::impl::onEntityCreated };
e += functions::OnTerminate{ glfw::impl::terminate };
e += functions::OnMouseCaptured{ glfw::impl::onMouseCaptured };
for (const auto & [e, buffer] : entities.with<InputBufferComponent>()) {
Input::g_buffer = &buffer;
break;
}
glfwInit();
execute(0.f); // init already existing windows
}
static void terminate() noexcept {
glfwTerminate();
}
static void onMouseCaptured(EntityID window, bool captured) noexcept {
const auto inputMode = captured ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL;
if (captured)
ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouse;
else
ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NoMouse;
if (window == INVALID_ID) {
for (const auto & [e, glfw] : entities.with<GLFWWindowComponent>())
glfwSetInputMode(glfw.window.get(), GLFW_CURSOR, inputMode);
return;
}
const auto glfw = entities.get(window).tryGet<GLFWWindowComponent>();
if (glfw == nullptr)
return;
glfwSetInputMode(glfw->window.get(), GLFW_CURSOR, inputMode);
}
static void onEntityCreated(Entity & e) noexcept {
const auto window = e.tryGet<WindowComponent>();
if (!window)
return;
const auto initGlfw = e.tryGet<GLFWWindowInitComponent>();
if (!initGlfw)
return;
createWindow(e, *window, *initGlfw);
}
static void execute(float deltaTime) noexcept {
for (const auto & [e, window, glfw] : entities.with<WindowComponent, GLFWWindowComponent>())
if (glfwWindowShouldClose(glfw.window.get())) {
if (window.shutdownOnClose)
stopRunning();
else
entities.remove(e.id);
}
for (auto [e, window, initGlfw, noGLFW] : entities.with<WindowComponent, GLFWWindowInitComponent, no<GLFWWindowComponent>>()) {
createWindow(e, window, initGlfw);
e.detach<GLFWWindowInitComponent>();
}
}
static void createWindow(Entity & e, WindowComponent & window, const GLFWWindowInitComponent & initGlfw) noexcept {
auto & glfwComp = e.attach<GLFWWindowComponent>();
if (initGlfw.setHints)
initGlfw.setHints();
// TODO: depend on g_windowComponent->fullscreen
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
glfwComp.window = glfwCreateWindow((int)window.size.x, (int)window.size.y, window.name, nullptr, nullptr);
// Desired size may not have been available, update to actual size
int width, height;
glfwGetWindowSize(glfwComp.window.get(), &width, &height);
window.size = { (unsigned int)width, (unsigned int)height };
glfwSetWindowAspectRatio(glfwComp.window.get(), window.size.x, window.size.y);
glfwMakeContextCurrent(glfwComp.window.get());
glfwSetWindowSizeCallback(glfwComp.window.get(), [](auto window, int width, int height) noexcept {
const auto id = (EntityID)glfwGetWindowUserPointer(window);
auto & comp = entities.get(id).get<WindowComponent>();
comp.size = { (unsigned int)width, (unsigned int)height };
});
glfwSetMouseButtonCallback(glfwComp.window.get(), Input::onClick);
glfwSetCursorPosCallback(glfwComp.window.get(), Input::onMouseMove);
glfwSetScrollCallback(glfwComp.window.get(), Input::onScroll);
glfwSetKeyCallback(glfwComp.window.get(), Input::onKey);
glfwSetWindowUserPointer(glfwComp.window.get(), (void *)e.id);
if (initGlfw.onWindowCreated)
initGlfw.onWindowCreated();
}
};
}
namespace kengine {
EntityCreator * GLFWSystem() noexcept {
return [](Entity & e) noexcept {
glfw::impl::init(e);
};
}
}<commit_msg>glfw -- style<commit_after>#include <GLFW/glfw3.h>
#include "GLFWSystem.hpp"
#include "kengine.hpp"
#include "data/InputBufferComponent.hpp"
#include "data/GLFWWindowComponent.hpp"
#include "data/WindowComponent.hpp"
#include "functions/OnTerminate.hpp"
#include "functions/OnMouseCaptured.hpp"
#include "functions/Execute.hpp"
#include "imgui.h"
#include "with.hpp"
namespace kengine {
namespace Input {
static InputBufferComponent * g_buffer;
static void onKey(GLFWwindow * window, int key, int scancode, int action, int mods) noexcept {
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureKeyboard))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
g_buffer->keys.push_back(InputBufferComponent::KeyEvent{ id, key, true });
else if (action == GLFW_RELEASE)
g_buffer->keys.push_back(InputBufferComponent::KeyEvent{ id, key, false });
}
static putils::Point2f lastPos{ FLT_MAX, FLT_MAX };
static void onClick(GLFWwindow * window, int button, int action, int mods) noexcept {
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureMouse))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
if (action == GLFW_PRESS)
g_buffer->clicks.push_back(InputBufferComponent::ClickEvent{ id, lastPos, button, true });
else if (action == GLFW_RELEASE)
g_buffer->clicks.push_back(InputBufferComponent::ClickEvent{ id, lastPos, button, false });
}
static void onMouseMove(GLFWwindow * window, double xpos, double ypos) noexcept {
if (lastPos.x == FLT_MAX) {
lastPos.x = (float)xpos;
lastPos.y = (float)ypos;
}
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureMouse))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
InputBufferComponent::MouseMoveEvent info;
info.window = id;
info.pos = { (float)xpos, (float)ypos };
info.rel = { (float)xpos - lastPos.x, (float)ypos - lastPos.y };
lastPos = info.pos;
g_buffer->moves.push_back(info);
}
static void onScroll(GLFWwindow * window, double xoffset, double yoffset) noexcept {
if (g_buffer == nullptr || (ImGui::GetCurrentContext() != nullptr && ImGui::GetIO().WantCaptureMouse))
return;
const auto id = (EntityID)glfwGetWindowUserPointer(window);
g_buffer->scrolls.push_back(InputBufferComponent::MouseScrollEvent{ id, (float)xoffset, (float)yoffset, lastPos });
}
}
EntityCreator * GLFWSystem() noexcept {
struct impl {
static void init(Entity & e) noexcept {
e += functions::Execute{ execute };
e += functions::OnEntityCreated{ onEntityCreated };
e += functions::OnTerminate{ terminate };
e += functions::OnMouseCaptured{ onMouseCaptured };
for (const auto & [e, buffer] : entities.with<InputBufferComponent>()) {
Input::g_buffer = &buffer;
break;
}
glfwInit();
execute(0.f); // init already existing windows
}
static void terminate() noexcept {
glfwTerminate();
}
static void onMouseCaptured(EntityID window, bool captured) noexcept {
const auto inputMode = captured ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL;
if (captured)
ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouse;
else
ImGui::GetIO().ConfigFlags &= ~ImGuiConfigFlags_NoMouse;
if (window == INVALID_ID) {
for (const auto & [e, glfw] : entities.with<GLFWWindowComponent>())
glfwSetInputMode(glfw.window.get(), GLFW_CURSOR, inputMode);
return;
}
const auto glfw = entities.get(window).tryGet<GLFWWindowComponent>();
if (glfw == nullptr)
return;
glfwSetInputMode(glfw->window.get(), GLFW_CURSOR, inputMode);
}
static void onEntityCreated(Entity & e) noexcept {
const auto window = e.tryGet<WindowComponent>();
if (!window)
return;
const auto initGlfw = e.tryGet<GLFWWindowInitComponent>();
if (!initGlfw)
return;
createWindow(e, *window, *initGlfw);
}
static void execute(float deltaTime) noexcept {
for (const auto & [e, window, glfw] : entities.with<WindowComponent, GLFWWindowComponent>())
if (glfwWindowShouldClose(glfw.window.get())) {
if (window.shutdownOnClose)
stopRunning();
else
entities.remove(e.id);
}
for (auto [e, window, initGlfw, noGLFW] : entities.with<WindowComponent, GLFWWindowInitComponent, no<GLFWWindowComponent>>()) {
createWindow(e, window, initGlfw);
e.detach<GLFWWindowInitComponent>();
}
}
static void createWindow(Entity & e, WindowComponent & window, const GLFWWindowInitComponent & initGlfw) noexcept {
auto & glfwComp = e.attach<GLFWWindowComponent>();
if (initGlfw.setHints)
initGlfw.setHints();
// TODO: depend on g_windowComponent->fullscreen
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
glfwComp.window = glfwCreateWindow((int)window.size.x, (int)window.size.y, window.name, nullptr, nullptr);
// Desired size may not have been available, update to actual size
int width, height;
glfwGetWindowSize(glfwComp.window.get(), &width, &height);
window.size = { (unsigned int)width, (unsigned int)height };
glfwSetWindowAspectRatio(glfwComp.window.get(), window.size.x, window.size.y);
glfwMakeContextCurrent(glfwComp.window.get());
glfwSetWindowSizeCallback(glfwComp.window.get(), [](auto window, int width, int height) noexcept {
const auto id = (EntityID)glfwGetWindowUserPointer(window);
auto & comp = entities.get(id).get<WindowComponent>();
comp.size = { (unsigned int)width, (unsigned int)height };
});
glfwSetMouseButtonCallback(glfwComp.window.get(), Input::onClick);
glfwSetCursorPosCallback(glfwComp.window.get(), Input::onMouseMove);
glfwSetScrollCallback(glfwComp.window.get(), Input::onScroll);
glfwSetKeyCallback(glfwComp.window.get(), Input::onKey);
glfwSetWindowUserPointer(glfwComp.window.get(), (void *)e.id);
if (initGlfw.onWindowCreated)
initGlfw.onWindowCreated();
}
};
return impl::init;
}
}<|endoftext|> |
<commit_before>#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <ncurses.h>
#include "barney_pilot.h"
#include "ros/ros.h"
#include <sensor_msgs/Joy.h>
#include "rxtx_server/distance.h"
#include "rxtx_server/AngularPos.h"
#include "rxtx_server/status.h"
#include "rxtx_server/command.h"
#include "osuar_telepilot/altitude_request.h"
#include "osuar_telepilot/altitude_command.h"
#include "osuar_telepilot/wall_command.h"
#include "osuar_telepilot/wall_request.h"
#include "osuar_telepilot/wall_command.h"
#include "osuar_telepilot/wall_request.h"
#include "rxtx_server/heading_pos.h"
#include "altitude.h"
#include "wall_follow.h"
int main(int argc, char ** argv){
initscr();
cbreak();
noecho();
timeout(0);
ros::init(argc, argv, "Barney");
status platStatus;
joystick stick;
distance lidar;
angular_pos orientation;
lidar.prev = 0;
ros::NodeHandle n;
ros::Publisher command = n.advertise<rxtx_server::command>("command", 1);
rxtx_server::command commandData;
ros::Publisher altitude_handler_pub = n.advertise<osuar_telepilot::altitude_request>("altitude_request", 1);
osuar_telepilot::altitude_request altitude_request_data;
altitude_request_data.p = 28;
altitude_request_data.d = 0;
altitude_request_data.i = 15;
altitude_request_data.target = 40;
altitude_request_data.status = STARTING;
altitude_handler altitude_controller_data;
ros::Publisher wall_handler_pub = n.advertise<osuar_telepilot::wall_request>("wall_request", 1);
osuar_telepilot::wall_request wall_request_data;
wall_request_data.p = 4;
wall_request_data.i = 0;
wall_request_data.d = 0;
wall_request_data.target = 250;
wall_request_data.status = FOLLOW;
wall_handler wall_controller_data;
char myStatus = 1;
lidar.updateFlag = 0;
lidar.prev = 0;
platStatus.platStatus = 1;
char prev = 20;
int i;
int throttle_little_buffer = 0;
int throttle_big_buffer = 0;
int roll_buffer = 0;
ros::spinOnce();
for(i=0;i<11;i++){
stick.button[i] = 0;
}
for(i=0;i<5;i++){
stick.axes[i] = -126;
}
char keyboard;
char landingflag = 0;
//char sent_status = 9;
//printw("BARNEY TIME!\n");
mvprintw(0,0,"STARTING \n");
while(1){
ros::spinOnce();
if((keyboard = getch()) != ERR){
if(keyboard == 's'){
endwin();
return 0;
}
else if(keyboard == 'y'){
altitude_request_data.p += 1;
}
else if(keyboard == 'h'){
altitude_request_data.p -= 1;
}
else if(keyboard == 'u'){
altitude_request_data.d += 1;
}
else if(keyboard == 'j'){
altitude_request_data.d -= 1;
}
else if(keyboard == 'i'){
altitude_request_data.i += 1;
}
else if(keyboard == 'k'){
altitude_request_data.i -= 1;
}
//For starting takeoff
else if((keyboard == 't') && ((altitude_request_data.status == STARTING) || (altitude_request_data.status == 7)) ){
altitude_request_data.status = TAKEOFF;
mvprintw(0,0,"TAKEOFF \n");
}
else if((keyboard == 'l')){
//altitude_request_data.status = LAND;
landingflag = 1;
altitude_request_data.target = 0;
mvprintw(0,0,"LAND \n");
}
else if(keyboard == 'r'){
altitude_request_data.status = STARTING;
mvprintw(0,0,"STARTING \n");
}
mvprintw(15,40,"ALTITUDE:\n");
mvprintw(16,40,"P: %4f\n",altitude_request_data.p * .2);
mvprintw(17,40,"D: %4f\n",altitude_request_data.d * .2);
mvprintw(18,40,"I: %4i/5625\n",altitude_request_data.i);
}
//TAKEOFF AND LAND AUTOMATIC STATUS CHANGES
//When Taking Off, check to make transition to hover
if((altitude_request_data.status == TAKEOFF) && (altitude_controller_data.status == HOVER)){
altitude_request_data.status = HOVER;
mvprintw(0,0,"HOVERING \n");
}
else if((altitude_request_data.status == HOVER) && (altitude_controller_data.status == LAND) && (landingflag == 0)){
altitude_request_data.status = TAKEOFF;
mvprintw(0,0,"TAKEOFF \n");
}
else if((landingflag == 1) && (altitude_controller_data.status == LAND)){
landingflag = 0;
altitude_request_data.status = LAND;
}
if(orientation.updateFlag){
orientation.updateFlag = 0;
mvprintw(2,0,"X: %4i\n",orientation.x);
mvprintw(3,0,"Y: %4i\n",orientation.y);
mvprintw(4,0,"Z: %4i\n",orientation.z);
}
myStatus = platStatus.platStatus;
if(myStatus == 9){
mvprintw(1,0,"booting \n");
//Don't have bad things happen when module resets
//sent_status = 9;
}
else if(myStatus == 4){
mvprintw(1,0,"stopping \n");
altitude_request_data.status = 7;
altitude_controller_data.throttle_big = 0;
altitude_controller_data.throttle_little = 0;
}
else if(myStatus == 1){
mvprintw(1,0,"running \n");
}
else if(myStatus == 10){
mvprintw(1,0,"offsetting\n");
}
if(lidar.updateFlag){
lidar.updateFlag = 0;
mvprintw(5,0,"Vertical: %4i\n", lidar.vertical);
mvprintw(6,0,"Horizontal 1: %4i\n", lidar.horizontal_1);
if((abs(orientation.x) < 200) && (abs(orientation.y) < 200)){
altitude_request_data.distance = lidar.vertical;
altitude_handler_pub.publish(altitude_request_data);
wall_request_data.distance = lidar.horizontal_1;
wall_handler_pub.publish(wall_request_data);
}
else{
//altitude_controller_data.throttle_big = 0;
//altitude_controller_data.throttle_little = 0;
}
}
throttle_little_buffer = stick.axes[2] + altitude_controller_data.throttle_little;
throttle_big_buffer = stick.axes[4] + altitude_controller_data.throttle_big;
//Will eventually be phased out of this section of code and put in altitude
/*
if(throttle_big_buffer > 127){
throttle_big_buffer = 127;
}
else if(throttle_big_buffer < -127){
throttle_big_buffer = -127;
}
if(throttle_little_buffer > 127){
if(throttle_big_buffer < 94){
throttle_little_buffer -= 127;
throttle_big_buffer += 32;
}
else{
throttle_little_buffer = 127;
}
}
else if(throttle_little_buffer < -127){
if(throttle_big_buffer > -94){
throttle_little_buffer += 127;
throttle_big_buffer -= 32;
}
else{
throttle_little_buffer = -127;
}
}
*/
/*
throttle_overflow = throttle_little_buffer/127;
throttle_little_buffer %= 127;
throttle_big_buffer += throttle_overflow * 32;
*/
while(throttle_little_buffer > 127){
throttle_little_buffer -= 127;
throttle_big_buffer += 32;
}
while(throttle_little_buffer < -127){
throttle_little_buffer += 127;
throttle_big_buffer -= 32;
}
if(throttle_big_buffer > 127){
throttle_big_buffer = 127;
}
else if(throttle_big_buffer < -127){
throttle_big_buffer = -127;
throttle_little_buffer = -127;
}
roll_buffer = stick.axes[0];//+ wall_controller_data.tilt;
if(roll_buffer > 127){
roll_buffer = 127;
}
else if(roll_buffer < -127){
roll_buffer = -127;
}
commandData.roll = char(roll_buffer) + 127;
commandData.pitch = char(stick.axes[1]) + 127;
commandData.throttleLittle = char(throttle_little_buffer) + 127;
commandData.yaw = char(stick.axes[3]) + 127;
commandData.throttleBig = char(throttle_big_buffer) + 127;
commandData.button = 20;
for(i = 0; i < 11; i ++){
if(stick.button[i]){
commandData.button = i;
}
}
//For status alignment varification
/*
if(commandData.button == 9){
sent_status = 9;
}
else if(commandData.button == 4){
sent_status = 4;
}
else if(commandData.button == 1){
sent_status = 1;
}
else if(commandData.button == 10){
sent_status = 10;
}
else if(sent_status != myStatus){
commandData.button = sent_status;
}
*/
/*Make sure it doesn't repeat any commands but stop and reset*/
if((commandData.button == prev) && (prev != 4) && (prev != 9)){
commandData.button = 20;
}
else{
prev = commandData.button;
}
mvprintw(10,0,"pitch: %4d\n", commandData.pitch);
mvprintw(11,0,"roll: %4d\n", commandData.roll);
mvprintw(12,0,"yaw: %4d\n", commandData.yaw);
mvprintw(13,0,"throttleLittle: %4d\n", commandData.throttleLittle);
mvprintw(14,0,"throttleBig: %4d\n", commandData.throttleBig);
mvprintw(15,0,"throttleLittle Buffer: %4d", stick.axes[2]);
mvprintw(16,0,"throttleBig Buffer: %4d", stick.axes[4]);
command.publish(commandData);
usleep(16600);
}
}
<commit_msg>Fixed bug where landing put target at 0 but didn't reset<commit_after>#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <ncurses.h>
#include "barney_pilot.h"
#include "ros/ros.h"
#include <sensor_msgs/Joy.h>
#include "rxtx_server/distance.h"
#include "rxtx_server/AngularPos.h"
#include "rxtx_server/status.h"
#include "rxtx_server/command.h"
#include "osuar_telepilot/altitude_request.h"
#include "osuar_telepilot/altitude_command.h"
#include "osuar_telepilot/wall_command.h"
#include "osuar_telepilot/wall_request.h"
#include "osuar_telepilot/wall_command.h"
#include "osuar_telepilot/wall_request.h"
#include "rxtx_server/heading_pos.h"
#include "altitude.h"
#include "wall_follow.h"
int main(int argc, char ** argv){
initscr();
cbreak();
noecho();
timeout(0);
ros::init(argc, argv, "Barney");
status platStatus;
joystick stick;
distance lidar;
angular_pos orientation;
lidar.prev = 0;
ros::NodeHandle n;
ros::Publisher command = n.advertise<rxtx_server::command>("command", 1);
rxtx_server::command commandData;
ros::Publisher altitude_handler_pub = n.advertise<osuar_telepilot::altitude_request>("altitude_request", 1);
osuar_telepilot::altitude_request altitude_request_data;
altitude_request_data.p = 28;
altitude_request_data.d = 0;
altitude_request_data.i = 15;
altitude_request_data.target = 40;
altitude_request_data.status = STARTING;
altitude_handler altitude_controller_data;
ros::Publisher wall_handler_pub = n.advertise<osuar_telepilot::wall_request>("wall_request", 1);
osuar_telepilot::wall_request wall_request_data;
wall_request_data.p = 4;
wall_request_data.i = 0;
wall_request_data.d = 0;
wall_request_data.target = 250;
wall_request_data.status = FOLLOW;
wall_handler wall_controller_data;
char myStatus = 1;
lidar.updateFlag = 0;
lidar.prev = 0;
platStatus.platStatus = 1;
char prev = 20;
int i;
int throttle_little_buffer = 0;
int throttle_big_buffer = 0;
int roll_buffer = 0;
ros::spinOnce();
for(i=0;i<11;i++){
stick.button[i] = 0;
}
for(i=0;i<5;i++){
stick.axes[i] = -126;
}
char keyboard;
char landingflag = 0;
//char sent_status = 9;
//printw("BARNEY TIME!\n");
mvprintw(0,0,"STARTING \n");
while(1){
ros::spinOnce();
if((keyboard = getch()) != ERR){
if(keyboard == 's'){
endwin();
return 0;
}
else if(keyboard == 'y'){
altitude_request_data.p += 1;
}
else if(keyboard == 'h'){
altitude_request_data.p -= 1;
}
else if(keyboard == 'u'){
altitude_request_data.d += 1;
}
else if(keyboard == 'j'){
altitude_request_data.d -= 1;
}
else if(keyboard == 'i'){
altitude_request_data.i += 1;
}
else if(keyboard == 'k'){
altitude_request_data.i -= 1;
}
//For starting takeoff
else if((keyboard == 't') && ((altitude_request_data.status == STARTING) || (altitude_request_data.status == 7)) ){
altitude_request_data.status = TAKEOFF;
mvprintw(0,0,"TAKEOFF \n");
}
else if((keyboard == 'l')){
//altitude_request_data.status = LAND;
landingflag = 1;
altitude_request_data.target = 0;
mvprintw(0,0,"LAND \n");
}
else if(keyboard == 'r'){
altitude_request_data.target = 40;
altitude_request_data.status = STARTING;
mvprintw(0,0,"STARTING \n");
}
mvprintw(15,40,"ALTITUDE:\n");
mvprintw(16,40,"P: %4f\n",altitude_request_data.p * .2);
mvprintw(17,40,"D: %4f\n",altitude_request_data.d * .2);
mvprintw(18,40,"I: %4i/5625\n",altitude_request_data.i);
}
//TAKEOFF AND LAND AUTOMATIC STATUS CHANGES
//When Taking Off, check to make transition to hover
if((altitude_request_data.status == TAKEOFF) && (altitude_controller_data.status == HOVER)){
altitude_request_data.status = HOVER;
mvprintw(0,0,"HOVERING \n");
}
else if((altitude_request_data.status == HOVER) && (altitude_controller_data.status == LAND) && (landingflag == 0)){
altitude_request_data.status = TAKEOFF;
mvprintw(0,0,"TAKEOFF \n");
}
else if((landingflag == 1) && (altitude_controller_data.status == LAND)){
landingflag = 0;
altitude_request_data.status = LAND;
}
if(orientation.updateFlag){
orientation.updateFlag = 0;
mvprintw(2,0,"X: %4i\n",orientation.x);
mvprintw(3,0,"Y: %4i\n",orientation.y);
mvprintw(4,0,"Z: %4i\n",orientation.z);
}
myStatus = platStatus.platStatus;
if(myStatus == 9){
mvprintw(1,0,"booting \n");
//Don't have bad things happen when module resets
//sent_status = 9;
}
else if(myStatus == 4){
mvprintw(1,0,"stopping \n");
altitude_request_data.status = 7;
altitude_controller_data.throttle_big = 0;
altitude_controller_data.throttle_little = 0;
}
else if(myStatus == 1){
mvprintw(1,0,"running \n");
}
else if(myStatus == 10){
mvprintw(1,0,"offsetting\n");
}
if(lidar.updateFlag){
lidar.updateFlag = 0;
mvprintw(5,0,"Vertical: %4i\n", lidar.vertical);
mvprintw(6,0,"Horizontal 1: %4i\n", lidar.horizontal_1);
if((abs(orientation.x) < 200) && (abs(orientation.y) < 200)){
altitude_request_data.distance = lidar.vertical;
altitude_handler_pub.publish(altitude_request_data);
wall_request_data.distance = lidar.horizontal_1;
wall_handler_pub.publish(wall_request_data);
}
else{
//altitude_controller_data.throttle_big = 0;
//altitude_controller_data.throttle_little = 0;
}
}
throttle_little_buffer = stick.axes[2] + altitude_controller_data.throttle_little;
throttle_big_buffer = stick.axes[4] + altitude_controller_data.throttle_big;
//Will eventually be phased out of this section of code and put in altitude
/*
if(throttle_big_buffer > 127){
throttle_big_buffer = 127;
}
else if(throttle_big_buffer < -127){
throttle_big_buffer = -127;
}
if(throttle_little_buffer > 127){
if(throttle_big_buffer < 94){
throttle_little_buffer -= 127;
throttle_big_buffer += 32;
}
else{
throttle_little_buffer = 127;
}
}
else if(throttle_little_buffer < -127){
if(throttle_big_buffer > -94){
throttle_little_buffer += 127;
throttle_big_buffer -= 32;
}
else{
throttle_little_buffer = -127;
}
}
*/
/*
throttle_overflow = throttle_little_buffer/127;
throttle_little_buffer %= 127;
throttle_big_buffer += throttle_overflow * 32;
*/
while(throttle_little_buffer > 127){
throttle_little_buffer -= 127;
throttle_big_buffer += 32;
}
while(throttle_little_buffer < -127){
throttle_little_buffer += 127;
throttle_big_buffer -= 32;
}
if(throttle_big_buffer > 127){
throttle_big_buffer = 127;
}
else if(throttle_big_buffer < -127){
throttle_big_buffer = -127;
throttle_little_buffer = -127;
}
roll_buffer = stick.axes[0];//+ wall_controller_data.tilt;
if(roll_buffer > 127){
roll_buffer = 127;
}
else if(roll_buffer < -127){
roll_buffer = -127;
}
commandData.roll = char(roll_buffer) + 127;
commandData.pitch = char(stick.axes[1]) + 127;
commandData.throttleLittle = char(throttle_little_buffer) + 127;
commandData.yaw = char(stick.axes[3]) + 127;
commandData.throttleBig = char(throttle_big_buffer) + 127;
commandData.button = 20;
for(i = 0; i < 11; i ++){
if(stick.button[i]){
commandData.button = i;
}
}
//For status alignment varification
/*
if(commandData.button == 9){
sent_status = 9;
}
else if(commandData.button == 4){
sent_status = 4;
}
else if(commandData.button == 1){
sent_status = 1;
}
else if(commandData.button == 10){
sent_status = 10;
}
else if(sent_status != myStatus){
commandData.button = sent_status;
}
*/
/*Make sure it doesn't repeat any commands but stop and reset*/
if((commandData.button == prev) && (prev != 4) && (prev != 9)){
commandData.button = 20;
}
else{
prev = commandData.button;
}
mvprintw(10,0,"pitch: %4d\n", commandData.pitch);
mvprintw(11,0,"roll: %4d\n", commandData.roll);
mvprintw(12,0,"yaw: %4d\n", commandData.yaw);
mvprintw(13,0,"throttleLittle: %4d\n", commandData.throttleLittle);
mvprintw(14,0,"throttleBig: %4d\n", commandData.throttleBig);
mvprintw(15,0,"throttleLittle Buffer: %4d", stick.axes[2]);
mvprintw(16,0,"throttleBig Buffer: %4d", stick.axes[4]);
command.publish(commandData);
usleep(16600);
}
}
<|endoftext|> |
<commit_before>#include "sqlitewrapper/exceptions.h"
#include "result_names.h"
#include "sqlitewrapper/sqlite3.h"
namespace SqliteWrapper {
Exception::Exception(const std::string &message) throw()
: m_message(message)
{
}
const char *Exception::what() const throw()
{
return m_message.c_str();
}
SqliteException::SqliteException(int resultCode)
: Exception(
resultToResultName(resultCode) + ": " +
sqlite3_errstr(resultCode)
)
{
}
SqliteException::SqliteException(int resultCode, const std::string &message)
: Exception(
resultToResultName(resultCode) + ": " +
sqlite3_errstr(resultCode) + "\n" +
message
)
{
}
}
<commit_msg>SqliteException: improve result code formatting<commit_after>#include "sqlitewrapper/exceptions.h"
#include "result_names.h"
#include "sqlitewrapper/sqlite3.h"
namespace SqliteWrapper {
Exception::Exception(const std::string &message) throw()
: m_message(message)
{
}
const char *Exception::what() const throw()
{
return m_message.c_str();
}
SqliteException::SqliteException(int resultCode)
: Exception(
resultToResultName(resultCode) +
" (" + sqlite3_errstr(resultCode) + ")"
)
{
}
SqliteException::SqliteException(int resultCode, const std::string &message)
: Exception(
resultToResultName(resultCode) +
" (" + sqlite3_errstr(resultCode) + "): " +
message
)
{
}
}
<|endoftext|> |
<commit_before>/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2020 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/deserializer.hpp"
#include "caf/detail/core_export.hpp"
#include "caf/dictionary.hpp"
#include "caf/fwd.hpp"
#include <memory>
#include <stack>
#include <vector>
namespace caf {
/// Extracts objects from a @ref config_value.
class CAF_CORE_EXPORT config_value_reader final : public deserializer {
public:
// -- member types------------------------------------------------------------
using super = deserializer;
using key_ptr = const std::string*;
struct absent_field {};
struct sequence {
using list_pointer = const std::vector<config_value>*;
size_t index;
list_pointer ls;
explicit sequence(list_pointer ls) : index(0), ls(ls) {
// nop
}
bool at_end() const noexcept;
const config_value& current();
void advance() {
++index;
}
};
struct associative_array {
settings::const_iterator pos;
settings::const_iterator end;
bool at_end() const noexcept;
const std::pair<const std::string, config_value>& current();
};
using value_type = variant<const settings*, const config_value*, key_ptr,
absent_field, sequence, associative_array>;
using stack_type = std::stack<value_type, std::vector<value_type>>;
// -- constructors, destructors, and assignment operators --------------------
config_value_reader(const config_value* input, actor_system& sys)
: super(sys) {
st_.push(input);
has_human_readable_format_ = true;
}
config_value_reader(const config_value* input, execution_unit* ctx)
: super(ctx) {
st_.push(input);
has_human_readable_format_ = true;
}
explicit config_value_reader(const config_value* input)
: config_value_reader(input, nullptr) {
// nop
}
~config_value_reader() override;
// -- stack access -----------------------------------------------------------
value_type& top() {
return st_.top();
}
void pop() {
return st_.pop();
}
// -- interface functions ----------------------------------------------------
bool fetch_next_object_type(type_id_t& type) override;
bool begin_object(type_id_t type, string_view name) override;
bool end_object() override;
bool begin_field(string_view) override;
bool begin_field(string_view name, bool& is_present) override;
bool begin_field(string_view name, span<const type_id_t> types,
size_t& index) override;
bool begin_field(string_view name, bool& is_present,
span<const type_id_t> types, size_t& index) override;
bool end_field() override;
bool begin_tuple(size_t size) override;
bool end_tuple() override;
bool begin_key_value_pair() override;
bool end_key_value_pair() override;
bool begin_sequence(size_t& size) override;
bool end_sequence() override;
bool begin_associative_array(size_t& size) override;
bool end_associative_array() override;
bool value(byte& x) override;
bool value(bool& x) override;
bool value(int8_t& x) override;
bool value(uint8_t& x) override;
bool value(int16_t& x) override;
bool value(uint16_t& x) override;
bool value(int32_t& x) override;
bool value(uint32_t& x) override;
bool value(int64_t& x) override;
bool value(uint64_t& x) override;
bool value(float& x) override;
bool value(double& x) override;
bool value(long double& x) override;
bool value(std::string& x) override;
bool value(std::u16string& x) override;
bool value(std::u32string& x) override;
bool value(span<byte> x) override;
private:
bool fetch_object_type(const settings* obj, type_id_t& type);
stack_type st_;
// Stores on-the-fly converted values.
std::vector<std::unique_ptr<config_value>> scratch_space_;
};
} // namespace caf
<commit_msg>Fix build on MSVC<commit_after>/******************************************************************************
* ____ _ _____ *
* / ___| / \ | ___| C++ *
* | | / _ \ | |_ Actor *
* | |___ / ___ \| _| Framework *
* \____/_/ \_|_| *
* *
* Copyright 2011-2020 Dominik Charousset *
* *
* Distributed under the terms and conditions of the BSD 3-Clause License or *
* (at your option) under the terms and conditions of the Boost Software *
* License 1.0. See accompanying files LICENSE and LICENSE_ALTERNATIVE. *
* *
* If you did not receive a copy of the license files, see *
* http://opensource.org/licenses/BSD-3-Clause and *
* http://www.boost.org/LICENSE_1_0.txt. *
******************************************************************************/
#pragma once
#include "caf/deserializer.hpp"
#include "caf/detail/core_export.hpp"
#include "caf/dictionary.hpp"
#include "caf/fwd.hpp"
#include <memory>
#include <stack>
#include <vector>
namespace caf {
/// Extracts objects from a @ref config_value.
class CAF_CORE_EXPORT config_value_reader final : public deserializer {
public:
// -- member types------------------------------------------------------------
using super = deserializer;
using key_ptr = const std::string*;
struct absent_field {};
struct sequence {
using list_pointer = const std::vector<config_value>*;
size_t index;
list_pointer ls;
explicit sequence(list_pointer ls) : index(0), ls(ls) {
// nop
}
bool at_end() const noexcept;
const config_value& current();
void advance() {
++index;
}
};
struct associative_array {
settings::const_iterator pos;
settings::const_iterator end;
bool at_end() const noexcept;
const std::pair<const std::string, config_value>& current();
};
using value_type = variant<const settings*, const config_value*, key_ptr,
absent_field, sequence, associative_array>;
using stack_type = std::stack<value_type, std::vector<value_type>>;
// -- constructors, destructors, and assignment operators --------------------
config_value_reader(const config_value* input, actor_system& sys)
: super(sys) {
st_.push(input);
has_human_readable_format_ = true;
}
config_value_reader(const config_value* input, execution_unit* ctx)
: super(ctx) {
st_.push(input);
has_human_readable_format_ = true;
}
explicit config_value_reader(const config_value* input)
: config_value_reader(input, nullptr) {
// nop
}
~config_value_reader() override;
config_value_reader(const config_value_reader&) = delete;
config_value_reader& operator=(const config_value_reader&) = delete;
// -- stack access -----------------------------------------------------------
value_type& top() {
return st_.top();
}
void pop() {
return st_.pop();
}
// -- interface functions ----------------------------------------------------
bool fetch_next_object_type(type_id_t& type) override;
bool begin_object(type_id_t type, string_view name) override;
bool end_object() override;
bool begin_field(string_view) override;
bool begin_field(string_view name, bool& is_present) override;
bool begin_field(string_view name, span<const type_id_t> types,
size_t& index) override;
bool begin_field(string_view name, bool& is_present,
span<const type_id_t> types, size_t& index) override;
bool end_field() override;
bool begin_tuple(size_t size) override;
bool end_tuple() override;
bool begin_key_value_pair() override;
bool end_key_value_pair() override;
bool begin_sequence(size_t& size) override;
bool end_sequence() override;
bool begin_associative_array(size_t& size) override;
bool end_associative_array() override;
bool value(byte& x) override;
bool value(bool& x) override;
bool value(int8_t& x) override;
bool value(uint8_t& x) override;
bool value(int16_t& x) override;
bool value(uint16_t& x) override;
bool value(int32_t& x) override;
bool value(uint32_t& x) override;
bool value(int64_t& x) override;
bool value(uint64_t& x) override;
bool value(float& x) override;
bool value(double& x) override;
bool value(long double& x) override;
bool value(std::string& x) override;
bool value(std::u16string& x) override;
bool value(std::u32string& x) override;
bool value(span<byte> x) override;
private:
bool fetch_object_type(const settings* obj, type_id_t& type);
stack_type st_;
// Stores on-the-fly converted values.
std::vector<std::unique_ptr<config_value>> scratch_space_;
};
} // namespace caf
<|endoftext|> |
<commit_before>/*
* Stack.cpp
*
* Created on: 24 Oct 2015
* Author: hieu
*/
#include <algorithm>
#include <boost/foreach.hpp>
#include "Stack.h"
#include "../Hypothesis.h"
#include "../Manager.h"
#include "../../Scores.h"
#include "../../System.h"
using namespace std;
namespace Moses2
{
namespace NSCubePruningCardinalStack
{
///////////////////////////////////////////////////////////////
Stack::Stack(const Manager &mgr)
:m_mgr(mgr)
,m_coll(MemPoolAllocator<const Hypothesis*>(mgr.GetPool()))
{
}
Stack::~Stack() {
// TODO Auto-generated destructor stub
}
void Stack::Add(const Hypothesis *hypo, Recycler<Hypothesis*> &hypoRecycle)
{
std::pair<_HCType::iterator, bool> addRet = m_coll.insert(hypo);
// CHECK RECOMBINATION
if (addRet.second) {
// equiv hypo doesn't exists
}
else {
const Hypothesis *hypoExisting = *addRet.first;
if (hypo->GetScores().GetTotalScore() > hypoExisting->GetScores().GetTotalScore()) {
// incoming hypo is better than the one we have
const Hypothesis *const &hypoExisting1 = *addRet.first;
const Hypothesis *&hypoExisting2 = const_cast<const Hypothesis *&>(hypoExisting1);
hypoExisting2 = hypo;
//hypoExisting->Prefetch();
Hypothesis *hypoToBeDeleted = const_cast<Hypothesis*>(hypoExisting);
hypoRecycle.Recycle(hypoToBeDeleted);
}
else {
// already storing the best hypo. discard incoming hypo
Hypothesis *hypoToBeDeleted = const_cast<Hypothesis*>(hypo);
hypoRecycle.Recycle(hypoToBeDeleted);
}
}
}
std::vector<const Hypothesis*> Stack::GetBestHypos(size_t num) const
{
std::vector<const Hypothesis*> ret;
ret.insert(ret.end(), m_coll.begin(), m_coll.end());
std::vector<const Hypothesis*>::iterator iterMiddle;
iterMiddle = (num == 0 || ret.size() < num)
? ret.end()
: ret.begin()+num;
std::partial_sort(ret.begin(), iterMiddle, ret.end(),
HypothesisFutureScoreOrderer());
return ret;
}
size_t Stack::GetHypoSize() const
{
return m_coll.size();
}
void Stack::Clear()
{
m_coll.clear();
}
Stack::SortedHypos Stack::GetSortedAndPruneHypos(const Manager &mgr) const
{
typedef boost::unordered_map<HypoCoverage, vector<const Hypothesis*> > SortedHypos2;
SortedHypos2 ret2;
MemPool &pool = mgr.GetPool();
// divide hypos by [bitmap, last end pos]
BOOST_FOREACH(const Hypothesis *hypo, m_coll) {
HypoCoverage key(&hypo->GetBitmap(), hypo->GetInputPath().range.GetEndPos());
vector<const Hypothesis*> &hypos = ret2[key];
hypos.push_back(hypo);
}
// put into real return variable and sort
SortedHypos ret;
BOOST_FOREACH(SortedHypos2::value_type &val, ret2) {
const vector<const Hypothesis*> &hypos2 = val.second;
Hypotheses *hypos = new (pool.Allocate<Hypotheses>()) Hypotheses(pool, hypos2.size());
for (size_t i = 0; i < hypos2.size(); ++i) {
(*hypos)[i] = hypos2[i];
}
SortAndPruneHypos(mgr, *hypos);
ret[val.first] = hypos;
}
return ret;
}
void Stack::SortAndPruneHypos(const Manager &mgr, Hypotheses &hypos) const
{
size_t stackSize = mgr.system.stackSize;
Recycler<Hypothesis*> &recycler = mgr.GetHypoRecycle();
/*
cerr << "UNSORTED hypos:" << endl;
for (size_t i = 0; i < hypos.size(); ++i) {
const Hypothesis *hypo = hypos[i];
cerr << *hypo << endl;
}
cerr << endl;
*/
Hypotheses::iterator iterMiddle;
iterMiddle = (stackSize == 0 || hypos.size() < stackSize)
? hypos.end()
: hypos.begin() + stackSize;
std::partial_sort(hypos.begin(), iterMiddle, hypos.end(),
HypothesisFutureScoreOrderer());
// prune
if (stackSize && hypos.size() > stackSize) {
for (size_t i = stackSize; i < hypos.size(); ++i) {
Hypothesis *hypo = const_cast<Hypothesis*>(hypos[i]);
recycler.Recycle(hypo);
}
hypos.resize(stackSize);
}
/*
cerr << "sorted hypos:" << endl;
for (size_t i = 0; i < hypos.size(); ++i) {
const Hypothesis *hypo = hypos[i];
cerr << hypo << " " << *hypo << endl;
}
cerr << endl;
*/
}
}
}
<commit_msg>don't copy from vector to Hypotheses<commit_after>/*
* Stack.cpp
*
* Created on: 24 Oct 2015
* Author: hieu
*/
#include <algorithm>
#include <boost/foreach.hpp>
#include "Stack.h"
#include "../Hypothesis.h"
#include "../Manager.h"
#include "../../Scores.h"
#include "../../System.h"
using namespace std;
namespace Moses2
{
namespace NSCubePruningCardinalStack
{
///////////////////////////////////////////////////////////////
Stack::Stack(const Manager &mgr)
:m_mgr(mgr)
,m_coll(MemPoolAllocator<const Hypothesis*>(mgr.GetPool()))
{
}
Stack::~Stack() {
// TODO Auto-generated destructor stub
}
void Stack::Add(const Hypothesis *hypo, Recycler<Hypothesis*> &hypoRecycle)
{
std::pair<_HCType::iterator, bool> addRet = m_coll.insert(hypo);
// CHECK RECOMBINATION
if (addRet.second) {
// equiv hypo doesn't exists
}
else {
const Hypothesis *hypoExisting = *addRet.first;
if (hypo->GetScores().GetTotalScore() > hypoExisting->GetScores().GetTotalScore()) {
// incoming hypo is better than the one we have
const Hypothesis *const &hypoExisting1 = *addRet.first;
const Hypothesis *&hypoExisting2 = const_cast<const Hypothesis *&>(hypoExisting1);
hypoExisting2 = hypo;
//hypoExisting->Prefetch();
Hypothesis *hypoToBeDeleted = const_cast<Hypothesis*>(hypoExisting);
hypoRecycle.Recycle(hypoToBeDeleted);
}
else {
// already storing the best hypo. discard incoming hypo
Hypothesis *hypoToBeDeleted = const_cast<Hypothesis*>(hypo);
hypoRecycle.Recycle(hypoToBeDeleted);
}
}
}
std::vector<const Hypothesis*> Stack::GetBestHypos(size_t num) const
{
std::vector<const Hypothesis*> ret;
ret.insert(ret.end(), m_coll.begin(), m_coll.end());
std::vector<const Hypothesis*>::iterator iterMiddle;
iterMiddle = (num == 0 || ret.size() < num)
? ret.end()
: ret.begin()+num;
std::partial_sort(ret.begin(), iterMiddle, ret.end(),
HypothesisFutureScoreOrderer());
return ret;
}
size_t Stack::GetHypoSize() const
{
return m_coll.size();
}
void Stack::Clear()
{
m_coll.clear();
}
Stack::SortedHypos Stack::GetSortedAndPruneHypos(const Manager &mgr) const
{
SortedHypos ret;
MemPool &pool = mgr.GetPool();
// divide hypos by [bitmap, last end pos]
BOOST_FOREACH(const Hypothesis *hypo, m_coll) {
HypoCoverage key(&hypo->GetBitmap(), hypo->GetInputPath().range.GetEndPos());
Hypotheses *hypos;
SortedHypos::iterator iter;
iter = ret.find(key);
if (iter == ret.end()) {
hypos = new (pool.Allocate<Hypotheses>()) Hypotheses(pool, 0);
ret[key] = hypos;
}
else {
hypos = iter->second;
}
hypos->push_back(hypo);
}
// put into real return variable and sort
BOOST_FOREACH(SortedHypos::value_type &val, ret) {
Hypotheses &hypos = *val.second;
SortAndPruneHypos(mgr, hypos);
}
return ret;
}
void Stack::SortAndPruneHypos(const Manager &mgr, Hypotheses &hypos) const
{
size_t stackSize = mgr.system.stackSize;
Recycler<Hypothesis*> &recycler = mgr.GetHypoRecycle();
/*
cerr << "UNSORTED hypos:" << endl;
for (size_t i = 0; i < hypos.size(); ++i) {
const Hypothesis *hypo = hypos[i];
cerr << *hypo << endl;
}
cerr << endl;
*/
Hypotheses::iterator iterMiddle;
iterMiddle = (stackSize == 0 || hypos.size() < stackSize)
? hypos.end()
: hypos.begin() + stackSize;
std::partial_sort(hypos.begin(), iterMiddle, hypos.end(),
HypothesisFutureScoreOrderer());
// prune
if (stackSize && hypos.size() > stackSize) {
for (size_t i = stackSize; i < hypos.size(); ++i) {
Hypothesis *hypo = const_cast<Hypothesis*>(hypos[i]);
recycler.Recycle(hypo);
}
hypos.resize(stackSize);
}
/*
cerr << "sorted hypos:" << endl;
for (size_t i = 0; i < hypos.size(); ++i) {
const Hypothesis *hypo = hypos[i];
cerr << hypo << " " << *hypo << endl;
}
cerr << endl;
*/
}
}
}
<|endoftext|> |
<commit_before>/*
* Copyright 2007-2017 Content Management AG
* All rights reserved.
*
* author: Max Kellermann <[email protected]>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Stock.hxx"
#include "Error.hxx"
#include "stock/MapStock.hxx"
#include "stock/Stock.hxx"
#include "stock/Class.hxx"
#include "stock/Item.hxx"
#include "child_stock.hxx"
#include "spawn/Prepared.hxx"
#include "spawn/ChildOptions.hxx"
#include "spawn/JailParams.hxx"
#include "spawn/JailConfig.hxx"
#include "pool/tpool.hxx"
#include "AllocatorPtr.hxx"
#include "event/SocketEvent.hxx"
#include "event/Duration.hxx"
#include "net/UniqueSocketDescriptor.hxx"
#include "io/UniqueFileDescriptor.hxx"
#include "io/Logger.hxx"
#include "util/ConstBuffer.hxx"
#include "util/RuntimeError.hxx"
#include "util/Exception.hxx"
#include "util/StringFormat.hxx"
#include <string>
#include <assert.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#ifdef __linux
#include <sched.h>
#endif
struct FcgiStock final : StockClass, ChildStockClass {
StockMap hstock;
ChildStock child_stock;
FcgiStock(unsigned limit, unsigned max_idle,
EventLoop &event_loop, SpawnService &spawn_service,
SocketDescriptor _log_socket) noexcept;
~FcgiStock() {
/* this one must be cleared before #child_stock; FadeAll()
calls ClearIdle(), so this method is the best match for
what we want to do (though a kludge) */
hstock.FadeAll();
}
EventLoop &GetEventLoop() {
return hstock.GetEventLoop();
}
SocketDescriptor GetLogSocket() const noexcept {
return child_stock.GetLogSocket();
}
void FadeAll() {
hstock.FadeAll();
child_stock.GetStockMap().FadeAll();
}
void FadeTag(const char *tag);
/* virtual methods from class StockClass */
void Create(CreateStockItem c, void *info, struct pool &caller_pool,
CancellablePointer &cancel_ptr) override;
/* virtual methods from class ChildStockClass */
const char *GetChildTag(void *info) const noexcept override;
void PrepareChild(void *info, UniqueSocketDescriptor &&fd,
PreparedChildProcess &p) override;
};
struct FcgiChildParams {
const char *executable_path;
ConstBuffer<const char *> args;
const ChildOptions &options;
FcgiChildParams(const char *_executable_path,
ConstBuffer<const char *> _args,
const ChildOptions &_options)
:executable_path(_executable_path), args(_args),
options(_options) {}
const char *GetStockKey(struct pool &pool) const;
};
struct FcgiConnection final : StockItem {
const LLogger logger;
std::string jail_home_directory;
JailConfig jail_config;
StockItem *child = nullptr;
UniqueSocketDescriptor fd;
SocketEvent event;
/**
* Is this a fresh connection to the FastCGI child process?
*/
bool fresh = true;
/**
* Shall the FastCGI child process be killed?
*/
bool kill = false;
/**
* Was the current request aborted by the fcgi_client caller?
*/
bool aborted = false;
explicit FcgiConnection(EventLoop &event_loop, CreateStockItem c)
:StockItem(c), logger(GetStockName()),
event(event_loop, BIND_THIS_METHOD(OnSocketEvent)) {}
~FcgiConnection() override;
gcc_pure
const char *GetTag() const {
assert(child != nullptr);
return child_stock_item_get_tag(*child);
}
void SetSite(const char *site) noexcept {
child_stock_item_set_site(*child, site);
}
void SetUri(const char *uri) noexcept {
child_stock_item_set_uri(*child, uri);
}
/* virtual methods from class StockItem */
bool Borrow() noexcept override;
bool Release() noexcept override;
private:
void OnSocketEvent(unsigned events);
};
const char *
FcgiChildParams::GetStockKey(struct pool &pool) const
{
const char *key = executable_path;
for (auto i : args)
key = p_strcat(&pool, key, " ", i, nullptr);
for (auto i : options.env)
key = p_strcat(&pool, key, "$", i, nullptr);
char options_buffer[16384];
*options.MakeId(options_buffer) = 0;
if (*options_buffer != 0)
key = p_strcat(&pool, key, options_buffer, nullptr);
return key;
}
/*
* libevent callback
*
*/
void
FcgiConnection::OnSocketEvent(unsigned events)
{
if ((events & SocketEvent::TIMEOUT) == 0) {
char buffer;
ssize_t nbytes = fd.Read(&buffer, sizeof(buffer));
if (nbytes < 0)
logger(2, "error on idle FastCGI connection: ", strerror(errno));
else if (nbytes > 0)
logger(2, "unexpected data from idle FastCGI connection");
}
InvokeIdleDisconnect();
}
/*
* child_stock class
*
*/
const char *
FcgiStock::GetChildTag(void *info) const noexcept
{
const auto ¶ms = *(const FcgiChildParams *)info;
return params.options.tag;
}
void
FcgiStock::PrepareChild(void *info, UniqueSocketDescriptor &&fd,
PreparedChildProcess &p)
{
auto ¶ms = *(FcgiChildParams *)info;
const ChildOptions &options = params.options;
p.SetStdin(std::move(fd));
/* the FastCGI protocol defines a channel for stderr, so we could
close its "real" stderr here, but many FastCGI applications
don't use the FastCGI protocol to send error messages, so we
just keep it open */
UniqueFileDescriptor null_fd;
if (null_fd.Open("/dev/null", O_WRONLY))
p.SetStdout(std::move(null_fd));
p.Append(params.executable_path);
for (auto i : params.args)
p.Append(i);
options.CopyTo(p, true, nullptr);
}
/*
* stock class
*
*/
void
FcgiStock::Create(CreateStockItem c, void *info,
struct pool &caller_pool,
gcc_unused CancellablePointer &cancel_ptr)
{
FcgiChildParams *params = (FcgiChildParams *)info;
assert(params != nullptr);
assert(params->executable_path != nullptr);
auto *connection = new FcgiConnection(GetEventLoop(), c);
const ChildOptions &options = params->options;
if (options.jail != nullptr && options.jail->enabled) {
connection->jail_home_directory = options.jail->home_directory;
if (!connection->jail_config.Load("/etc/cm4all/jailcgi/jail.conf")) {
delete connection;
throw FcgiClientError("Failed to load /etc/cm4all/jailcgi/jail.conf");
}
}
const char *key = c.GetStockName();
try {
connection->child = child_stock.GetStockMap().GetNow(caller_pool, key, params);
} catch (...) {
delete connection;
std::throw_with_nested(FcgiClientError(StringFormat<256>("Failed to start FastCGI server '%s'",
key)));
}
try {
connection->fd = child_stock_item_connect(*connection->child);
} catch (...) {
connection->kill = true;
delete connection;
std::throw_with_nested(FcgiClientError(StringFormat<256>("Failed to connect to FastCGI server '%s'",
key)));
}
connection->event.Set(connection->fd.Get(), SocketEvent::READ);
connection->InvokeCreateSuccess();
}
bool
FcgiConnection::Borrow() noexcept
{
/* check the connection status before using it, just in case the
FastCGI server has decided to close the connection before
fcgi_connection_event_callback() got invoked */
char buffer;
ssize_t nbytes = fd.Read(&buffer, sizeof(buffer));
if (nbytes > 0) {
logger(2, "unexpected data from idle FastCGI connection");
return false;
} else if (nbytes == 0) {
/* connection closed (not worth a log message) */
return false;
} else if (errno != EAGAIN) {
logger(2, "error on idle FastCGI connection: ", strerror(errno));
return false;
}
event.Delete();
aborted = false;
return true;
}
bool
FcgiConnection::Release() noexcept
{
fresh = false;
event.Add(EventDuration<300>::value);
return true;
}
FcgiConnection::~FcgiConnection()
{
if (fd.IsDefined()) {
event.Delete();
fd.Close();
}
if (fresh && aborted)
/* the fcgi_client caller has aborted the request before the
first response on a fresh connection was received: better
kill the child process, it may be failing on us
completely */
kill = true;
if (child != nullptr)
child->Put(kill);
}
/*
* interface
*
*/
inline
FcgiStock::FcgiStock(unsigned limit, unsigned max_idle,
EventLoop &event_loop, SpawnService &spawn_service,
SocketDescriptor _log_socket) noexcept
:hstock(event_loop, *this, limit, max_idle),
child_stock(event_loop, spawn_service,
*this,
_log_socket,
limit, max_idle) {}
void
FcgiStock::FadeTag(const char *tag)
{
assert(tag != nullptr);
hstock.FadeIf([tag](const StockItem &item){
const auto &connection = (const FcgiConnection &)item;
const char *tag2 = connection.GetTag();
return tag2 != nullptr && strcmp(tag, tag2) == 0;
});
child_stock.FadeTag(tag);
}
FcgiStock *
fcgi_stock_new(unsigned limit, unsigned max_idle,
EventLoop &event_loop, SpawnService &spawn_service,
SocketDescriptor log_socket)
{
return new FcgiStock(limit, max_idle, event_loop, spawn_service,
log_socket);
}
void
fcgi_stock_free(FcgiStock *fcgi_stock)
{
delete fcgi_stock;
}
SocketDescriptor
fcgi_stock_get_log_socket(const FcgiStock &fs) noexcept
{
return fs.GetLogSocket();
}
void
fcgi_stock_fade_all(FcgiStock &fs)
{
fs.FadeAll();
}
void
fcgi_stock_fade_tag(FcgiStock &fs, const char *tag)
{
fs.FadeTag(tag);
}
StockItem *
fcgi_stock_get(FcgiStock *fcgi_stock,
const ChildOptions &options,
const char *executable_path,
ConstBuffer<const char *> args)
{
const AutoRewindPool auto_rewind(*tpool);
auto params = NewFromPool<FcgiChildParams>(*tpool, executable_path,
args, options);
return fcgi_stock->hstock.GetNow(*tpool,
params->GetStockKey(*tpool), params);
}
int
fcgi_stock_item_get_domain(gcc_unused const StockItem &item)
{
return AF_UNIX;
}
void
fcgi_stock_item_set_site(StockItem &item, const char *site) noexcept
{
auto &connection = (FcgiConnection &)item;
connection.SetSite(site);
}
void
fcgi_stock_item_set_uri(StockItem &item, const char *uri) noexcept
{
auto &connection = (FcgiConnection &)item;
connection.SetUri(uri);
}
SocketDescriptor
fcgi_stock_item_get(const StockItem &item)
{
const auto *connection = (const FcgiConnection *)&item;
assert(connection->fd.IsDefined());
return connection->fd;
}
const char *
fcgi_stock_translate_path(const StockItem &item,
const char *path, AllocatorPtr alloc)
{
const auto *connection = (const FcgiConnection *)&item;
if (connection->jail_home_directory.empty())
/* no JailCGI - application's namespace is the same as ours,
no translation needed */
return path;
const char *jailed = connection->jail_config.TranslatePath(path,
connection->jail_home_directory.c_str(),
alloc);
return jailed != nullptr ? jailed : path;
}
void
fcgi_stock_aborted(StockItem &item)
{
auto *connection = (FcgiConnection *)&item;
connection->aborted = true;
}
<commit_msg>fcgi/Stock: separate TimerEvent for the timeout<commit_after>/*
* Copyright 2007-2017 Content Management AG
* All rights reserved.
*
* author: Max Kellermann <[email protected]>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "Stock.hxx"
#include "Error.hxx"
#include "stock/MapStock.hxx"
#include "stock/Stock.hxx"
#include "stock/Class.hxx"
#include "stock/Item.hxx"
#include "child_stock.hxx"
#include "spawn/Prepared.hxx"
#include "spawn/ChildOptions.hxx"
#include "spawn/JailParams.hxx"
#include "spawn/JailConfig.hxx"
#include "pool/tpool.hxx"
#include "AllocatorPtr.hxx"
#include "event/SocketEvent.hxx"
#include "event/TimerEvent.hxx"
#include "event/Duration.hxx"
#include "net/UniqueSocketDescriptor.hxx"
#include "io/UniqueFileDescriptor.hxx"
#include "io/Logger.hxx"
#include "util/ConstBuffer.hxx"
#include "util/RuntimeError.hxx"
#include "util/Exception.hxx"
#include "util/StringFormat.hxx"
#include <string>
#include <assert.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#ifdef __linux
#include <sched.h>
#endif
struct FcgiStock final : StockClass, ChildStockClass {
StockMap hstock;
ChildStock child_stock;
FcgiStock(unsigned limit, unsigned max_idle,
EventLoop &event_loop, SpawnService &spawn_service,
SocketDescriptor _log_socket) noexcept;
~FcgiStock() {
/* this one must be cleared before #child_stock; FadeAll()
calls ClearIdle(), so this method is the best match for
what we want to do (though a kludge) */
hstock.FadeAll();
}
EventLoop &GetEventLoop() {
return hstock.GetEventLoop();
}
SocketDescriptor GetLogSocket() const noexcept {
return child_stock.GetLogSocket();
}
void FadeAll() {
hstock.FadeAll();
child_stock.GetStockMap().FadeAll();
}
void FadeTag(const char *tag);
/* virtual methods from class StockClass */
void Create(CreateStockItem c, void *info, struct pool &caller_pool,
CancellablePointer &cancel_ptr) override;
/* virtual methods from class ChildStockClass */
const char *GetChildTag(void *info) const noexcept override;
void PrepareChild(void *info, UniqueSocketDescriptor &&fd,
PreparedChildProcess &p) override;
};
struct FcgiChildParams {
const char *executable_path;
ConstBuffer<const char *> args;
const ChildOptions &options;
FcgiChildParams(const char *_executable_path,
ConstBuffer<const char *> _args,
const ChildOptions &_options)
:executable_path(_executable_path), args(_args),
options(_options) {}
const char *GetStockKey(struct pool &pool) const;
};
struct FcgiConnection final : StockItem {
const LLogger logger;
std::string jail_home_directory;
JailConfig jail_config;
StockItem *child = nullptr;
UniqueSocketDescriptor fd;
SocketEvent event;
TimerEvent idle_timeout_event;
/**
* Is this a fresh connection to the FastCGI child process?
*/
bool fresh = true;
/**
* Shall the FastCGI child process be killed?
*/
bool kill = false;
/**
* Was the current request aborted by the fcgi_client caller?
*/
bool aborted = false;
explicit FcgiConnection(EventLoop &event_loop, CreateStockItem c)
:StockItem(c), logger(GetStockName()),
event(event_loop, BIND_THIS_METHOD(OnSocketEvent)),
idle_timeout_event(c.stock.GetEventLoop(),
BIND_THIS_METHOD(OnIdleTimeout)) {}
~FcgiConnection() override;
gcc_pure
const char *GetTag() const {
assert(child != nullptr);
return child_stock_item_get_tag(*child);
}
void SetSite(const char *site) noexcept {
child_stock_item_set_site(*child, site);
}
void SetUri(const char *uri) noexcept {
child_stock_item_set_uri(*child, uri);
}
/* virtual methods from class StockItem */
bool Borrow() noexcept override;
bool Release() noexcept override;
private:
void OnSocketEvent(unsigned events);
void OnIdleTimeout() noexcept;
};
const char *
FcgiChildParams::GetStockKey(struct pool &pool) const
{
const char *key = executable_path;
for (auto i : args)
key = p_strcat(&pool, key, " ", i, nullptr);
for (auto i : options.env)
key = p_strcat(&pool, key, "$", i, nullptr);
char options_buffer[16384];
*options.MakeId(options_buffer) = 0;
if (*options_buffer != 0)
key = p_strcat(&pool, key, options_buffer, nullptr);
return key;
}
/*
* libevent callback
*
*/
void
FcgiConnection::OnSocketEvent(unsigned)
{
char buffer;
ssize_t nbytes = fd.Read(&buffer, sizeof(buffer));
if (nbytes < 0)
logger(2, "error on idle FastCGI connection: ", strerror(errno));
else if (nbytes > 0)
logger(2, "unexpected data from idle FastCGI connection");
InvokeIdleDisconnect();
}
inline void
FcgiConnection::OnIdleTimeout() noexcept
{
InvokeIdleDisconnect();
}
/*
* child_stock class
*
*/
const char *
FcgiStock::GetChildTag(void *info) const noexcept
{
const auto ¶ms = *(const FcgiChildParams *)info;
return params.options.tag;
}
void
FcgiStock::PrepareChild(void *info, UniqueSocketDescriptor &&fd,
PreparedChildProcess &p)
{
auto ¶ms = *(FcgiChildParams *)info;
const ChildOptions &options = params.options;
p.SetStdin(std::move(fd));
/* the FastCGI protocol defines a channel for stderr, so we could
close its "real" stderr here, but many FastCGI applications
don't use the FastCGI protocol to send error messages, so we
just keep it open */
UniqueFileDescriptor null_fd;
if (null_fd.Open("/dev/null", O_WRONLY))
p.SetStdout(std::move(null_fd));
p.Append(params.executable_path);
for (auto i : params.args)
p.Append(i);
options.CopyTo(p, true, nullptr);
}
/*
* stock class
*
*/
void
FcgiStock::Create(CreateStockItem c, void *info,
struct pool &caller_pool,
gcc_unused CancellablePointer &cancel_ptr)
{
FcgiChildParams *params = (FcgiChildParams *)info;
assert(params != nullptr);
assert(params->executable_path != nullptr);
auto *connection = new FcgiConnection(GetEventLoop(), c);
const ChildOptions &options = params->options;
if (options.jail != nullptr && options.jail->enabled) {
connection->jail_home_directory = options.jail->home_directory;
if (!connection->jail_config.Load("/etc/cm4all/jailcgi/jail.conf")) {
delete connection;
throw FcgiClientError("Failed to load /etc/cm4all/jailcgi/jail.conf");
}
}
const char *key = c.GetStockName();
try {
connection->child = child_stock.GetStockMap().GetNow(caller_pool, key, params);
} catch (...) {
delete connection;
std::throw_with_nested(FcgiClientError(StringFormat<256>("Failed to start FastCGI server '%s'",
key)));
}
try {
connection->fd = child_stock_item_connect(*connection->child);
} catch (...) {
connection->kill = true;
delete connection;
std::throw_with_nested(FcgiClientError(StringFormat<256>("Failed to connect to FastCGI server '%s'",
key)));
}
connection->event.Set(connection->fd.Get(), SocketEvent::READ);
connection->InvokeCreateSuccess();
}
bool
FcgiConnection::Borrow() noexcept
{
/* check the connection status before using it, just in case the
FastCGI server has decided to close the connection before
fcgi_connection_event_callback() got invoked */
char buffer;
ssize_t nbytes = fd.Read(&buffer, sizeof(buffer));
if (nbytes > 0) {
logger(2, "unexpected data from idle FastCGI connection");
return false;
} else if (nbytes == 0) {
/* connection closed (not worth a log message) */
return false;
} else if (errno != EAGAIN) {
logger(2, "error on idle FastCGI connection: ", strerror(errno));
return false;
}
event.Delete();
idle_timeout_event.Cancel();
aborted = false;
return true;
}
bool
FcgiConnection::Release() noexcept
{
fresh = false;
event.Add();
idle_timeout_event.Add(EventDuration<300>::value);
return true;
}
FcgiConnection::~FcgiConnection()
{
if (fd.IsDefined()) {
event.Delete();
fd.Close();
}
if (fresh && aborted)
/* the fcgi_client caller has aborted the request before the
first response on a fresh connection was received: better
kill the child process, it may be failing on us
completely */
kill = true;
if (child != nullptr)
child->Put(kill);
}
/*
* interface
*
*/
inline
FcgiStock::FcgiStock(unsigned limit, unsigned max_idle,
EventLoop &event_loop, SpawnService &spawn_service,
SocketDescriptor _log_socket) noexcept
:hstock(event_loop, *this, limit, max_idle),
child_stock(event_loop, spawn_service,
*this,
_log_socket,
limit, max_idle) {}
void
FcgiStock::FadeTag(const char *tag)
{
assert(tag != nullptr);
hstock.FadeIf([tag](const StockItem &item){
const auto &connection = (const FcgiConnection &)item;
const char *tag2 = connection.GetTag();
return tag2 != nullptr && strcmp(tag, tag2) == 0;
});
child_stock.FadeTag(tag);
}
FcgiStock *
fcgi_stock_new(unsigned limit, unsigned max_idle,
EventLoop &event_loop, SpawnService &spawn_service,
SocketDescriptor log_socket)
{
return new FcgiStock(limit, max_idle, event_loop, spawn_service,
log_socket);
}
void
fcgi_stock_free(FcgiStock *fcgi_stock)
{
delete fcgi_stock;
}
SocketDescriptor
fcgi_stock_get_log_socket(const FcgiStock &fs) noexcept
{
return fs.GetLogSocket();
}
void
fcgi_stock_fade_all(FcgiStock &fs)
{
fs.FadeAll();
}
void
fcgi_stock_fade_tag(FcgiStock &fs, const char *tag)
{
fs.FadeTag(tag);
}
StockItem *
fcgi_stock_get(FcgiStock *fcgi_stock,
const ChildOptions &options,
const char *executable_path,
ConstBuffer<const char *> args)
{
const AutoRewindPool auto_rewind(*tpool);
auto params = NewFromPool<FcgiChildParams>(*tpool, executable_path,
args, options);
return fcgi_stock->hstock.GetNow(*tpool,
params->GetStockKey(*tpool), params);
}
int
fcgi_stock_item_get_domain(gcc_unused const StockItem &item)
{
return AF_UNIX;
}
void
fcgi_stock_item_set_site(StockItem &item, const char *site) noexcept
{
auto &connection = (FcgiConnection &)item;
connection.SetSite(site);
}
void
fcgi_stock_item_set_uri(StockItem &item, const char *uri) noexcept
{
auto &connection = (FcgiConnection &)item;
connection.SetUri(uri);
}
SocketDescriptor
fcgi_stock_item_get(const StockItem &item)
{
const auto *connection = (const FcgiConnection *)&item;
assert(connection->fd.IsDefined());
return connection->fd;
}
const char *
fcgi_stock_translate_path(const StockItem &item,
const char *path, AllocatorPtr alloc)
{
const auto *connection = (const FcgiConnection *)&item;
if (connection->jail_home_directory.empty())
/* no JailCGI - application's namespace is the same as ours,
no translation needed */
return path;
const char *jailed = connection->jail_config.TranslatePath(path,
connection->jail_home_directory.c_str(),
alloc);
return jailed != nullptr ? jailed : path;
}
void
fcgi_stock_aborted(StockItem &item)
{
auto *connection = (FcgiConnection *)&item;
connection->aborted = true;
}
<|endoftext|> |
<commit_before>
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBBoxRecord.h"
void SkBBoxRecord::drawOval(const SkRect& rect, const SkPaint& paint) {
if (this->transformBounds(rect, &paint)) {
INHERITED::drawOval(rect, paint);
}
}
void SkBBoxRecord::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
if (this->transformBounds(rrect.rect(), &paint)) {
INHERITED::drawRRect(rrect, paint);
}
}
void SkBBoxRecord::drawRect(const SkRect& rect, const SkPaint& paint) {
if (this->transformBounds(rect, &paint)) {
INHERITED::drawRect(rect, paint);
}
}
void SkBBoxRecord::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
const SkPaint& paint) {
if (this->transformBounds(outer.rect(), &paint)) {
this->INHERITED::onDrawDRRect(outer, inner, paint);
}
}
void SkBBoxRecord::drawPath(const SkPath& path, const SkPaint& paint) {
if (path.isInverseFillType()) {
// If path is inverse filled, use the current clip bounds as the
// path's device-space bounding box.
SkIRect clipBounds;
if (this->getClipDeviceBounds(&clipBounds)) {
this->handleBBox(SkRect::Make(clipBounds));
INHERITED::drawPath(path, paint);
}
} else if (this->transformBounds(path.getBounds(), &paint)) {
INHERITED::drawPath(path, paint);
}
}
void SkBBoxRecord::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
const SkPaint& paint) {
SkRect bbox;
bbox.set(pts, SkToInt(count));
// Small min width value, just to ensure hairline point bounding boxes aren't empty.
// Even though we know hairline primitives are drawn one pixel wide, we do not use a
// minimum of 1 because the playback scale factor is unknown at record time. Later
// outsets will take care of adding additional padding for antialiasing and rounding out
// to integer device coordinates, guaranteeing that the rasterized pixels will be included
// in the computed bounds.
// Note: The device coordinate outset in SkBBoxHierarchyRecord::handleBBox is currently
// done in the recording coordinate space, which is wrong.
// http://code.google.com/p/skia/issues/detail?id=1021
static const SkScalar kMinWidth = 0.01f;
SkScalar halfStrokeWidth = SkMaxScalar(paint.getStrokeWidth(), kMinWidth) / 2;
bbox.outset(halfStrokeWidth, halfStrokeWidth);
if (this->transformBounds(bbox, &paint)) {
INHERITED::drawPoints(mode, count, pts, paint);
}
}
void SkBBoxRecord::drawPaint(const SkPaint& paint) {
SkRect bbox;
if (this->getClipBounds(&bbox)) {
if (this->transformBounds(bbox, &paint)) {
INHERITED::drawPaint(paint);
}
}
}
void SkBBoxRecord::clear(SkColor color) {
SkISize size = this->getDeviceSize();
SkRect bbox = {0, 0, SkIntToScalar(size.width()), SkIntToScalar(size.height())};
this->handleBBox(bbox);
INHERITED::clear(color);
}
void SkBBoxRecord::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint) {
SkRect bbox;
paint.measureText(text, byteLength, &bbox);
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
// Vertical and aligned text need to be offset
if (paint.isVerticalText()) {
SkScalar h = bbox.fBottom - bbox.fTop;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
bbox.fTop -= h / 2;
bbox.fBottom -= h / 2;
}
// Pad top and bottom with max extents from FontMetrics
bbox.fBottom += metrics.fBottom;
bbox.fTop += metrics.fTop;
} else {
SkScalar w = bbox.fRight - bbox.fLeft;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
bbox.fLeft -= w / 2;
bbox.fRight -= w / 2;
} else if (paint.getTextAlign() == SkPaint::kRight_Align) {
bbox.fLeft -= w;
bbox.fRight -= w;
}
// Set vertical bounds to max extents from font metrics
bbox.fTop = metrics.fTop;
bbox.fBottom = metrics.fBottom;
}
// Pad horizontal bounds on each side by half of max vertical extents (this is sort of
// arbitrary, but seems to produce reasonable results, if there were a way of getting max
// glyph X-extents to pad by, that may be better here, but FontMetrics fXMin and fXMax seem
// incorrect on most platforms (too small in Linux, never even set in Windows).
SkScalar pad = (metrics.fBottom - metrics.fTop) / 2;
bbox.fLeft -= pad;
bbox.fRight += pad;
bbox.fLeft += x;
bbox.fRight += x;
bbox.fTop += y;
bbox.fBottom += y;
if (this->transformBounds(bbox, &paint)) {
INHERITED::onDrawText(text, byteLength, x, y, paint);
}
}
void SkBBoxRecord::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint) {
SkRect bbox = {left, top, left + bitmap.width(), top + bitmap.height()};
if (this->transformBounds(bbox, paint)) {
INHERITED::drawBitmap(bitmap, left, top, paint);
}
}
void SkBBoxRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint,
DrawBitmapRectFlags flags) {
if (this->transformBounds(dst, paint)) {
INHERITED::drawBitmapRectToRect(bitmap, src, dst, paint, flags);
}
}
void SkBBoxRecord::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& mat,
const SkPaint* paint) {
SkMatrix m = mat;
SkRect bbox = {0, 0, SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height())};
m.mapRect(&bbox);
if (this->transformBounds(bbox, paint)) {
INHERITED::drawBitmapMatrix(bitmap, mat, paint);
}
}
void SkBBoxRecord::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint) {
if (this->transformBounds(dst, paint)) {
INHERITED::drawBitmapNine(bitmap, center, dst, paint);
}
}
void SkBBoxRecord::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
const SkPaint& paint) {
SkRect bbox;
bbox.set(pos, paint.countText(text, byteLength));
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
bbox.fTop += metrics.fTop;
bbox.fBottom += metrics.fBottom;
// pad on left and right by half of max vertical glyph extents
SkScalar pad = (metrics.fTop - metrics.fBottom) / 2;
bbox.fLeft += pad;
bbox.fRight -= pad;
if (this->transformBounds(bbox, &paint)) {
INHERITED::onDrawPosText(text, byteLength, pos, paint);
}
}
void SkBBoxRecord::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
SkScalar constY, const SkPaint& paint) {
size_t numChars = paint.countText(text, byteLength);
if (numChars == 0) {
return;
}
const SkFlatData* flatPaintData = this->getFlatPaintData(paint);
WriteTopBot(paint, *flatPaintData);
SkScalar top = flatPaintData->topBot()[0];
SkScalar bottom = flatPaintData->topBot()[1];
SkScalar pad = top - bottom;
SkRect bbox;
bbox.fLeft = SK_ScalarMax;
bbox.fRight = SK_ScalarMin;
for (size_t i = 0; i < numChars; ++i) {
if (xpos[i] < bbox.fLeft) {
bbox.fLeft = xpos[i];
}
if (xpos[i] > bbox.fRight) {
bbox.fRight = xpos[i];
}
}
// pad horizontally by max glyph height
bbox.fLeft += pad;
bbox.fRight -= pad;
bbox.fTop = top + constY;
bbox.fBottom = bottom + constY;
if (!this->transformBounds(bbox, &paint)) {
return;
}
// This is the equivalent of calling:
// INHERITED::drawPosTextH(text, byteLength, xpos, constY, paint);
// but we filled our flat paint beforehand so that we could get font metrics.
drawPosTextHImpl(text, byteLength, xpos, constY, paint, flatPaintData);
}
void SkBBoxRecord::drawSprite(const SkBitmap& bitmap, int left, int top,
const SkPaint* paint) {
SkRect bbox;
bbox.set(SkIRect::MakeXYWH(left, top, bitmap.width(), bitmap.height()));
this->handleBBox(bbox); // directly call handleBBox, matrix is ignored
INHERITED::drawSprite(bitmap, left, top, paint);
}
void SkBBoxRecord::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
const SkMatrix* matrix, const SkPaint& paint) {
SkRect bbox = path.getBounds();
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
// pad out all sides by the max glyph height above baseline
SkScalar pad = metrics.fTop;
bbox.fLeft += pad;
bbox.fRight -= pad;
bbox.fTop += pad;
bbox.fBottom -= pad;
if (this->transformBounds(bbox, &paint)) {
INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
}
}
void SkBBoxRecord::drawVertices(VertexMode mode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xfer,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
SkRect bbox;
bbox.set(vertices, vertexCount);
if (this->transformBounds(bbox, &paint)) {
INHERITED::drawVertices(mode, vertexCount, vertices, texs,
colors, xfer, indices, indexCount, paint);
}
}
void SkBBoxRecord::drawPicture(SkPicture& picture) {
if (picture.width() > 0 && picture.height() > 0 &&
this->transformBounds(SkRect::MakeWH(picture.width(), picture.height()), NULL)) {
INHERITED::drawPicture(picture);
}
}
bool SkBBoxRecord::transformBounds(const SkRect& bounds, const SkPaint* paint) {
SkRect outBounds = bounds;
outBounds.sort();
if (paint) {
// account for stroking, path effects, shadows, etc
if (paint->canComputeFastBounds()) {
SkRect temp;
outBounds = paint->computeFastBounds(outBounds, &temp);
} else {
// set bounds to current clip
if (!this->getClipBounds(&outBounds)) {
// current clip is empty
return false;
}
}
}
if (!outBounds.isEmpty() && !this->quickReject(outBounds)) {
this->getTotalMatrix().mapRect(&outBounds);
this->handleBBox(outBounds);
return true;
}
return false;
}
<commit_msg>hack to expand 'pad' to account for very wide glyphs<commit_after>
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBBoxRecord.h"
void SkBBoxRecord::drawOval(const SkRect& rect, const SkPaint& paint) {
if (this->transformBounds(rect, &paint)) {
INHERITED::drawOval(rect, paint);
}
}
void SkBBoxRecord::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
if (this->transformBounds(rrect.rect(), &paint)) {
INHERITED::drawRRect(rrect, paint);
}
}
void SkBBoxRecord::drawRect(const SkRect& rect, const SkPaint& paint) {
if (this->transformBounds(rect, &paint)) {
INHERITED::drawRect(rect, paint);
}
}
void SkBBoxRecord::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
const SkPaint& paint) {
if (this->transformBounds(outer.rect(), &paint)) {
this->INHERITED::onDrawDRRect(outer, inner, paint);
}
}
void SkBBoxRecord::drawPath(const SkPath& path, const SkPaint& paint) {
if (path.isInverseFillType()) {
// If path is inverse filled, use the current clip bounds as the
// path's device-space bounding box.
SkIRect clipBounds;
if (this->getClipDeviceBounds(&clipBounds)) {
this->handleBBox(SkRect::Make(clipBounds));
INHERITED::drawPath(path, paint);
}
} else if (this->transformBounds(path.getBounds(), &paint)) {
INHERITED::drawPath(path, paint);
}
}
void SkBBoxRecord::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
const SkPaint& paint) {
SkRect bbox;
bbox.set(pts, SkToInt(count));
// Small min width value, just to ensure hairline point bounding boxes aren't empty.
// Even though we know hairline primitives are drawn one pixel wide, we do not use a
// minimum of 1 because the playback scale factor is unknown at record time. Later
// outsets will take care of adding additional padding for antialiasing and rounding out
// to integer device coordinates, guaranteeing that the rasterized pixels will be included
// in the computed bounds.
// Note: The device coordinate outset in SkBBoxHierarchyRecord::handleBBox is currently
// done in the recording coordinate space, which is wrong.
// http://code.google.com/p/skia/issues/detail?id=1021
static const SkScalar kMinWidth = 0.01f;
SkScalar halfStrokeWidth = SkMaxScalar(paint.getStrokeWidth(), kMinWidth) / 2;
bbox.outset(halfStrokeWidth, halfStrokeWidth);
if (this->transformBounds(bbox, &paint)) {
INHERITED::drawPoints(mode, count, pts, paint);
}
}
void SkBBoxRecord::drawPaint(const SkPaint& paint) {
SkRect bbox;
if (this->getClipBounds(&bbox)) {
if (this->transformBounds(bbox, &paint)) {
INHERITED::drawPaint(paint);
}
}
}
void SkBBoxRecord::clear(SkColor color) {
SkISize size = this->getDeviceSize();
SkRect bbox = {0, 0, SkIntToScalar(size.width()), SkIntToScalar(size.height())};
this->handleBBox(bbox);
INHERITED::clear(color);
}
void SkBBoxRecord::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint) {
SkRect bbox;
paint.measureText(text, byteLength, &bbox);
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
// Vertical and aligned text need to be offset
if (paint.isVerticalText()) {
SkScalar h = bbox.fBottom - bbox.fTop;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
bbox.fTop -= h / 2;
bbox.fBottom -= h / 2;
}
// Pad top and bottom with max extents from FontMetrics
bbox.fBottom += metrics.fBottom;
bbox.fTop += metrics.fTop;
} else {
SkScalar w = bbox.fRight - bbox.fLeft;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
bbox.fLeft -= w / 2;
bbox.fRight -= w / 2;
} else if (paint.getTextAlign() == SkPaint::kRight_Align) {
bbox.fLeft -= w;
bbox.fRight -= w;
}
// Set vertical bounds to max extents from font metrics
bbox.fTop = metrics.fTop;
bbox.fBottom = metrics.fBottom;
}
// Pad horizontal bounds on each side by half of max vertical extents (this is sort of
// arbitrary, but seems to produce reasonable results, if there were a way of getting max
// glyph X-extents to pad by, that may be better here, but FontMetrics fXMin and fXMax seem
// incorrect on most platforms (too small in Linux, never even set in Windows).
SkScalar pad = (metrics.fBottom - metrics.fTop) / 2;
bbox.fLeft -= pad;
bbox.fRight += pad;
bbox.fLeft += x;
bbox.fRight += x;
bbox.fTop += y;
bbox.fBottom += y;
if (this->transformBounds(bbox, &paint)) {
INHERITED::onDrawText(text, byteLength, x, y, paint);
}
}
void SkBBoxRecord::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
const SkPaint* paint) {
SkRect bbox = {left, top, left + bitmap.width(), top + bitmap.height()};
if (this->transformBounds(bbox, paint)) {
INHERITED::drawBitmap(bitmap, left, top, paint);
}
}
void SkBBoxRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
const SkRect& dst, const SkPaint* paint,
DrawBitmapRectFlags flags) {
if (this->transformBounds(dst, paint)) {
INHERITED::drawBitmapRectToRect(bitmap, src, dst, paint, flags);
}
}
void SkBBoxRecord::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& mat,
const SkPaint* paint) {
SkMatrix m = mat;
SkRect bbox = {0, 0, SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height())};
m.mapRect(&bbox);
if (this->transformBounds(bbox, paint)) {
INHERITED::drawBitmapMatrix(bitmap, mat, paint);
}
}
void SkBBoxRecord::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint* paint) {
if (this->transformBounds(dst, paint)) {
INHERITED::drawBitmapNine(bitmap, center, dst, paint);
}
}
// Hack to work-around https://code.google.com/p/chromium/issues/detail?id=373785
// This logic assums that 'pad' is enough to add to the left and right to account for
// big glyphs. For the font in question (a logo font) the glyphs is much wider than just
// the pointsize (approx 3x wider).
// As a temp work-around, we scale-up pad.
// A more correct fix might be to add fontmetrics.fMaxX, but we don't have that value in hand
// at the moment, and (possibly) the value in the font may not be accurate (but who knows).
//
static SkScalar hack_373785_amend_pad(SkScalar pad) {
return pad * 4;
}
void SkBBoxRecord::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
const SkPaint& paint) {
SkRect bbox;
bbox.set(pos, paint.countText(text, byteLength));
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
bbox.fTop += metrics.fTop;
bbox.fBottom += metrics.fBottom;
// pad on left and right by half of max vertical glyph extents
SkScalar pad = (metrics.fTop - metrics.fBottom) / 2;
pad = hack_373785_amend_pad(pad);
bbox.fLeft += pad;
bbox.fRight -= pad;
if (this->transformBounds(bbox, &paint)) {
INHERITED::onDrawPosText(text, byteLength, pos, paint);
}
}
void SkBBoxRecord::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
SkScalar constY, const SkPaint& paint) {
size_t numChars = paint.countText(text, byteLength);
if (numChars == 0) {
return;
}
const SkFlatData* flatPaintData = this->getFlatPaintData(paint);
WriteTopBot(paint, *flatPaintData);
SkScalar top = flatPaintData->topBot()[0];
SkScalar bottom = flatPaintData->topBot()[1];
SkScalar pad = top - bottom;
SkRect bbox;
bbox.fLeft = SK_ScalarMax;
bbox.fRight = SK_ScalarMin;
for (size_t i = 0; i < numChars; ++i) {
if (xpos[i] < bbox.fLeft) {
bbox.fLeft = xpos[i];
}
if (xpos[i] > bbox.fRight) {
bbox.fRight = xpos[i];
}
}
// pad horizontally by max glyph height
pad = hack_373785_amend_pad(pad);
bbox.fLeft += pad;
bbox.fRight -= pad;
bbox.fTop = top + constY;
bbox.fBottom = bottom + constY;
if (!this->transformBounds(bbox, &paint)) {
return;
}
// This is the equivalent of calling:
// INHERITED::drawPosTextH(text, byteLength, xpos, constY, paint);
// but we filled our flat paint beforehand so that we could get font metrics.
drawPosTextHImpl(text, byteLength, xpos, constY, paint, flatPaintData);
}
void SkBBoxRecord::drawSprite(const SkBitmap& bitmap, int left, int top,
const SkPaint* paint) {
SkRect bbox;
bbox.set(SkIRect::MakeXYWH(left, top, bitmap.width(), bitmap.height()));
this->handleBBox(bbox); // directly call handleBBox, matrix is ignored
INHERITED::drawSprite(bitmap, left, top, paint);
}
void SkBBoxRecord::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
const SkMatrix* matrix, const SkPaint& paint) {
SkRect bbox = path.getBounds();
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
// pad out all sides by the max glyph height above baseline
SkScalar pad = metrics.fTop;
bbox.fLeft += pad;
bbox.fRight -= pad;
bbox.fTop += pad;
bbox.fBottom -= pad;
if (this->transformBounds(bbox, &paint)) {
INHERITED::onDrawTextOnPath(text, byteLength, path, matrix, paint);
}
}
void SkBBoxRecord::drawVertices(VertexMode mode, int vertexCount,
const SkPoint vertices[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xfer,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
SkRect bbox;
bbox.set(vertices, vertexCount);
if (this->transformBounds(bbox, &paint)) {
INHERITED::drawVertices(mode, vertexCount, vertices, texs,
colors, xfer, indices, indexCount, paint);
}
}
void SkBBoxRecord::drawPicture(SkPicture& picture) {
if (picture.width() > 0 && picture.height() > 0 &&
this->transformBounds(SkRect::MakeWH(picture.width(), picture.height()), NULL)) {
INHERITED::drawPicture(picture);
}
}
bool SkBBoxRecord::transformBounds(const SkRect& bounds, const SkPaint* paint) {
SkRect outBounds = bounds;
outBounds.sort();
if (paint) {
// account for stroking, path effects, shadows, etc
if (paint->canComputeFastBounds()) {
SkRect temp;
outBounds = paint->computeFastBounds(outBounds, &temp);
} else {
// set bounds to current clip
if (!this->getClipBounds(&outBounds)) {
// current clip is empty
return false;
}
}
}
if (!outBounds.isEmpty() && !this->quickReject(outBounds)) {
this->getTotalMatrix().mapRect(&outBounds);
this->handleBBox(outBounds);
return true;
}
return false;
}
<|endoftext|> |
<commit_before>/*
* =====================================================================================
*
* Filename: file_utils.cpp
*
* Description: A collection of helper functions related to file operations
*
* Version: 1.0
* Created: 12/15/2014 11:37:05 AM
* Revision: none
* Compiler: gcc
*
* Author: Mohamed Ashraf (m0hamed)
* Organization: GUC
*
* =====================================================================================
*/
#include "file_utils.h"
#include <dirent.h>
bool file_exists(string path) {
if (FILE *file = fopen(path.c_str(), "r")) {
fclose(file);
return true;
} else {
return false;
}
}
vector<string> get_files_in_directory(string path) {
DIR *dir;
struct dirent *ent;
vector<string> files;
if ((dir = opendir(path.c_str())) != NULL) {
/* print all the files and directories within directory */
while ((ent = readdir(dir)) != NULL) {
files.push_back(ent->d_name);
}
closedir(dir);
}
return files;
}
<commit_msg>Removed dotfiles from file listing<commit_after>/*
* =====================================================================================
*
* Filename: file_utils.cpp
*
* Description: A collection of helper functions related to file operations
*
* Version: 1.0
* Created: 12/15/2014 11:37:05 AM
* Revision: none
* Compiler: gcc
*
* Author: Mohamed Ashraf (m0hamed)
* Organization: GUC
*
* =====================================================================================
*/
#include "file_utils.h"
#include <dirent.h>
bool file_exists(string path) {
if (FILE *file = fopen(path.c_str(), "r")) {
fclose(file);
return true;
} else {
return false;
}
}
vector<string> get_files_in_directory(string path) {
DIR *dir;
struct dirent *ent;
vector<string> files;
if ((dir = opendir(path.c_str())) != NULL) {
/* print all the files and directories within directory */
while ((ent = readdir(dir)) != NULL) {
if (ent->d_name[0] != '.') { // remove hidden files
files.push_back(path + ent->d_name);
}
}
closedir(dir);
}
return files;
}
<|endoftext|> |
<commit_before>/*
*
* NodeRippleLikeBlockchainExplorer
*
* Created by El Khalil Bellakrid on 09/01/2019.
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Ledger
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "NodeRippleLikeBlockchainExplorer.h"
#include <api/RippleConfigurationDefaults.hpp>
#include <api/Configuration.hpp>
#include <rapidjson/document.h>
#include <wallet/currencies.hpp>
namespace ledger {
namespace core {
NodeRippleLikeBlockchainExplorer::NodeRippleLikeBlockchainExplorer(
const std::shared_ptr<api::ExecutionContext> &context,
const std::shared_ptr<HttpClient> &http,
const api::RippleLikeNetworkParameters ¶meters,
const std::shared_ptr<api::DynamicObject> &configuration) :
DedicatedContext(context),
RippleLikeBlockchainExplorer(configuration, {api::Configuration::BLOCKCHAIN_EXPLORER_API_ENDPOINT}) {
_http = http;
_parameters = parameters;
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getBalance(const std::vector<RippleLikeKeychain::Address> &addresses) {
auto size = addresses.size();
if (size != 1) {
throw make_exception(api::ErrorCode::INVALID_ARGUMENT,
"Can only get balance of 1 address from Ripple Node, but got {} addresses", addresses.size());
}
std::string addressesStr = addresses[0]->toBase58();
return getAccountInfo(addressesStr, "Balance", BigInt::ZERO);
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getSequence(const std::string &address) {
return getAccountInfo(address, "Sequence", BigInt::ZERO);
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getFees() {
return getServerState("base_fee");
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getBaseReserve() {
return getServerState("reserve_base");
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getLedgerSequence() {
return getServerState("seq");
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getServerState(const std::string &field) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("server_state");
auto requestBody = bodyRequest.getString();
bool parseNumberAsString = true;
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json(parseNumberAsString).mapPtr<BigInt>(getContext(), [field](const HttpRequest::JsonResult &result) {
auto &json = *std::get<1>(result);
//Is there a result field ?
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to get base reserve from network, no (or malformed) field \"result\" in response");
}
//Is there an info field ?
auto resultObj = json["result"].GetObject();
if (!resultObj.HasMember("state") || !resultObj["state"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to get base reserve from network, no (or malformed) field \"state\" in response");
}
//Is there a validated_ledger field ?
auto infoObj = resultObj["state"].GetObject();
if (!infoObj.HasMember("validated_ledger") || !infoObj["validated_ledger"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to get base reserve from network, no (or malformed) field \"validated_ledger\" in response");
}
auto reserveObj = infoObj["validated_ledger"].GetObject();
if (!reserveObj.HasMember(field.c_str()) || !reserveObj[field.c_str()].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
fmt::format("Failed to get {} from network, no (or malformed) field \"{}\" in response", field, field));
}
auto value = reserveObj[field.c_str()].GetString();
return std::make_shared<BigInt>(value);
});
}
Future<String>
NodeRippleLikeBlockchainExplorer::pushLedgerApiTransaction(const std::vector<uint8_t> &transaction) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("submit");
bodyRequest.pushParameter("tx_blob", hex::toString(transaction));
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json().template map<String>(getExplorerContext(), [](const HttpRequest::JsonResult &result) -> String {
auto &json = *std::get<1>(result);
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to broadcast transaction, no (or malformed) field \"result\" in response");
}
auto resultObj = json["result"].GetObject();
if (resultObj.HasMember("engine_result") &&
(resultObj["engine_result"] == "tesSUCCESS" ||
resultObj["engine_result"] == "terQUEUED")) {
// Check presence of tx_json field
if (!resultObj.HasMember("tx_json") || !resultObj["tx_json"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to broadcast transaction, no (or malformed) field \"tx_json\" in response");
}
auto txnObj = resultObj["tx_json"].GetObject();
// Check presence of hash field
if (!txnObj.HasMember("hash") || !txnObj["hash"].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to broadcast transaction, no (or malformed) field \"hash\" in response");
}
return txnObj["hash"].GetString();
}
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to broadcast transaction: {}",
resultObj["engine_result"].GetString());
});
}
Future<void *> NodeRippleLikeBlockchainExplorer::startSession() {
return Future<void *>::successful(new std::string("", 0));
}
Future<Unit> NodeRippleLikeBlockchainExplorer::killSession(void *session) {
return Future<Unit>::successful(unit);
}
Future<Bytes> NodeRippleLikeBlockchainExplorer::getRawTransaction(const String &transactionHash) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("tx");
bodyRequest.pushParameter("transaction", transactionHash);
bodyRequest.pushParameter("binary", "true");
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json().template map<Bytes>(getExplorerContext(), [](const HttpRequest::JsonResult &result) -> Bytes {
auto &json = *std::get<1>(result);
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get raw transaction, no (or malformed) field \"result\" in response");
}
//Is there a tx field ?
auto resultObj = json["result"].GetObject();
if (!resultObj.HasMember("tx") || !resultObj["tx"].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get raw transaction, no (or malformed) field \"tx\" in response");
}
return Bytes(hex::toByteArray(std::string(resultObj["tx"].GetString(), resultObj["tx"].GetStringLength())));
});
}
Future<String> NodeRippleLikeBlockchainExplorer::pushTransaction(const std::vector<uint8_t> &transaction) {
return pushLedgerApiTransaction(transaction);
}
FuturePtr<RippleLikeBlockchainExplorer::TransactionsBulk>
NodeRippleLikeBlockchainExplorer::getTransactions(
const std::vector<std::string> &addresses,
Option<std::string> fromBlockHash,
Option<void *> session
) {
if (addresses.size() != 1) {
throw make_exception(api::ErrorCode::INVALID_ARGUMENT,
"Can only get transactions for 1 address from Ripple Node, but got {} addresses", addresses.size());
}
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("account_tx");
bodyRequest.pushParameter("account", addresses[0]);
if (fromBlockHash.hasValue() && _paginationMarker.empty()) {
bodyRequest.pushParameter("ledger_index_min", fromBlockHash.getValue());
}
// handle transaction pagination in the case we have a pagination marker, which happens
// when a getTransactions returns a TransactionsBulk containing such a marker
if (!_paginationMarker.empty()) {
auto marker = strings::split(_paginationMarker, "-");
bodyRequest.pushPagination(marker[0], marker[1]);
}
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
auto self = shared_from_this();
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.template json<TransactionsBulk, Exception>(
LedgerApiParser<TransactionsBulk, RippleLikeTransactionsBulkParser>())
.template mapPtr<TransactionsBulk>(getExplorerContext(), [self, fromBlockHash](
const Either<Exception, std::shared_ptr<TransactionsBulk>> &result) {
if (result.isLeft()) {
// Only case where we should emit block not found error
if (!fromBlockHash.isEmpty() && result.getLeft().getErrorCode() == api::ErrorCode::HTTP_ERROR) {
throw make_exception(api::ErrorCode::BLOCK_NOT_FOUND, "Unable to find block with hash {}", fromBlockHash.getValue());
} else {
throw result.getLeft();
}
} else {
// handle pagination if a pagination marker is present
auto bulk = result.getRight();
if (!bulk->paginationMarker.empty()) {
bulk->hasNext = true;
self->_paginationMarker = bulk->paginationMarker;
} else {
self->_paginationMarker = "";
}
return bulk;
}
});
}
FuturePtr<Block> NodeRippleLikeBlockchainExplorer::getCurrentBlock() const {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("ledger");
bodyRequest.pushParameter("ledger_index", std::string("validated"));
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.template json<Block, Exception>(LedgerApiParser<Block, RippleLikeBlockParser>())
.template mapPtr<Block>(getExplorerContext(),
[](const Either<Exception, std::shared_ptr<Block>> &result) {
if (result.isLeft()) {
throw result.getLeft();
} else {
return result.getRight();
}
});
}
FuturePtr<RippleLikeBlockchainExplorerTransaction>
NodeRippleLikeBlockchainExplorer::getTransactionByHash(const String &transactionHash) const {
return getLedgerApiTransactionByHash(transactionHash);
}
Future<int64_t> NodeRippleLikeBlockchainExplorer::getTimestamp() const {
return getLedgerApiTimestamp();
}
std::shared_ptr<api::ExecutionContext> NodeRippleLikeBlockchainExplorer::getExplorerContext() const {
return _executionContext;
}
api::RippleLikeNetworkParameters NodeRippleLikeBlockchainExplorer::getNetworkParameters() const {
return _parameters;
}
std::string NodeRippleLikeBlockchainExplorer::getExplorerVersion() const {
return "";
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getAccountInfo(const std::string &address,
const std::string &key,
const BigInt &defaultValue) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("account_info");
bodyRequest.pushParameter("account", address);
bodyRequest.pushParameter("ledger_index", std::string("validated"));
auto requestBody = bodyRequest.getString();
bool parseNumberAsString = true;
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json(parseNumberAsString).mapPtr<BigInt>(getContext(), [address, key, defaultValue](const HttpRequest::JsonResult &result) {
auto &json = *std::get<1>(result);
//Is there a result field ?
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get {} for {}, no (or malformed) field \"result\" in response",
key, address);
}
//Is there an account_data field ?
auto resultObj = json["result"].GetObject();
if (!resultObj.HasMember("account_data") || !resultObj["account_data"].IsObject()) {
// Case of account not found (not activated yet)
return std::make_shared<BigInt>(defaultValue);
}
//Is there an field with key name ?
auto accountObj = resultObj["account_data"].GetObject();
if (!accountObj.HasMember(key.c_str()) || !accountObj[key.c_str()].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get {} for {}, no (or malformed) field \"{}\" in response",
key, address, key);
}
auto value = accountObj[key.c_str()].GetString();
return std::make_shared<BigInt>(value);
});
}
}
}
<commit_msg>Fetch transactions for an account in chronological order<commit_after>/*
*
* NodeRippleLikeBlockchainExplorer
*
* Created by El Khalil Bellakrid on 09/01/2019.
*
* The MIT License (MIT)
*
* Copyright (c) 2019 Ledger
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "NodeRippleLikeBlockchainExplorer.h"
#include <api/RippleConfigurationDefaults.hpp>
#include <api/Configuration.hpp>
#include <rapidjson/document.h>
#include <wallet/currencies.hpp>
namespace ledger {
namespace core {
NodeRippleLikeBlockchainExplorer::NodeRippleLikeBlockchainExplorer(
const std::shared_ptr<api::ExecutionContext> &context,
const std::shared_ptr<HttpClient> &http,
const api::RippleLikeNetworkParameters ¶meters,
const std::shared_ptr<api::DynamicObject> &configuration) :
DedicatedContext(context),
RippleLikeBlockchainExplorer(configuration, {api::Configuration::BLOCKCHAIN_EXPLORER_API_ENDPOINT}) {
_http = http;
_parameters = parameters;
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getBalance(const std::vector<RippleLikeKeychain::Address> &addresses) {
auto size = addresses.size();
if (size != 1) {
throw make_exception(api::ErrorCode::INVALID_ARGUMENT,
"Can only get balance of 1 address from Ripple Node, but got {} addresses", addresses.size());
}
std::string addressesStr = addresses[0]->toBase58();
return getAccountInfo(addressesStr, "Balance", BigInt::ZERO);
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getSequence(const std::string &address) {
return getAccountInfo(address, "Sequence", BigInt::ZERO);
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getFees() {
return getServerState("base_fee");
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getBaseReserve() {
return getServerState("reserve_base");
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getLedgerSequence() {
return getServerState("seq");
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getServerState(const std::string &field) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("server_state");
auto requestBody = bodyRequest.getString();
bool parseNumberAsString = true;
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json(parseNumberAsString).mapPtr<BigInt>(getContext(), [field](const HttpRequest::JsonResult &result) {
auto &json = *std::get<1>(result);
//Is there a result field ?
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to get base reserve from network, no (or malformed) field \"result\" in response");
}
//Is there an info field ?
auto resultObj = json["result"].GetObject();
if (!resultObj.HasMember("state") || !resultObj["state"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to get base reserve from network, no (or malformed) field \"state\" in response");
}
//Is there a validated_ledger field ?
auto infoObj = resultObj["state"].GetObject();
if (!infoObj.HasMember("validated_ledger") || !infoObj["validated_ledger"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to get base reserve from network, no (or malformed) field \"validated_ledger\" in response");
}
auto reserveObj = infoObj["validated_ledger"].GetObject();
if (!reserveObj.HasMember(field.c_str()) || !reserveObj[field.c_str()].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR,
fmt::format("Failed to get {} from network, no (or malformed) field \"{}\" in response", field, field));
}
auto value = reserveObj[field.c_str()].GetString();
return std::make_shared<BigInt>(value);
});
}
Future<String>
NodeRippleLikeBlockchainExplorer::pushLedgerApiTransaction(const std::vector<uint8_t> &transaction) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("submit");
bodyRequest.pushParameter("tx_blob", hex::toString(transaction));
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json().template map<String>(getExplorerContext(), [](const HttpRequest::JsonResult &result) -> String {
auto &json = *std::get<1>(result);
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to broadcast transaction, no (or malformed) field \"result\" in response");
}
auto resultObj = json["result"].GetObject();
if (resultObj.HasMember("engine_result") &&
(resultObj["engine_result"] == "tesSUCCESS" ||
resultObj["engine_result"] == "terQUEUED")) {
// Check presence of tx_json field
if (!resultObj.HasMember("tx_json") || !resultObj["tx_json"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to broadcast transaction, no (or malformed) field \"tx_json\" in response");
}
auto txnObj = resultObj["tx_json"].GetObject();
// Check presence of hash field
if (!txnObj.HasMember("hash") || !txnObj["hash"].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to broadcast transaction, no (or malformed) field \"hash\" in response");
}
return txnObj["hash"].GetString();
}
throw make_exception(api::ErrorCode::HTTP_ERROR,
"Failed to broadcast transaction: {}",
resultObj["engine_result"].GetString());
});
}
Future<void *> NodeRippleLikeBlockchainExplorer::startSession() {
return Future<void *>::successful(new std::string("", 0));
}
Future<Unit> NodeRippleLikeBlockchainExplorer::killSession(void *session) {
return Future<Unit>::successful(unit);
}
Future<Bytes> NodeRippleLikeBlockchainExplorer::getRawTransaction(const String &transactionHash) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("tx");
bodyRequest.pushParameter("transaction", transactionHash);
bodyRequest.pushParameter("binary", "true");
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json().template map<Bytes>(getExplorerContext(), [](const HttpRequest::JsonResult &result) -> Bytes {
auto &json = *std::get<1>(result);
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get raw transaction, no (or malformed) field \"result\" in response");
}
//Is there a tx field ?
auto resultObj = json["result"].GetObject();
if (!resultObj.HasMember("tx") || !resultObj["tx"].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get raw transaction, no (or malformed) field \"tx\" in response");
}
return Bytes(hex::toByteArray(std::string(resultObj["tx"].GetString(), resultObj["tx"].GetStringLength())));
});
}
Future<String> NodeRippleLikeBlockchainExplorer::pushTransaction(const std::vector<uint8_t> &transaction) {
return pushLedgerApiTransaction(transaction);
}
FuturePtr<RippleLikeBlockchainExplorer::TransactionsBulk>
NodeRippleLikeBlockchainExplorer::getTransactions(
const std::vector<std::string> &addresses,
Option<std::string> fromBlockHash,
Option<void *> session
) {
if (addresses.size() != 1) {
throw make_exception(api::ErrorCode::INVALID_ARGUMENT,
"Can only get transactions for 1 address from Ripple Node, but got {} addresses", addresses.size());
}
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("account_tx");
bodyRequest.pushParameter("account", addresses[0]);
bodyRequest.pushParameter("forward", true);
if (fromBlockHash.hasValue() && _paginationMarker.empty()) {
bodyRequest.pushParameter("ledger_index_min", fromBlockHash.getValue());
}
// handle transaction pagination in the case we have a pagination marker, which happens
// when a getTransactions returns a TransactionsBulk containing such a marker
if (!_paginationMarker.empty()) {
auto marker = strings::split(_paginationMarker, "-");
bodyRequest.pushPagination(marker[0], marker[1]);
}
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
auto self = shared_from_this();
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.template json<TransactionsBulk, Exception>(
LedgerApiParser<TransactionsBulk, RippleLikeTransactionsBulkParser>())
.template mapPtr<TransactionsBulk>(getExplorerContext(), [self, fromBlockHash](
const Either<Exception, std::shared_ptr<TransactionsBulk>> &result) {
if (result.isLeft()) {
// Only case where we should emit block not found error
if (!fromBlockHash.isEmpty() && result.getLeft().getErrorCode() == api::ErrorCode::HTTP_ERROR) {
throw make_exception(api::ErrorCode::BLOCK_NOT_FOUND, "Unable to find block with hash {}", fromBlockHash.getValue());
} else {
throw result.getLeft();
}
} else {
// handle pagination if a pagination marker is present
auto bulk = result.getRight();
if (!bulk->paginationMarker.empty()) {
bulk->hasNext = true;
self->_paginationMarker = bulk->paginationMarker;
} else {
self->_paginationMarker = "";
}
return bulk;
}
});
}
FuturePtr<Block> NodeRippleLikeBlockchainExplorer::getCurrentBlock() const {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("ledger");
bodyRequest.pushParameter("ledger_index", std::string("validated"));
auto requestBody = bodyRequest.getString();
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.template json<Block, Exception>(LedgerApiParser<Block, RippleLikeBlockParser>())
.template mapPtr<Block>(getExplorerContext(),
[](const Either<Exception, std::shared_ptr<Block>> &result) {
if (result.isLeft()) {
throw result.getLeft();
} else {
return result.getRight();
}
});
}
FuturePtr<RippleLikeBlockchainExplorerTransaction>
NodeRippleLikeBlockchainExplorer::getTransactionByHash(const String &transactionHash) const {
return getLedgerApiTransactionByHash(transactionHash);
}
Future<int64_t> NodeRippleLikeBlockchainExplorer::getTimestamp() const {
return getLedgerApiTimestamp();
}
std::shared_ptr<api::ExecutionContext> NodeRippleLikeBlockchainExplorer::getExplorerContext() const {
return _executionContext;
}
api::RippleLikeNetworkParameters NodeRippleLikeBlockchainExplorer::getNetworkParameters() const {
return _parameters;
}
std::string NodeRippleLikeBlockchainExplorer::getExplorerVersion() const {
return "";
}
Future<std::shared_ptr<BigInt>>
NodeRippleLikeBlockchainExplorer::getAccountInfo(const std::string &address,
const std::string &key,
const BigInt &defaultValue) {
NodeRippleLikeBodyRequest bodyRequest;
bodyRequest.setMethod("account_info");
bodyRequest.pushParameter("account", address);
bodyRequest.pushParameter("ledger_index", std::string("validated"));
auto requestBody = bodyRequest.getString();
bool parseNumberAsString = true;
std::unordered_map<std::string, std::string> headers{{"Content-Type", "application/json"}};
return _http->POST("", std::vector<uint8_t>(requestBody.begin(), requestBody.end()), headers)
.json(parseNumberAsString).mapPtr<BigInt>(getContext(), [address, key, defaultValue](const HttpRequest::JsonResult &result) {
auto &json = *std::get<1>(result);
//Is there a result field ?
if (!json.IsObject() || !json.HasMember("result") ||
!json["result"].IsObject()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get {} for {}, no (or malformed) field \"result\" in response",
key, address);
}
//Is there an account_data field ?
auto resultObj = json["result"].GetObject();
if (!resultObj.HasMember("account_data") || !resultObj["account_data"].IsObject()) {
// Case of account not found (not activated yet)
return std::make_shared<BigInt>(defaultValue);
}
//Is there an field with key name ?
auto accountObj = resultObj["account_data"].GetObject();
if (!accountObj.HasMember(key.c_str()) || !accountObj[key.c_str()].IsString()) {
throw make_exception(api::ErrorCode::HTTP_ERROR, "Failed to get {} for {}, no (or malformed) field \"{}\" in response",
key, address, key);
}
auto value = accountObj[key.c_str()].GetString();
return std::make_shared<BigInt>(value);
});
}
}
}
<|endoftext|> |
<commit_before>/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
* Main authors:
* Guido Tack <[email protected]>
* Modified:
* Laurent Perron ([email protected])
*
* Copyright:
* Guido Tack, 2007
*
*
* This file is part of Gecode, the generic constraint
* development environment:
* http://www.gecode.org
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#include <iostream>
#include <fstream>
#include <cstring>
#include "base/commandlineflags.h"
#include "base/commandlineflags.h"
#include "base/integral_types.h"
#include "base/logging.h"
#include "base/scoped_ptr.h"
#include "base/stringprintf.h"
#include "flatzinc/flatzinc.h"
DEFINE_int32(log_frequency, 100000, "Search log frequency");
DEFINE_bool(log, false, "Show search log");
DEFINE_bool(all, false, "Search for all solutions");
DEFINE_bool(free, false, "Ignore search annotations");
DEFINE_int32(num_solutions, 0, "Number of solution to search for");
DEFINE_int32(time_limit, 0, "time limit in ms");
DECLARE_bool(log_prefix);
namespace operations_research {
void Run(const std::string& file) {
FlatZincModel fz_model;
if (file == "-") {
fz_model.Parse(std::cin);
} else {
fz_model.Parse(file);
}
fz_model.Solve(FLAGS_log_frequency,
FLAGS_log,
FLAGS_all,
FLAGS_free,
FLAGS_num_solutions,
FLAGS_time_limit);
}
}
int main(int argc, char** argv) {
FLAGS_log_prefix=false;
google::ParseCommandLineFlags(&argc, &argv, true);
if (argc <= 1) {
LOG(ERROR) << "Usage: " << argv[0] << " <file>";
exit(EXIT_FAILURE);
}
operations_research::Run(argv[1]);
return 0;
}
<commit_msg>support official flags -p, -f, -a<commit_after>/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
* Main authors:
* Guido Tack <[email protected]>
* Modified:
* Laurent Perron ([email protected])
*
* Copyright:
* Guido Tack, 2007
*
*
* This file is part of Gecode, the generic constraint
* development environment:
* http://www.gecode.org
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#include <iostream>
#include <fstream>
#include <cstring>
#include "base/commandlineflags.h"
#include "base/commandlineflags.h"
#include "base/integral_types.h"
#include "base/logging.h"
#include "base/scoped_ptr.h"
#include "base/stringprintf.h"
#include "flatzinc/flatzinc.h"
DEFINE_int32(log_frequency, 100000, "Search log frequency");
DEFINE_bool(log, false, "Show search log");
DEFINE_bool(all, false, "Search for all solutions");
DEFINE_bool(free, false, "Ignore search annotations");
DEFINE_int32(num_solutions, 0, "Number of solution to search for");
DEFINE_int32(time_limit, 0, "time limit in ms");
DEFINE_int32(threads, 0, "threads");
DECLARE_bool(log_prefix);
namespace operations_research {
void Run(const std::string& file) {
FlatZincModel fz_model;
if (file == "-") {
fz_model.Parse(std::cin);
} else {
fz_model.Parse(file);
}
fz_model.Solve(FLAGS_log_frequency,
FLAGS_log,
FLAGS_all,
FLAGS_free,
FLAGS_num_solutions,
FLAGS_time_limit);
}
}
int main(int argc, char** argv) {
FLAGS_log_prefix=false;
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "-a") == 0) {
argv[i] = "--all";
}
if (strcmp(argv[i], "-f") == 0) {
argv[i] = "--free";
}
if (strcmp(argv[i], "-p") == 0) {
argv[i] = "--threads";
}
}
google::ParseCommandLineFlags(&argc, &argv, true);
if (argc <= 1) {
LOG(ERROR) << "Usage: " << argv[0] << " <file>";
exit(EXIT_FAILURE);
}
operations_research::Run(argv[1]);
return 0;
}
<|endoftext|> |
<commit_before>#ifndef KEYCODE_HPP
#define KEYCODE_HPP
namespace org_pqrs_KeyRemap4MacBook {
class KeyCode;
class Flags;
class Buttons;
// ======================================================================
class EventType {
public:
EventType(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(EventType other) const { return value_ == other.get(); }
bool operator!=(EventType other) const { return ! (*this == other); }
bool isKeyDownOrModifierDown(KeyCode key, Flags flags) const;
#include "keycode/output/include.EventType.hpp"
private:
unsigned int value_;
};
// ======================================================================
class KeyboardType {
public:
KeyboardType(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(KeyboardType other) const { return value_ == other.get(); }
bool operator!=(KeyboardType other) const { return ! (*this == other); }
#include "keycode/output/include.KeyboardType.hpp"
private:
unsigned int value_;
};
// ======================================================================
class ModifierFlag {
public:
unsigned int get(void) const { return value_; }
bool operator==(ModifierFlag other) const { return value_ == other.get(); }
bool operator!=(ModifierFlag other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
KeyCode getKeyCode(void) const;
#include "keycode/output/include.ModifierFlag.hpp"
private:
ModifierFlag(unsigned int v) : value_(v) {}
unsigned int value_;
};
class Flags {
public:
Flags(unsigned int v = 0) : value_(v) {}
Flags(ModifierFlag v) : value_(v.get()) {}
unsigned int get(void) const { return value_; }
bool operator==(Flags other) const { return value_ == other.get(); }
bool operator!=(Flags other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
Flags operator|(Flags other) const { return value_ | other.get(); }
Flags operator&(Flags other) const { return value_ & other.get(); }
Flags& add(Flags flags) { value_ |= flags.get(); return *this; }
Flags& remove(Flags flags) { value_ &= ~flags; return *this; }
Flags& stripFN(void) { return remove(ModifierFlag::FN); }
Flags& stripCURSOR(void) { return remove(ModifierFlag::CURSOR); }
Flags& stripKEYPAD(void) { return remove(ModifierFlag::KEYPAD); }
Flags& stripNONE(void) { return remove(ModifierFlag::NONE); }
Flags& stripEXTRA(void) {
return remove(Flags(ModifierFlag::EXTRA1) |
Flags(ModifierFlag::EXTRA2) |
Flags(ModifierFlag::EXTRA3) |
Flags(ModifierFlag::EXTRA4) |
Flags(ModifierFlag::EXTRA5));
}
bool isOn(ModifierFlag flag) const {
return (value_ & flag.get()) == flag.get();
}
bool isOn(Flags flags) const {
if (flags.isOn(ModifierFlag::NONE)) {
return (value_ | ModifierFlag::NONE.get()) == flags.get();
} else {
return (value_ & flags.get()) == flags.get();
}
}
private:
unsigned int value_;
};
inline Flags operator|(ModifierFlag lhs, ModifierFlag rhs) { return lhs.get() | rhs.get(); }
// ======================================================================
class KeyCode {
public:
KeyCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(KeyCode other) const { return value_ == other.get(); }
bool operator!=(KeyCode other) const { return ! (*this == other); }
bool operator>(KeyCode other) const { return value_ > other.get(); }
bool operator>=(KeyCode other) const { return value_ >= other.get(); }
void normalizeKey(Flags& flags, EventType eventType, KeyboardType keyboardType);
void reverseNormalizeKey(Flags& flags, EventType eventType, KeyboardType keyboardType);
ModifierFlag getModifierFlag(void) const;
bool isModifier(void) const { return getModifierFlag() != ModifierFlag::NONE; }
#include "keycode/output/include.KeyCode.hpp"
// When FN key and Arrow key were pushed together, another key code was sent (Home,End,PageUp,PageDown or something).
// We need to change these Home,End,PageUp,PageDown keys to FN+Arrow key before sending key code to remapper.
// (If we change FN to Control_L, FN+Up-Arrow must be changed to Control_L+Up-Arrow. Not Control_L+PageUp).
// We also need to change FN+Arrow to Home,End,PageUp,PageDown before outputting key code.
//
// This class handles the above.
class FNKeyHack {
public:
FNKeyHack(const KeyCode& fk, const KeyCode& tk) : fromKeyCode_(fk), toKeyCode_(tk), active_normalize_(false), active_reverse_(false) {}
// FN+PageUp to FN+Up-Arrow
bool normalize(KeyCode& key, Flags flags, EventType eventType) { return remap(key, flags, eventType, active_normalize_, fromKeyCode_, toKeyCode_); }
// FN+Up-Arrow to PageUp
bool reverse(KeyCode& key, Flags flags, EventType eventType) { return remap(key, flags, eventType, active_reverse_, toKeyCode_, fromKeyCode_); }
private:
bool remap(KeyCode& key, Flags flags, EventType eventType, bool& active, KeyCode fromKeyCode, KeyCode toKeyCode);
const KeyCode& fromKeyCode_;
const KeyCode& toKeyCode_;
bool active_normalize_;
bool active_reverse_;
};
private:
unsigned int value_;
};
class CharCode {
public:
CharCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(CharCode other) const { return value_ == other.get(); }
bool operator!=(CharCode other) const { return ! (*this == other); }
private:
unsigned int value_;
};
class CharSet {
public:
CharSet(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(CharSet other) const { return value_ == other.get(); }
bool operator!=(CharSet other) const { return ! (*this == other); }
private:
unsigned int value_;
};
class OrigCharCode {
public:
OrigCharCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(OrigCharCode other) const { return value_ == other.get(); }
bool operator!=(OrigCharCode other) const { return ! (*this == other); }
private:
unsigned int value_;
};
class OrigCharSet {
public:
OrigCharSet(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(OrigCharSet other) const { return value_ == other.get(); }
bool operator!=(OrigCharSet other) const { return ! (*this == other); }
private:
unsigned int value_;
};
// ======================================================================
class ConsumerKeyCode {
public:
ConsumerKeyCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(ConsumerKeyCode other) const { return value_ == other.get(); }
bool operator!=(ConsumerKeyCode other) const { return ! (*this == other); }
bool operator>(ConsumerKeyCode other) const { return value_ > other.get(); }
bool operator>=(ConsumerKeyCode other) const { return value_ >= other.get(); }
#include "keycode/output/include.ConsumerKeyCode.hpp"
private:
unsigned int value_;
};
// ======================================================================
class PointingButton {
public:
PointingButton(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(PointingButton other) const { return value_ == other.get(); }
bool operator!=(PointingButton other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
#include "keycode/output/include.PointingButton.hpp"
private:
unsigned int value_;
};
class Buttons {
public:
Buttons(unsigned int v = 0) : value_(v) {}
Buttons(PointingButton v) : value_(v.get()) {}
unsigned int get(void) const { return value_; }
bool operator==(Buttons other) const { return value_ == other.get(); }
bool operator!=(Buttons other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
Buttons operator|(Buttons other) const { return value_ | other.get(); }
Buttons& add(Buttons button) { value_ |= button.get(); return *this; }
Buttons& remove(Buttons button) { value_ &= ~button; return *this; }
bool isNONE(void) const { return value_ == 0; }
bool isOn(Buttons buttons) const {
return (value_ & buttons.get()) == buttons.get();
}
Buttons justPressed(Buttons previous) {
return value_ & ~(previous.get());
}
Buttons justReleased(Buttons previous) {
return ~value_ & (previous.get());
}
private:
unsigned int value_;
};
inline Buttons operator|(PointingButton lhs, PointingButton rhs) { return lhs.get() | rhs.get(); }
// ======================================================================
typedef unsigned int DeviceVendorID;
typedef unsigned int DeviceProductID;
namespace DeviceType {
enum DeviceType {
UNKNOWN,
APPLE_INTERNAL,
APPLE_EXTERNAL,
USB_OVERDRIVE,
};
}
}
#endif
<commit_msg>update Buttons::justPressed,justReleased<commit_after>#ifndef KEYCODE_HPP
#define KEYCODE_HPP
namespace org_pqrs_KeyRemap4MacBook {
class KeyCode;
class Flags;
class Buttons;
// ======================================================================
class EventType {
public:
EventType(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(EventType other) const { return value_ == other.get(); }
bool operator!=(EventType other) const { return ! (*this == other); }
bool isKeyDownOrModifierDown(KeyCode key, Flags flags) const;
#include "keycode/output/include.EventType.hpp"
private:
unsigned int value_;
};
// ======================================================================
class KeyboardType {
public:
KeyboardType(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(KeyboardType other) const { return value_ == other.get(); }
bool operator!=(KeyboardType other) const { return ! (*this == other); }
#include "keycode/output/include.KeyboardType.hpp"
private:
unsigned int value_;
};
// ======================================================================
class ModifierFlag {
public:
unsigned int get(void) const { return value_; }
bool operator==(ModifierFlag other) const { return value_ == other.get(); }
bool operator!=(ModifierFlag other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
KeyCode getKeyCode(void) const;
#include "keycode/output/include.ModifierFlag.hpp"
private:
ModifierFlag(unsigned int v) : value_(v) {}
unsigned int value_;
};
class Flags {
public:
Flags(unsigned int v = 0) : value_(v) {}
Flags(ModifierFlag v) : value_(v.get()) {}
unsigned int get(void) const { return value_; }
bool operator==(Flags other) const { return value_ == other.get(); }
bool operator!=(Flags other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
Flags operator|(Flags other) const { return value_ | other.get(); }
Flags operator&(Flags other) const { return value_ & other.get(); }
Flags& add(Flags flags) { value_ |= flags.get(); return *this; }
Flags& remove(Flags flags) { value_ &= ~flags; return *this; }
Flags& stripFN(void) { return remove(ModifierFlag::FN); }
Flags& stripCURSOR(void) { return remove(ModifierFlag::CURSOR); }
Flags& stripKEYPAD(void) { return remove(ModifierFlag::KEYPAD); }
Flags& stripNONE(void) { return remove(ModifierFlag::NONE); }
Flags& stripEXTRA(void) {
return remove(Flags(ModifierFlag::EXTRA1) |
Flags(ModifierFlag::EXTRA2) |
Flags(ModifierFlag::EXTRA3) |
Flags(ModifierFlag::EXTRA4) |
Flags(ModifierFlag::EXTRA5));
}
bool isOn(ModifierFlag flag) const {
return (value_ & flag.get()) == flag.get();
}
bool isOn(Flags flags) const {
if (flags.isOn(ModifierFlag::NONE)) {
return (value_ | ModifierFlag::NONE.get()) == flags.get();
} else {
return (value_ & flags.get()) == flags.get();
}
}
private:
unsigned int value_;
};
inline Flags operator|(ModifierFlag lhs, ModifierFlag rhs) { return lhs.get() | rhs.get(); }
// ======================================================================
class KeyCode {
public:
KeyCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(KeyCode other) const { return value_ == other.get(); }
bool operator!=(KeyCode other) const { return ! (*this == other); }
bool operator>(KeyCode other) const { return value_ > other.get(); }
bool operator>=(KeyCode other) const { return value_ >= other.get(); }
void normalizeKey(Flags& flags, EventType eventType, KeyboardType keyboardType);
void reverseNormalizeKey(Flags& flags, EventType eventType, KeyboardType keyboardType);
ModifierFlag getModifierFlag(void) const;
bool isModifier(void) const { return getModifierFlag() != ModifierFlag::NONE; }
#include "keycode/output/include.KeyCode.hpp"
// When FN key and Arrow key were pushed together, another key code was sent (Home,End,PageUp,PageDown or something).
// We need to change these Home,End,PageUp,PageDown keys to FN+Arrow key before sending key code to remapper.
// (If we change FN to Control_L, FN+Up-Arrow must be changed to Control_L+Up-Arrow. Not Control_L+PageUp).
// We also need to change FN+Arrow to Home,End,PageUp,PageDown before outputting key code.
//
// This class handles the above.
class FNKeyHack {
public:
FNKeyHack(const KeyCode& fk, const KeyCode& tk) : fromKeyCode_(fk), toKeyCode_(tk), active_normalize_(false), active_reverse_(false) {}
// FN+PageUp to FN+Up-Arrow
bool normalize(KeyCode& key, Flags flags, EventType eventType) { return remap(key, flags, eventType, active_normalize_, fromKeyCode_, toKeyCode_); }
// FN+Up-Arrow to PageUp
bool reverse(KeyCode& key, Flags flags, EventType eventType) { return remap(key, flags, eventType, active_reverse_, toKeyCode_, fromKeyCode_); }
private:
bool remap(KeyCode& key, Flags flags, EventType eventType, bool& active, KeyCode fromKeyCode, KeyCode toKeyCode);
const KeyCode& fromKeyCode_;
const KeyCode& toKeyCode_;
bool active_normalize_;
bool active_reverse_;
};
private:
unsigned int value_;
};
class CharCode {
public:
CharCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(CharCode other) const { return value_ == other.get(); }
bool operator!=(CharCode other) const { return ! (*this == other); }
private:
unsigned int value_;
};
class CharSet {
public:
CharSet(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(CharSet other) const { return value_ == other.get(); }
bool operator!=(CharSet other) const { return ! (*this == other); }
private:
unsigned int value_;
};
class OrigCharCode {
public:
OrigCharCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(OrigCharCode other) const { return value_ == other.get(); }
bool operator!=(OrigCharCode other) const { return ! (*this == other); }
private:
unsigned int value_;
};
class OrigCharSet {
public:
OrigCharSet(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(OrigCharSet other) const { return value_ == other.get(); }
bool operator!=(OrigCharSet other) const { return ! (*this == other); }
private:
unsigned int value_;
};
// ======================================================================
class ConsumerKeyCode {
public:
ConsumerKeyCode(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(ConsumerKeyCode other) const { return value_ == other.get(); }
bool operator!=(ConsumerKeyCode other) const { return ! (*this == other); }
bool operator>(ConsumerKeyCode other) const { return value_ > other.get(); }
bool operator>=(ConsumerKeyCode other) const { return value_ >= other.get(); }
#include "keycode/output/include.ConsumerKeyCode.hpp"
private:
unsigned int value_;
};
// ======================================================================
class PointingButton {
public:
PointingButton(unsigned int v = 0) : value_(v) {}
unsigned int get(void) const { return value_; }
bool operator==(PointingButton other) const { return value_ == other.get(); }
bool operator!=(PointingButton other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
#include "keycode/output/include.PointingButton.hpp"
private:
unsigned int value_;
};
class Buttons {
public:
Buttons(unsigned int v = 0) : value_(v) {}
Buttons(PointingButton v) : value_(v.get()) {}
unsigned int get(void) const { return value_; }
bool operator==(Buttons other) const { return value_ == other.get(); }
bool operator!=(Buttons other) const { return ! (*this == other); }
unsigned int operator~(void) const { return ~value_; }
Buttons operator|(Buttons other) const { return value_ | other.get(); }
Buttons& add(Buttons button) { value_ |= button.get(); return *this; }
Buttons& remove(Buttons button) { value_ &= ~button; return *this; }
bool isNONE(void) const { return value_ == 0; }
bool isOn(Buttons buttons) const {
return (value_ & buttons.get()) == buttons.get();
}
Buttons justPressed(Buttons previous) const {
return value_ & ~(previous.get());
}
Buttons justReleased(Buttons previous) const {
return ~value_ & (previous.get());
}
private:
unsigned int value_;
};
inline Buttons operator|(PointingButton lhs, PointingButton rhs) { return lhs.get() | rhs.get(); }
// ======================================================================
typedef unsigned int DeviceVendorID;
typedef unsigned int DeviceProductID;
namespace DeviceType {
enum DeviceType {
UNKNOWN,
APPLE_INTERNAL,
APPLE_EXTERNAL,
USB_OVERDRIVE,
};
}
}
#endif
<|endoftext|> |
<commit_before>// Copyright (c) 2012-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "coins.h"
#include "consensus/consensus.h"
#include "memusage.h"
#include "random.h"
#include <assert.h>
bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const { return false; }
bool CCoinsView::HaveCoin(const COutPoint &outpoint) const { return false; }
uint256 CCoinsView::GetBestBlock() const { return uint256(); }
bool CCoinsView::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return false; }
CCoinsViewCursor *CCoinsView::Cursor() const { return 0; }
CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
bool CCoinsViewBacked::GetCoin(const COutPoint &outpoint, Coin &coin) const { return base->GetCoin(outpoint, coin); }
bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const { return base->HaveCoin(outpoint); }
uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlock(); }
void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
bool CCoinsViewBacked::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return base->BatchWrite(mapCoins, hashBlock); }
CCoinsViewCursor *CCoinsViewBacked::Cursor() const { return base->Cursor(); }
size_t CCoinsViewBacked::EstimateSize() const { return base->EstimateSize(); }
SaltedOutpointHasher::SaltedOutpointHasher() : k0(GetRand(std::numeric_limits<uint64_t>::max())), k1(GetRand(std::numeric_limits<uint64_t>::max())) {}
CCoinsViewCache::CCoinsViewCache(CCoinsView *baseIn) : CCoinsViewBacked(baseIn), cachedCoinsUsage(0) {}
size_t CCoinsViewCache::DynamicMemoryUsage() const {
return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
}
CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
CCoinsMap::iterator it = cacheCoins.find(outpoint);
if (it != cacheCoins.end())
return it;
Coin tmp;
if (!base->GetCoin(outpoint, tmp))
return cacheCoins.end();
CCoinsMap::iterator ret = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::forward_as_tuple(std::move(tmp))).first;
if (ret->second.coin.IsSpent()) {
// The parent only has an empty entry for this outpoint; we can consider our
// version as fresh.
ret->second.flags = CCoinsCacheEntry::FRESH;
}
cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
return ret;
}
bool CCoinsViewCache::GetCoin(const COutPoint &outpoint, Coin &coin) const {
CCoinsMap::const_iterator it = FetchCoin(outpoint);
if (it != cacheCoins.end()) {
coin = it->second.coin;
return true;
}
return false;
}
void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possible_overwrite) {
assert(!coin.IsSpent());
if (coin.out.scriptPubKey.IsUnspendable()) return;
CCoinsMap::iterator it;
bool inserted;
std::tie(it, inserted) = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::tuple<>());
bool fresh = false;
if (!inserted) {
cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
}
if (!possible_overwrite) {
if (!it->second.coin.IsSpent()) {
throw std::logic_error("Adding new coin that replaces non-pruned entry");
}
fresh = !(it->second.flags & CCoinsCacheEntry::DIRTY);
}
it->second.coin = std::move(coin);
it->second.flags |= CCoinsCacheEntry::DIRTY | (fresh ? CCoinsCacheEntry::FRESH : 0);
cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
}
void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight) {
bool fCoinbase = tx.IsCoinBase();
bool fCoinstake = tx.IsCoinStake();
const uint256& txid = tx.GetHash();
for (size_t i = 0; i < tx.vout.size(); ++i) {
// Pass fCoinbase as the possible_overwrite flag to AddCoin, in order to correctly
// deal with the pre-BIP30 occurrances of duplicate coinbase transactions.
cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase, fCoinstake), fCoinbase || fCoinstake);
}
}
void CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
CCoinsMap::iterator it = FetchCoin(outpoint);
if (it == cacheCoins.end()) return;
cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
if (moveout) {
*moveout = std::move(it->second.coin);
}
if (it->second.flags & CCoinsCacheEntry::FRESH) {
cacheCoins.erase(it);
} else {
it->second.flags |= CCoinsCacheEntry::DIRTY;
it->second.coin.Clear();
}
}
double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight, CAmount &inChainInputValue) const
{
inChainInputValue = 0;
if (tx.IsCoinBase() || tx.IsCoinStake())
return 0.0;
double dResult = 0.0;
BOOST_FOREACH(const CTxIn& txin, tx.vin)
{
const Coin coin = AccessCoin(txin.prevout);
assert(!coin.IsSpent());
if (coin.IsSpent()) continue;
if (coin.nHeight <= nHeight) {
dResult += (double)(coin.out.nValue) * (nHeight-coin.nHeight);
inChainInputValue += coin.out.nValue;
}
}
return tx.ComputePriority(dResult);
}
static const Coin coinEmpty;
const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
CCoinsMap::const_iterator it = FetchCoin(outpoint);
if (it == cacheCoins.end()) {
return coinEmpty;
} else {
return it->second.coin;
}
}
bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
CCoinsMap::const_iterator it = FetchCoin(outpoint);
return (it != cacheCoins.end() && !it->second.coin.IsSpent());
}
bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
return it != cacheCoins.end();
}
uint256 CCoinsViewCache::GetBestBlock() const {
if (hashBlock.IsNull())
hashBlock = base->GetBestBlock();
return hashBlock;
}
void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
hashBlock = hashBlockIn;
}
bool CCoinsViewCache::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlockIn) {
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
if (it->second.flags & CCoinsCacheEntry::DIRTY) { // Ignore non-dirty entries (optimization).
CCoinsMap::iterator itUs = cacheCoins.find(it->first);
if (itUs == cacheCoins.end()) {
// The parent cache does not have an entry, while the child does
// We can ignore it if it's both FRESH and pruned in the child
if (!(it->second.flags & CCoinsCacheEntry::FRESH && it->second.coin.IsSpent())) {
// Otherwise we will need to create it in the parent
// and move the data up and mark it as dirty
CCoinsCacheEntry& entry = cacheCoins[it->first];
entry.coin = std::move(it->second.coin);
cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
entry.flags = CCoinsCacheEntry::DIRTY;
// We can mark it FRESH in the parent if it was FRESH in the child
// Otherwise it might have just been flushed from the parent's cache
// and already exist in the grandparent
if (it->second.flags & CCoinsCacheEntry::FRESH)
entry.flags |= CCoinsCacheEntry::FRESH;
}
} else {
// Assert that the child cache entry was not marked FRESH if the
// parent cache entry has unspent outputs. If this ever happens,
// it means the FRESH flag was misapplied and there is a logic
// error in the calling code.
if ((it->second.flags & CCoinsCacheEntry::FRESH) && !itUs->second.coin.IsSpent())
throw std::logic_error("FRESH flag misapplied to cache entry for base transaction with spendable outputs");
// Found the entry in the parent cache
if ((itUs->second.flags & CCoinsCacheEntry::FRESH) && it->second.coin.IsSpent()) {
// The grandparent does not have an entry, and the child is
// modified and being pruned. This means we can just delete
// it from the parent.
cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
cacheCoins.erase(itUs);
} else {
// A normal modification.
cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
itUs->second.coin = std::move(it->second.coin);
cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
itUs->second.flags |= CCoinsCacheEntry::DIRTY;
// NOTE: It is possible the child has a FRESH flag here in
// the event the entry we found in the parent is pruned. But
// we must not copy that FRESH flag to the parent as that
// pruned state likely still needs to be communicated to the
// grandparent.
}
}
}
CCoinsMap::iterator itOld = it++;
mapCoins.erase(itOld);
}
hashBlock = hashBlockIn;
return true;
}
bool CCoinsViewCache::Flush() {
bool fOk = base->BatchWrite(cacheCoins, hashBlock);
cacheCoins.clear();
cachedCoinsUsage = 0;
return fOk;
}
void CCoinsViewCache::Uncache(const COutPoint& hash)
{
CCoinsMap::iterator it = cacheCoins.find(hash);
if (it != cacheCoins.end() && it->second.flags == 0) {
cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
cacheCoins.erase(it);
}
}
unsigned int CCoinsViewCache::GetCacheSize() const {
return cacheCoins.size();
}
CAmount CCoinsViewCache::GetValueIn(const CTransaction& tx) const
{
if (tx.IsCoinBase())
return 0;
CAmount nResult = 0;
for (unsigned int i = 0; i < tx.vin.size(); i++)
nResult += AccessCoin(tx.vin[i].prevout).out.nValue;
return nResult;
}
bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
{
if (!tx.IsCoinBase()) {
for (unsigned int i = 0; i < tx.vin.size(); i++) {
if (!HaveCoin(tx.vin[i].prevout)) {
return false;
}
}
}
return true;
}
static const size_t MAX_OUTPUTS_PER_BLOCK = dgpMaxBlockBaseSize / ::GetSerializeSize(CTxOut(), SER_NETWORK, PROTOCOL_VERSION); // TODO: merge with similar definition in undo.h.
const Coin& AccessByTxid(const CCoinsViewCache& view, const uint256& txid)
{
COutPoint iter(txid, 0);
while (iter.n < MAX_OUTPUTS_PER_BLOCK) {
const Coin& alternate = view.AccessCoin(iter);
if (!alternate.IsSpent()) return alternate;
++iter.n;
}
return coinEmpty;
}
<commit_msg>Completely disallow overwrite<commit_after>// Copyright (c) 2012-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "coins.h"
#include "consensus/consensus.h"
#include "memusage.h"
#include "random.h"
#include <assert.h>
bool CCoinsView::GetCoin(const COutPoint &outpoint, Coin &coin) const { return false; }
bool CCoinsView::HaveCoin(const COutPoint &outpoint) const { return false; }
uint256 CCoinsView::GetBestBlock() const { return uint256(); }
bool CCoinsView::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return false; }
CCoinsViewCursor *CCoinsView::Cursor() const { return 0; }
CCoinsViewBacked::CCoinsViewBacked(CCoinsView *viewIn) : base(viewIn) { }
bool CCoinsViewBacked::GetCoin(const COutPoint &outpoint, Coin &coin) const { return base->GetCoin(outpoint, coin); }
bool CCoinsViewBacked::HaveCoin(const COutPoint &outpoint) const { return base->HaveCoin(outpoint); }
uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlock(); }
void CCoinsViewBacked::SetBackend(CCoinsView &viewIn) { base = &viewIn; }
bool CCoinsViewBacked::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { return base->BatchWrite(mapCoins, hashBlock); }
CCoinsViewCursor *CCoinsViewBacked::Cursor() const { return base->Cursor(); }
size_t CCoinsViewBacked::EstimateSize() const { return base->EstimateSize(); }
SaltedOutpointHasher::SaltedOutpointHasher() : k0(GetRand(std::numeric_limits<uint64_t>::max())), k1(GetRand(std::numeric_limits<uint64_t>::max())) {}
CCoinsViewCache::CCoinsViewCache(CCoinsView *baseIn) : CCoinsViewBacked(baseIn), cachedCoinsUsage(0) {}
size_t CCoinsViewCache::DynamicMemoryUsage() const {
return memusage::DynamicUsage(cacheCoins) + cachedCoinsUsage;
}
CCoinsMap::iterator CCoinsViewCache::FetchCoin(const COutPoint &outpoint) const {
CCoinsMap::iterator it = cacheCoins.find(outpoint);
if (it != cacheCoins.end())
return it;
Coin tmp;
if (!base->GetCoin(outpoint, tmp))
return cacheCoins.end();
CCoinsMap::iterator ret = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::forward_as_tuple(std::move(tmp))).first;
if (ret->second.coin.IsSpent()) {
// The parent only has an empty entry for this outpoint; we can consider our
// version as fresh.
ret->second.flags = CCoinsCacheEntry::FRESH;
}
cachedCoinsUsage += ret->second.coin.DynamicMemoryUsage();
return ret;
}
bool CCoinsViewCache::GetCoin(const COutPoint &outpoint, Coin &coin) const {
CCoinsMap::const_iterator it = FetchCoin(outpoint);
if (it != cacheCoins.end()) {
coin = it->second.coin;
return true;
}
return false;
}
void CCoinsViewCache::AddCoin(const COutPoint &outpoint, Coin&& coin, bool possible_overwrite) {
assert(!coin.IsSpent());
if (coin.out.scriptPubKey.IsUnspendable()) return;
CCoinsMap::iterator it;
bool inserted;
std::tie(it, inserted) = cacheCoins.emplace(std::piecewise_construct, std::forward_as_tuple(outpoint), std::tuple<>());
bool fresh = false;
if (!inserted) {
cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
}
if (!possible_overwrite) {
if (!it->second.coin.IsSpent()) {
throw std::logic_error("Adding new coin that replaces non-pruned entry");
}
fresh = !(it->second.flags & CCoinsCacheEntry::DIRTY);
}
it->second.coin = std::move(coin);
it->second.flags |= CCoinsCacheEntry::DIRTY | (fresh ? CCoinsCacheEntry::FRESH : 0);
cachedCoinsUsage += it->second.coin.DynamicMemoryUsage();
}
void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeight) {
bool fCoinbase = tx.IsCoinBase();
bool fCoinstake = tx.IsCoinStake();
const uint256& txid = tx.GetHash();
for (size_t i = 0; i < tx.vout.size(); ++i) {
// Pass fCoinbase as the possible_overwrite flag to AddCoin, in order to correctly
// deal with the pre-BIP30 occurrances of duplicate coinbase transactions.
cache.AddCoin(COutPoint(txid, i), Coin(tx.vout[i], nHeight, fCoinbase, fCoinstake), false);
}
}
void CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
CCoinsMap::iterator it = FetchCoin(outpoint);
if (it == cacheCoins.end()) return;
cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
if (moveout) {
*moveout = std::move(it->second.coin);
}
if (it->second.flags & CCoinsCacheEntry::FRESH) {
cacheCoins.erase(it);
} else {
it->second.flags |= CCoinsCacheEntry::DIRTY;
it->second.coin.Clear();
}
}
double CCoinsViewCache::GetPriority(const CTransaction &tx, int nHeight, CAmount &inChainInputValue) const
{
inChainInputValue = 0;
if (tx.IsCoinBase() || tx.IsCoinStake())
return 0.0;
double dResult = 0.0;
BOOST_FOREACH(const CTxIn& txin, tx.vin)
{
const Coin coin = AccessCoin(txin.prevout);
assert(!coin.IsSpent());
if (coin.IsSpent()) continue;
if (coin.nHeight <= nHeight) {
dResult += (double)(coin.out.nValue) * (nHeight-coin.nHeight);
inChainInputValue += coin.out.nValue;
}
}
return tx.ComputePriority(dResult);
}
static const Coin coinEmpty;
const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
CCoinsMap::const_iterator it = FetchCoin(outpoint);
if (it == cacheCoins.end()) {
return coinEmpty;
} else {
return it->second.coin;
}
}
bool CCoinsViewCache::HaveCoin(const COutPoint &outpoint) const {
CCoinsMap::const_iterator it = FetchCoin(outpoint);
return (it != cacheCoins.end() && !it->second.coin.IsSpent());
}
bool CCoinsViewCache::HaveCoinInCache(const COutPoint &outpoint) const {
CCoinsMap::const_iterator it = cacheCoins.find(outpoint);
return it != cacheCoins.end();
}
uint256 CCoinsViewCache::GetBestBlock() const {
if (hashBlock.IsNull())
hashBlock = base->GetBestBlock();
return hashBlock;
}
void CCoinsViewCache::SetBestBlock(const uint256 &hashBlockIn) {
hashBlock = hashBlockIn;
}
bool CCoinsViewCache::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlockIn) {
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
if (it->second.flags & CCoinsCacheEntry::DIRTY) { // Ignore non-dirty entries (optimization).
CCoinsMap::iterator itUs = cacheCoins.find(it->first);
if (itUs == cacheCoins.end()) {
// The parent cache does not have an entry, while the child does
// We can ignore it if it's both FRESH and pruned in the child
if (!(it->second.flags & CCoinsCacheEntry::FRESH && it->second.coin.IsSpent())) {
// Otherwise we will need to create it in the parent
// and move the data up and mark it as dirty
CCoinsCacheEntry& entry = cacheCoins[it->first];
entry.coin = std::move(it->second.coin);
cachedCoinsUsage += entry.coin.DynamicMemoryUsage();
entry.flags = CCoinsCacheEntry::DIRTY;
// We can mark it FRESH in the parent if it was FRESH in the child
// Otherwise it might have just been flushed from the parent's cache
// and already exist in the grandparent
if (it->second.flags & CCoinsCacheEntry::FRESH)
entry.flags |= CCoinsCacheEntry::FRESH;
}
} else {
// Assert that the child cache entry was not marked FRESH if the
// parent cache entry has unspent outputs. If this ever happens,
// it means the FRESH flag was misapplied and there is a logic
// error in the calling code.
if ((it->second.flags & CCoinsCacheEntry::FRESH) && !itUs->second.coin.IsSpent())
throw std::logic_error("FRESH flag misapplied to cache entry for base transaction with spendable outputs");
// Found the entry in the parent cache
if ((itUs->second.flags & CCoinsCacheEntry::FRESH) && it->second.coin.IsSpent()) {
// The grandparent does not have an entry, and the child is
// modified and being pruned. This means we can just delete
// it from the parent.
cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
cacheCoins.erase(itUs);
} else {
// A normal modification.
cachedCoinsUsage -= itUs->second.coin.DynamicMemoryUsage();
itUs->second.coin = std::move(it->second.coin);
cachedCoinsUsage += itUs->second.coin.DynamicMemoryUsage();
itUs->second.flags |= CCoinsCacheEntry::DIRTY;
// NOTE: It is possible the child has a FRESH flag here in
// the event the entry we found in the parent is pruned. But
// we must not copy that FRESH flag to the parent as that
// pruned state likely still needs to be communicated to the
// grandparent.
}
}
}
CCoinsMap::iterator itOld = it++;
mapCoins.erase(itOld);
}
hashBlock = hashBlockIn;
return true;
}
bool CCoinsViewCache::Flush() {
bool fOk = base->BatchWrite(cacheCoins, hashBlock);
cacheCoins.clear();
cachedCoinsUsage = 0;
return fOk;
}
void CCoinsViewCache::Uncache(const COutPoint& hash)
{
CCoinsMap::iterator it = cacheCoins.find(hash);
if (it != cacheCoins.end() && it->second.flags == 0) {
cachedCoinsUsage -= it->second.coin.DynamicMemoryUsage();
cacheCoins.erase(it);
}
}
unsigned int CCoinsViewCache::GetCacheSize() const {
return cacheCoins.size();
}
CAmount CCoinsViewCache::GetValueIn(const CTransaction& tx) const
{
if (tx.IsCoinBase())
return 0;
CAmount nResult = 0;
for (unsigned int i = 0; i < tx.vin.size(); i++)
nResult += AccessCoin(tx.vin[i].prevout).out.nValue;
return nResult;
}
bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
{
if (!tx.IsCoinBase()) {
for (unsigned int i = 0; i < tx.vin.size(); i++) {
if (!HaveCoin(tx.vin[i].prevout)) {
return false;
}
}
}
return true;
}
static const size_t MAX_OUTPUTS_PER_BLOCK = dgpMaxBlockBaseSize / ::GetSerializeSize(CTxOut(), SER_NETWORK, PROTOCOL_VERSION); // TODO: merge with similar definition in undo.h.
const Coin& AccessByTxid(const CCoinsViewCache& view, const uint256& txid)
{
COutPoint iter(txid, 0);
while (iter.n < MAX_OUTPUTS_PER_BLOCK) {
const Coin& alternate = view.AccessCoin(iter);
if (!alternate.IsSpent()) return alternate;
++iter.n;
}
return coinEmpty;
}
<|endoftext|> |
<commit_before>#include "acmacs-base/debug.hh"
#include "time-series-draw.hh"
#include "tree.hh"
#include "tree-draw.hh"
#include "coloring.hh"
// ----------------------------------------------------------------------
void TimeSeriesDraw::prepare()
{
std::map<date::year_month_day, size_t> sequences_per_month;
mTree.sequences_per_month(sequences_per_month);
if (!sequences_per_month.empty()) {
std::cout << "INFO: Sequences per month:" << '\n';
for (const auto& e: sequences_per_month) {
std::cout << " " << e.first << " " << e.second << '\n';
}
const auto today = date::today();
auto end_of_ts = today;
if (mSettings.end.empty()) {
for (auto ms = sequences_per_month.crbegin(); ms != sequences_per_month.crend(); ++ms) {
if (ms->second && ms->first <= today) {
end_of_ts = ms->first;
mSettings.end = date::display(date::end_of_month(ms->first));
break;
}
}
}
if (mSettings.begin.empty()) {
for (const auto& entry : sequences_per_month) {
if (entry.second && months_between_dates(entry.first, end_of_ts) < 25) {
mSettings.begin = date::display(entry.first);
break;
}
}
}
mNumberOfMonths = static_cast<size_t>(calendar_months_between_dates_inclusive(date::from_string(*mSettings.begin), date::from_string(*mSettings.end)));
std::cout << "INFO: dates to show: " << mSettings.begin << " .. " << mSettings.end << " months: " << mNumberOfMonths << DEBUG_LINE_FUNC << '\n';
}
else {
std::cout << "WARNING: no dates found for sequences" << DEBUG_LINE_FUNC << '\n';
mNumberOfMonths = 0;
}
} // TimeSeriesDraw::prepare
// ----------------------------------------------------------------------
std::vector<std::string> TimeSeriesDraw::all_months() const
{
std::vector<std::string> result;
auto current_month{date::from_string(*mSettings.begin)};
for (size_t month_no = 0; month_no < mNumberOfMonths; ++month_no, date::increment_month(current_month))
result.push_back(date::year4_month2(current_month));
return result;
} // TimeSeriesDraw::all_months
// ----------------------------------------------------------------------
void TimeSeriesDraw::init_settings(const SettingsInitializer& /*settings_initilizer*/)
{
} // TimeSeriesDraw::init_settings
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw()
{
if (mNumberOfMonths) {
// mSurface.border("green3", 1);
const double month_width = mSurface.viewport().size.width / mNumberOfMonths;
draw_labels(month_width);
draw_month_separators(month_width);
draw_dashes(month_width);
draw_hz_section_lines();
}
} // TimeSeriesDraw::draw
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_labels(double month_width)
{
const acmacs::Size& surface_size = mSurface.viewport().size;
const double month_max_height = mSurface.text_size("May ", Pixels{mSettings.label_size}, mSettings.label_style).width;
double x_bearing;
const auto big_label_size = mSurface.text_size("May 99", Pixels{mSettings.label_size}, mSettings.label_style, &x_bearing);
const auto text_up = (month_width - big_label_size.height) * 0.5;
const double month_year_to_timeseries_gap = mSurface.convert(Pixels{mSettings.month_year_to_timeseries_gap}).value();
draw_labels_at_side({text_up, - big_label_size.width - x_bearing - 2 /*month_year_to_timeseries_gap*/}, month_width, month_max_height);
draw_labels_at_side({text_up, surface_size.height + x_bearing + month_year_to_timeseries_gap}, month_width, month_max_height);
} // TimeSeriesDraw::draw_labels
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_labels_at_side(const acmacs::PointCoordinates& aOrigin, double month_width, double month_max_height)
{
try {
auto current_month{date::from_string(*mSettings.begin)};
for (size_t month_no = 0; month_no < mNumberOfMonths; ++month_no, date::increment_month(current_month)) {
const double left = aOrigin.x() + month_no * month_width;
mSurface.text({left, aOrigin.y()}, date::month_3(current_month), 0, Pixels{mSettings.label_size}, mSettings.label_style, Rotation{M_PI_2});
mSurface.text({left, aOrigin.y() + month_max_height}, date::year_2(current_month), 0, Pixels{mSettings.label_size}, mSettings.label_style, Rotation{M_PI_2});
}
}
catch (std::exception& err) {
std::cerr << "WARNING: " << err.what() << " (TimeSeriesDraw::draw_labels_at_side)\n";
}
} // TimeSeriesDraw::draw_labels_at_side
// ----------------------------------------------------------------------
// for tracked antigens in antigenic maps colored by date
void TimeSeriesDraw::draw_color_scale(const std::map<std::string, Color, std::less<>>& aTrackedAntigenColorByMonth)
{
const acmacs::Size& surface_size = mSurface.viewport().size;
const double month_width = mSurface.viewport().size.width / mNumberOfMonths;
const auto top = surface_size.height;
auto current_month{date::from_string(*mSettings.begin)};
for (size_t month_no = 0; month_no < mNumberOfMonths; ++month_no, date::increment_month(current_month)) {
const auto left = month_no * month_width;
mSurface.rectangle_filled({left, top}, acmacs::Size{10, 10}, PINK, Pixels{0}, aTrackedAntigenColorByMonth.find(date::year4_month2(current_month))->second);
}
} // TimeSeriesDraw::draw_color_scale
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_month_separators(double month_width)
{
const double bottom = mSurface.viewport().size.height;
for (size_t month_no = 0; month_no <= mNumberOfMonths; ++month_no) {
const double left = month_no * month_width;
mSurface.line({left, 0}, {left, bottom}, mSettings.month_separator_color, Pixels{mSettings.month_separator_width});
}
} // TimeSeriesDraw::draw_month_separators
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_dashes(double month_width)
{
const double base_x = month_width * (1.0 - mSettings.dash_width) / 2;
const Coloring& coloring = mTreeDraw.coloring();
const auto begin{date::from_string(*mSettings.begin)}, end{date::from_string(*mSettings.end)};
auto draw_dash = [&](const Node& aNode) {
if (aNode.draw.shown && !aNode.data.date().empty()) {
if (const auto node_date_s = aNode.data.date(); node_date_s.size() > 3 && node_date_s.substr(node_date_s.size() - 3) != "-00") { // ignore incomplete dates
try {
if (const auto node_date{date::from_string(node_date_s)}; node_date >= begin && node_date <= end) {
const int month_no = date::months_between_dates(begin, node_date);
const acmacs::PointCoordinates a(base_x + month_width * month_no, aNode.draw.vertical_pos);
mSurface.line(a, {a.x() + month_width * mSettings.dash_width, a.y()}, coloring.color(aNode), Pixels{mSettings.dash_line_width}, acmacs::surface::LineCap::Round);
}
}
catch (std::exception& err) {
std::cerr << "WARNING: " << err.what() << " (TimeSeriesDraw::draw_dashes) Date: " << aNode.data.date() << "\n";
}
}
}
};
try {
tree::iterate_leaf(mTree, draw_dash);
}
catch (std::exception& err) {
std::cerr << "WARNING: " << err.what() << " (TimeSeriesDraw::draw_dashes)\n";
}
} // TimeSeriesDraw::draw_dashes
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_hz_section_lines()
{
double previous_vertical_pos = -1e-8;
auto draw = [&](const Node& aNode) {
if (aNode.draw.shown) {
if (aNode.draw.hz_section_index != NodeDrawData::HzSectionNoIndex) {
const auto section_settings = mHzSections.sections[aNode.draw.hz_section_index];
double y = aNode.draw.vertical_pos;
if (section_settings->show_line) {
y = (previous_vertical_pos + aNode.draw.vertical_pos) / 2;
mSurface.line({0, y}, {mSurface.viewport().size.width, y}, mHzSections.line_color, Pixels{mHzSections.line_width});
}
if ((!mTreeMode || mHzSections.show_labels_in_time_series_in_tree_mode) && section_settings->show_label_in_time_series) {
draw_hz_section_label(aNode.draw.hz_section_index, y);
}
}
previous_vertical_pos = aNode.draw.vertical_pos;
}
};
tree::iterate_leaf(mTree, draw);
} // TimeSeriesDraw::draw_hz_section_lines
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_hz_section_label(size_t aSectionIndex, double aY)
{
const auto section_settings = mHzSections.sections[aSectionIndex];
if (section_settings->show && section_settings->show_map) {
std::string label = mHzSections.node_refs[aSectionIndex].index; // (1, 'A' + static_cast<char>(aSectionNo));
const acmacs::Size tsize = mSurface.text_size(label, Pixels{mHzSections.ts_label_size}, mHzSections.ts_label_style);
mSurface.text({mSurface.viewport().size.width - tsize.width * 1.2, aY + tsize.height * 1.2}, label, mHzSections.ts_label_color, Pixels{mHzSections.ts_label_size}, mHzSections.ts_label_style);
}
} // TimeSeriesDraw::draw_hz_section_label
// ----------------------------------------------------------------------
// void TimeSeriesDraw::hide_hz_section_labels_in_time_series()
// {
// for (auto& section: mHzSections.sections)
// section.show_label_in_time_series = false;
// } // TimeSeriesDraw::hide_hz_section_labels_in_time_series
// ----------------------------------------------------------------------
void TimeSeriesDrawSettings::remove_for_tree_settings()
{
label_style.remove();
} // TimeSeriesDrawSettings::remove_for_tree_settings
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
<commit_msg>minor fix<commit_after>#include "acmacs-base/debug.hh"
#include "time-series-draw.hh"
#include "tree.hh"
#include "tree-draw.hh"
#include "coloring.hh"
// ----------------------------------------------------------------------
void TimeSeriesDraw::prepare()
{
std::map<date::year_month_day, size_t> sequences_per_month;
mTree.sequences_per_month(sequences_per_month);
if (!sequences_per_month.empty()) {
std::cout << "INFO: Sequences per month:" << '\n';
for (const auto& e: sequences_per_month) {
std::cout << " " << e.first << " " << e.second << '\n';
}
const auto today = date::today();
auto end_of_ts = today;
if (mSettings.end.empty()) {
for (auto ms = sequences_per_month.crbegin(); ms != sequences_per_month.crend(); ++ms) {
if (ms->second && ms->first <= today) {
end_of_ts = ms->first;
mSettings.end = date::display(date::end_of_month(ms->first));
break;
}
}
}
if (mSettings.begin.empty()) {
for (const auto& entry : sequences_per_month) {
if (entry.second && months_between_dates(entry.first, end_of_ts) < 25) {
mSettings.begin = date::display(entry.first);
break;
}
}
}
mNumberOfMonths = static_cast<size_t>(calendar_months_between_dates_inclusive(date::from_string(*mSettings.begin), date::from_string(*mSettings.end)));
std::cout << "INFO: dates to show: " << mSettings.begin << " .. " << mSettings.end << " months: " << mNumberOfMonths << DEBUG_LINE_FUNC << '\n';
}
else {
std::cout << "WARNING: no dates found for sequences" << DEBUG_LINE_FUNC << '\n';
mNumberOfMonths = 0;
}
} // TimeSeriesDraw::prepare
// ----------------------------------------------------------------------
std::vector<std::string> TimeSeriesDraw::all_months() const
{
std::vector<std::string> result;
auto current_month{date::from_string(*mSettings.begin)};
for (size_t month_no = 0; month_no < mNumberOfMonths; ++month_no, date::increment_month(current_month))
result.push_back(date::year4_month2(current_month));
return result;
} // TimeSeriesDraw::all_months
// ----------------------------------------------------------------------
void TimeSeriesDraw::init_settings(const SettingsInitializer& /*settings_initilizer*/)
{
} // TimeSeriesDraw::init_settings
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw()
{
if (mNumberOfMonths) {
// mSurface.border("green3", 1);
const double month_width = mSurface.viewport().size.width / mNumberOfMonths;
draw_labels(month_width);
draw_month_separators(month_width);
draw_dashes(month_width);
draw_hz_section_lines();
}
} // TimeSeriesDraw::draw
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_labels(double month_width)
{
const acmacs::Size& surface_size = mSurface.viewport().size;
const double month_max_height = mSurface.text_size("May ", Pixels{mSettings.label_size}, mSettings.label_style).width;
double x_bearing;
const auto big_label_size = mSurface.text_size("May 99", Pixels{mSettings.label_size}, mSettings.label_style, &x_bearing);
const auto text_up = (month_width - big_label_size.height) * 0.5;
const double month_year_to_timeseries_gap = mSurface.convert(Pixels{mSettings.month_year_to_timeseries_gap}).value();
draw_labels_at_side({text_up, - big_label_size.width - x_bearing - 2 /*month_year_to_timeseries_gap*/}, month_width, month_max_height);
draw_labels_at_side({text_up, surface_size.height + x_bearing + month_year_to_timeseries_gap}, month_width, month_max_height);
} // TimeSeriesDraw::draw_labels
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_labels_at_side(const acmacs::PointCoordinates& aOrigin, double month_width, double month_max_height)
{
try {
auto current_month{date::from_string(*mSettings.begin)};
for (size_t month_no = 0; month_no < mNumberOfMonths; ++month_no, date::increment_month(current_month)) {
const double left = aOrigin.x() + month_no * month_width;
mSurface.text({left, aOrigin.y()}, date::month_3(current_month), 0, Pixels{mSettings.label_size}, mSettings.label_style, Rotation{M_PI_2});
mSurface.text({left, aOrigin.y() + month_max_height}, date::year_2(current_month), 0, Pixels{mSettings.label_size}, mSettings.label_style, Rotation{M_PI_2});
}
}
catch (std::exception& err) {
std::cerr << "WARNING: " << err.what() << " (TimeSeriesDraw::draw_labels_at_side)\n";
}
} // TimeSeriesDraw::draw_labels_at_side
// ----------------------------------------------------------------------
// for tracked antigens in antigenic maps colored by date
void TimeSeriesDraw::draw_color_scale(const std::map<std::string, Color, std::less<>>& aTrackedAntigenColorByMonth)
{
const acmacs::Size& surface_size = mSurface.viewport().size;
const double month_width = mSurface.viewport().size.width / mNumberOfMonths;
const auto top = surface_size.height;
auto current_month{date::from_string(*mSettings.begin)};
for (size_t month_no = 0; month_no < mNumberOfMonths; ++month_no, date::increment_month(current_month)) {
const auto left = month_no * month_width;
mSurface.rectangle_filled({left, top}, acmacs::Size{10, 10}, PINK, Pixels{0}, aTrackedAntigenColorByMonth.find(date::year4_month2(current_month))->second);
}
} // TimeSeriesDraw::draw_color_scale
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_month_separators(double month_width)
{
const double bottom = mSurface.viewport().size.height;
for (size_t month_no = 0; month_no <= mNumberOfMonths; ++month_no) {
const double left = month_no * month_width;
mSurface.line({left, 0}, {left, bottom}, mSettings.month_separator_color, Pixels{mSettings.month_separator_width});
}
} // TimeSeriesDraw::draw_month_separators
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_dashes(double month_width)
{
const double base_x = month_width * (1.0 - mSettings.dash_width) / 2;
const Coloring& coloring = mTreeDraw.coloring();
const auto begin{date::from_string(*mSettings.begin)}, end{date::from_string(*mSettings.end)};
auto draw_dash = [&](const Node& aNode) {
if (aNode.draw.shown && !aNode.data.date().empty()) {
if (const auto node_date_s = aNode.data.date(); node_date_s.size() > 3 && node_date_s.substr(node_date_s.size() - 3) != "-00") { // ignore incomplete dates
try {
if (const auto node_date{date::from_string(node_date_s)}; node_date >= begin && node_date <= end) {
const int month_no = date::months_between_dates(begin, node_date);
const acmacs::PointCoordinates a(base_x + month_width * month_no, aNode.draw.vertical_pos);
mSurface.line(a, {a.x() + month_width * mSettings.dash_width, a.y()}, coloring.color(aNode), Pixels{mSettings.dash_line_width}, acmacs::surface::LineCap::Round);
}
}
catch (std::exception& err) {
if (aNode.data.date().size() > 4)
std::cerr << "WARNING: " << err.what() << " (TimeSeriesDraw::draw_dashes) Date: " << aNode.data.date() << "\n";
}
}
}
};
try {
tree::iterate_leaf(mTree, draw_dash);
}
catch (std::exception& err) {
std::cerr << "WARNING: " << err.what() << " (TimeSeriesDraw::draw_dashes)\n";
}
} // TimeSeriesDraw::draw_dashes
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_hz_section_lines()
{
double previous_vertical_pos = -1e-8;
auto draw = [&](const Node& aNode) {
if (aNode.draw.shown) {
if (aNode.draw.hz_section_index != NodeDrawData::HzSectionNoIndex) {
const auto section_settings = mHzSections.sections[aNode.draw.hz_section_index];
double y = aNode.draw.vertical_pos;
if (section_settings->show_line) {
y = (previous_vertical_pos + aNode.draw.vertical_pos) / 2;
mSurface.line({0, y}, {mSurface.viewport().size.width, y}, mHzSections.line_color, Pixels{mHzSections.line_width});
}
if ((!mTreeMode || mHzSections.show_labels_in_time_series_in_tree_mode) && section_settings->show_label_in_time_series) {
draw_hz_section_label(aNode.draw.hz_section_index, y);
}
}
previous_vertical_pos = aNode.draw.vertical_pos;
}
};
tree::iterate_leaf(mTree, draw);
} // TimeSeriesDraw::draw_hz_section_lines
// ----------------------------------------------------------------------
void TimeSeriesDraw::draw_hz_section_label(size_t aSectionIndex, double aY)
{
const auto section_settings = mHzSections.sections[aSectionIndex];
if (section_settings->show && section_settings->show_map) {
std::string label = mHzSections.node_refs[aSectionIndex].index; // (1, 'A' + static_cast<char>(aSectionNo));
const acmacs::Size tsize = mSurface.text_size(label, Pixels{mHzSections.ts_label_size}, mHzSections.ts_label_style);
mSurface.text({mSurface.viewport().size.width - tsize.width * 1.2, aY + tsize.height * 1.2}, label, mHzSections.ts_label_color, Pixels{mHzSections.ts_label_size}, mHzSections.ts_label_style);
}
} // TimeSeriesDraw::draw_hz_section_label
// ----------------------------------------------------------------------
// void TimeSeriesDraw::hide_hz_section_labels_in_time_series()
// {
// for (auto& section: mHzSections.sections)
// section.show_label_in_time_series = false;
// } // TimeSeriesDraw::hide_hz_section_labels_in_time_series
// ----------------------------------------------------------------------
void TimeSeriesDrawSettings::remove_for_tree_settings()
{
label_style.remove();
} // TimeSeriesDrawSettings::remove_for_tree_settings
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
<|endoftext|> |
<commit_before>#include "task_charset.h"
#include "cortex/class.h"
#include "math/gauss.hpp"
#include "math/clamp.hpp"
#include "math/random.hpp"
#include "tensor/numeric.hpp"
#include "text/to_string.hpp"
#include "text/to_params.hpp"
#include "text/from_params.hpp"
#include "tensor/algorithm.hpp"
#include "vision/warp.h"
#include "vision/image_io.h"
#include "vision/convolve.hpp"
#include "vision/bilinear.hpp"
#include "synth_bitstream_vera_sans_mono_bold.h"
#include "synth_bitstream_vera_sans_mono.h"
#include "synth_dejavu_sans_mono_bold.h"
#include "synth_dejavu_sans_mono.h"
#include "synth_droid_sans_mono.h"
#include "synth_liberation_mono_bold.h"
#include "synth_liberation_mono.h"
#include "synth_nimbus_mono_bold.h"
#include "synth_nimbus_mono.h"
#include "synth_oxygen_mono.h"
namespace nano
{
static rgba_t make_random_rgba()
{
random_t<luma_t> rng(0, 255);
return rgba_t{rng(), rng(), rng(), rng()};
}
static rgba_t make_random_opposite_rgba(const rgba_t& rgba)
{
random_t<int> rng(-55, +55);
return rgba_t
{
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(0)) + rng(), 0, 255)),
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(1)) + rng(), 0, 255)),
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(2)) + rng(), 0, 255)),
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(3)) + rng(), 0, 255))
};
}
template <>
inline std::map<nano::charset, std::string> enum_string<nano::charset>()
{
return
{
{ nano::charset::digit, "digit" },
{ nano::charset::lalpha, "lalpha" },
{ nano::charset::ualpha, "ualpha" },
{ nano::charset::alpha, "alpha" },
{ nano::charset::alphanum, "alphanum" }
};
}
static tensor_size_t obegin(const charset cs)
{
switch (cs)
{
case charset::digit: return 0;
case charset::lalpha: return 0 + 10;
case charset::ualpha: return 0 + 10 + 26;
case charset::alpha: return 10;
case charset::alphanum: return 0;
default: assert(false); return 0;
}
}
static tensor_size_t oend(const charset cs)
{
switch (cs)
{
case charset::digit: return 10;
case charset::lalpha: return 10 + 26;
case charset::ualpha: return 10 + 26 + 26;
case charset::alpha: return 10 + 26 + 26;
case charset::alphanum: return 10 + 26 + 26;
default: assert(false); return 0;
}
}
static tensor_size_t osize(const charset cs)
{
return oend(cs) - obegin(cs);
}
template
<
typename tindex,
typename tsize
>
tensor3d_t get_object_patch(const image_tensor_t& image,
const tindex object_index, const tsize objects, const scalar_t max_offset)
{
nano::random_t<scalar_t> rng(-max_offset, max_offset);
const auto icols = static_cast<int>(image.cols());
const auto irows = static_cast<int>(image.rows());
const auto dx = static_cast<scalar_t>(icols) / static_cast<scalar_t>(objects);
const auto x = dx * static_cast<scalar_t>(object_index) + rng();
const auto ppx = nano::clamp(nano::cast<int>(x), 0, icols - 1);
const auto ppw = nano::clamp(nano::cast<int>(dx + rng()), 0, icols - ppx);
const auto ppy = nano::clamp(nano::cast<int>(rng()), 0, irows - 1);
const auto pph = nano::clamp(nano::cast<int>(static_cast<scalar_t>(irows) + rng()), 0, irows - ppy);
tensor3d_t ret(4, pph, ppw);
ret.matrix(0) = image.matrix(0).block(ppy, ppx, pph, ppw).cast<scalar_t>() / 255;
ret.matrix(1) = image.matrix(1).block(ppy, ppx, pph, ppw).cast<scalar_t>() / 255;
ret.matrix(2) = image.matrix(2).block(ppy, ppx, pph, ppw).cast<scalar_t>() / 255;
ret.matrix(3) = image.matrix(3).block(ppy, ppx, pph, ppw).cast<scalar_t>() / 255;
return ret;
}
tensor3d_t make_random_rgba_image(const tensor_size_t rows, const tensor_size_t cols,
const rgba_t back_color,
const scalar_t max_noise, const scalar_t sigma)
{
// noisy background
tensor3d_t image(4, rows, cols);
image.matrix(0).setConstant(back_color(0) / 255);
image.matrix(1).setConstant(back_color(1) / 255);
image.matrix(2).setConstant(back_color(2) / 255);
image.matrix(3).setConstant(1);
tensor::add_random(nano::make_rng<scalar_t>(-max_noise, +max_noise),
image.matrix(0), image.matrix(1), image.matrix(2));
// smooth background
const nano::gauss_kernel_t<scalar_t> back_gauss(sigma);
nano::convolve(back_gauss, image.matrix(0));
nano::convolve(back_gauss, image.matrix(1));
nano::convolve(back_gauss, image.matrix(2));
return image;
}
tensor3d_t alpha_blend(const tensor3d_t& mask, const tensor3d_t& img1, const tensor3d_t& img2)
{
const auto op = [] (const auto a, const auto v1, const auto v2)
{
return (1 - a) * v1 + a * v2;
};
tensor3d_t imgb(4, mask.rows(), mask.cols());
tensor::transform(mask.matrix(3), img1.matrix(0), img2.matrix(0), imgb.matrix(0), op);
tensor::transform(mask.matrix(3), img1.matrix(1), img2.matrix(1), imgb.matrix(1), op);
tensor::transform(mask.matrix(3), img1.matrix(2), img2.matrix(2), imgb.matrix(2), op);
imgb.matrix(3).setConstant(1);
return imgb;
}
charset_task_t::charset_task_t(const string_t& configuration) : mem_vision_task_t(
"charset",
nano::from_params<color_mode>(configuration, "color", color_mode::rgb),
nano::clamp(nano::from_params<tensor_size_t>(configuration, "irows", 32), 12, 128),
nano::clamp(nano::from_params<tensor_size_t>(configuration, "icols", 32), 12, 128),
nano::osize(nano::from_params<charset>(configuration, "type", charset::digit)),
1),
m_charset(nano::from_params<charset>(configuration, "type", charset::digit)),
m_color(nano::from_params<color_mode>(configuration, "color", color_mode::rgb)),
m_count(nano::clamp(nano::from_params<size_t>(configuration, "count", 1000), 100, 1024 * 1024))
{
}
charset_task_t::charset_task_t(const charset type, const color_mode mode,
const tensor_size_t irows, const tensor_size_t icols, const size_t count) :
charset_task_t(to_params("color", mode, "irows", irows, "icols", icols, "type", type, "count", count))
{
}
bool charset_task_t::populate()
{
const string_t characters =
"0123456789" \
"abcdefghijklmnopqrstuvwxyz" \
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const size_t n_chars = characters.size();
std::vector<image_tensor_t> char_patches;
image_tensor_t char_patch;
#define INSERT_IMAGE(name) \
if (!nano::load_rgba_image(get_ ##name ##_name(), get_ ##name ##_data(), get_ ##name ##_size(), char_patch)) \
{ \
return false; \
} \
char_patches.push_back(char_patch);
INSERT_IMAGE(synth_bitstream_vera_sans_mono_bold)
INSERT_IMAGE(synth_bitstream_vera_sans_mono)
INSERT_IMAGE(synth_dejavu_sans_mono_bold)
INSERT_IMAGE(synth_dejavu_sans_mono)
INSERT_IMAGE(synth_droid_sans_mono)
INSERT_IMAGE(synth_liberation_mono_bold)
INSERT_IMAGE(synth_liberation_mono)
INSERT_IMAGE(synth_nimbus_mono_bold)
INSERT_IMAGE(synth_nimbus_mono)
INSERT_IMAGE(synth_oxygen_mono)
#undef INSERT_IMAGE
const size_t n_fonts = char_patches.size();
nano::random_t<tensor_size_t> rng_output(obegin(m_charset), oend(m_charset) - 1);
nano::random_t<size_t> rng_font(1, n_fonts);
nano::random_t<scalar_t> rng_gauss(0, 2);
// generate samples
for (size_t i = 0; i < m_count; ++ i)
{
// random target: character
const tensor_index_t o = rng_output();
// image: original object patch
const tensor3d_t opatch = get_object_patch(char_patches[rng_font() - 1], o, n_chars, 0.0);
// image: resize to the input size
tensor3d_t mpatch(4, irows(), icols());
nano::bilinear(opatch.matrix(0), mpatch.matrix(0));
nano::bilinear(opatch.matrix(1), mpatch.matrix(1));
nano::bilinear(opatch.matrix(2), mpatch.matrix(2));
nano::bilinear(opatch.matrix(3), mpatch.matrix(3));
// image: random warping
mpatch = nano::warp(mpatch,
warp_params_t(field_type::random, scalar_t(0.1), scalar_t(4.0), scalar_t(16.0), scalar_t(2.0)));
// image: background & foreground layer
const auto bcolor = make_random_rgba();
const auto fcolor = make_random_opposite_rgba(bcolor);
const auto bnoise = scalar_t(0.1);
const auto fnoise = scalar_t(0.1);
const auto bsigma = rng_gauss();
const auto fsigma = rng_gauss();
const auto bpatch = make_random_rgba_image(irows(), icols(), bcolor, bnoise, bsigma);
const auto fpatch = make_random_rgba_image(irows(), icols(), fcolor, fnoise, fsigma);
// image: alpha-blend the background & foreground layer
const tensor3d_t patch = alpha_blend(mpatch, bpatch, fpatch);
image_t image;
image.from_tensor(patch);
switch (m_color)
{
case color_mode::luma: image.make_luma(); break;
case color_mode::rgba: image.make_rgba(); break;
case color_mode::rgb: image.make_rgb(); break;
}
// generate image
add_chunk(image);
// generate sample
const auto fold = make_fold(0);
const auto target = class_target(o - nano::obegin(m_charset), nano::osize(m_charset));
const auto label = string_t("char") + characters[static_cast<size_t>(o)];
add_sample(fold, n_chunks() - 1, target, label);
}
return true;
}
}
<commit_msg>fix warning<commit_after>#include "task_charset.h"
#include "cortex/class.h"
#include "math/gauss.hpp"
#include "math/clamp.hpp"
#include "math/random.hpp"
#include "tensor/numeric.hpp"
#include "text/to_string.hpp"
#include "text/to_params.hpp"
#include "text/from_params.hpp"
#include "tensor/algorithm.hpp"
#include "vision/warp.h"
#include "vision/image_io.h"
#include "vision/convolve.hpp"
#include "vision/bilinear.hpp"
#include "synth_bitstream_vera_sans_mono_bold.h"
#include "synth_bitstream_vera_sans_mono.h"
#include "synth_dejavu_sans_mono_bold.h"
#include "synth_dejavu_sans_mono.h"
#include "synth_droid_sans_mono.h"
#include "synth_liberation_mono_bold.h"
#include "synth_liberation_mono.h"
#include "synth_nimbus_mono_bold.h"
#include "synth_nimbus_mono.h"
#include "synth_oxygen_mono.h"
namespace nano
{
static rgba_t make_random_rgba()
{
random_t<luma_t> rng(0, 255);
return rgba_t{rng(), rng(), rng(), rng()};
}
static rgba_t make_random_opposite_rgba(const rgba_t& rgba)
{
random_t<int> rng(-55, +55);
return rgba_t
{
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(0)) + rng(), 0, 255)),
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(1)) + rng(), 0, 255)),
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(2)) + rng(), 0, 255)),
static_cast<luma_t>(clamp(255 - static_cast<int>(rgba(3)) + rng(), 0, 255))
};
}
template <>
inline std::map<nano::charset, std::string> enum_string<nano::charset>()
{
return
{
{ nano::charset::digit, "digit" },
{ nano::charset::lalpha, "lalpha" },
{ nano::charset::ualpha, "ualpha" },
{ nano::charset::alpha, "alpha" },
{ nano::charset::alphanum, "alphanum" }
};
}
static tensor_size_t obegin(const charset cs)
{
switch (cs)
{
case charset::digit: return 0;
case charset::lalpha: return 0 + 10;
case charset::ualpha: return 0 + 10 + 26;
case charset::alpha: return 10;
case charset::alphanum: return 0;
default: assert(false); return 0;
}
}
static tensor_size_t oend(const charset cs)
{
switch (cs)
{
case charset::digit: return 10;
case charset::lalpha: return 10 + 26;
case charset::ualpha: return 10 + 26 + 26;
case charset::alpha: return 10 + 26 + 26;
case charset::alphanum: return 10 + 26 + 26;
default: assert(false); return 0;
}
}
static tensor_size_t osize(const charset cs)
{
return oend(cs) - obegin(cs);
}
template
<
typename tindex,
typename tsize
>
tensor3d_t get_object_patch(const image_tensor_t& image,
const tindex object_index, const tsize objects, const scalar_t max_offset)
{
nano::random_t<scalar_t> rng(-max_offset, max_offset);
const auto icols = static_cast<int>(image.cols());
const auto irows = static_cast<int>(image.rows());
const auto dx = static_cast<scalar_t>(icols) / static_cast<scalar_t>(objects);
const auto x = dx * static_cast<scalar_t>(object_index) + rng();
const auto ppx = nano::clamp(nano::cast<int>(x), 0, icols - 1);
const auto ppw = nano::clamp(nano::cast<int>(dx + rng()), 0, icols - ppx);
const auto ppy = nano::clamp(nano::cast<int>(rng()), 0, irows - 1);
const auto pph = nano::clamp(nano::cast<int>(static_cast<scalar_t>(irows) + rng()), 0, irows - ppy);
tensor3d_t ret(4, pph, ppw);
ret.matrix(0) = image.matrix(0).block(ppy, ppx, pph, ppw).cast<scalar_t>() / scalar_t(255);
ret.matrix(1) = image.matrix(1).block(ppy, ppx, pph, ppw).cast<scalar_t>() / scalar_t(255);
ret.matrix(2) = image.matrix(2).block(ppy, ppx, pph, ppw).cast<scalar_t>() / scalar_t(255);
ret.matrix(3) = image.matrix(3).block(ppy, ppx, pph, ppw).cast<scalar_t>() / scalar_t(255);
return ret;
}
tensor3d_t make_random_rgba_image(const tensor_size_t rows, const tensor_size_t cols,
const rgba_t back_color,
const scalar_t max_noise, const scalar_t sigma)
{
// noisy background
tensor3d_t image(4, rows, cols);
image.matrix(0).setConstant(back_color(0) / scalar_t(255));
image.matrix(1).setConstant(back_color(1) / scalar_t(255));
image.matrix(2).setConstant(back_color(2) / scalar_t(255));
image.matrix(3).setConstant(1);
tensor::add_random(nano::make_rng<scalar_t>(-max_noise, +max_noise),
image.matrix(0), image.matrix(1), image.matrix(2));
// smooth background
const nano::gauss_kernel_t<scalar_t> back_gauss(sigma);
nano::convolve(back_gauss, image.matrix(0));
nano::convolve(back_gauss, image.matrix(1));
nano::convolve(back_gauss, image.matrix(2));
return image;
}
tensor3d_t alpha_blend(const tensor3d_t& mask, const tensor3d_t& img1, const tensor3d_t& img2)
{
const auto op = [] (const auto a, const auto v1, const auto v2)
{
return (1 - a) * v1 + a * v2;
};
tensor3d_t imgb(4, mask.rows(), mask.cols());
tensor::transform(mask.matrix(3), img1.matrix(0), img2.matrix(0), imgb.matrix(0), op);
tensor::transform(mask.matrix(3), img1.matrix(1), img2.matrix(1), imgb.matrix(1), op);
tensor::transform(mask.matrix(3), img1.matrix(2), img2.matrix(2), imgb.matrix(2), op);
imgb.matrix(3).setConstant(1);
return imgb;
}
charset_task_t::charset_task_t(const string_t& configuration) : mem_vision_task_t(
"charset",
nano::from_params<color_mode>(configuration, "color", color_mode::rgb),
nano::clamp(nano::from_params<tensor_size_t>(configuration, "irows", 32), 12, 128),
nano::clamp(nano::from_params<tensor_size_t>(configuration, "icols", 32), 12, 128),
nano::osize(nano::from_params<charset>(configuration, "type", charset::digit)),
1),
m_charset(nano::from_params<charset>(configuration, "type", charset::digit)),
m_color(nano::from_params<color_mode>(configuration, "color", color_mode::rgb)),
m_count(nano::clamp(nano::from_params<size_t>(configuration, "count", 1000), 100, 1024 * 1024))
{
}
charset_task_t::charset_task_t(const charset type, const color_mode mode,
const tensor_size_t irows, const tensor_size_t icols, const size_t count) :
charset_task_t(to_params("color", mode, "irows", irows, "icols", icols, "type", type, "count", count))
{
}
bool charset_task_t::populate()
{
const string_t characters =
"0123456789" \
"abcdefghijklmnopqrstuvwxyz" \
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const size_t n_chars = characters.size();
std::vector<image_tensor_t> char_patches;
image_tensor_t char_patch;
#define INSERT_IMAGE(name) \
if (!nano::load_rgba_image(get_ ##name ##_name(), get_ ##name ##_data(), get_ ##name ##_size(), char_patch)) \
{ \
return false; \
} \
char_patches.push_back(char_patch);
INSERT_IMAGE(synth_bitstream_vera_sans_mono_bold)
INSERT_IMAGE(synth_bitstream_vera_sans_mono)
INSERT_IMAGE(synth_dejavu_sans_mono_bold)
INSERT_IMAGE(synth_dejavu_sans_mono)
INSERT_IMAGE(synth_droid_sans_mono)
INSERT_IMAGE(synth_liberation_mono_bold)
INSERT_IMAGE(synth_liberation_mono)
INSERT_IMAGE(synth_nimbus_mono_bold)
INSERT_IMAGE(synth_nimbus_mono)
INSERT_IMAGE(synth_oxygen_mono)
#undef INSERT_IMAGE
const size_t n_fonts = char_patches.size();
nano::random_t<tensor_size_t> rng_output(obegin(m_charset), oend(m_charset) - 1);
nano::random_t<size_t> rng_font(1, n_fonts);
nano::random_t<scalar_t> rng_gauss(0, 2);
// generate samples
for (size_t i = 0; i < m_count; ++ i)
{
// random target: character
const tensor_index_t o = rng_output();
// image: original object patch
const tensor3d_t opatch = get_object_patch(char_patches[rng_font() - 1], o, n_chars, 0.0);
// image: resize to the input size
tensor3d_t mpatch(4, irows(), icols());
nano::bilinear(opatch.matrix(0), mpatch.matrix(0));
nano::bilinear(opatch.matrix(1), mpatch.matrix(1));
nano::bilinear(opatch.matrix(2), mpatch.matrix(2));
nano::bilinear(opatch.matrix(3), mpatch.matrix(3));
// image: random warping
mpatch = nano::warp(mpatch,
warp_params_t(field_type::random, scalar_t(0.1), scalar_t(4.0), scalar_t(16.0), scalar_t(2.0)));
// image: background & foreground layer
const auto bcolor = make_random_rgba();
const auto fcolor = make_random_opposite_rgba(bcolor);
const auto bnoise = scalar_t(0.1);
const auto fnoise = scalar_t(0.1);
const auto bsigma = rng_gauss();
const auto fsigma = rng_gauss();
const auto bpatch = make_random_rgba_image(irows(), icols(), bcolor, bnoise, bsigma);
const auto fpatch = make_random_rgba_image(irows(), icols(), fcolor, fnoise, fsigma);
// image: alpha-blend the background & foreground layer
const tensor3d_t patch = alpha_blend(mpatch, bpatch, fpatch);
image_t image;
image.from_tensor(patch);
switch (m_color)
{
case color_mode::luma: image.make_luma(); break;
case color_mode::rgba: image.make_rgba(); break;
case color_mode::rgb: image.make_rgb(); break;
}
// generate image
add_chunk(image);
// generate sample
const auto fold = make_fold(0);
const auto target = class_target(o - nano::obegin(m_charset), nano::osize(m_charset));
const auto label = string_t("char") + characters[static_cast<size_t>(o)];
add_sample(fold, n_chunks() - 1, target, label);
}
return true;
}
}
<|endoftext|> |
<commit_before>#include "qtkapplicationparameters.h"
#include <QFile>
#include <QDebug>
#include <QDateTime>
#ifndef VEJAM_NO_GUI
#include <QMessageBox>
#endif
#include <QJsonObject>
#include <QJsonDocument>
#include <qcoreapplication.h>
QtKApplicationParameters::QtKApplicationParameters(QObject *parent, QString appName) :
QObject(parent)
{
this->m_appName = appName;
}
void QtKApplicationParameters::saveParam(QString groupName, QString paramName, QString paramValue, quint16 order)
{
QString pn;
QMap<QString, QVariant>::const_iterator i;
i = this->m_projectParameters.find(this->m_appName);
if(i == this->m_projectParameters.end())
//Creem la entrada per el projecte
{
this->m_projectParameters.insert(this->m_appName,this->m_appName);
}
pn.append(this->m_appName);
pn.append(".");
pn.append(groupName);
pn.append(".");
pn.append(paramName);
if(order)
{
pn.append(".");
pn.append(QString("%1").arg(order));
}
this->m_projectParameters.insert(pn,paramValue);
qDebug() << "saveParam(): " << this->m_projectParameters;
}
QString QtKApplicationParameters::loadParam(QString groupName, QString paramName, quint16 order)
{
QString r;
QString pn;
QVariant d;
pn.append(this->m_appName);
pn.append(".");
pn.append(groupName);
pn.append(".");
pn.append(paramName);
if(order)
{
pn.append(".");
pn.append(QString("%1").arg(order));
}
d = this->m_projectParameters.value(pn,QVariant(QString("void")));
r = d.toString();
//qDebug() << "loadParam(): " << pn << d;
return r;
}
bool QtKApplicationParameters::fileLoad(bool showAlerts)
{
QString fileName = this->m_appName;
fileName.append(AP_FILE_EXTENSION);
fileName.prepend(qApp->applicationDirPath()+"/");
QFile f(fileName);
QByteArray fd;
f.open(QIODevice::ReadOnly);
fd = f.readAll();
f.close();
QJsonDocument doc;
QJsonParseError err;
QJsonObject obj;
doc = QJsonDocument::fromJson(fd,&err);
if(err.error != QJsonParseError::NoError)
{
if(showAlerts)
{
#ifdef VEJAM_NO_GUI
qDebug() << "Error en el archivo de configuración: " << err.errorString().toLatin1().data() << "posición: " << err.offset;
#else
QMessageBox msgBox;
QString msg;
msg.sprintf("Error en el archivo de configuración:\n\r[%s] - posición %d",err.errorString().toLatin1().data(),err.offset);
msgBox.setText(msg);
msgBox.exec();
#endif
}
emit applicationParametersError();
return 1;
}
obj = doc.object();
this->m_projectParameters.clear();
this->m_projectParameters = obj.toVariantMap();
#ifdef AP_DEBUG_TRACES_ON
qDebug() << "fileLoad(): " << this->m_projectParameters;
#endif
if(this->m_projectParameters.contains(this->m_appName))
{
emit applicationParametersLoaded();
}
#ifdef AP_DEBUG_TRACES_ON
qDebug() << "fileLoad(END)";
#endif
return 0; //Tot ok.
}
bool QtKApplicationParameters::fileSave()
{
QDateTime time = QDateTime::currentDateTime();
QString fileName = this->m_appName;
fileName.append(AP_FILE_EXTENSION);
fileName.prepend(qApp->applicationDirPath()+"/");
saveParam(QString("Common"), QString("LastSave"),time.toString("dd.MM.yyyy - hh:mm:ss.zzz"), 0);
QJsonDocument doc;
QJsonObject obj;
obj = QJsonObject::fromVariantMap(this->m_projectParameters);
qDebug() << "fileSave(): " << obj;
doc.setObject(obj);
QFile f(fileName);
f.open(QIODevice::WriteOnly);
f.write(doc.toJson());
f.close();
qDebug() << "fileSave(END)";
return 0;
}
<commit_msg>Vejam QML adaptation<commit_after>#include "qtkapplicationparameters.h"
#include <QFile>
#include <QDebug>
#include <QDateTime>
#include <QJsonObject>
#include <QJsonDocument>
#include <qcoreapplication.h>
QtKApplicationParameters::QtKApplicationParameters(QObject *parent, QString appName) :
QObject(parent)
{
this->m_appName = appName;
}
void QtKApplicationParameters::saveParam(QString groupName, QString paramName, QString paramValue, quint16 order)
{
QString pn;
QMap<QString, QVariant>::const_iterator i;
i = this->m_projectParameters.find(this->m_appName);
if(i == this->m_projectParameters.end())
//Creem la entrada per el projecte
{
this->m_projectParameters.insert(this->m_appName,this->m_appName);
}
pn.append(this->m_appName);
pn.append(".");
pn.append(groupName);
pn.append(".");
pn.append(paramName);
if(order)
{
pn.append(".");
pn.append(QString("%1").arg(order));
}
this->m_projectParameters.insert(pn,paramValue);
qDebug() << "saveParam() " << paramName << ":" << paramValue;
}
QString QtKApplicationParameters::loadParam(QString groupName, QString paramName, quint16 order)
{
QString r;
QString pn;
QVariant d;
pn.append(this->m_appName);
pn.append(".");
pn.append(groupName);
pn.append(".");
pn.append(paramName);
if(order)
{
pn.append(".");
pn.append(QString("%1").arg(order));
}
d = this->m_projectParameters.value(pn,QVariant(QString("void")));
r = d.toString();
qDebug() << "loadParam() " << paramName << ":" << r;
return r;
}
bool QtKApplicationParameters::fileLoad(bool showAlerts)
{
QString fileName = this->m_appName;
fileName.append(AP_FILE_EXTENSION);
#ifndef ANDROID_PLATFORM
fileName.prepend(qApp->applicationDirPath()+"/");
#endif
QFile f(fileName);
QByteArray fd;
f.open(QIODevice::ReadOnly);
if(f.error())
{
qDebug() << "fileLoad() Error: " << f.error() << ", " << f.errorString();
}
fd = f.readAll();
f.close();
QJsonDocument doc;
QJsonParseError err;
QJsonObject obj;
doc = QJsonDocument::fromJson(fd,&err);
if(err.error != QJsonParseError::NoError)
{
if(showAlerts)
{
qDebug() << "Error en el archivo de configuración: " << err.errorString().toLatin1().data() << "posición: " << err.offset;
}
emit applicationParametersError();
return 1;
}
obj = doc.object();
this->m_projectParameters.clear();
this->m_projectParameters = obj.toVariantMap();
#ifdef AP_DEBUG_TRACES_ON
qDebug() << "fileLoad(): " << this->m_projectParameters;
#endif
if(this->m_projectParameters.contains(this->m_appName))
{
emit applicationParametersLoaded();
}
#ifdef AP_DEBUG_TRACES_ON
qDebug() << "fileLoad(END)";
#endif
return 0; //Tot ok.
}
bool QtKApplicationParameters::fileSave()
{
QDateTime time = QDateTime::currentDateTime();
QString fileName = this->m_appName;
fileName.append(AP_FILE_EXTENSION);
#ifndef ANDROID_PLATFORM
fileName.prepend(qApp->applicationDirPath()+"/");
#endif
saveParam(QString("Common"), QString("LastSave"),time.toString("dd.MM.yyyy - hh:mm:ss.zzz"), 0);
QJsonDocument doc;
QJsonObject obj;
obj = QJsonObject::fromVariantMap(this->m_projectParameters);
//qDebug() << "fileSave(): " << obj;
doc.setObject(obj);
QFile f(fileName);
f.open(QIODevice::WriteOnly);
if(f.error())
{
qDebug() << "fileSave() Error: " << f.error() << ", " << f.errorString();
}
f.write(doc.toJson());
f.close();
qDebug() << "fileSave(END)";
return 0;
}
<|endoftext|> |
<commit_before>/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
#include <quic/logging/FileQLogger.h>
#include <fstream>
#include <folly/json.h>
namespace quic {
void FileQLogger::addPacket(
const RegularQuicPacket& regularPacket,
uint64_t packetSize) {
logs.push_back(createPacketEvent(regularPacket, packetSize));
}
void FileQLogger::addPacket(
const RegularQuicWritePacket& writePacket,
uint64_t packetSize) {
logs.push_back(createPacketEvent(writePacket, packetSize));
}
void FileQLogger::addPacket(
const VersionNegotiationPacket& versionPacket,
uint64_t packetSize,
bool isPacketRecvd) {
logs.push_back(createPacketEvent(versionPacket, packetSize, isPacketRecvd));
}
void FileQLogger::addConnectionClose(
std::string error,
std::string reason,
bool drainConnection,
bool sendCloseImmediately) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogConnectionCloseEvent>(
std::move(error),
std::move(reason),
drainConnection,
sendCloseImmediately,
refTime));
}
void FileQLogger::addTransportSummary(
uint64_t totalBytesSent,
uint64_t totalBytesRecvd,
uint64_t sumCurWriteOffset,
uint64_t sumMaxObservedOffset,
uint64_t sumCurStreamBufferLen,
uint64_t totalBytesRetransmitted,
uint64_t totalStreamBytesCloned,
uint64_t totalBytesCloned,
uint64_t totalCryptoDataWritten,
uint64_t totalCryptoDataRecvd) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogTransportSummaryEvent>(
totalBytesSent,
totalBytesRecvd,
sumCurWriteOffset,
sumMaxObservedOffset,
sumCurStreamBufferLen,
totalBytesRetransmitted,
totalStreamBytesCloned,
totalBytesCloned,
totalCryptoDataWritten,
totalCryptoDataRecvd,
refTime));
}
void FileQLogger::addCongestionMetricUpdate(
uint64_t bytesInFlight,
uint64_t currentCwnd,
std::string congestionEvent,
std::string state,
std::string recoveryState) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogCongestionMetricUpdateEvent>(
bytesInFlight,
currentCwnd,
std::move(congestionEvent),
std::move(state),
std::move(recoveryState),
refTime));
}
void FileQLogger::addBandwidthEstUpdate(
uint64_t bytes,
std::chrono::microseconds interval) {
logs.push_back(std::make_unique<quic::QLogBandwidthEstUpdateEvent>(
bytes,
interval,
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint)));
}
void FileQLogger::addAppLimitedUpdate() {
logs.push_back(std::make_unique<quic::QLogAppLimitedUpdateEvent>(
true,
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint)));
}
void FileQLogger::addAppUnlimitedUpdate() {
logs.push_back(std::make_unique<quic::QLogAppLimitedUpdateEvent>(
false,
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint)));
}
void FileQLogger::addPacingMetricUpdate(
uint64_t pacingBurstSizeIn,
std::chrono::microseconds pacingIntervalIn) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacingMetricUpdateEvent>(
pacingBurstSizeIn, pacingIntervalIn, refTime));
}
void FileQLogger::addPacingObservation(
std::string actual,
std::string expect,
std::string conclusion) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacingObservationEvent>(
std::move(actual), std::move(expect), std::move(conclusion), refTime));
}
void FileQLogger::addAppIdleUpdate(std::string idleEvent, bool idle) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogAppIdleUpdateEvent>(
std::move(idleEvent), idle, refTime));
}
void FileQLogger::addPacketDrop(size_t packetSize, std::string dropReason) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketDropEvent>(
packetSize, std::move(dropReason), refTime));
}
void FileQLogger::addDatagramReceived(uint64_t dataLen) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(
std::make_unique<quic::QLogDatagramReceivedEvent>(dataLen, refTime));
}
void FileQLogger::addLossAlarm(
PacketNum largestSent,
uint64_t alarmCount,
uint64_t outstandingPackets,
std::string type) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogLossAlarmEvent>(
largestSent, alarmCount, outstandingPackets, std::move(type), refTime));
}
void FileQLogger::addPacketsLost(
PacketNum largestLostPacketNum,
uint64_t lostBytes,
uint64_t lostPackets) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketsLostEvent>(
largestLostPacketNum, lostBytes, lostPackets, refTime));
}
void FileQLogger::addTransportStateUpdate(std::string update) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogTransportStateUpdateEvent>(
std::move(update), refTime));
}
void FileQLogger::addPacketBuffered(
PacketNum packetNum,
ProtectionType protectionType,
uint64_t packetSize) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketBufferedEvent>(
packetNum, protectionType, packetSize, refTime));
}
void FileQLogger::addPacketAck(
PacketNumberSpace packetNumSpace,
PacketNum packetNum) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketAckEvent>(
packetNumSpace, packetNum, refTime));
}
void FileQLogger::addMetricUpdate(
std::chrono::microseconds latestRtt,
std::chrono::microseconds mrtt,
std::chrono::microseconds srtt,
std::chrono::microseconds ackDelay) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogMetricUpdateEvent>(
latestRtt, mrtt, srtt, ackDelay, refTime));
}
folly::dynamic FileQLogger::toDynamic() const {
folly::dynamic dynamicObj = folly::dynamic::object;
dynamicObj[kQLogVersionField] = kQLogVersion;
dynamicObj[kQLogTitleField] = kQLogTitle;
dynamicObj[kQLogDescriptionField] = kQLogDescription;
folly::dynamic summaryObj = folly::dynamic::object;
summaryObj[kQLogTraceCountField] =
1; // hardcoded, we only support 1 trace right now
// max duration is calculated like this:
// if there is <= 1 event, max_duration is 0
// otherwise, it is the (time of the last event - time of the first event)
summaryObj["max_duration"] = (logs.size() == 0)
? 0
: (logs.back()->refTime - logs[0]->refTime).count();
summaryObj["max_outgoing_loss_rate"] = "";
summaryObj["total_event_count"] = logs.size();
dynamicObj["summary"] = summaryObj;
dynamicObj["traces"] = folly::dynamic::array();
folly::dynamic dynamicTrace = folly::dynamic::object;
dynamicTrace["vantage_point"] =
folly::dynamic::object("type", vantagePointString(vantagePoint))(
"name", vantagePointString(vantagePoint));
dynamicTrace["title"] = kQLogTraceTitle;
dynamicTrace["description"] = kQLogTraceDescription;
dynamicTrace["configuration"] =
folly::dynamic::object("time_offset", 0)("time_units", kQLogTimeUnits);
std::string dcidStr = dcid.hasValue() ? dcid.value().hex() : "";
std::string scidStr = scid.hasValue() ? scid.value().hex() : "";
folly::dynamic commonFieldsObj = folly::dynamic::object;
commonFieldsObj["reference_time"] = "0";
commonFieldsObj["dcid"] = dcidStr;
commonFieldsObj["scid"] = scidStr;
commonFieldsObj["protocol_type"] = protocolType;
dynamicTrace["common_fields"] = std::move(commonFieldsObj);
// convert stored logs into folly::Dynamic event array
auto events = folly::dynamic::array();
for (auto& event : logs) {
events.push_back(event->toDynamic());
}
dynamicTrace["events"] = events;
dynamicTrace["event_fields"] = folly::dynamic::array(
"relative_time", "CATEGORY", "EVENT_TYPE", "TRIGGER", "DATA");
dynamicObj["traces"].push_back(dynamicTrace);
return dynamicObj;
}
void FileQLogger::addStreamStateUpdate(
quic::StreamId id,
std::string update,
folly::Optional<std::chrono::milliseconds> timeSinceStreamCreation) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogStreamStateUpdateEvent>(
id,
std::move(update),
std::move(timeSinceStreamCreation),
vantagePoint,
refTime));
}
void FileQLogger::outputLogsToFile(const std::string& path, bool prettyJson) {
if (!dcid.hasValue()) {
LOG(ERROR) << "Error: No dcid found";
return;
}
std::string outputPath =
folly::to<std::string>(path, "/", (dcid.value()).hex(), ".qlog");
std::ofstream fileObj(outputPath);
if (fileObj) {
LOG(INFO) << "Logging QLogger JSON to file: " << outputPath;
auto qLog = prettyJson ? folly::toPrettyJson(toDynamic())
: folly::toJson(toDynamic());
fileObj << qLog;
} else {
LOG(ERROR) << "Error: Can't write to provided path: " << path;
}
fileObj.close();
}
} // namespace quic
<commit_msg>Remove excessive FileQLogger logging message<commit_after>/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
#include <quic/logging/FileQLogger.h>
#include <fstream>
#include <folly/json.h>
namespace quic {
void FileQLogger::addPacket(
const RegularQuicPacket& regularPacket,
uint64_t packetSize) {
logs.push_back(createPacketEvent(regularPacket, packetSize));
}
void FileQLogger::addPacket(
const RegularQuicWritePacket& writePacket,
uint64_t packetSize) {
logs.push_back(createPacketEvent(writePacket, packetSize));
}
void FileQLogger::addPacket(
const VersionNegotiationPacket& versionPacket,
uint64_t packetSize,
bool isPacketRecvd) {
logs.push_back(createPacketEvent(versionPacket, packetSize, isPacketRecvd));
}
void FileQLogger::addConnectionClose(
std::string error,
std::string reason,
bool drainConnection,
bool sendCloseImmediately) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogConnectionCloseEvent>(
std::move(error),
std::move(reason),
drainConnection,
sendCloseImmediately,
refTime));
}
void FileQLogger::addTransportSummary(
uint64_t totalBytesSent,
uint64_t totalBytesRecvd,
uint64_t sumCurWriteOffset,
uint64_t sumMaxObservedOffset,
uint64_t sumCurStreamBufferLen,
uint64_t totalBytesRetransmitted,
uint64_t totalStreamBytesCloned,
uint64_t totalBytesCloned,
uint64_t totalCryptoDataWritten,
uint64_t totalCryptoDataRecvd) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogTransportSummaryEvent>(
totalBytesSent,
totalBytesRecvd,
sumCurWriteOffset,
sumMaxObservedOffset,
sumCurStreamBufferLen,
totalBytesRetransmitted,
totalStreamBytesCloned,
totalBytesCloned,
totalCryptoDataWritten,
totalCryptoDataRecvd,
refTime));
}
void FileQLogger::addCongestionMetricUpdate(
uint64_t bytesInFlight,
uint64_t currentCwnd,
std::string congestionEvent,
std::string state,
std::string recoveryState) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogCongestionMetricUpdateEvent>(
bytesInFlight,
currentCwnd,
std::move(congestionEvent),
std::move(state),
std::move(recoveryState),
refTime));
}
void FileQLogger::addBandwidthEstUpdate(
uint64_t bytes,
std::chrono::microseconds interval) {
logs.push_back(std::make_unique<quic::QLogBandwidthEstUpdateEvent>(
bytes,
interval,
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint)));
}
void FileQLogger::addAppLimitedUpdate() {
logs.push_back(std::make_unique<quic::QLogAppLimitedUpdateEvent>(
true,
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint)));
}
void FileQLogger::addAppUnlimitedUpdate() {
logs.push_back(std::make_unique<quic::QLogAppLimitedUpdateEvent>(
false,
std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint)));
}
void FileQLogger::addPacingMetricUpdate(
uint64_t pacingBurstSizeIn,
std::chrono::microseconds pacingIntervalIn) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacingMetricUpdateEvent>(
pacingBurstSizeIn, pacingIntervalIn, refTime));
}
void FileQLogger::addPacingObservation(
std::string actual,
std::string expect,
std::string conclusion) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacingObservationEvent>(
std::move(actual), std::move(expect), std::move(conclusion), refTime));
}
void FileQLogger::addAppIdleUpdate(std::string idleEvent, bool idle) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogAppIdleUpdateEvent>(
std::move(idleEvent), idle, refTime));
}
void FileQLogger::addPacketDrop(size_t packetSize, std::string dropReason) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketDropEvent>(
packetSize, std::move(dropReason), refTime));
}
void FileQLogger::addDatagramReceived(uint64_t dataLen) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(
std::make_unique<quic::QLogDatagramReceivedEvent>(dataLen, refTime));
}
void FileQLogger::addLossAlarm(
PacketNum largestSent,
uint64_t alarmCount,
uint64_t outstandingPackets,
std::string type) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogLossAlarmEvent>(
largestSent, alarmCount, outstandingPackets, std::move(type), refTime));
}
void FileQLogger::addPacketsLost(
PacketNum largestLostPacketNum,
uint64_t lostBytes,
uint64_t lostPackets) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketsLostEvent>(
largestLostPacketNum, lostBytes, lostPackets, refTime));
}
void FileQLogger::addTransportStateUpdate(std::string update) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogTransportStateUpdateEvent>(
std::move(update), refTime));
}
void FileQLogger::addPacketBuffered(
PacketNum packetNum,
ProtectionType protectionType,
uint64_t packetSize) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketBufferedEvent>(
packetNum, protectionType, packetSize, refTime));
}
void FileQLogger::addPacketAck(
PacketNumberSpace packetNumSpace,
PacketNum packetNum) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogPacketAckEvent>(
packetNumSpace, packetNum, refTime));
}
void FileQLogger::addMetricUpdate(
std::chrono::microseconds latestRtt,
std::chrono::microseconds mrtt,
std::chrono::microseconds srtt,
std::chrono::microseconds ackDelay) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogMetricUpdateEvent>(
latestRtt, mrtt, srtt, ackDelay, refTime));
}
folly::dynamic FileQLogger::toDynamic() const {
folly::dynamic dynamicObj = folly::dynamic::object;
dynamicObj[kQLogVersionField] = kQLogVersion;
dynamicObj[kQLogTitleField] = kQLogTitle;
dynamicObj[kQLogDescriptionField] = kQLogDescription;
folly::dynamic summaryObj = folly::dynamic::object;
summaryObj[kQLogTraceCountField] =
1; // hardcoded, we only support 1 trace right now
// max duration is calculated like this:
// if there is <= 1 event, max_duration is 0
// otherwise, it is the (time of the last event - time of the first event)
summaryObj["max_duration"] = (logs.size() == 0)
? 0
: (logs.back()->refTime - logs[0]->refTime).count();
summaryObj["max_outgoing_loss_rate"] = "";
summaryObj["total_event_count"] = logs.size();
dynamicObj["summary"] = summaryObj;
dynamicObj["traces"] = folly::dynamic::array();
folly::dynamic dynamicTrace = folly::dynamic::object;
dynamicTrace["vantage_point"] =
folly::dynamic::object("type", vantagePointString(vantagePoint))(
"name", vantagePointString(vantagePoint));
dynamicTrace["title"] = kQLogTraceTitle;
dynamicTrace["description"] = kQLogTraceDescription;
dynamicTrace["configuration"] =
folly::dynamic::object("time_offset", 0)("time_units", kQLogTimeUnits);
std::string dcidStr = dcid.hasValue() ? dcid.value().hex() : "";
std::string scidStr = scid.hasValue() ? scid.value().hex() : "";
folly::dynamic commonFieldsObj = folly::dynamic::object;
commonFieldsObj["reference_time"] = "0";
commonFieldsObj["dcid"] = dcidStr;
commonFieldsObj["scid"] = scidStr;
commonFieldsObj["protocol_type"] = protocolType;
dynamicTrace["common_fields"] = std::move(commonFieldsObj);
// convert stored logs into folly::Dynamic event array
auto events = folly::dynamic::array();
for (auto& event : logs) {
events.push_back(event->toDynamic());
}
dynamicTrace["events"] = events;
dynamicTrace["event_fields"] = folly::dynamic::array(
"relative_time", "CATEGORY", "EVENT_TYPE", "TRIGGER", "DATA");
dynamicObj["traces"].push_back(dynamicTrace);
return dynamicObj;
}
void FileQLogger::addStreamStateUpdate(
quic::StreamId id,
std::string update,
folly::Optional<std::chrono::milliseconds> timeSinceStreamCreation) {
auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - refTimePoint);
logs.push_back(std::make_unique<quic::QLogStreamStateUpdateEvent>(
id,
std::move(update),
std::move(timeSinceStreamCreation),
vantagePoint,
refTime));
}
void FileQLogger::outputLogsToFile(const std::string& path, bool prettyJson) {
if (!dcid.hasValue()) {
LOG(ERROR) << "Error: No dcid found";
return;
}
std::string outputPath =
folly::to<std::string>(path, "/", (dcid.value()).hex(), ".qlog");
std::ofstream fileObj(outputPath);
if (fileObj) {
auto qLog = prettyJson ? folly::toPrettyJson(toDynamic())
: folly::toJson(toDynamic());
fileObj << qLog;
} else {
LOG(ERROR) << "Error: Can't write to provided path: " << path;
}
fileObj.close();
}
} // namespace quic
<|endoftext|> |
<commit_before>/*
* This file is part of signon
*
* Copyright (C) 2009-2010 Nokia Corporation.
*
* Contact: Aurel Popirtac <[email protected]>
* Contact: Alberto Mardegan <[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.
*
* 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 "dbusoperationqueuehandler.h"
#include <QMetaMethod>
#include <QDebug>
#include <QMetaType>
#include "signoncommon.h"
#include "identityinfo.h"
namespace SignOn {
/* --------------- DBusOperationQueueHandler::Operation ---------------- */
DBusOperationQueueHandler::Operation::Operation(const char *name,
QList<QGenericArgument *> args)
{
copy(name, args);
qDeleteAll(args);
}
void DBusOperationQueueHandler::Operation::copy(const char *name,
const QList<QGenericArgument *> &args)
{
Q_ASSERT(name != NULL);
m_name = new char[qstrlen(name) + 1];
qstrcpy(m_name, name);
QListIterator<QGenericArgument *> it(args);
while (it.hasNext()) {
QGenericArgument *arg = it.next();
int type = QMetaType::type(arg->name());
if (!QMetaType::isRegistered(type)) {
qCritical()
<< Q_FUNC_INFO
<< QString(QLatin1String("Type %1 not registered."))
.arg(QLatin1String(arg->name()));
} else {
Q_ASSERT(arg->name() != NULL);
char *localName = new char[qstrlen(arg->name()) + 1];
qstrcpy(localName, arg->name());
void *localData = QMetaType::construct(type, arg->data());
m_args << (new QGenericArgument(localName, localData));
}
}
}
DBusOperationQueueHandler::Operation::~Operation()
{
if (m_name)
delete [] m_name;
foreach (QGenericArgument *arg, m_args) {
QMetaType::destroy(QMetaType::type(arg->name()), arg->data());
if (arg->name())
delete [] arg->name();
}
}
/* --------------------- DBusOperationQueueHandler --------------------- */
DBusOperationQueueHandler::DBusOperationQueueHandler(QObject *clientObject)
: m_clientObject(clientObject),
m_maxNumberOfOperationParameters(6)
{
}
DBusOperationQueueHandler::~DBusOperationQueueHandler()
{
}
void DBusOperationQueueHandler::enqueueOperation(Operation *operation)
{
m_operationsQueue.enqueue(operation);
}
void DBusOperationQueueHandler::enqueueOperation(const char *name,
QList<QGenericArgument *> args)
{
m_operationsQueue.enqueue(new Operation(name, args));
}
void DBusOperationQueueHandler::execQueuedOperations()
{
while (!m_operationsQueue.empty()) {
Operation *op = m_operationsQueue.dequeue();
if (op->m_args.size() > m_maxNumberOfOperationParameters) {
qWarning() << "DBusOperationQueueHandler::execQueuedOperations(): "
"Maximum number of operation parameters exceeded(6).";
continue;
}
int indexOfMethod = m_clientObject->metaObject()->indexOfMethod(
QMetaObject::normalizedSignature(op->m_name));
QMetaMethod method = m_clientObject->metaObject()->method(indexOfMethod);
TRACE() << "Executing cached oparation: SIGNATURE:" << method.signature();
switch (op->m_args.count()) {
case 0: TRACE(); method.invoke(m_clientObject); break;
case 1: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0))); break;
case 2: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1))); break;
case 3: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2))); break;
case 4: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2)),
*(op->m_args.at(3))); break;
case 5: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2)),
*(op->m_args.at(3)),
*(op->m_args.at(4))); break;
case 6: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2)),
*(op->m_args.at(3)),
*(op->m_args.at(4)),
*(op->m_args.at(5))); break;
default: TRACE(); method.invoke(m_clientObject); break;
}
delete op;
}
}
void DBusOperationQueueHandler::removeOperation(const char *name, bool removeAll)
{
Operation op(name);
foreach (Operation *operation, m_operationsQueue) {
if (*operation == op) {
m_operationsQueue.removeOne(operation);
if (!removeAll)
break;
}
}
}
bool DBusOperationQueueHandler::queueContainsOperation(const char *name)
{
Operation op(name);
foreach (Operation *operation, m_operationsQueue)
if (*operation == op)
return true;
return false;
}
} //SignOn
<commit_msg>Memory leak<commit_after>/*
* This file is part of signon
*
* Copyright (C) 2009-2010 Nokia Corporation.
*
* Contact: Aurel Popirtac <[email protected]>
* Contact: Alberto Mardegan <[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.
*
* 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 "dbusoperationqueuehandler.h"
#include <QMetaMethod>
#include <QDebug>
#include <QMetaType>
#include "signoncommon.h"
#include "identityinfo.h"
namespace SignOn {
/* --------------- DBusOperationQueueHandler::Operation ---------------- */
DBusOperationQueueHandler::Operation::Operation(const char *name,
QList<QGenericArgument *> args)
{
copy(name, args);
qDeleteAll(args);
}
void DBusOperationQueueHandler::Operation::copy(const char *name,
const QList<QGenericArgument *> &args)
{
Q_ASSERT(name != NULL);
m_name = new char[qstrlen(name) + 1];
qstrcpy(m_name, name);
QListIterator<QGenericArgument *> it(args);
while (it.hasNext()) {
QGenericArgument *arg = it.next();
int type = QMetaType::type(arg->name());
if (!QMetaType::isRegistered(type)) {
qCritical()
<< Q_FUNC_INFO
<< QString(QLatin1String("Type %1 not registered."))
.arg(QLatin1String(arg->name()));
} else {
Q_ASSERT(arg->name() != NULL);
char *localName = new char[qstrlen(arg->name()) + 1];
qstrcpy(localName, arg->name());
void *localData = QMetaType::construct(type, arg->data());
m_args << (new QGenericArgument(localName, localData));
}
}
}
DBusOperationQueueHandler::Operation::~Operation()
{
if (m_name)
delete [] m_name;
foreach (QGenericArgument *arg, m_args) {
QMetaType::destroy(QMetaType::type(arg->name()), arg->data());
if (arg->name())
delete [] arg->name();
delete arg;
}
}
/* --------------------- DBusOperationQueueHandler --------------------- */
DBusOperationQueueHandler::DBusOperationQueueHandler(QObject *clientObject)
: m_clientObject(clientObject),
m_maxNumberOfOperationParameters(6)
{
}
DBusOperationQueueHandler::~DBusOperationQueueHandler()
{
}
void DBusOperationQueueHandler::enqueueOperation(Operation *operation)
{
m_operationsQueue.enqueue(operation);
}
void DBusOperationQueueHandler::enqueueOperation(const char *name,
QList<QGenericArgument *> args)
{
m_operationsQueue.enqueue(new Operation(name, args));
}
void DBusOperationQueueHandler::execQueuedOperations()
{
while (!m_operationsQueue.empty()) {
Operation *op = m_operationsQueue.dequeue();
if (op->m_args.size() > m_maxNumberOfOperationParameters) {
qWarning() << "DBusOperationQueueHandler::execQueuedOperations(): "
"Maximum number of operation parameters exceeded(6).";
continue;
}
int indexOfMethod = m_clientObject->metaObject()->indexOfMethod(
QMetaObject::normalizedSignature(op->m_name));
QMetaMethod method = m_clientObject->metaObject()->method(indexOfMethod);
TRACE() << "Executing cached oparation: SIGNATURE:" << method.signature();
switch (op->m_args.count()) {
case 0: TRACE(); method.invoke(m_clientObject); break;
case 1: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0))); break;
case 2: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1))); break;
case 3: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2))); break;
case 4: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2)),
*(op->m_args.at(3))); break;
case 5: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2)),
*(op->m_args.at(3)),
*(op->m_args.at(4))); break;
case 6: TRACE(); method.invoke(
m_clientObject,
*(op->m_args.at(0)),
*(op->m_args.at(1)),
*(op->m_args.at(2)),
*(op->m_args.at(3)),
*(op->m_args.at(4)),
*(op->m_args.at(5))); break;
default: TRACE(); method.invoke(m_clientObject); break;
}
delete op;
}
}
void DBusOperationQueueHandler::removeOperation(const char *name, bool removeAll)
{
Operation op(name);
foreach (Operation *operation, m_operationsQueue) {
if (*operation == op) {
m_operationsQueue.removeOne(operation);
if (!removeAll)
break;
}
}
}
bool DBusOperationQueueHandler::queueContainsOperation(const char *name)
{
Operation op(name);
foreach (Operation *operation, m_operationsQueue)
if (*operation == op)
return true;
return false;
}
} //SignOn
<|endoftext|> |
<commit_before>#include "cpu.h"
#include "../bitwise.h"
#include "../util/log.h"
#include <cstdlib>
[[noreturn]] inline void unimplemented_opcode() {
log_error("Unimplemented opcode");
std::exit(1);
}
/* ADC */
inline void CPU::_opcode_adc(u8 value) {
u8 reg = a.value();
u8 carry = flag_carry_value();
u16 result16 = reg + value + carry;
set_flag_zero(reg == 0);
set_flag_subtract(false);
set_flag_half_carry(((reg ^ value ^ result16) & 0x10) != 0);
set_flag_carry((result16 & 0x100) != 0);
u8 result = static_cast<u8>(result16);
a.set(result);
}
void CPU::opcode_adc() {
_opcode_adc(get_byte_from_pc());
}
void CPU::opcode_adc(const ByteRegister& reg) {
_opcode_adc(reg.value());
}
void CPU::opcode_adc(const Address&& addr) {
_opcode_adc(mmu.read(addr));
}
/* ADD */
inline void CPU::_opcode_add(u8 reg, u8 value) {
u16 result16 = reg + value;
set_flag_zero(a.value() == 0);
set_flag_subtract(false);
set_flag_half_carry(((reg ^ value ^ result16) & 0x10) != 0);
set_flag_carry((result16 & 0x100) != 0);
u8 result = static_cast<u8>(result16);
a.set(result);
}
void CPU::opcode_add_a() {
_opcode_add(a.value(), get_byte_from_pc());
}
void CPU::opcode_add_a(const ByteRegister& reg) {
_opcode_add(a.value(), reg.value());
}
void CPU::opcode_add_a(const Address& addr) {
_opcode_add(a.value(), mmu.read(addr));
}
void CPU::opcode_add_hl(const RegisterPair& reg_pair) {
unimplemented_opcode();
}
void CPU::opcode_add_hl(const WordRegister& word_reg) {
unimplemented_opcode();
}
void CPU::opcode_add_sp() {
unimplemented_opcode();
}
void CPU::opcode_add_signed() {
unimplemented_opcode();
}
/* AND */
void CPU::opcode_and() {
unimplemented_opcode();
}
void CPU::opcode_and(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_and(Address&& addr) {
unimplemented_opcode();
}
/* BIT */
void CPU::_opcode_bit(const u8 bit, const u8 value) {
set_flag_zero(!check_bit(value, bit));
set_flag_subtract(false);
set_flag_half_carry(true);
}
void CPU::opcode_bit(const u8 bit, ByteRegister& reg) {
_opcode_bit(bit, reg.value());
}
void CPU::opcode_bit(const u8 bit, Address&& addr) {
_opcode_bit(bit, mmu.read(addr));
}
/* CALL */
void CPU::opcode_call() {
u16 address = get_word_from_pc();
stack_push(pc);
pc.set(address);
}
void CPU::opcode_call(Condition condition) {
if (is_condition(condition)) {
opcode_call();
}
}
/* CCF */
void CPU::opcode_ccf() {
unimplemented_opcode();
}
/* CP */
void CPU::opcode_cp() {
unimplemented_opcode();
}
void CPU::opcode_cp(const ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_cp(const Address& addr) {
unimplemented_opcode();
}
/* CPL */
void CPU::opcode_cpl() {
unimplemented_opcode();
}
/* DAA */
void CPU::opcode_daa() {
unimplemented_opcode();
}
/* DEC */
void CPU::opcode_dec(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_dec(RegisterPair& reg) {
unimplemented_opcode();
}
void CPU::opcode_dec(WordRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_dec(Address&& addr) {
unimplemented_opcode();
}
/* DI */
void CPU::opcode_di() {
// TODO: should this write a value into memory?
interrupts_enabled = false;
}
/* EI */
void CPU::opcode_ei() {
// TODO: should this write a value into memory?
interrupts_enabled = true;
}
/* INC */
void CPU::opcode_inc(ByteRegister& reg) {
reg.increment();
}
void CPU::opcode_inc(RegisterPair& reg) {
reg.increment();
}
void CPU::opcode_inc(WordRegister& addr) {
unimplemented_opcode();
}
void CPU::opcode_inc(Address&& addr) {
unimplemented_opcode();
}
/* JP */
void CPU::opcode_jp() {
unimplemented_opcode();
}
void CPU::opcode_jp(Condition condition) {
unimplemented_opcode();
}
void CPU::opcode_jp(const Address& addr) {
unimplemented_opcode();
}
/* JR */
void CPU::opcode_jr() {
s8 n = get_signed_byte_from_pc();
u16 old_pc = pc.value();
u16 new_pc = static_cast<u16>(old_pc + n);
pc.set(new_pc);
}
void CPU::opcode_jr(Condition condition) {
if (is_condition(condition)) {
opcode_jr();
}
}
/* HALT */
void CPU::opcode_halt() {
unimplemented_opcode();
}
/* LD */
void CPU::opcode_ld(ByteRegister& reg) {
u8 n = get_byte_from_pc();
reg.set(n);
}
void CPU::opcode_ld(ByteRegister& reg, const ByteRegister& byte_reg) {
reg.set(byte_reg.value());
}
void CPU::opcode_ld(ByteRegister& reg, const Address& address) {
reg.set(mmu.read(address));
}
void CPU::opcode_ld(RegisterPair& reg) {
u16 nn = get_word_from_pc();
reg.set(nn);
}
void CPU::opcode_ld(WordRegister& reg) {
u16 nn = get_word_from_pc();
reg.set(nn);
}
void CPU::opcode_ld(WordRegister& reg, const RegisterPair& reg_pair) {
unimplemented_opcode();
}
void CPU::opcode_ld(const Address& address) {
u8 n = get_byte_from_pc();
mmu.write(address, n);
}
void CPU::opcode_ld(const Address& address, const ByteRegister& byte_reg) {
mmu.write(address, byte_reg.value());
}
void CPU::opcode_ld(const Address& address, const WordRegister& word_reg) {
mmu.write_word(address, word_reg.value());
}
void CPU::opcode_ld_to_addr(const ByteRegister ®) {
unimplemented_opcode();
}
/* LDD */
void CPU::opcode_ldd(ByteRegister& reg, const Address& address) {
// TODO: clean up
// two ways of doing ldd
// address is always that of HL
reg.set(mmu.read(address));
hl.decrement();
}
void CPU::opcode_ldd(const Address& address, const ByteRegister& reg) {
mmu.write(address, reg.value());
hl.decrement();
}
/* LDH */
void CPU::opcode_ldh_into_a() {
unimplemented_opcode();
}
void CPU::opcode_ldh_into_data() {
u8 offset = get_byte_from_pc();
auto address = Address(0xFF00 + offset);
mmu.write(address, a.value());
}
void CPU::opcode_ldh_into_c() {
u8 offset = c.value();
auto address = Address(0xFF00 + offset);
mmu.write(address, a.value());
}
/* LDHL */
void CPU::opcode_ldhl() {
unimplemented_opcode();
}
/* LDI */
void CPU::opcode_ldi(const ByteRegister& reg, const Address& address) {
unimplemented_opcode();
}
void CPU::opcode_ldi(const Address& address, const ByteRegister& reg) {
unimplemented_opcode();
}
/* NOP */
void CPU::opcode_nop() {
unimplemented_opcode();
}
/* OR */
void CPU::opcode_or() {
unimplemented_opcode();
}
void CPU::opcode_or(const ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_or(const Address& addr) {
unimplemented_opcode();
}
/* POP */
void CPU::opcode_pop(const RegisterPair& reg) {
stack_pop(reg);
}
/* PUSH */
void CPU::opcode_push(const RegisterPair& reg) {
stack_push(reg);
}
/* RES */
void CPU::opcode_res(const int bit, ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_res(const int bit, Address&& addr) {
unimplemented_opcode();
}
/* RET */
void CPU::opcode_ret() {
unimplemented_opcode();
}
void CPU::opcode_ret(Condition condition) {
unimplemented_opcode();
}
/* RETI */
void CPU::opcode_reti() {
unimplemented_opcode();
}
/* RL */
void CPU::opcode_rl(ByteRegister& reg) {
u8 carry = flag_carry_value();
u8 value = reg.value();
// TODO: in other emulators, flags are only reset if carry flag is not set
reset_flags();
bool will_carry = check_bit(value, 7);
set_flag_carry(will_carry);
u8 result = static_cast<u8>(value << 1);
result |= carry;
set_flag_zero(result == 0);
reg.set(result);
}
void CPU::opcode_rl(Address&& addr) {
u8 old_carry = flag_carry_value();
u8 value = mmu.read(addr);
// TODO: in other emulators, flags are only reset if carry flag is not set
reset_flags();
bool will_carry = check_bit(value, 7);
set_flag_carry(will_carry);
u8 result = static_cast<u8>(value << 1);
result |= old_carry;
set_flag_zero(result == 0);
mmu.write(addr, result);
}
/* RLC */
void CPU::opcode_rlc(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_rlc(Address&& addr) {
unimplemented_opcode();
}
/* RR */
void CPU::opcode_rr(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_rr(Address&& addr) {
unimplemented_opcode();
}
/* RRC */
void CPU::opcode_rrc(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_rrc(Address&& addr) {
unimplemented_opcode();
}
/* RST */
// TODO: offset type
void CPU::opcode_rst(const u8 offset) {
unimplemented_opcode();
}
/* SBC */
void CPU::opcode_sbc() {
unimplemented_opcode();
}
void CPU::opcode_sbc(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sbc(Address&& addr) {
unimplemented_opcode();
}
/* SCF */
void CPU::opcode_scf() {
unimplemented_opcode();
}
/* SET */
void CPU::opcode_set(const int bit, ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_set(const int bit, Address&& addr) {
unimplemented_opcode();
}
/* SLA */
void CPU::opcode_sla(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sla(Address&& addr) {
unimplemented_opcode();
}
/* SRA */
void CPU::opcode_sra(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sra(Address&& addr) {
unimplemented_opcode();
}
/* SRL */
void CPU::opcode_srl(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_srl(Address&& addr) {
unimplemented_opcode();
}
/* STOP */
void CPU::opcode_stop() {
unimplemented_opcode();
}
/* SUB */
void CPU::opcode_sub() {
unimplemented_opcode();
}
void CPU::opcode_sub(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sub(Address&& addr) {
unimplemented_opcode();
}
/* SWAP */
void CPU::opcode_swap(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_swap(Address&& addr) {
unimplemented_opcode();
}
/* XOR */
void CPU::_opcode_xor(u8 value) {
u8 reg = a.value();
u8 result = reg ^ value;
set_flag_zero(reg == 0);
set_flag_subtract(false);
set_flag_half_carry(false);
set_flag_carry(false);
a.set(result);
}
void CPU::opcode_xor() {
_opcode_xor(get_byte_from_pc());
}
void CPU::opcode_xor(const ByteRegister& reg) {
_opcode_xor(reg.value());
}
void CPU::opcode_xor(const Address& addr) {
_opcode_xor(mmu.read(addr));
}
<commit_msg>Implement more INC, DEC<commit_after>#include "cpu.h"
#include "../bitwise.h"
#include "../util/log.h"
#include <cstdlib>
[[noreturn]] inline void unimplemented_opcode() {
log_error("Unimplemented opcode");
std::exit(1);
}
/* ADC */
inline void CPU::_opcode_adc(u8 value) {
u8 reg = a.value();
u8 carry = flag_carry_value();
u16 result16 = reg + value + carry;
set_flag_zero(reg == 0);
set_flag_subtract(false);
set_flag_half_carry(((reg ^ value ^ result16) & 0x10) != 0);
set_flag_carry((result16 & 0x100) != 0);
u8 result = static_cast<u8>(result16);
a.set(result);
}
void CPU::opcode_adc() {
_opcode_adc(get_byte_from_pc());
}
void CPU::opcode_adc(const ByteRegister& reg) {
_opcode_adc(reg.value());
}
void CPU::opcode_adc(const Address&& addr) {
_opcode_adc(mmu.read(addr));
}
/* ADD */
inline void CPU::_opcode_add(u8 reg, u8 value) {
u16 result16 = reg + value;
set_flag_zero(a.value() == 0);
set_flag_subtract(false);
set_flag_half_carry(((reg ^ value ^ result16) & 0x10) != 0);
set_flag_carry((result16 & 0x100) != 0);
u8 result = static_cast<u8>(result16);
a.set(result);
}
void CPU::opcode_add_a() {
_opcode_add(a.value(), get_byte_from_pc());
}
void CPU::opcode_add_a(const ByteRegister& reg) {
_opcode_add(a.value(), reg.value());
}
void CPU::opcode_add_a(const Address& addr) {
_opcode_add(a.value(), mmu.read(addr));
}
void CPU::opcode_add_hl(const RegisterPair& reg_pair) {
unimplemented_opcode();
}
void CPU::opcode_add_hl(const WordRegister& word_reg) {
unimplemented_opcode();
}
void CPU::opcode_add_sp() {
unimplemented_opcode();
}
void CPU::opcode_add_signed() {
unimplemented_opcode();
}
/* AND */
void CPU::opcode_and() {
unimplemented_opcode();
}
void CPU::opcode_and(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_and(Address&& addr) {
unimplemented_opcode();
}
/* BIT */
void CPU::_opcode_bit(const u8 bit, const u8 value) {
set_flag_zero(!check_bit(value, bit));
set_flag_subtract(false);
set_flag_half_carry(true);
}
void CPU::opcode_bit(const u8 bit, ByteRegister& reg) {
_opcode_bit(bit, reg.value());
}
void CPU::opcode_bit(const u8 bit, Address&& addr) {
_opcode_bit(bit, mmu.read(addr));
}
/* CALL */
void CPU::opcode_call() {
u16 address = get_word_from_pc();
stack_push(pc);
pc.set(address);
}
void CPU::opcode_call(Condition condition) {
if (is_condition(condition)) {
opcode_call();
}
}
/* CCF */
void CPU::opcode_ccf() {
unimplemented_opcode();
}
/* CP */
void CPU::opcode_cp() {
unimplemented_opcode();
}
void CPU::opcode_cp(const ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_cp(const Address& addr) {
unimplemented_opcode();
}
/* CPL */
void CPU::opcode_cpl() {
unimplemented_opcode();
}
/* DAA */
void CPU::opcode_daa() {
unimplemented_opcode();
}
/* DEC */
void CPU::opcode_dec(ByteRegister& reg) {
reg.decrement();
}
void CPU::opcode_dec(RegisterPair& reg) {
reg.decrement();
}
void CPU::opcode_dec(WordRegister& reg) {
reg.decrement();
}
void CPU::opcode_dec(Address&& addr) {
u8 value = mmu.read(addr);
u8 result = static_cast<u8>(value - 1);
mmu.write(addr, result);
}
/* DI */
void CPU::opcode_di() {
// TODO: should this write a value into memory?
interrupts_enabled = false;
}
/* EI */
void CPU::opcode_ei() {
// TODO: should this write a value into memory?
interrupts_enabled = true;
}
/* INC */
void CPU::opcode_inc(ByteRegister& reg) {
reg.increment();
}
void CPU::opcode_inc(RegisterPair& reg) {
reg.increment();
}
void CPU::opcode_inc(WordRegister& reg) {
reg.increment();
}
void CPU::opcode_inc(Address&& addr) {
u8 value = mmu.read(addr);
u8 result = static_cast<u8>(value + 1);
mmu.write(addr, result);
}
/* JP */
void CPU::opcode_jp() {
unimplemented_opcode();
}
void CPU::opcode_jp(Condition condition) {
unimplemented_opcode();
}
void CPU::opcode_jp(const Address& addr) {
unimplemented_opcode();
}
/* JR */
void CPU::opcode_jr() {
s8 n = get_signed_byte_from_pc();
u16 old_pc = pc.value();
u16 new_pc = static_cast<u16>(old_pc + n);
pc.set(new_pc);
}
void CPU::opcode_jr(Condition condition) {
if (is_condition(condition)) {
opcode_jr();
}
}
/* HALT */
void CPU::opcode_halt() {
unimplemented_opcode();
}
/* LD */
void CPU::opcode_ld(ByteRegister& reg) {
u8 n = get_byte_from_pc();
reg.set(n);
}
void CPU::opcode_ld(ByteRegister& reg, const ByteRegister& byte_reg) {
reg.set(byte_reg.value());
}
void CPU::opcode_ld(ByteRegister& reg, const Address& address) {
reg.set(mmu.read(address));
}
void CPU::opcode_ld(RegisterPair& reg) {
u16 nn = get_word_from_pc();
reg.set(nn);
}
void CPU::opcode_ld(WordRegister& reg) {
u16 nn = get_word_from_pc();
reg.set(nn);
}
void CPU::opcode_ld(WordRegister& reg, const RegisterPair& reg_pair) {
unimplemented_opcode();
}
void CPU::opcode_ld(const Address& address) {
u8 n = get_byte_from_pc();
mmu.write(address, n);
}
void CPU::opcode_ld(const Address& address, const ByteRegister& byte_reg) {
mmu.write(address, byte_reg.value());
}
void CPU::opcode_ld(const Address& address, const WordRegister& word_reg) {
mmu.write_word(address, word_reg.value());
}
void CPU::opcode_ld_to_addr(const ByteRegister ®) {
unimplemented_opcode();
}
/* LDD */
void CPU::opcode_ldd(ByteRegister& reg, const Address& address) {
// TODO: clean up
// two ways of doing ldd
// address is always that of HL
reg.set(mmu.read(address));
hl.decrement();
}
void CPU::opcode_ldd(const Address& address, const ByteRegister& reg) {
mmu.write(address, reg.value());
hl.decrement();
}
/* LDH */
void CPU::opcode_ldh_into_a() {
unimplemented_opcode();
}
void CPU::opcode_ldh_into_data() {
u8 offset = get_byte_from_pc();
auto address = Address(0xFF00 + offset);
mmu.write(address, a.value());
}
void CPU::opcode_ldh_into_c() {
u8 offset = c.value();
auto address = Address(0xFF00 + offset);
mmu.write(address, a.value());
}
/* LDHL */
void CPU::opcode_ldhl() {
unimplemented_opcode();
}
/* LDI */
void CPU::opcode_ldi(const ByteRegister& reg, const Address& address) {
unimplemented_opcode();
}
void CPU::opcode_ldi(const Address& address, const ByteRegister& reg) {
unimplemented_opcode();
}
/* NOP */
void CPU::opcode_nop() {
unimplemented_opcode();
}
/* OR */
void CPU::opcode_or() {
unimplemented_opcode();
}
void CPU::opcode_or(const ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_or(const Address& addr) {
unimplemented_opcode();
}
/* POP */
void CPU::opcode_pop(const RegisterPair& reg) {
stack_pop(reg);
}
/* PUSH */
void CPU::opcode_push(const RegisterPair& reg) {
stack_push(reg);
}
/* RES */
void CPU::opcode_res(const int bit, ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_res(const int bit, Address&& addr) {
unimplemented_opcode();
}
/* RET */
void CPU::opcode_ret() {
unimplemented_opcode();
}
void CPU::opcode_ret(Condition condition) {
unimplemented_opcode();
}
/* RETI */
void CPU::opcode_reti() {
unimplemented_opcode();
}
/* RL */
void CPU::opcode_rl(ByteRegister& reg) {
u8 carry = flag_carry_value();
u8 value = reg.value();
// TODO: in other emulators, flags are only reset if carry flag is not set
reset_flags();
bool will_carry = check_bit(value, 7);
set_flag_carry(will_carry);
u8 result = static_cast<u8>(value << 1);
result |= carry;
set_flag_zero(result == 0);
reg.set(result);
}
void CPU::opcode_rl(Address&& addr) {
u8 old_carry = flag_carry_value();
u8 value = mmu.read(addr);
// TODO: in other emulators, flags are only reset if carry flag is not set
reset_flags();
bool will_carry = check_bit(value, 7);
set_flag_carry(will_carry);
u8 result = static_cast<u8>(value << 1);
result |= old_carry;
set_flag_zero(result == 0);
mmu.write(addr, result);
}
/* RLC */
void CPU::opcode_rlc(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_rlc(Address&& addr) {
unimplemented_opcode();
}
/* RR */
void CPU::opcode_rr(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_rr(Address&& addr) {
unimplemented_opcode();
}
/* RRC */
void CPU::opcode_rrc(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_rrc(Address&& addr) {
unimplemented_opcode();
}
/* RST */
// TODO: offset type
void CPU::opcode_rst(const u8 offset) {
unimplemented_opcode();
}
/* SBC */
void CPU::opcode_sbc() {
unimplemented_opcode();
}
void CPU::opcode_sbc(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sbc(Address&& addr) {
unimplemented_opcode();
}
/* SCF */
void CPU::opcode_scf() {
unimplemented_opcode();
}
/* SET */
void CPU::opcode_set(const int bit, ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_set(const int bit, Address&& addr) {
unimplemented_opcode();
}
/* SLA */
void CPU::opcode_sla(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sla(Address&& addr) {
unimplemented_opcode();
}
/* SRA */
void CPU::opcode_sra(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sra(Address&& addr) {
unimplemented_opcode();
}
/* SRL */
void CPU::opcode_srl(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_srl(Address&& addr) {
unimplemented_opcode();
}
/* STOP */
void CPU::opcode_stop() {
unimplemented_opcode();
}
/* SUB */
void CPU::opcode_sub() {
unimplemented_opcode();
}
void CPU::opcode_sub(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_sub(Address&& addr) {
unimplemented_opcode();
}
/* SWAP */
void CPU::opcode_swap(ByteRegister& reg) {
unimplemented_opcode();
}
void CPU::opcode_swap(Address&& addr) {
unimplemented_opcode();
}
/* XOR */
void CPU::_opcode_xor(u8 value) {
u8 reg = a.value();
u8 result = reg ^ value;
set_flag_zero(reg == 0);
set_flag_subtract(false);
set_flag_half_carry(false);
set_flag_carry(false);
a.set(result);
}
void CPU::opcode_xor() {
_opcode_xor(get_byte_from_pc());
}
void CPU::opcode_xor(const ByteRegister& reg) {
_opcode_xor(reg.value());
}
void CPU::opcode_xor(const Address& addr) {
_opcode_xor(mmu.read(addr));
}
<|endoftext|> |
<commit_before>/* This file is part of VoltDB.
* Copyright (C) 2008-2014 VoltDB Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with VoltDB. If not, see <http://www.gnu.org/licenses/>.
*/
#include "storage/ElasticContext.h"
#include "storage/persistenttable.h"
#include "common/TupleOutputStreamProcessor.h"
#include "common/FixUnusedAssertHack.h"
#include "expressions/hashrangeexpression.h"
#include "logging/LogManager.h"
#include <cassert>
#include <sstream>
#include <limits>
namespace voltdb {
ElasticContext::ElasticContext(PersistentTable &table,
PersistentTableSurgeon &surgeon,
int32_t partitionId,
TupleSerializer &serializer,
const std::vector<std::string> &predicateStrings,
size_t nTuplesPerCall) :
TableStreamerContext(table, surgeon, partitionId, serializer, predicateStrings),
m_predicateStrings(predicateStrings), // retained for cloning here, not in TableStreamerContext.
m_nTuplesPerCall(nTuplesPerCall),
m_indexActive(false)
{
if (predicateStrings.size() != 1) {
throwFatalException("ElasticContext::ElasticContext() expects a single predicate.");
}
}
ElasticContext::~ElasticContext()
{}
TableStreamerContext* ElasticContext::cloneForTruncatedTable(PersistentTableSurgeon &surgeon)
{
if ( ! m_indexActive) {
return NULL;
}
ElasticContext *cloned = new ElasticContext(surgeon.getTable(), surgeon,
getPartitionId(), getSerializer(), m_predicateStrings, m_nTuplesPerCall);
cloned->handleActivation(TABLE_STREAM_ELASTIC_INDEX);
TupleOutputStreamProcessor dummyProcessor;
std::vector<int> dummyPosition;
while (true) {
int64_t retCode = cloned->handleStreamMore(dummyProcessor, dummyPosition);
if (retCode == 0) {
break;
} else if (retCode == TABLE_STREAM_SERIALIZATION_ERROR) {
break;
} else if (retCode == 1) {
continue;
} else {
char errMsg[1024];
snprintf(errMsg, 1024, "Received an unrecognized return value %jd from handleStreamMore()", retCode);
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR, errMsg);
}
}
return cloned;
}
/**
* Activation handler.
*/
TableStreamerContext::ActivationReturnCode
ElasticContext::handleActivation(TableStreamType streamType)
{
// Create the index?
if (streamType == TABLE_STREAM_ELASTIC_INDEX) {
// Can't activate an indexing stream during a snapshot.
if (m_surgeon.hasStreamType(TABLE_STREAM_SNAPSHOT)) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_WARN,
"Elastic context activation is not allowed while a snapshot is in progress.");
return ACTIVATION_FAILED;
}
// Allow activation if there is an index, we will check when the predicates
// are updated to make sure the existing index satisfies the request
if (m_surgeon.hasIndex()) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_INFO,
"Activating elastic index build for index that already exists.");
return ACTIVATION_SUCCEEDED;
}
m_surgeon.createIndex();
m_scanner.reset(new ElasticScanner(getTable(), m_surgeon.getData()));
m_indexActive = true;
return ACTIVATION_SUCCEEDED;
}
// Clear the index?
if (streamType == TABLE_STREAM_ELASTIC_INDEX_CLEAR) {
if (m_surgeon.hasIndex()) {
if (!m_surgeon.isIndexEmpty()) {
std::ostringstream os;
os << "Elastic index clear is not allowed while an index is "
<< "present that has not been completely consumed."
<< std::endl
<< "Remaining index elements count is "
<< m_surgeon.indexSize()
<< std::endl;
os << "the index contains: " << std::endl;
const int32_t printUpTo = 1024;
m_surgeon.printIndex(os, printUpTo);
if (m_surgeon.indexSize() > printUpTo) {
os << "... " << (m_surgeon.indexSize() - printUpTo) << " more elements" << std::endl;
}
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR, os.str().c_str());
return ACTIVATION_FAILED;
}
//Clear the predicates so when we are activated again we won't
//compare against the old predicate
m_predicates.clear();
m_surgeon.dropIndex();
m_scanner.reset();
m_indexActive = false;
}
return ACTIVATION_SUCCEEDED;
}
// It wasn't one of the supported stream types.
return ACTIVATION_UNSUPPORTED;
}
/**
* Reactivation handler.
*/
TableStreamerContext::ActivationReturnCode
ElasticContext::handleReactivation(TableStreamType streamType)
{
return handleActivation(streamType);
}
/**
* Deactivation handler.
*/
bool ElasticContext::handleDeactivation(TableStreamType streamType)
{
// Keep this context around to maintain the index.
return true;
}
/*
* Serialize to output stream.
* Return remaining tuple count, 0 if done, or TABLE_STREAM_SERIALIZATION_ERROR on error.
*/
int64_t ElasticContext::handleStreamMore(TupleOutputStreamProcessor &outputStreams,
std::vector<int> &retPositions)
{
if (!m_surgeon.hasIndex()) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR,
"Elastic streaming was invoked without proper activation.");
return TABLE_STREAM_SERIALIZATION_ERROR;
}
if (m_surgeon.isIndexingComplete()) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_INFO,
"Indexing was already complete.");
return 0;
}
// Populate index with current tuples.
// Table changes are tracked through notifications.
size_t i = 0;
TableTuple tuple(getTable().schema());
while (m_scanner->next(tuple)) {
if (getPredicates()[0].eval(&tuple).isTrue()) {
m_surgeon.indexAdd(tuple);
}
// Take a breather after every chunk of m_nTuplesPerCall tuples.
if (++i == m_nTuplesPerCall) {
break;
}
}
// Done with indexing?
bool indexingComplete = m_scanner->isScanComplete();
if (indexingComplete) {
m_surgeon.setIndexingComplete();
}
return indexingComplete ? 0 : 1;
}
/**
* Tuple insert handler lets us add late arriving tuples to the index.
*/
bool ElasticContext::notifyTupleInsert(TableTuple &tuple)
{
if (m_indexActive) {
StreamPredicateList &predicates = getPredicates();
assert(predicates.size() > 0);
if (predicates[0].eval(&tuple).isTrue()) {
m_surgeon.indexAdd(tuple);
}
}
return true;
}
/**
* Tuple update handler is not currently needed.
*/
bool ElasticContext::notifyTupleUpdate(TableTuple &tuple)
{
return true;
}
/**
* Tuple delete handler lets us erase tuples from the index.
*/
bool ElasticContext::notifyTupleDelete(TableTuple &tuple)
{
if (m_indexActive) {
if (m_surgeon.indexHas(tuple)) {
m_surgeon.indexRemove(tuple);
}
}
return true;
}
/**
* Tuple compaction handler lets us reindex when a tuple's address changes.
*/
void ElasticContext::notifyTupleMovement(TBPtr sourceBlock,
TBPtr targetBlock,
TableTuple &sourceTuple,
TableTuple &targetTuple)
{
if (m_indexActive) {
StreamPredicateList &predicates = getPredicates();
assert(predicates.size() > 0);
if (m_surgeon.indexHas(sourceTuple)) {
m_surgeon.indexRemove(sourceTuple);
}
if (predicates[0].eval(&targetTuple).isTrue()) {
m_surgeon.indexAdd(targetTuple);
}
}
}
/**
* Parse and save predicates.
*/
void ElasticContext::updatePredicates(const std::vector<std::string> &predicateStrings) {
//If there is already a predicate and thus presumably an index, make sure the request is a subset of what exists
//That should always be the case, but wrong answers will follow if we are wrong
if (m_predicates.size() > 0 && dynamic_cast<HashRangeExpression*>(&m_predicates[0]) != NULL && predicateStrings.size() > 0) {
PlannerDomRoot domRoot(predicateStrings[0].c_str());
if (!domRoot.isNull()) {
PlannerDomValue predicateObject = domRoot.rootObject();
HashRangeExpression *expression = dynamic_cast<HashRangeExpression*>(&m_predicates[0]);
if (predicateObject.hasKey("predicateExpression")) {
PlannerDomValue predicateExpression = predicateObject.valueForKey("predicateExpression");
PlannerDomValue rangesArray = predicateExpression.valueForKey("RANGES");
for (int ii = 0; ii < rangesArray.arrayLen(); ii++) {
PlannerDomValue arrayObject = rangesArray.valueAtIndex(ii);
PlannerDomValue rangeStartValue = arrayObject.valueForKey("RANGE_START");
PlannerDomValue rangeEndValue = arrayObject.valueForKey("RANGE_END");
if (!expression->binarySearch(rangeStartValue.asInt()).isTrue()) {
throwFatalException("ElasticContext activate failed because a context already existed with conflicting ranges, conflicting range start is %d", rangeStartValue.asInt());
}
if (!expression->binarySearch(rangeEndValue.asInt()).isTrue()) {
throwFatalException("ElasticContext activate failed because a context already existed with conflicting ranges, conflicting range end is %d", rangeStartValue.asInt());
}
}
}
}
}
m_predicateStrings = predicateStrings; // retain for possible clone after TRUNCATE TABLE
TableStreamerContext::updatePredicates(predicateStrings);
}
} // namespace voltdb
<commit_msg>Add missing break<commit_after>/* This file is part of VoltDB.
* Copyright (C) 2008-2014 VoltDB Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with VoltDB. If not, see <http://www.gnu.org/licenses/>.
*/
#include "storage/ElasticContext.h"
#include "storage/persistenttable.h"
#include "common/TupleOutputStreamProcessor.h"
#include "common/FixUnusedAssertHack.h"
#include "expressions/hashrangeexpression.h"
#include "logging/LogManager.h"
#include <cassert>
#include <sstream>
#include <limits>
namespace voltdb {
ElasticContext::ElasticContext(PersistentTable &table,
PersistentTableSurgeon &surgeon,
int32_t partitionId,
TupleSerializer &serializer,
const std::vector<std::string> &predicateStrings,
size_t nTuplesPerCall) :
TableStreamerContext(table, surgeon, partitionId, serializer, predicateStrings),
m_predicateStrings(predicateStrings), // retained for cloning here, not in TableStreamerContext.
m_nTuplesPerCall(nTuplesPerCall),
m_indexActive(false)
{
if (predicateStrings.size() != 1) {
throwFatalException("ElasticContext::ElasticContext() expects a single predicate.");
}
}
ElasticContext::~ElasticContext()
{}
TableStreamerContext* ElasticContext::cloneForTruncatedTable(PersistentTableSurgeon &surgeon)
{
if ( ! m_indexActive) {
return NULL;
}
ElasticContext *cloned = new ElasticContext(surgeon.getTable(), surgeon,
getPartitionId(), getSerializer(), m_predicateStrings, m_nTuplesPerCall);
cloned->handleActivation(TABLE_STREAM_ELASTIC_INDEX);
TupleOutputStreamProcessor dummyProcessor;
std::vector<int> dummyPosition;
while (true) {
int64_t retCode = cloned->handleStreamMore(dummyProcessor, dummyPosition);
if (retCode == 0) {
break;
} else if (retCode == TABLE_STREAM_SERIALIZATION_ERROR) {
break;
} else if (retCode == 1) {
continue;
} else {
char errMsg[1024];
snprintf(errMsg, 1024, "Received an unrecognized return value %jd from handleStreamMore()", retCode);
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR, errMsg);
break;
}
}
return cloned;
}
/**
* Activation handler.
*/
TableStreamerContext::ActivationReturnCode
ElasticContext::handleActivation(TableStreamType streamType)
{
// Create the index?
if (streamType == TABLE_STREAM_ELASTIC_INDEX) {
// Can't activate an indexing stream during a snapshot.
if (m_surgeon.hasStreamType(TABLE_STREAM_SNAPSHOT)) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_WARN,
"Elastic context activation is not allowed while a snapshot is in progress.");
return ACTIVATION_FAILED;
}
// Allow activation if there is an index, we will check when the predicates
// are updated to make sure the existing index satisfies the request
if (m_surgeon.hasIndex()) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_INFO,
"Activating elastic index build for index that already exists.");
return ACTIVATION_SUCCEEDED;
}
m_surgeon.createIndex();
m_scanner.reset(new ElasticScanner(getTable(), m_surgeon.getData()));
m_indexActive = true;
return ACTIVATION_SUCCEEDED;
}
// Clear the index?
if (streamType == TABLE_STREAM_ELASTIC_INDEX_CLEAR) {
if (m_surgeon.hasIndex()) {
if (!m_surgeon.isIndexEmpty()) {
std::ostringstream os;
os << "Elastic index clear is not allowed while an index is "
<< "present that has not been completely consumed."
<< std::endl
<< "Remaining index elements count is "
<< m_surgeon.indexSize()
<< std::endl;
os << "the index contains: " << std::endl;
const int32_t printUpTo = 1024;
m_surgeon.printIndex(os, printUpTo);
if (m_surgeon.indexSize() > printUpTo) {
os << "... " << (m_surgeon.indexSize() - printUpTo) << " more elements" << std::endl;
}
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR, os.str().c_str());
return ACTIVATION_FAILED;
}
//Clear the predicates so when we are activated again we won't
//compare against the old predicate
m_predicates.clear();
m_surgeon.dropIndex();
m_scanner.reset();
m_indexActive = false;
}
return ACTIVATION_SUCCEEDED;
}
// It wasn't one of the supported stream types.
return ACTIVATION_UNSUPPORTED;
}
/**
* Reactivation handler.
*/
TableStreamerContext::ActivationReturnCode
ElasticContext::handleReactivation(TableStreamType streamType)
{
return handleActivation(streamType);
}
/**
* Deactivation handler.
*/
bool ElasticContext::handleDeactivation(TableStreamType streamType)
{
// Keep this context around to maintain the index.
return true;
}
/*
* Serialize to output stream.
* Return remaining tuple count, 0 if done, or TABLE_STREAM_SERIALIZATION_ERROR on error.
*/
int64_t ElasticContext::handleStreamMore(TupleOutputStreamProcessor &outputStreams,
std::vector<int> &retPositions)
{
if (!m_surgeon.hasIndex()) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR,
"Elastic streaming was invoked without proper activation.");
return TABLE_STREAM_SERIALIZATION_ERROR;
}
if (m_surgeon.isIndexingComplete()) {
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_INFO,
"Indexing was already complete.");
return 0;
}
// Populate index with current tuples.
// Table changes are tracked through notifications.
size_t i = 0;
TableTuple tuple(getTable().schema());
while (m_scanner->next(tuple)) {
if (getPredicates()[0].eval(&tuple).isTrue()) {
m_surgeon.indexAdd(tuple);
}
// Take a breather after every chunk of m_nTuplesPerCall tuples.
if (++i == m_nTuplesPerCall) {
break;
}
}
// Done with indexing?
bool indexingComplete = m_scanner->isScanComplete();
if (indexingComplete) {
m_surgeon.setIndexingComplete();
}
return indexingComplete ? 0 : 1;
}
/**
* Tuple insert handler lets us add late arriving tuples to the index.
*/
bool ElasticContext::notifyTupleInsert(TableTuple &tuple)
{
if (m_indexActive) {
StreamPredicateList &predicates = getPredicates();
assert(predicates.size() > 0);
if (predicates[0].eval(&tuple).isTrue()) {
m_surgeon.indexAdd(tuple);
}
}
return true;
}
/**
* Tuple update handler is not currently needed.
*/
bool ElasticContext::notifyTupleUpdate(TableTuple &tuple)
{
return true;
}
/**
* Tuple delete handler lets us erase tuples from the index.
*/
bool ElasticContext::notifyTupleDelete(TableTuple &tuple)
{
if (m_indexActive) {
if (m_surgeon.indexHas(tuple)) {
m_surgeon.indexRemove(tuple);
}
}
return true;
}
/**
* Tuple compaction handler lets us reindex when a tuple's address changes.
*/
void ElasticContext::notifyTupleMovement(TBPtr sourceBlock,
TBPtr targetBlock,
TableTuple &sourceTuple,
TableTuple &targetTuple)
{
if (m_indexActive) {
StreamPredicateList &predicates = getPredicates();
assert(predicates.size() > 0);
if (m_surgeon.indexHas(sourceTuple)) {
m_surgeon.indexRemove(sourceTuple);
}
if (predicates[0].eval(&targetTuple).isTrue()) {
m_surgeon.indexAdd(targetTuple);
}
}
}
/**
* Parse and save predicates.
*/
void ElasticContext::updatePredicates(const std::vector<std::string> &predicateStrings) {
//If there is already a predicate and thus presumably an index, make sure the request is a subset of what exists
//That should always be the case, but wrong answers will follow if we are wrong
if (m_predicates.size() > 0 && dynamic_cast<HashRangeExpression*>(&m_predicates[0]) != NULL && predicateStrings.size() > 0) {
PlannerDomRoot domRoot(predicateStrings[0].c_str());
if (!domRoot.isNull()) {
PlannerDomValue predicateObject = domRoot.rootObject();
HashRangeExpression *expression = dynamic_cast<HashRangeExpression*>(&m_predicates[0]);
if (predicateObject.hasKey("predicateExpression")) {
PlannerDomValue predicateExpression = predicateObject.valueForKey("predicateExpression");
PlannerDomValue rangesArray = predicateExpression.valueForKey("RANGES");
for (int ii = 0; ii < rangesArray.arrayLen(); ii++) {
PlannerDomValue arrayObject = rangesArray.valueAtIndex(ii);
PlannerDomValue rangeStartValue = arrayObject.valueForKey("RANGE_START");
PlannerDomValue rangeEndValue = arrayObject.valueForKey("RANGE_END");
if (!expression->binarySearch(rangeStartValue.asInt()).isTrue()) {
throwFatalException("ElasticContext activate failed because a context already existed with conflicting ranges, conflicting range start is %d", rangeStartValue.asInt());
}
if (!expression->binarySearch(rangeEndValue.asInt()).isTrue()) {
throwFatalException("ElasticContext activate failed because a context already existed with conflicting ranges, conflicting range end is %d", rangeStartValue.asInt());
}
}
}
}
}
m_predicateStrings = predicateStrings; // retain for possible clone after TRUNCATE TABLE
TableStreamerContext::updatePredicates(predicateStrings);
}
} // namespace voltdb
<|endoftext|> |
<commit_before>/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2006 Artem Pavlenko
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id: layer.cpp 17 2005-03-08 23:58:43Z pavlenko $
#include "style.hpp"
#include "datasource.hpp"
#include "datasource_cache.hpp"
#include "layer.hpp"
#include <string>
#include <iostream>
namespace mapnik
{
using namespace std;
Layer::Layer()
: params_(),
name_("uknown"),
minZoom_(0),
maxZoom_(std::numeric_limits<double>::max()),
active_(true),
selectable_(false),
selection_style_("default_selection")
{}
Layer::Layer(const parameters& params)
:params_(params),
name_(params_["name"]),
minZoom_(0),
maxZoom_(std::numeric_limits<double>::max()),
active_(true),
selectable_(false),
selection_style_("default_selection")
{}
Layer::Layer(const Layer& rhs)
:params_(rhs.params_),
name_(rhs.name_),
minZoom_(rhs.minZoom_),
maxZoom_(rhs.maxZoom_),
active_(rhs.active_),
selectable_(rhs.selectable_),
ds_(rhs.ds_),
styles_(rhs.styles_),
selection_style_(rhs.selection_style_) {}
Layer& Layer::operator=(const Layer& rhs)
{
Layer tmp(rhs);
swap(tmp);
return *this;
}
bool Layer::operator==(Layer const& other) const
{
return (this == &other);
}
void Layer::swap(const Layer& rhs)
{
params_=rhs.params_;
name_=rhs.name_;
minZoom_=rhs.minZoom_;
maxZoom_=rhs.maxZoom_;
active_=rhs.active_;
selectable_=rhs.selectable_;
styles_=rhs.styles_;
ds_=rhs.ds_;
selection_style_=rhs.selection_style_;
}
Layer::~Layer() {}
parameters const& Layer::params() const
{
return params_;
}
const string& Layer::name() const
{
return name_;
}
void Layer::add_style(std::string const& stylename)
{
styles_.push_back(stylename);
}
std::vector<std::string> const& Layer::styles() const
{
return styles_;
}
void Layer::setMinZoom(double minZoom)
{
minZoom_=minZoom;
}
void Layer::setMaxZoom(double maxZoom)
{
maxZoom_=maxZoom;
}
double Layer::getMinZoom() const
{
return minZoom_;
}
double Layer::getMaxZoom() const
{
return maxZoom_;
}
void Layer::setActive(bool active)
{
active_=active;
}
bool Layer::isActive() const
{
return active_;
}
bool Layer::isVisible(double scale) const
{
return isActive() && scale>=minZoom_ && scale<maxZoom_;
}
void Layer::setSelectable(bool selectable)
{
selectable_=selectable;
}
bool Layer::isSelectable() const
{
return selectable_;
}
const datasource_p& Layer::datasource() const
{
if (!ds_)
{
try
{
ds_=datasource_cache::instance()->create(params_);
}
catch (...)
{
std::clog << "exception caught : can not create datasource" << std::endl;
}
}
return ds_;
}
// TODO: !!!!
void Layer::set_datasource(datasource_p const& ds)
{
ds_ = ds;
}
Envelope<double> Layer::envelope() const
{
datasource_p const& ds = datasource();
if (ds)
{
return ds->envelope();
}
return Envelope<double>();
}
void Layer::selection_style(const std::string& name)
{
selection_style_=name;
}
const std::string& Layer::selection_style() const
{
return selection_style_;
}
void Layer::add_to_selection(shared_ptr<Feature>& feature) const
{
selection_.push_back(feature);
}
vector<shared_ptr<Feature> >& Layer::selection() const
{
return selection_;
}
void Layer::clear_selection() const
{
selection_.clear();
}
}
<commit_msg>added set_name method<commit_after>/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2006 Artem Pavlenko
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id: layer.cpp 17 2005-03-08 23:58:43Z pavlenko $
#include "style.hpp"
#include "datasource.hpp"
#include "datasource_cache.hpp"
#include "layer.hpp"
#include <string>
#include <iostream>
namespace mapnik
{
using namespace std;
Layer::Layer()
: params_(),
name_("unknown"),
minZoom_(0),
maxZoom_(std::numeric_limits<double>::max()),
active_(true),
selectable_(false),
selection_style_("default_selection")
{}
Layer::Layer(const parameters& params)
:params_(params),
name_(params_["name"]),
minZoom_(0),
maxZoom_(std::numeric_limits<double>::max()),
active_(true),
selectable_(false),
selection_style_("default_selection")
{}
Layer::Layer(const Layer& rhs)
:params_(rhs.params_),
name_(rhs.name_),
minZoom_(rhs.minZoom_),
maxZoom_(rhs.maxZoom_),
active_(rhs.active_),
selectable_(rhs.selectable_),
ds_(rhs.ds_),
styles_(rhs.styles_),
selection_style_(rhs.selection_style_) {}
Layer& Layer::operator=(const Layer& rhs)
{
Layer tmp(rhs);
swap(tmp);
return *this;
}
bool Layer::operator==(Layer const& other) const
{
return (this == &other);
}
void Layer::swap(const Layer& rhs)
{
params_=rhs.params_;
name_=rhs.name_;
minZoom_=rhs.minZoom_;
maxZoom_=rhs.maxZoom_;
active_=rhs.active_;
selectable_=rhs.selectable_;
//ds_=rhs.ds_;
styles_=rhs.styles_;
selection_style_=rhs.selection_style_;
}
Layer::~Layer() {}
parameters const& Layer::params() const
{
return params_;
}
void Layer::set_name( std::string const& name)
{
name_ = name;
}
string const& Layer::name() const
{
return name_;
}
void Layer::add_style(std::string const& stylename)
{
styles_.push_back(stylename);
}
std::vector<std::string> const& Layer::styles() const
{
return styles_;
}
void Layer::setMinZoom(double minZoom)
{
minZoom_=minZoom;
}
void Layer::setMaxZoom(double maxZoom)
{
maxZoom_=maxZoom;
}
double Layer::getMinZoom() const
{
return minZoom_;
}
double Layer::getMaxZoom() const
{
return maxZoom_;
}
void Layer::setActive(bool active)
{
active_=active;
}
bool Layer::isActive() const
{
return active_;
}
bool Layer::isVisible(double scale) const
{
return isActive() && scale>=minZoom_ && scale<maxZoom_;
}
void Layer::setSelectable(bool selectable)
{
selectable_=selectable;
}
bool Layer::isSelectable() const
{
return selectable_;
}
const datasource_p& Layer::datasource() const
{
if (!ds_)
{
try
{
ds_=datasource_cache::instance()->create(params_);
}
catch (...)
{
std::clog << "exception caught : can not create datasource" << std::endl;
}
}
return ds_;
}
// TODO: !!!!
void Layer::set_datasource(datasource_p const& ds)
{
ds_ = ds;
}
Envelope<double> Layer::envelope() const
{
datasource_p const& ds = datasource();
if (ds)
{
return ds->envelope();
}
return Envelope<double>();
}
void Layer::selection_style(const std::string& name)
{
selection_style_=name;
}
const std::string& Layer::selection_style() const
{
return selection_style_;
}
void Layer::add_to_selection(shared_ptr<Feature>& feature) const
{
selection_.push_back(feature);
}
vector<shared_ptr<Feature> >& Layer::selection() const
{
return selection_;
}
void Layer::clear_selection() const
{
selection_.clear();
}
}
<|endoftext|> |
<commit_before>#include "SkCanvas.h"
#include "SkLayerDrawLooper.h"
#include "SkPaint.h"
SkLayerDrawLooper::SkLayerDrawLooper() {
fRecs = NULL;
fCount = 0;
}
SkLayerDrawLooper::~SkLayerDrawLooper() {
Rec* rec = fRecs;
while (rec) {
Rec* next = rec->fNext;
SkDELETE(rec);
rec = next;
}
}
SkPaint* SkLayerDrawLooper::addLayer(SkScalar dx, SkScalar dy, BitFlags bits) {
fCount += 1;
Rec* rec = SkNEW(Rec);
rec->fNext = fRecs;
rec->fOffset.set(dx, dy);
rec->fBits = bits;
fRecs = rec;
return &rec->fPaint;
}
void SkLayerDrawLooper::init(SkCanvas* canvas) {
fCurrRec = fRecs;
canvas->save(SkCanvas::kMatrix_SaveFlag);
}
void SkLayerDrawLooper::ApplyBits(SkPaint* dst, const SkPaint& src,
BitFlags bits) {
if (kEntirePaint_Bits == bits) {
*dst = src;
return;
}
SkColor c = dst->getColor();
if (bits & kAlpha_Bit) {
c &= 0x00FFFFFF;
c |= src.getColor() & 0xFF000000;
}
if (bits & kColor_Bit) {
c &= 0xFF000000;
c |= src.getColor() & 0x00FFFFFF;
}
dst->setColor(c);
if (bits & kStyle_Bit) {
dst->setStyle(src.getStyle());
dst->setStrokeWidth(src.getStrokeWidth());
dst->setStrokeMiter(src.getStrokeMiter());
dst->setStrokeCap(src.getStrokeCap());
dst->setStrokeJoin(src.getStrokeJoin());
}
if (bits & kTextSkewX_Bit) {
dst->setTextSkewX(src.getTextSkewX());
}
if (bits & kPathEffect_Bit) {
dst->setPathEffect(src.getPathEffect());
}
if (bits & kMaskFilter_Bit) {
dst->setMaskFilter(src.getMaskFilter());
}
if (bits & kShader_Bit) {
dst->setShader(src.getShader());
}
if (bits & kColorFilter_Bit) {
dst->setColorFilter(src.getColorFilter());
}
if (bits & kXfermode_Bit) {
dst->setXfermode(src.getXfermode());
}
// we never copy these
#if 0
dst->setFlags(src.getFlags());
dst->setTypeface(src.getTypeface());
dst->setTextSize(src.getTextSize());
dst->setTextScaleX(src.getTextScaleX());
dst->setTextSkewX(src.getTextSkewX());
dst->setRasterizer(src.getRasterizer());
dst->setLooper(src.getLooper());
dst->setTextEncoding(src.getTextEncoding());
dst->setHinting(src.getHinting());
#endif
}
bool SkLayerDrawLooper::next(SkCanvas* canvas, SkPaint* paint) {
canvas->restore();
if (NULL == fCurrRec) {
return false;
}
ApplyBits(paint, fCurrRec->fPaint, fCurrRec->fBits);
canvas->save(SkCanvas::kMatrix_SaveFlag);
canvas->translate(fCurrRec->fOffset.fX, fCurrRec->fOffset.fY);
fCurrRec = fCurrRec->fNext;
return true;
}
SkLayerDrawLooper::Rec* SkLayerDrawLooper::Rec::Reverse(Rec* head) {
Rec* rec = head;
Rec* prev = NULL;
while (rec) {
Rec* next = rec->fNext;
rec->fNext = prev;
prev = rec;
rec = next;
}
return prev;
}
///////////////////////////////////////////////////////////////////////////////
void SkLayerDrawLooper::flatten(SkFlattenableWriteBuffer& buffer) {
this->INHERITED::flatten(buffer);
#ifdef SK_DEBUG
{
Rec* rec = fRecs;
int count = 0;
while (rec) {
rec = rec->fNext;
count += 1;
}
SkASSERT(count == fCount);
}
#endif
buffer.writeInt(fCount);
Rec* rec = fRecs;
for (int i = 0; i < fCount; i++) {
buffer.writeScalar(rec->fOffset.fX);
buffer.writeScalar(rec->fOffset.fY);
rec->fPaint.flatten(buffer);
rec = rec->fNext;
}
}
SkLayerDrawLooper::SkLayerDrawLooper(SkFlattenableReadBuffer& buffer)
: INHERITED(buffer) {
fRecs = NULL;
fCount = 0;
int count = buffer.readInt();
for (int i = 0; i < count; i++) {
SkScalar dx = buffer.readScalar();
SkScalar dy = buffer.readScalar();
this->addLayer(dx, dy)->unflatten(buffer);
}
SkASSERT(count == fCount);
// we're in reverse order, so fix it now
fRecs = Rec::Reverse(fRecs);
#ifdef SK_DEBUG
{
Rec* rec = fRecs;
int n = 0;
while (rec) {
rec = rec->fNext;
n += 1;
}
SkASSERT(count == n);
}
#endif
}
///////////////////////////////////////////////////////////////////////////////
static SkFlattenable::Registrar gReg("SkLayerDrawLooper",
SkLayerDrawLooper::CreateProc);
<commit_msg>fast return if no part of the paint gets replaced<commit_after>#include "SkCanvas.h"
#include "SkLayerDrawLooper.h"
#include "SkPaint.h"
SkLayerDrawLooper::SkLayerDrawLooper() {
fRecs = NULL;
fCount = 0;
}
SkLayerDrawLooper::~SkLayerDrawLooper() {
Rec* rec = fRecs;
while (rec) {
Rec* next = rec->fNext;
SkDELETE(rec);
rec = next;
}
}
SkPaint* SkLayerDrawLooper::addLayer(SkScalar dx, SkScalar dy, BitFlags bits) {
fCount += 1;
Rec* rec = SkNEW(Rec);
rec->fNext = fRecs;
rec->fOffset.set(dx, dy);
rec->fBits = bits;
fRecs = rec;
return &rec->fPaint;
}
void SkLayerDrawLooper::init(SkCanvas* canvas) {
fCurrRec = fRecs;
canvas->save(SkCanvas::kMatrix_SaveFlag);
}
void SkLayerDrawLooper::ApplyBits(SkPaint* dst, const SkPaint& src,
BitFlags bits) {
if (0 == bits) {
return;
}
if (kEntirePaint_Bits == bits) {
*dst = src;
return;
}
SkColor c = dst->getColor();
if (bits & kAlpha_Bit) {
c &= 0x00FFFFFF;
c |= src.getColor() & 0xFF000000;
}
if (bits & kColor_Bit) {
c &= 0xFF000000;
c |= src.getColor() & 0x00FFFFFF;
}
dst->setColor(c);
if (bits & kStyle_Bit) {
dst->setStyle(src.getStyle());
dst->setStrokeWidth(src.getStrokeWidth());
dst->setStrokeMiter(src.getStrokeMiter());
dst->setStrokeCap(src.getStrokeCap());
dst->setStrokeJoin(src.getStrokeJoin());
}
if (bits & kTextSkewX_Bit) {
dst->setTextSkewX(src.getTextSkewX());
}
if (bits & kPathEffect_Bit) {
dst->setPathEffect(src.getPathEffect());
}
if (bits & kMaskFilter_Bit) {
dst->setMaskFilter(src.getMaskFilter());
}
if (bits & kShader_Bit) {
dst->setShader(src.getShader());
}
if (bits & kColorFilter_Bit) {
dst->setColorFilter(src.getColorFilter());
}
if (bits & kXfermode_Bit) {
dst->setXfermode(src.getXfermode());
}
// we never copy these
#if 0
dst->setFlags(src.getFlags());
dst->setTypeface(src.getTypeface());
dst->setTextSize(src.getTextSize());
dst->setTextScaleX(src.getTextScaleX());
dst->setTextSkewX(src.getTextSkewX());
dst->setRasterizer(src.getRasterizer());
dst->setLooper(src.getLooper());
dst->setTextEncoding(src.getTextEncoding());
dst->setHinting(src.getHinting());
#endif
}
bool SkLayerDrawLooper::next(SkCanvas* canvas, SkPaint* paint) {
canvas->restore();
if (NULL == fCurrRec) {
return false;
}
ApplyBits(paint, fCurrRec->fPaint, fCurrRec->fBits);
canvas->save(SkCanvas::kMatrix_SaveFlag);
canvas->translate(fCurrRec->fOffset.fX, fCurrRec->fOffset.fY);
fCurrRec = fCurrRec->fNext;
return true;
}
SkLayerDrawLooper::Rec* SkLayerDrawLooper::Rec::Reverse(Rec* head) {
Rec* rec = head;
Rec* prev = NULL;
while (rec) {
Rec* next = rec->fNext;
rec->fNext = prev;
prev = rec;
rec = next;
}
return prev;
}
///////////////////////////////////////////////////////////////////////////////
void SkLayerDrawLooper::flatten(SkFlattenableWriteBuffer& buffer) {
this->INHERITED::flatten(buffer);
#ifdef SK_DEBUG
{
Rec* rec = fRecs;
int count = 0;
while (rec) {
rec = rec->fNext;
count += 1;
}
SkASSERT(count == fCount);
}
#endif
buffer.writeInt(fCount);
Rec* rec = fRecs;
for (int i = 0; i < fCount; i++) {
buffer.writeScalar(rec->fOffset.fX);
buffer.writeScalar(rec->fOffset.fY);
rec->fPaint.flatten(buffer);
rec = rec->fNext;
}
}
SkLayerDrawLooper::SkLayerDrawLooper(SkFlattenableReadBuffer& buffer)
: INHERITED(buffer) {
fRecs = NULL;
fCount = 0;
int count = buffer.readInt();
for (int i = 0; i < count; i++) {
SkScalar dx = buffer.readScalar();
SkScalar dy = buffer.readScalar();
this->addLayer(dx, dy)->unflatten(buffer);
}
SkASSERT(count == fCount);
// we're in reverse order, so fix it now
fRecs = Rec::Reverse(fRecs);
#ifdef SK_DEBUG
{
Rec* rec = fRecs;
int n = 0;
while (rec) {
rec = rec->fNext;
n += 1;
}
SkASSERT(count == n);
}
#endif
}
///////////////////////////////////////////////////////////////////////////////
static SkFlattenable::Registrar gReg("SkLayerDrawLooper",
SkLayerDrawLooper::CreateProc);
<|endoftext|> |
<commit_before>/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include <memory>
#include <numeric>
#include <utility>
#include <vector>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "absl/container/inlined_vector.h"
#include "absl/strings/str_cat.h"
#include "absl/types/span.h"
#include "third_party/eigen3/unsupported/Eigen/CXX11/FixedPoint"
#include "tensorflow/cc/framework/scope.h"
#include "tensorflow/cc/ops/function_ops.h"
#include "tensorflow/cc/ops/math_ops.h"
#include "tensorflow/compiler/tf2tensorrt/convert/convert_graph.h"
#include "tensorflow/compiler/tf2tensorrt/utils/trt_lru_cache.h"
#include "tensorflow/core/common_runtime/device.h"
#include "tensorflow/core/common_runtime/device_factory.h"
#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
#include "tensorflow/core/framework/attr_value.pb.h"
#include "tensorflow/core/framework/fake_input.h"
#include "tensorflow/core/framework/function.h"
#include "tensorflow/core/framework/graph.pb.h"
#include "tensorflow/core/framework/node_def_builder.h"
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/resource_mgr.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/graph/graph.h"
#include "tensorflow/core/kernels/ops_testutil.h"
#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/refcount.h"
#include "tensorflow/core/platform/status.h"
#include "tensorflow/core/public/version.h"
#if GOOGLE_CUDA
#if GOOGLE_TENSORRT
namespace tensorflow {
namespace tensorrt {
using ::absl::StrCat;
using ::testing::ElementsAre;
class TRTEngineOpTestBase : public OpsTestBase {
public:
void AddSimpleTrtOp(DataType dtype, int max_cached_engines_count = 1,
PartialTensorShape shape = PartialTensorShape({-1, -1}),
bool use_implicit_batch = true) {
// Create the GPU device.
std::unique_ptr<Device> device(
DeviceFactory::NewDevice("GPU", {}, "/job:worker/replica:0/task:0"));
// Create simple TF graph.
Scope s = Scope::NewRootScope();
auto feed = ops::_Arg(s.WithOpName("TensorRTInputPH_0"), dtype, 0);
auto add = ops::Add(s.WithOpName("add"), feed, feed);
ops::_Retval(s.WithOpName("TensorRTOutputPH_0"), add, 0);
// Serialize the graph. TRTEngineOp will convert it using dynamic mode.
GraphDef graph_def;
TF_ASSERT_OK(s.ToGraphDef(&graph_def));
Graph* graph = s.graph();
const char* op_name = "myop";
TF_ASSERT_OK(
convert::RegisterGraphToFunctionLibrary(graph_def, graph, op_name));
TF_ASSERT_OK(flib_def_->AddLibrary(graph->flib_def()));
// Create the op.
// In implicit batch mode, the input shapes that we specify here are not
// used for engine creation, we use the concrete shapes during inference
// time for creating the engine.
// In explicit batch mode, the input shapes attribute is used to define
// the network for the TensorRT engine.
OpsTestBase::SetDevice(DEVICE_GPU, std::move(device));
NameAttrList function;
function.set_name(StrCat(op_name, "_native_segment"));
TF_ASSERT_OK(NodeDefBuilder(op_name, "TRTEngineOp")
.Input(FakeInput(1, dtype))
.Attr("input_shapes", {shape})
.Attr("output_shapes", {shape})
.Attr("static_engine", false)
.Attr("segment_func", function)
.Attr("serialized_segment", "")
.Attr("calibration_data", "")
.Attr("max_cached_engines_count", max_cached_engines_count)
.Attr("workspace_size_bytes", 1 << 20)
.Attr("precision_mode", "FP32")
.Attr("use_calibration", false)
.Attr("_use_implicit_batch", use_implicit_batch)
.Attr("OutT", {dtype})
.Finalize(OpsTestBase::node_def()));
TF_ASSERT_OK(InitOpWithFunctionLibrary());
}
template <typename T>
void AddSimpleInput(const TensorShape& shape) {
std::vector<T> input(shape.num_elements());
std::iota(input.begin(), input.end(), T(0));
OpsTestBase::AddInputFromArray<T>(shape, input);
}
void ResetInputs() {
inputs_.clear();
for (auto& temp : tensors_) {
delete temp;
}
tensors_.clear();
}
private:
Status InitOpWithFunctionLibrary() {
OpKernel* kernel = nullptr;
Status status = CreateOpKernel(device_type_, device_, allocator(),
pflr_->GetFLR(device_->name()), node_def_,
TF_GRAPH_DEF_VERSION, &kernel);
kernel_ = std::unique_ptr<OpKernel>(kernel);
if (kernel_ != nullptr) input_types_ = kernel_->input_types();
return status;
}
};
TEST_F(TRTEngineOpTestBase, DynamicEngines) {
// Test dynamic engine creation during inference time
TRTEngineOpTestBase::AddSimpleTrtOp(DT_FLOAT, /*max_cached_engines_count=*/4);
// Execute the op with batch size > 1.
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({2, 2}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Get the engine cache.
TRTEngineCacheResource* cache_resource = nullptr;
TF_ASSERT_OK(
device_->resource_manager()->Lookup("TF-TRT", "myop", &cache_resource));
core::ScopedUnref sc(cache_resource);
// It should contain only one engine.
auto cache = &cache_resource->cache_;
EXPECT_EQ(1, cache->size());
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
// Execute the op with batch size 1. It should reuse existing engine to
// execute.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({1, 2}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
EXPECT_EQ(1, cache->size());
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
// Execute the op with a larger batch size.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({3, 2}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
EXPECT_EQ(2, cache->size());
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
EXPECT_EQ(1, cache->count({TensorShape({3, 2})}));
// Execute the op with an input that has different non-batch dimension.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({10, 10}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Execute it again with an input that has the same non-batch dimension but
// smallest batch size. It should find the correct engine to use.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({1, 10}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
EXPECT_EQ(3, cache->size()); // Should only create 3 engines in total.
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
EXPECT_EQ(1, cache->count({TensorShape({3, 2})}));
EXPECT_EQ(1, cache->count({TensorShape({10, 10})}));
}
TEST_F(TRTEngineOpTestBase, ExplicitBatch) {
// Test inference in explicit batch mode with static input shapes. Static
// shapes in this context means that the TensorRT knows all the input shapes
// during engine creation time.
TRTEngineOpTestBase::AddSimpleTrtOp(DT_FLOAT, /*max_cached_engines_count=*/1,
/*shape=*/PartialTensorShape({1, 2}),
/*use_implicit_batch=*/false);
TensorShape input_shape({1, 2});
TRTEngineOpTestBase::AddSimpleInput<float>(input_shape);
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Get the engine cache.
TRTEngineCacheResource* cache_resource = nullptr;
TF_ASSERT_OK(
device_->resource_manager()->Lookup("TF-TRT", "myop", &cache_resource));
core::ScopedUnref sc(cache_resource);
// The cache should contain only one EngineContext, with a valid cuda_engine.
auto cache = &cache_resource->cache_;
EXPECT_EQ(1, cache->size());
ASSERT_EQ(1, cache->count({input_shape}));
EngineContext* ectx = cache->at({input_shape}).get();
EXPECT_NE(ectx->cuda_engine, nullptr);
}
TEST_F(TRTEngineOpTestBase, DynamicShapes) {
// Test inference in explicit batch mode with dynamic input shapes. Dynamic
// shapes in this context means that some input shapes for TensorRT are
// unknown during engine creation time. When we create the network, the
// unknow shapes are repsesented as -1. Before we run inference, these shapes
// have to be specified by calling setBindingDimensions.
TRTEngineOpTestBase::AddSimpleTrtOp(DT_FLOAT, /*max_cached_engines_count=*/1,
/*shape=*/PartialTensorShape({-1, -1}),
/*use_implicit_batch=*/false);
TensorShape input_shape({1, 2});
TRTEngineOpTestBase::AddSimpleInput<float>(input_shape);
// We expect that TensorRT engine creation fails: we would need to configure
// the engine with optimization profiles to use dynamic input shapes, but that
// feature is not yet implemented.
//
// Since TRT engine creation has failed, we fall back to native segment.
// Calling the native segment fails for the same reason that is investigated
// in https://github.com/tensorflow/tensorflow/pull/34919. This is irrelevant
// for the current test, here we want to just check wether TRT engine creation
// has failed.
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Get the engine cache.
TRTEngineCacheResource* cache_resource = nullptr;
TF_ASSERT_OK(
device_->resource_manager()->Lookup("TF-TRT", "myop", &cache_resource));
core::ScopedUnref sc(cache_resource);
// The cache should contain only one EngineContext.
auto cache = &cache_resource->cache_;
EXPECT_EQ(1, cache->size());
ASSERT_EQ(1, cache->count({input_shape}));
EngineContext* ectx = cache->at({input_shape}).get();
// Since engine creation failed, we expect to find nullptr. Finding a nullptr
// indicates that unknown shapes were used to define the TensorRT network.
EXPECT_EQ(ectx->cuda_engine, nullptr);
}
template <typename T>
class TRTEngineOpTest : public TRTEngineOpTestBase {};
using TypeList = ::testing::Types<float, Eigen::half>;
TYPED_TEST_SUITE(TRTEngineOpTest, TypeList);
TYPED_TEST(TRTEngineOpTest, Basic) {
TRTEngineOpTestBase::AddSimpleTrtOp(DataTypeToEnum<TypeParam>::v());
// Execute the op.
OpsTestBase::AddInputFromArray<TypeParam>(TensorShape({1, 2}),
{TypeParam(0.0f), TypeParam(1.0f)});
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Verify the result.
Tensor* output = OpsTestBase::GetOutput(0);
EXPECT_THAT(
absl::Span<const TypeParam>(output->template flat<TypeParam>().data(),
output->NumElements()),
ElementsAre(TypeParam(0.0f), TypeParam(2.0f)));
}
} // namespace tensorrt
} // namespace tensorflow
#endif // GOOGLE_TENSORRT
#endif // GOOGLE_CUDA
<commit_msg>Disable the check for no engine is built in DynamicShapes test to fix the test failure.<commit_after>/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include <memory>
#include <numeric>
#include <utility>
#include <vector>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "absl/container/inlined_vector.h"
#include "absl/strings/str_cat.h"
#include "absl/types/span.h"
#include "third_party/eigen3/unsupported/Eigen/CXX11/FixedPoint"
#include "tensorflow/cc/framework/scope.h"
#include "tensorflow/cc/ops/function_ops.h"
#include "tensorflow/cc/ops/math_ops.h"
#include "tensorflow/compiler/tf2tensorrt/convert/convert_graph.h"
#include "tensorflow/compiler/tf2tensorrt/utils/trt_lru_cache.h"
#include "tensorflow/core/common_runtime/device.h"
#include "tensorflow/core/common_runtime/device_factory.h"
#include "tensorflow/core/common_runtime/process_function_library_runtime.h"
#include "tensorflow/core/framework/attr_value.pb.h"
#include "tensorflow/core/framework/fake_input.h"
#include "tensorflow/core/framework/function.h"
#include "tensorflow/core/framework/graph.pb.h"
#include "tensorflow/core/framework/node_def_builder.h"
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/resource_mgr.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/graph/graph.h"
#include "tensorflow/core/kernels/ops_testutil.h"
#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/refcount.h"
#include "tensorflow/core/platform/status.h"
#include "tensorflow/core/public/version.h"
#if GOOGLE_CUDA
#if GOOGLE_TENSORRT
namespace tensorflow {
namespace tensorrt {
using ::absl::StrCat;
using ::testing::ElementsAre;
class TRTEngineOpTestBase : public OpsTestBase {
public:
void AddSimpleTrtOp(DataType dtype, int max_cached_engines_count = 1,
PartialTensorShape shape = PartialTensorShape({-1, -1}),
bool use_implicit_batch = true) {
// Create the GPU device.
std::unique_ptr<Device> device(
DeviceFactory::NewDevice("GPU", {}, "/job:worker/replica:0/task:0"));
// Create simple TF graph.
Scope s = Scope::NewRootScope();
auto feed = ops::_Arg(s.WithOpName("TensorRTInputPH_0"), dtype, 0);
auto add = ops::Add(s.WithOpName("add"), feed, feed);
ops::_Retval(s.WithOpName("TensorRTOutputPH_0"), add, 0);
// Serialize the graph. TRTEngineOp will convert it using dynamic mode.
GraphDef graph_def;
TF_ASSERT_OK(s.ToGraphDef(&graph_def));
Graph* graph = s.graph();
const char* op_name = "myop";
TF_ASSERT_OK(
convert::RegisterGraphToFunctionLibrary(graph_def, graph, op_name));
TF_ASSERT_OK(flib_def_->AddLibrary(graph->flib_def()));
// Create the op.
// In implicit batch mode, the input shapes that we specify here are not
// used for engine creation, we use the concrete shapes during inference
// time for creating the engine.
// In explicit batch mode, the input shapes attribute is used to define
// the network for the TensorRT engine.
OpsTestBase::SetDevice(DEVICE_GPU, std::move(device));
NameAttrList function;
function.set_name(StrCat(op_name, "_native_segment"));
TF_ASSERT_OK(NodeDefBuilder(op_name, "TRTEngineOp")
.Input(FakeInput(1, dtype))
.Attr("input_shapes", {shape})
.Attr("output_shapes", {shape})
.Attr("static_engine", false)
.Attr("segment_func", function)
.Attr("serialized_segment", "")
.Attr("calibration_data", "")
.Attr("max_cached_engines_count", max_cached_engines_count)
.Attr("workspace_size_bytes", 1 << 20)
.Attr("precision_mode", "FP32")
.Attr("use_calibration", false)
.Attr("_use_implicit_batch", use_implicit_batch)
.Attr("OutT", {dtype})
.Finalize(OpsTestBase::node_def()));
TF_ASSERT_OK(InitOpWithFunctionLibrary());
}
template <typename T>
void AddSimpleInput(const TensorShape& shape) {
std::vector<T> input(shape.num_elements());
std::iota(input.begin(), input.end(), T(0));
OpsTestBase::AddInputFromArray<T>(shape, input);
}
void ResetInputs() {
inputs_.clear();
for (auto& temp : tensors_) {
delete temp;
}
tensors_.clear();
}
private:
Status InitOpWithFunctionLibrary() {
OpKernel* kernel = nullptr;
Status status = CreateOpKernel(device_type_, device_, allocator(),
pflr_->GetFLR(device_->name()), node_def_,
TF_GRAPH_DEF_VERSION, &kernel);
kernel_ = std::unique_ptr<OpKernel>(kernel);
if (kernel_ != nullptr) input_types_ = kernel_->input_types();
return status;
}
};
TEST_F(TRTEngineOpTestBase, DynamicEngines) {
// Test dynamic engine creation during inference time
TRTEngineOpTestBase::AddSimpleTrtOp(DT_FLOAT, /*max_cached_engines_count=*/4);
// Execute the op with batch size > 1.
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({2, 2}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Get the engine cache.
TRTEngineCacheResource* cache_resource = nullptr;
TF_ASSERT_OK(
device_->resource_manager()->Lookup("TF-TRT", "myop", &cache_resource));
core::ScopedUnref sc(cache_resource);
// It should contain only one engine.
auto cache = &cache_resource->cache_;
EXPECT_EQ(1, cache->size());
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
// Execute the op with batch size 1. It should reuse existing engine to
// execute.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({1, 2}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
EXPECT_EQ(1, cache->size());
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
// Execute the op with a larger batch size.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({3, 2}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
EXPECT_EQ(2, cache->size());
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
EXPECT_EQ(1, cache->count({TensorShape({3, 2})}));
// Execute the op with an input that has different non-batch dimension.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({10, 10}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Execute it again with an input that has the same non-batch dimension but
// smallest batch size. It should find the correct engine to use.
ResetInputs();
TRTEngineOpTestBase::AddSimpleInput<float>(TensorShape({1, 10}));
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
EXPECT_EQ(3, cache->size()); // Should only create 3 engines in total.
EXPECT_EQ(1, cache->count({TensorShape({2, 2})}));
EXPECT_EQ(1, cache->count({TensorShape({3, 2})}));
EXPECT_EQ(1, cache->count({TensorShape({10, 10})}));
}
TEST_F(TRTEngineOpTestBase, ExplicitBatch) {
// Test inference in explicit batch mode with static input shapes. Static
// shapes in this context means that the TensorRT knows all the input shapes
// during engine creation time.
TRTEngineOpTestBase::AddSimpleTrtOp(DT_FLOAT, /*max_cached_engines_count=*/1,
/*shape=*/PartialTensorShape({1, 2}),
/*use_implicit_batch=*/false);
TensorShape input_shape({1, 2});
TRTEngineOpTestBase::AddSimpleInput<float>(input_shape);
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Get the engine cache.
TRTEngineCacheResource* cache_resource = nullptr;
TF_ASSERT_OK(
device_->resource_manager()->Lookup("TF-TRT", "myop", &cache_resource));
core::ScopedUnref sc(cache_resource);
// The cache should contain only one EngineContext, with a valid cuda_engine.
auto cache = &cache_resource->cache_;
EXPECT_EQ(1, cache->size());
ASSERT_EQ(1, cache->count({input_shape}));
EngineContext* ectx = cache->at({input_shape}).get();
EXPECT_NE(ectx->cuda_engine, nullptr);
}
TEST_F(TRTEngineOpTestBase, DynamicShapes) {
// Test inference in explicit batch mode with dynamic input shapes. Dynamic
// shapes in this context means that some input shapes for TensorRT are
// unknown during engine creation time. When we create the network, the
// unknow shapes are repsesented as -1. Before we run inference, these shapes
// have to be specified by calling setBindingDimensions.
TRTEngineOpTestBase::AddSimpleTrtOp(DT_FLOAT, /*max_cached_engines_count=*/1,
/*shape=*/PartialTensorShape({-1, -1}),
/*use_implicit_batch=*/false);
TensorShape input_shape({1, 2});
TRTEngineOpTestBase::AddSimpleInput<float>(input_shape);
// We expect that TensorRT engine creation fails: we would need to configure
// the engine with optimization profiles to use dynamic input shapes, but that
// feature is not yet implemented.
//
// Since TRT engine creation has failed, we fall back to native segment.
// Calling the native segment fails for the same reason that is investigated
// in https://github.com/tensorflow/tensorflow/pull/34919. This is irrelevant
// for the current test, here we want to just check wether TRT engine creation
// has failed.
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Get the engine cache.
TRTEngineCacheResource* cache_resource = nullptr;
TF_ASSERT_OK(
device_->resource_manager()->Lookup("TF-TRT", "myop", &cache_resource));
core::ScopedUnref sc(cache_resource);
// The cache should contain only one EngineContext.
auto cache = &cache_resource->cache_;
EXPECT_EQ(1, cache->size());
ASSERT_EQ(1, cache->count({input_shape}));
// TODO(bixia): re-enable the check below when the problem is fixed.
// EngineContext* ectx = cache->at({input_shape}).get();
// Since engine creation failed, we expect to find nullptr. Finding a nullptr
// indicates that unknown shapes were used to define the TensorRT network.
// EXPECT_EQ(ectx->cuda_engine, nullptr);
}
template <typename T>
class TRTEngineOpTest : public TRTEngineOpTestBase {};
using TypeList = ::testing::Types<float, Eigen::half>;
TYPED_TEST_SUITE(TRTEngineOpTest, TypeList);
TYPED_TEST(TRTEngineOpTest, Basic) {
TRTEngineOpTestBase::AddSimpleTrtOp(DataTypeToEnum<TypeParam>::v());
// Execute the op.
OpsTestBase::AddInputFromArray<TypeParam>(TensorShape({1, 2}),
{TypeParam(0.0f), TypeParam(1.0f)});
TF_ASSERT_OK(OpsTestBase::RunOpKernel());
// Verify the result.
Tensor* output = OpsTestBase::GetOutput(0);
EXPECT_THAT(
absl::Span<const TypeParam>(output->template flat<TypeParam>().data(),
output->NumElements()),
ElementsAre(TypeParam(0.0f), TypeParam(2.0f)));
}
} // namespace tensorrt
} // namespace tensorflow
#endif // GOOGLE_TENSORRT
#endif // GOOGLE_CUDA
<|endoftext|> |
<commit_before>///
/// @file D4.cpp
/// @brief This is a highly optimized implementation of the D(x, y)
/// formula in Xavier Gourdon's prime counting algorithm. The D
/// formula is very similar to the formula of the hard special
/// leaves in the Deleglise-Rivat algorithm. Hence this
/// implementation is basically identical to S2_hard.cpp except
/// that the bounds have been changed slightly.
///
/// This implementation uses multi-threading with advanced load
/// balancing, it scales well up to a large number of CPU cores
/// because the compute threads are completely independent from
/// each other. This implementation also uses the highly
/// optimized Sieve class and the DFactorTable class which is a
/// compressed lookup table of moebius function values,
/// least prime factors and max prime factors.
///
/// Copyright (C) 2019 Kim Walisch, <[email protected]>
///
/// This file is distributed under the BSD License. See the COPYING
/// file in the top level directory.
///
#include <primecount-internal.hpp>
#include <PiTable.hpp>
#include <Sieve.hpp>
#include <LoadBalancer.hpp>
#include <fast_div.hpp>
#include <generate.hpp>
#include <generate_phi.hpp>
#include <imath.hpp>
#include <int128_t.hpp>
#include <min.hpp>
#include <print.hpp>
#include "DFactorTable.hpp"
#include <stdint.h>
#include <vector>
using namespace std;
using namespace primecount;
namespace {
/// Compute the contribution of the hard special leaves using a
/// segmented sieve. Each thread processes the interval
/// [low, low + segments * segment_size[.
///
template <typename T, typename DFactorTable, typename Primes>
T D_thread(T x,
int64_t x_star,
int64_t xz,
int64_t y,
int64_t z,
int64_t k,
int64_t low,
int64_t segments,
int64_t segment_size,
DFactorTable& factor,
PiTable& pi,
Primes& primes,
Runtime& runtime)
{
T sum = 0;
int64_t pi_sqrtz = pi[isqrt(z)];
int64_t low1 = max(low, 1);
int64_t limit = min(low + segments * segment_size, xz + 1);
int64_t max_b = pi[min3(isqrt(x / low1), isqrt(limit), x_star)];
int64_t min_b = pi[min(xz / limit, x_star)];
min_b = max(k, min_b) + 1;
if (min_b > max_b)
return 0;
runtime.init_start();
Sieve sieve(low, segment_size, max_b);
auto phi = generate_phi(low, max_b, primes, pi);
runtime.init_stop();
// Segmented sieve of Eratosthenes
for (; low < limit; low += segment_size)
{
// current segment [low, high[
int64_t high = min(low + segment_size, limit);
low1 = max(low, 1);
// For i < min_b there are no special leaves:
// low <= x / (primes[i] * m) < high
sieve.pre_sieve(primes, min_b - 1, low, high);
int64_t count_low_high = sieve.count((high - 1) - low);
int64_t b = min_b;
// For k + 1 <= b <= pi_sqrtz
// Find all special leaves in the current segment that are
// composed of a prime and a square free number:
// low <= x / (primes[b] * m) < high
for (int64_t end = min(pi_sqrtz, max_b); b <= end; b++)
{
int64_t prime = primes[b];
T xp = x / prime;
int64_t xp_div_low = min(fast_div(xp, low1), z);
int64_t xp_div_high = min(fast_div(xp, high), z);
int64_t min_m = max(xp_div_high, z / prime);
int64_t max_m = min(x / ipow<T>(prime, 3), xp_div_low);
if (prime >= max_m)
goto next_segment;
min_m = factor.to_index(min_m);
max_m = factor.to_index(max_m);
int64_t count = 0;
int64_t start = 0;
for (int64_t m = max_m; m > min_m; m--)
{
// mu[m] != 0 &&
// lpf[m] > prime &&
// mpf[m] <= y
if (prime < factor.is_leaf(m))
{
int64_t xpm = fast_div64(xp, factor.to_number(m));
int64_t stop = xpm - low;
count += sieve.count(start, stop, low, high, count, count_low_high);
start = stop + 1;
int64_t phi_xpm = phi[b] + count;
int64_t mu_m = factor.mu(m);
sum -= mu_m * phi_xpm;
}
}
phi[b] += count_low_high;
count_low_high -= sieve.cross_off_count(prime, b);
}
// For pi_sqrtz < b <= pi_x_star
// Find all special leaves in the current segment
// that are composed of 2 primes:
// low <= x / (primes[b] * primes[l]) < high
for (; b <= max_b; b++)
{
int64_t prime = primes[b];
T xp = x / prime;
int64_t xp_div_low = min(fast_div(xp, low1), y);
int64_t xp_div_high = min(fast_div(xp, high), y);
int64_t min_m = max(xp_div_high, prime);
int64_t max_m = min(x / ipow<T>(prime, 3), xp_div_low);
int64_t l = pi[max_m];
int64_t count = 0;
int64_t start = 0;
if (prime >= primes[l])
goto next_segment;
for (; primes[l] > min_m; l--)
{
int64_t xpq = fast_div64(xp, primes[l]);
int64_t stop = xpq - low;
count += sieve.count(start, stop, low, high, count, count_low_high);
start = stop + 1;
int64_t phi_xpq = phi[b] + count;
sum += phi_xpq;
}
phi[b] += count_low_high;
count_low_high -= sieve.cross_off_count(prime, b);
}
next_segment:;
}
return sum;
}
/// Calculate the contribution of the hard special leaves.
///
/// This is a parallel D(x, y) implementation with advanced load
/// balancing. As most special leaves tend to be in the first segments
/// we start off with a tiny segment size and one segment per thread.
/// After each iteration we dynamically increase the segment size (until
/// it reaches some limit) or the number of segments.
///
/// D(x, y) has been parallelized using an idea devised by Xavier
/// Gourdon. The idea is to make the individual threads completely
/// independent from each other so that no thread depends on values
/// calculated by another thread. The benefit of this approach is that
/// the algorithm will scale well up to a very large number of CPU
/// cores. In order to make the threads independent from each other
/// each thread needs to precompute a lookup table of phi(x, a) values
/// (this is done in D_thread(x, y)) every time the thread starts
/// a new computation.
///
template <typename T, typename DFactorTable, typename Primes>
T D_OpenMP(T x,
int64_t y,
int64_t z,
int64_t k,
T d_approx,
Primes& primes,
DFactorTable& factor,
int threads)
{
int64_t xz = x / z;
int64_t x_star = get_x_star_gourdon(x, y);
threads = ideal_num_threads(threads, xz);
PiTable pi(y);
LoadBalancer loadBalancer(x, xz, d_approx);
#pragma omp parallel for num_threads(threads)
for (int i = 0; i < threads; i++)
{
int64_t low = 0;
int64_t segments = 0;
int64_t segment_size = 0;
T sum = 0;
Runtime runtime;
while (loadBalancer.get_work(&low, &segments, &segment_size, sum, runtime))
{
runtime.start();
// Unsigned integer division is usually slightly
// faster than signed integer division
using UT = typename make_unsigned<T>::type;
sum = D_thread((UT) x, x_star, xz, y, z, k, low, segments, segment_size, factor, pi, primes, runtime);
runtime.stop();
}
}
T sum = (T) loadBalancer.get_sum();
return sum;
}
} // namespace
namespace primecount {
int64_t D(int64_t x,
int64_t y,
int64_t z,
int64_t k,
int64_t d_approx,
int threads)
{
print("");
print("=== D(x, y) ===");
print_gourdon_vars(x, y, z, k, threads);
double time = get_time();
DFactorTable<uint16_t> factor(y, z, threads);
auto primes = generate_primes<int32_t>(y);
int64_t sum = D_OpenMP(x, y, z, k, d_approx, primes, factor, threads);
print("D", sum, time);
return sum;
}
#ifdef HAVE_INT128_T
int128_t D(int128_t x,
int64_t y,
int64_t z,
int64_t k,
int128_t d_approx,
int threads)
{
print("");
print("=== D(x, y) ===");
print_gourdon_vars(x, y, z, k, threads);
double time = get_time();
int128_t sum;
// uses less memory
if (z <= DFactorTable<uint16_t>::max())
{
DFactorTable<uint16_t> factor(y, z, threads);
auto primes = generate_primes<uint32_t>(y);
sum = D_OpenMP(x, y, z, k, d_approx, primes, factor, threads);
}
else
{
DFactorTable<uint32_t> factor(y, z, threads);
auto primes = generate_primes<int64_t>(y);
sum = D_OpenMP(x, y, z, k, d_approx, primes, factor, threads);
}
print("D", sum, time);
return sum;
}
#endif
} // namespace
<commit_msg>Refactor<commit_after>///
/// @file D4.cpp
/// @brief This is a highly optimized implementation of the D(x, y)
/// formula in Xavier Gourdon's prime counting algorithm. The D
/// formula is very similar to the formula of the hard special
/// leaves in the Deleglise-Rivat algorithm. Hence this
/// implementation is basically identical to S2_hard.cpp except
/// that the bounds have been changed slightly.
///
/// This implementation uses multi-threading with advanced load
/// balancing, it scales well up to a large number of CPU cores
/// because the compute threads are completely independent from
/// each other. This implementation also uses the highly
/// optimized Sieve class and the DFactorTable class which is a
/// compressed lookup table of moebius function values,
/// least prime factors and max prime factors.
///
/// Copyright (C) 2019 Kim Walisch, <[email protected]>
///
/// This file is distributed under the BSD License. See the COPYING
/// file in the top level directory.
///
#include <primecount-internal.hpp>
#include <PiTable.hpp>
#include <Sieve.hpp>
#include <LoadBalancer.hpp>
#include <fast_div.hpp>
#include <generate.hpp>
#include <generate_phi.hpp>
#include <imath.hpp>
#include <int128_t.hpp>
#include <min.hpp>
#include <print.hpp>
#include "DFactorTable.hpp"
#include <stdint.h>
#include <vector>
using namespace std;
using namespace primecount;
namespace {
/// Compute the contribution of the hard special leaves using a
/// segmented sieve. Each thread processes the interval
/// [low, low + segments * segment_size[.
///
template <typename T, typename DFactorTable, typename Primes>
T D_thread(T x,
int64_t x_star,
int64_t xz,
int64_t y,
int64_t z,
int64_t k,
int64_t low,
int64_t segments,
int64_t segment_size,
DFactorTable& factor,
PiTable& pi,
Primes& primes,
Runtime& runtime)
{
T sum = 0;
int64_t pi_sqrtz = pi[isqrt(z)];
int64_t low1 = max(low, 1);
int64_t limit = min(low + segments * segment_size, xz + 1);
int64_t max_b = pi[min3(isqrt(x / low1), isqrt(limit), x_star)];
int64_t min_b = pi[min(xz / limit, x_star)];
min_b = max(k, min_b) + 1;
if (min_b > max_b)
return 0;
runtime.init_start();
Sieve sieve(low, segment_size, max_b);
auto phi = generate_phi(low, max_b, primes, pi);
runtime.init_stop();
// Segmented sieve of Eratosthenes
for (; low < limit; low += segment_size)
{
// current segment [low, high[
int64_t high = min(low + segment_size, limit);
low1 = max(low, 1);
// For i < min_b there are no special leaves:
// low <= x / (primes[i] * m) < high
sieve.pre_sieve(primes, min_b - 1, low, high);
int64_t count_low_high = sieve.count((high - 1) - low);
int64_t b = min_b;
// For k + 1 <= b <= pi_sqrtz
// Find all special leaves in the current segment that are
// composed of a prime and a square free number:
// low <= x / (primes[b] * m) < high
for (int64_t end = min(pi_sqrtz, max_b); b <= end; b++)
{
int64_t prime = primes[b];
T xp = x / prime;
int64_t xp_div_low = min(fast_div(xp, low1), z);
int64_t xp_div_high = min(fast_div(xp, high), z);
int64_t min_m = max(xp_div_high, z / prime);
int64_t max_m = min(x / ipow<T>(prime, 3), xp_div_low);
if (prime >= max_m)
goto next_segment;
min_m = factor.to_index(min_m);
max_m = factor.to_index(max_m);
int64_t count = 0;
int64_t start = 0;
for (int64_t m = max_m; m > min_m; m--)
{
// mu[m] != 0 &&
// lpf[m] > prime &&
// mpf[m] <= y
if (prime < factor.is_leaf(m))
{
int64_t xpm = fast_div64(xp, factor.to_number(m));
int64_t stop = xpm - low;
count += sieve.count(start, stop, low, high, count, count_low_high);
start = stop + 1;
int64_t phi_xpm = phi[b] + count;
int64_t mu_m = factor.mu(m);
sum -= mu_m * phi_xpm;
}
}
phi[b] += count_low_high;
count_low_high -= sieve.cross_off_count(prime, b);
}
// For pi_sqrtz < b <= pi_x_star
// Find all special leaves in the current segment
// that are composed of 2 primes:
// low <= x / (primes[b] * primes[l]) < high
for (; b <= max_b; b++)
{
int64_t prime = primes[b];
T xp = x / prime;
int64_t xp_div_low = min(fast_div(xp, low1), y);
int64_t xp_div_high = min(fast_div(xp, high), y);
int64_t min_m = max(xp_div_high, prime);
int64_t max_m = min(x / ipow<T>(prime, 3), xp_div_low);
int64_t l = pi[max_m];
int64_t count = 0;
int64_t start = 0;
if (prime >= primes[l])
goto next_segment;
for (; primes[l] > min_m; l--)
{
int64_t xpq = fast_div64(xp, primes[l]);
int64_t stop = xpq - low;
count += sieve.count(start, stop, low, high, count, count_low_high);
start = stop + 1;
int64_t phi_xpq = phi[b] + count;
sum += phi_xpq;
}
phi[b] += count_low_high;
count_low_high -= sieve.cross_off_count(prime, b);
}
next_segment:;
}
return sum;
}
/// Calculate the contribution of the hard special leaves.
///
/// This is a parallel D(x, y) implementation with advanced load
/// balancing. As most special leaves tend to be in the first segments
/// we start off with a tiny segment size and one segment per thread.
/// After each iteration we dynamically increase the segment size (until
/// it reaches some limit) or the number of segments.
///
/// D(x, y) has been parallelized using an idea devised by Xavier
/// Gourdon. The idea is to make the individual threads completely
/// independent from each other so that no thread depends on values
/// calculated by another thread. The benefit of this approach is that
/// the algorithm will scale well up to a very large number of CPU
/// cores. In order to make the threads independent from each other
/// each thread needs to precompute a lookup table of phi(x, a) values
/// (this is done in D_thread(x, y)) every time the thread starts
/// a new computation.
///
template <typename T, typename DFactorTable, typename Primes>
T D_OpenMP(T x,
int64_t y,
int64_t z,
int64_t k,
T d_approx,
Primes& primes,
DFactorTable& factor,
int threads)
{
int64_t xz = x / z;
int64_t x_star = get_x_star_gourdon(x, y);
threads = ideal_num_threads(threads, xz);
PiTable pi(y);
LoadBalancer loadBalancer(x, xz, d_approx);
#pragma omp parallel for num_threads(threads)
for (int i = 0; i < threads; i++)
{
int64_t low = 0;
int64_t segments = 0;
int64_t segment_size = 0;
T sum = 0;
Runtime runtime;
while (loadBalancer.get_work(&low, &segments, &segment_size, sum, runtime))
{
runtime.start();
// Unsigned integer division is usually slightly
// faster than signed integer division
using UT = typename make_unsigned<T>::type;
sum = D_thread((UT) x, x_star, xz, y, z, k, low, segments, segment_size, factor, pi, primes, runtime);
runtime.stop();
}
}
T sum = (T) loadBalancer.get_sum();
return sum;
}
} // namespace
namespace primecount {
int64_t D(int64_t x,
int64_t y,
int64_t z,
int64_t k,
int64_t d_approx,
int threads)
{
print("");
print("=== D(x, y) ===");
print_gourdon_vars(x, y, z, k, threads);
double time = get_time();
DFactorTable<uint16_t> factor(y, z, threads);
auto primes = generate_primes<int32_t>(y);
int64_t sum = D_OpenMP(x, y, z, k, d_approx, primes, factor, threads);
print("D", sum, time);
return sum;
}
#ifdef HAVE_INT128_T
int128_t D(int128_t x,
int64_t y,
int64_t z,
int64_t k,
int128_t d_approx,
int threads)
{
print("");
print("=== D(x, y) ===");
print_gourdon_vars(x, y, z, k, threads);
double time = get_time();
int128_t sum;
// uses less memory
if (z <= DFactorTable<uint16_t>::max())
{
DFactorTable<uint16_t> factor(y, z, threads);
auto primes = generate_primes<uint32_t>(y);
sum = D_OpenMP(x, y, z, k, d_approx, primes, factor, threads);
}
else
{
DFactorTable<uint32_t> factor(y, z, threads);
auto primes = generate_primes<int64_t>(y);
sum = D_OpenMP(x, y, z, k, d_approx, primes, factor, threads);
}
print("D", sum, time);
return sum;
}
#endif
} // namespace
<|endoftext|> |
<commit_before>// This file is part of the dune-gdt project:
// http://users.dune-project.org/projects/dune-gdt
// Copyright holders: Felix Schindler
// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
#include "config.h"
#if HAVE_ALUGRID
#include <dune/grid/alugrid.hh>
#include "../problems/ESV2007.hh"
#include "../eocexpectations.hh"
namespace Dune {
namespace GDT {
namespace Test {
template <bool anything>
class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, conforming>, double, 1>,
LinearElliptic::ChooseDiscretizer::cg, 1, anything>
: public internal::LinearEllipticEocExpectationsBase<1>
{
typedef LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, conforming>, double, 1> TestCaseType;
public:
static std::vector<double> results(const TestCaseType& /*test_case*/, const std::string type)
{
if (type == "L2")
return {3.82e-02, 9.64e-03, 2.42e-03, 6.04e-04};
else if (type == "H1_semi" || type == "energy")
return {1.84e-01, 9.24e-02, 4.63e-02, 2.31e-02};
else
EXPECT_TRUE(false) << "test results missing for type: " << type;
return {};
} // ... results(...)
}; // LinearEllipticEocExpectations
template <bool anything>
class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, nonconforming>, double, 1>,
LinearElliptic::ChooseDiscretizer::cg, 1, anything>
: public internal::LinearEllipticEocExpectationsBase<1>
{
typedef LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, nonconforming>, double, 1> TestCaseType;
public:
static std::vector<double> results(const TestCaseType& /*test_case*/, const std::string type)
{
if (type == "L2")
return {1.08e-02, 2.70e-03, 6.76e-04, 1.69e-04};
else if (type == "H1_semi" || type == "energy")
return {9.79e-02, 4.91e-02, 2.45e-02, 1.23e-02};
else
EXPECT_TRUE(false) << "test results missing for type: " << type;
return {};
} // ... results(...)
}; // LinearEllipticEocExpectations
template class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, conforming>, double,
1>,
LinearElliptic::ChooseDiscretizer::cg, 1>;
template class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, nonconforming>,
double, 1>,
LinearElliptic::ChooseDiscretizer::cg, 1>;
} // namespace Test
} // namespace GDT
} // namespace Dune
#endif // HAVE_ALUGRID
<commit_msg>[linearelliptic.cg...] update expected results<commit_after>// This file is part of the dune-gdt project:
// http://users.dune-project.org/projects/dune-gdt
// Copyright holders: Felix Schindler
// License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
#include "config.h"
#if HAVE_ALUGRID
#include <dune/grid/alugrid.hh>
#include "../problems/ESV2007.hh"
#include "../eocexpectations.hh"
namespace Dune {
namespace GDT {
namespace Test {
template <bool anything>
class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, conforming>, double, 1>,
LinearElliptic::ChooseDiscretizer::cg, 1, anything>
: public internal::LinearEllipticEocExpectationsBase<1>
{
typedef LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, conforming>, double, 1> TestCaseType;
public:
static std::vector<double> results(const TestCaseType& /*test_case*/, const std::string type)
{
if (type == "L2")
return {3.82e-02, 9.64e-03, 2.42e-03, 6.04e-04};
else if (type == "H1_semi" || type == "energy")
return {1.84e-01, 9.24e-02, 4.63e-02, 2.31e-02};
else
EXPECT_TRUE(false) << "test results missing for type: " << type;
return {};
} // ... results(...)
}; // LinearEllipticEocExpectations
template <bool anything>
class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, nonconforming>, double, 1>,
LinearElliptic::ChooseDiscretizer::cg, 1, anything>
: public internal::LinearEllipticEocExpectationsBase<1>
{
typedef LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, nonconforming>, double, 1> TestCaseType;
public:
static std::vector<double> results(const TestCaseType& /*test_case*/, const std::string type)
{
if (type == "L2")
return {4.22e-02, 1.08e-02, 2.70e-03, 6.76e-04};
else if (type == "H1_semi" || type == "energy")
return {1.94e-01, 9.79e-02, 4.91e-02, 2.45e-02};
else
EXPECT_TRUE(false) << "test results missing for type: " << type;
return {};
} // ... results(...)
}; // LinearEllipticEocExpectations
template class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, conforming>, double,
1>,
LinearElliptic::ChooseDiscretizer::cg, 1>;
template class LinearEllipticEocExpectations<LinearElliptic::ESV2007TestCase<ALUGrid<2, 2, simplex, nonconforming>,
double, 1>,
LinearElliptic::ChooseDiscretizer::cg, 1>;
} // namespace Test
} // namespace GDT
} // namespace Dune
#endif // HAVE_ALUGRID
<|endoftext|> |
<commit_before>/*
* Copyright (C) 2006,2007,2008,2009,2010,2011,2012 Olly Betts
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "length.h"
std::string encode_length(size_t len)
{
std::string result;
if (len < 255) {
result += static_cast<unsigned char>(len);
} else {
result += '\xff';
len -= 255;
while (true) {
unsigned char b = static_cast<unsigned char>(len & 0x7f);
len >>= 7;
if (!len) {
result += (b | static_cast<unsigned char>(0x80));
break;
}
result += b;
}
}
return result;
}
size_t
decode_length(const char ** p, const char *end, bool check_remaining)
{
const char *pos = *p;
if (pos == end) {
return -1;
}
size_t len = static_cast<unsigned char>(*pos++);
if (len == 0xff) {
len = 0;
unsigned char ch;
int shift = 0;
do {
if (*p == end || shift > 28)
return -1;
ch = *pos++;
len |= size_t(ch & 0x7f) << shift;
shift += 7;
} while ((ch & 0x80) == 0);
len += 255;
}
if (check_remaining && len > size_t(end - *p)) {
return -1;
}
*p = pos;
return len;
}<commit_msg>Fixed decode_length() to really check against current walking position<commit_after>/*
* Copyright (C) 2006,2007,2008,2009,2010,2011,2012 Olly Betts
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "length.h"
std::string
encode_length(size_t len)
{
std::string result;
if (len < 255) {
result += static_cast<unsigned char>(len);
} else {
result += '\xff';
len -= 255;
while (true) {
unsigned char b = static_cast<unsigned char>(len & 0x7f);
len >>= 7;
if (!len) {
result += (b | static_cast<unsigned char>(0x80));
break;
}
result += b;
}
}
return result;
}
size_t
decode_length(const char ** p, const char *end, bool check_remaining)
{
const char *pos = *p;
if (pos == end) {
return -1;
}
size_t len = static_cast<unsigned char>(*pos++);
if (len == 0xff) {
len = 0;
unsigned char ch;
int shift = 0;
do {
if (pos == end || shift > 28)
return -1;
ch = *pos++;
len |= size_t(ch & 0x7f) << shift;
shift += 7;
} while ((ch & 0x80) == 0);
len += 255;
}
if (check_remaining && len > size_t(end - pos)) {
return -1;
}
*p = pos;
return len;
}
<|endoftext|> |
<commit_before>/*
* Copyright 2012 Bram van der Kroef
*
* This file is part of LESS CSS Compiler.
*
* LESS CSS Compiler 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.
*
* LESS CSS Compiler 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 LESS CSS Compiler. If not, see <http://www.gnu.org/licenses/>.
*
* Author: Bram van der Kroef <[email protected]>
*/
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <getopt.h>
#include "LessTokenizer.h"
#include "LessParser.h"
#include "CssWriter.h"
#include "CssPrettyWriter.h"
#include "Stylesheet.h"
#include "IOException.h"
#include "LessStylesheet.h"
#include <config.h>
#ifdef WITH_LIBGLOG
#include <glog/logging.h>
#endif
using namespace std;
/**
* /main Less CSS compiler, implemented in C++.
*
*/
void usage () {
cout <<
"Usage: lessc [OPTION]... [FILE]\n"
"\n"
" FILE Less source file. If not given, source \
is read from stdin.\n"
" -h, --help Show this message and exit.\n"
" --version Print the program name and version.\n"
"\n"
" -o, --output=<FILE> Send output to FILE\n"
" -f, --format Format output CSS with newlines and \
indentation. By default the output is unformatted.\n"
"\n"
" -m, --source-map=[FILE] Generate a source map.\n"
" --source-map-rootpath=<PATH> PATH is prepended to the \
source file references in the source map, and also to the source map \
reference in the css output. \n"
" --source-map-basepath=<PATH> PATH is removed from the \
source file references in the source map, and also from the source \
map reference in the css output.\n"
"\n"
" -v, --verbose=<LEVEL> Output log data for debugging. LEVEL is \
a number in the range 1-3 that defines granularity.\n"
"\n"
"Example:\n"
" lessc in.less -o out.css\n"
"\n"
"Report bugs to: " PACKAGE_BUGREPORT "\n"
PACKAGE_NAME " home page: <" PACKAGE_URL ">\n";
}
void version () {
cout <<
PACKAGE_STRING "\n"
"Copyright 2012 Bram van der Kroef\n"
"License GPLv3+: GNU GPL version 3 or later \
<http://gnu.org/licenses/gpl.html>\n"
"This is free software: you are free to change and redistribute it.\n"
"There is NO WARRANTY, to the extent permitted by law.\n";
}
bool parseInput(LessStylesheet &stylesheet,
istream &in,
const char* source,
std::list<const char*> &sources){
std::list<const char*>::iterator i;
LessTokenizer tokenizer(in, source);
LessParser parser(tokenizer, sources);
try{
parser.parseStylesheet(stylesheet);
} catch(ParseException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#else
cerr << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#endif
return false;
} catch(ValueException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Error: " << e->what();
#else
cerr << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Error: " << e->what();
#endif
} catch(exception* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << " Error: " << e->what();
#else
cerr << " Error: " << e->what();
#endif
return false;
}
#ifdef WITH_LIBGLOG
VLOG(1) << "Source files: ";
for(i = sources.begin(); i != sources.end(); i++) {
VLOG(1) << (*i);
}
#endif
return true;
}
void writeOutput (LessStylesheet &stylesheet,
CssWriter &writer) {
Stylesheet css;
ProcessingContext context;
try{
stylesheet.process(css, context);
} catch(ParseException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#else
cerr << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#endif
return;
} catch(exception* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << "Error: " << e->what();
#else
cerr << "Error: " << e->what();
#endif
return;
}
css.write(writer);
}
int main(int argc, char * argv[]){
istream* in = &cin;
ostream* out = &cout;
bool formatoutput = false;
char* source = NULL;
string output = "-";
LessStylesheet stylesheet;
std::list<const char*> sources;
CssWriter* writer;
std::string sourcemap_file = "";
ostream* sourcemap_s = NULL;
SourceMapWriter* sourcemap = NULL;
const char* sourcemap_rootpath = NULL;
const char* sourcemap_basepath = NULL;
static struct option long_options[] = {
{"version", no_argument, 0, 1},
{"help", no_argument, 0, 'h'},
{"output", required_argument, 0, 'o'},
{"format", no_argument, 0, 'f'},
{"verbose", required_argument, 0, 'v'},
{"source-map", optional_argument, 0, 'm'},
{"source-map-rootpath", required_argument, 0, 2},
{"source-map-basepath", required_argument, 0, 3},
{0,0,0,0}
};
#ifdef WITH_LIBGLOG
FLAGS_logtostderr = 1;
google::InitGoogleLogging(argv[0]);
VLOG(1) << "Start.";
#endif
try {
int c, option_index;
#ifdef WITH_LIBGLOG
VLOG(3) << "argc: " << argc;
#endif
while((c = getopt_long(argc, argv, ":o:hfv:m::", long_options, &option_index)) != -1) {
switch (c) {
case 1:
version();
return 0;
case 'h':
usage();
return 0;
case 'o':
output = optarg;
out = new ofstream(optarg);
break;
case 'f':
formatoutput = true;
break;
case 'v':
#ifdef WITH_LIBGLOG
FLAGS_v = atoi(optarg);
#else
std::cerr << "Warning: -v flag not supported: lessc has to be compiled with libglog.\n";
#endif
break;
case 'm':
if (optarg)
sourcemap_file = optarg;
else
sourcemap_file = "-";
break;
case 2:
sourcemap_rootpath = optarg;
break;
case 3:
sourcemap_basepath = optarg;
break;
}
}
if(argc - optind >= 1){
#ifdef WITH_LIBGLOG
VLOG(1) << argv[optind];
#endif
source = new char[std::strlen(argv[optind]) + 1];
std::strcpy(source, argv[optind]);
in = new ifstream(source);
if (in->fail() || in->bad())
throw new IOException("Error opening file");
} else if (sourcemap_file == "-") {
throw new IOException("source-map option requires that \
a file name is specified for either the source map or the less \
source.");
} else {
source = new char[2];
std::strcpy(source, "-");
}
if (sourcemap_file == "-") {
sourcemap_file = source;
sourcemap_file += ".map";
}
sources.push_back(source);
if (parseInput(stylesheet, *in, source, sources)) {
if (sourcemap_file != "") {
#ifdef WITH_LIBGLOG
VLOG(1) << "sourcemap: " << sourcemap_file;
#endif
sourcemap_s = new ofstream(sourcemap_file.c_str());
sourcemap = new SourceMapWriter(*sourcemap_s, sources, output.c_str(),
sourcemap_rootpath,
sourcemap_basepath);
writer = formatoutput ? new CssPrettyWriter(*out, *sourcemap) :
new CssWriter(*out, *sourcemap);
} else {
writer = formatoutput ? new CssPrettyWriter(*out) :
new CssWriter(*out);
}
writeOutput(stylesheet, *writer);
if (sourcemap != NULL) {
if (sourcemap_basepath != NULL &&
sourcemap_file.compare(0, std::strlen(sourcemap_basepath),
sourcemap_basepath) == 0) {
sourcemap_file.erase(0, std::strlen(sourcemap_basepath));
}
if (sourcemap_rootpath != NULL)
sourcemap_file.insert(0, sourcemap_rootpath);
writer->writeSourceMapUrl(sourcemap_file.c_str());
sourcemap->close();
delete sourcemap;
if (sourcemap_s != NULL)
delete sourcemap_s;
}
delete writer;
*out << endl;
} else
return 1;
delete source;
} catch (IOException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << " Error: " << e->what();
#else
cerr << " Error: " << e->what();
#endif
return 1;
}
return 0;
}
<commit_msg>Put the ValueException catching in the right place.<commit_after>/*
* Copyright 2012 Bram van der Kroef
*
* This file is part of LESS CSS Compiler.
*
* LESS CSS Compiler 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.
*
* LESS CSS Compiler 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 LESS CSS Compiler. If not, see <http://www.gnu.org/licenses/>.
*
* Author: Bram van der Kroef <[email protected]>
*/
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <getopt.h>
#include "LessTokenizer.h"
#include "LessParser.h"
#include "CssWriter.h"
#include "CssPrettyWriter.h"
#include "Stylesheet.h"
#include "IOException.h"
#include "LessStylesheet.h"
#include <config.h>
#ifdef WITH_LIBGLOG
#include <glog/logging.h>
#endif
using namespace std;
/**
* /main Less CSS compiler, implemented in C++.
*
*/
void usage () {
cout <<
"Usage: lessc [OPTION]... [FILE]\n"
"\n"
" FILE Less source file. If not given, source \
is read from stdin.\n"
" -h, --help Show this message and exit.\n"
" --version Print the program name and version.\n"
"\n"
" -o, --output=<FILE> Send output to FILE\n"
" -f, --format Format output CSS with newlines and \
indentation. By default the output is unformatted.\n"
"\n"
" -m, --source-map=[FILE] Generate a source map.\n"
" --source-map-rootpath=<PATH> PATH is prepended to the \
source file references in the source map, and also to the source map \
reference in the css output. \n"
" --source-map-basepath=<PATH> PATH is removed from the \
source file references in the source map, and also from the source \
map reference in the css output.\n"
"\n"
" -v, --verbose=<LEVEL> Output log data for debugging. LEVEL is \
a number in the range 1-3 that defines granularity.\n"
"\n"
"Example:\n"
" lessc in.less -o out.css\n"
"\n"
"Report bugs to: " PACKAGE_BUGREPORT "\n"
PACKAGE_NAME " home page: <" PACKAGE_URL ">\n";
}
void version () {
cout <<
PACKAGE_STRING "\n"
"Copyright 2012 Bram van der Kroef\n"
"License GPLv3+: GNU GPL version 3 or later \
<http://gnu.org/licenses/gpl.html>\n"
"This is free software: you are free to change and redistribute it.\n"
"There is NO WARRANTY, to the extent permitted by law.\n";
}
bool parseInput(LessStylesheet &stylesheet,
istream &in,
const char* source,
std::list<const char*> &sources){
std::list<const char*>::iterator i;
LessTokenizer tokenizer(in, source);
LessParser parser(tokenizer, sources);
try{
parser.parseStylesheet(stylesheet);
} catch(ParseException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#else
cerr << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#endif
return false;
} catch(exception* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << " Error: " << e->what();
#else
cerr << " Error: " << e->what();
#endif
return false;
}
#ifdef WITH_LIBGLOG
VLOG(1) << "Source files: ";
for(i = sources.begin(); i != sources.end(); i++) {
VLOG(1) << (*i);
}
#endif
return true;
}
void writeOutput (LessStylesheet &stylesheet,
CssWriter &writer) {
Stylesheet css;
ProcessingContext context;
try{
stylesheet.process(css, context);
} catch(ParseException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#else
cerr << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Parse Error: " << e->what();
#endif
return;
} catch(ValueException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Error: " << e->what();
#else
cerr << e->getSource() << ": Line " << e->getLineNumber() << ", Column " <<
e->getColumn() << " Error: " << e->what();
#endif
return;
} catch(exception* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << "Error: " << e->what();
#else
cerr << "Error: " << e->what();
#endif
return;
}
css.write(writer);
}
int main(int argc, char * argv[]){
istream* in = &cin;
ostream* out = &cout;
bool formatoutput = false;
char* source = NULL;
string output = "-";
LessStylesheet stylesheet;
std::list<const char*> sources;
CssWriter* writer;
std::string sourcemap_file = "";
ostream* sourcemap_s = NULL;
SourceMapWriter* sourcemap = NULL;
const char* sourcemap_rootpath = NULL;
const char* sourcemap_basepath = NULL;
static struct option long_options[] = {
{"version", no_argument, 0, 1},
{"help", no_argument, 0, 'h'},
{"output", required_argument, 0, 'o'},
{"format", no_argument, 0, 'f'},
{"verbose", required_argument, 0, 'v'},
{"source-map", optional_argument, 0, 'm'},
{"source-map-rootpath", required_argument, 0, 2},
{"source-map-basepath", required_argument, 0, 3},
{0,0,0,0}
};
#ifdef WITH_LIBGLOG
FLAGS_logtostderr = 1;
google::InitGoogleLogging(argv[0]);
VLOG(1) << "Start.";
#endif
try {
int c, option_index;
#ifdef WITH_LIBGLOG
VLOG(3) << "argc: " << argc;
#endif
while((c = getopt_long(argc, argv, ":o:hfv:m::", long_options, &option_index)) != -1) {
switch (c) {
case 1:
version();
return 0;
case 'h':
usage();
return 0;
case 'o':
output = optarg;
out = new ofstream(optarg);
break;
case 'f':
formatoutput = true;
break;
case 'v':
#ifdef WITH_LIBGLOG
FLAGS_v = atoi(optarg);
#else
std::cerr << "Warning: -v flag not supported: lessc has to be compiled with libglog.\n";
#endif
break;
case 'm':
if (optarg)
sourcemap_file = optarg;
else
sourcemap_file = "-";
break;
case 2:
sourcemap_rootpath = optarg;
break;
case 3:
sourcemap_basepath = optarg;
break;
}
}
if(argc - optind >= 1){
#ifdef WITH_LIBGLOG
VLOG(1) << argv[optind];
#endif
source = new char[std::strlen(argv[optind]) + 1];
std::strcpy(source, argv[optind]);
in = new ifstream(source);
if (in->fail() || in->bad())
throw new IOException("Error opening file");
} else if (sourcemap_file == "-") {
throw new IOException("source-map option requires that \
a file name is specified for either the source map or the less \
source.");
} else {
source = new char[2];
std::strcpy(source, "-");
}
if (sourcemap_file == "-") {
sourcemap_file = source;
sourcemap_file += ".map";
}
sources.push_back(source);
if (parseInput(stylesheet, *in, source, sources)) {
if (sourcemap_file != "") {
#ifdef WITH_LIBGLOG
VLOG(1) << "sourcemap: " << sourcemap_file;
#endif
sourcemap_s = new ofstream(sourcemap_file.c_str());
sourcemap = new SourceMapWriter(*sourcemap_s, sources, output.c_str(),
sourcemap_rootpath,
sourcemap_basepath);
writer = formatoutput ? new CssPrettyWriter(*out, *sourcemap) :
new CssWriter(*out, *sourcemap);
} else {
writer = formatoutput ? new CssPrettyWriter(*out) :
new CssWriter(*out);
}
writeOutput(stylesheet, *writer);
if (sourcemap != NULL) {
if (sourcemap_basepath != NULL &&
sourcemap_file.compare(0, std::strlen(sourcemap_basepath),
sourcemap_basepath) == 0) {
sourcemap_file.erase(0, std::strlen(sourcemap_basepath));
}
if (sourcemap_rootpath != NULL)
sourcemap_file.insert(0, sourcemap_rootpath);
writer->writeSourceMapUrl(sourcemap_file.c_str());
sourcemap->close();
delete sourcemap;
if (sourcemap_s != NULL)
delete sourcemap_s;
}
delete writer;
*out << endl;
} else
return 1;
delete source;
} catch (IOException* e) {
#ifdef WITH_LIBGLOG
LOG(ERROR) << " Error: " << e->what();
#else
cerr << " Error: " << e->what();
#endif
return 1;
}
return 0;
}
<|endoftext|> |
<commit_before>// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/fastos/fastos.h>
#include <vespa/filedistribution/common/logfwd.h>
#include <stdarg.h>
#include <iostream>
#include <boost/scoped_array.hpp>
#include <stdio.h>
void filedistribution::logfwd::log_forward(LogLevel level, const char* file, int line, const char* fmt, ...)
{
if (level == debug || level == info)
return;
const size_t maxSize(0x8000);
boost::scoped_array<char> payload(new char[maxSize]);
va_list args;
va_start(args, fmt);
vsnprintf(payload.get(), maxSize, fmt, args);
va_end(args);
std::cerr <<"Error: " <<payload.get() <<" File: " <<file <<" Line: " <<line <<std::endl;
}
<commit_msg>boost::scoped_array -> std::vector<commit_after>// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <vespa/fastos/fastos.h>
#include <vespa/filedistribution/common/logfwd.h>
#include <stdarg.h>
#include <iostream>
#include <stdio.h>
void filedistribution::logfwd::log_forward(LogLevel level, const char* file, int line, const char* fmt, ...)
{
if (level == debug || level == info)
return;
const size_t maxSize(0x8000);
std::vector<char> payload(maxSize);
char * buf = &payload[0];
va_list args;
va_start(args, fmt);
vsnprintf(buf, maxSize, fmt, args);
va_end(args);
std::cerr <<"Error: " << buf <<" File: " <<file <<" Line: " <<line <<std::endl;
}
<|endoftext|> |
<commit_before>/*
* Copyright (c) 2011, Peter Thorson. 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 WebSocket++ Project 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 PETER THORSON 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 WSPERF_CASE__AUTOBAHN_HPP
#define WSPERF_CASE__AUTOBAHN_HPP
#include "case.hpp"
namespace wsperf {
// test class for 9.1.* and 9.2.*
class test_9_1_X : public case_handler {
public:
test_9_1_X(int minor, int subtest)
: m_minor(minor),
m_subtest(subtest)
{
// needs more C++11 intializer lists =(
m_test_sizes[0] = 65536;
m_test_sizes[1] = 262144;
m_test_sizes[2] = 1048576;
m_test_sizes[3] = 4194304;
m_test_sizes[4] = 8388608;
m_test_sizes[5] = 16777216;
}
void on_open(connection_ptr con) {
std::stringstream o;
o << "Test 9." << m_minor << "." << m_subtest;
m_name = o.str();
m_data.reserve(m_test_sizes[m_subtest-1]);
int timeout = 10000; // 10 sec
// extend timeout to 100 sec for the longer tests
if ((m_minor == 1 && m_subtest >= 3) || (m_minor == 2 && m_subtest >= 5)) {
timeout = 100000;
}
if (m_minor == 1) {
fill_utf8(m_data,m_test_sizes[m_subtest-1],true);
start(con,timeout);
con->send(m_data,websocketpp::frame::opcode::TEXT);
} else if (m_minor == 2) {
fill_binary(m_data,m_test_sizes[m_subtest-1],true);
start(con,timeout);
con->send(m_data,websocketpp::frame::opcode::BINARY);
} else {
std::cout << " has unknown definition." << std::endl;
}
}
void on_message(connection_ptr con,websocketpp::message::data_ptr msg) {
m_timer->cancel();
mark();
// Check whether the echoed data matches exactly
m_pass = ((msg->get_payload() == m_data) ? PASS : FAIL);
this->end(con);
}
private:
int m_minor;
int m_subtest;
int m_test_sizes[6];
std::string m_data;
};
// test class for 9.7.* and 9.8.*
class test_9_7_X : public case_handler {
public:
test_9_7_X(int minor, int subtest)
: m_minor(minor),
m_subtest(subtest),
m_acks(0)
{
// needs more C++11 intializer lists =(
m_test_sizes[0] = 0;
m_test_sizes[1] = 16;
m_test_sizes[2] = 64;
m_test_sizes[3] = 256;
m_test_sizes[4] = 1024;
m_test_sizes[5] = 4096;
m_test_timeouts[0] = 60000;
m_test_timeouts[1] = 60000;
m_test_timeouts[2] = 60000;
m_test_timeouts[3] = 120000;
m_test_timeouts[4] = 240000;
m_test_timeouts[5] = 480000;
m_iterations = 1000;
}
void on_open(connection_ptr con) {
std::stringstream o;
o << "Test 9." << m_minor << "." << m_subtest;
m_name = o.str();
// Get a message buffer from the connection
m_msg = con->get_data_message();
// reserve space in our local data buffer
m_data.reserve(m_test_sizes[m_subtest-1]);
// Reset message to appropriate opcode and fill local buffer with
// appropriate types of random data.
if (m_minor == 7) {
fill_utf8(m_data,m_test_sizes[m_subtest-1],true);
m_msg->reset(websocketpp::frame::opcode::TEXT);
} else if (m_minor == 8) {
fill_binary(m_data,m_test_sizes[m_subtest-1],true);
m_msg->reset(websocketpp::frame::opcode::BINARY);
} else {
std::cout << " has unknown definition." << std::endl;
return;
}
m_msg->set_payload(m_data);
// start test timer with 60-480 second timeout based on test length
start(con,m_test_timeouts[m_subtest-1]);
con->send(m_msg);
// send 1000 copies of prepared message
/*for (int i = 0; i < m_iterations; i++) {
con->send(msg);
}*/
}
void on_message(connection_ptr con, message_ptr msg) {
if (msg->get_payload() == m_data) {
m_acks++;
mark();
} else {
mark();
m_timer->cancel();
m_msg.reset();
this->end(con);
}
if (m_acks == m_iterations) {
m_pass = PASS;
mark();
m_timer->cancel();
m_msg.reset();
this->end(con);
} else {
con->send(m_msg);
}
}
private:
int m_minor;
int m_subtest;
int m_test_timeouts[6];
size_t m_test_sizes[6];
int m_iterations;
std::string m_data;
int m_acks;
message_ptr m_msg;
};
} // namespace wsperf
#endif // WSPERF_CASE__AUTOBAHN_HPP<commit_msg>adds welcome message to wsperf, lots of wsperf cleanup<commit_after><|endoftext|> |
<commit_before>/*
* ImageWrapper_to_GLTexture.cpp
*
* Copyright (C) 2021 by VISUS (Universitaet Stuttgart).
* Alle Rechte vorbehalten.
*/
#include "ImageWrapper_to_GLTexture.hpp"
#include "ImageWrapper_Conversion_Helpers.hpp"
#include "glad/gl.h"
#include <tuple>
using namespace megamol::frontend_resources;
namespace gl_wrapper_impl {
void gl_init_texture(unsigned int& handle) {
glCreateTextures(GL_TEXTURE_2D, 1, &handle);
}
std::tuple<int, int, int> getInternalformatFormatType(ImageWrapper::DataChannels channels) {
const auto internalformat = channels == ImageWrapper::DataChannels::RGB8 ? GL_RGB8 : GL_RGBA8;
const auto format = channels == ImageWrapper::DataChannels::RGB8 ? GL_RGB : GL_RGBA;
const auto type = GL_UNSIGNED_BYTE;
return {internalformat, format, type};
}
void gl_set_and_resize_texture(unsigned int& handle, ImageWrapper::ImageSize size, ImageWrapper::DataChannels channels,
const void* data = nullptr) {
if (!handle)
gl_init_texture(handle);
int old_handle = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_handle);
glBindTexture(GL_TEXTURE_2D, handle);
glTextureParameteri(handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTextureParameteri(handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTextureParameteri(handle, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTextureParameteri(handle, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
const auto [internalformat, format, type] = getInternalformatFormatType(channels);
glTexImage2D(GL_TEXTURE_2D, 0, internalformat, size.width, size.height, 0, format, type, data);
glBindTexture(GL_TEXTURE_2D, old_handle);
}
void gl_copy_texture(unsigned int from_handle, unsigned int to_handle, ImageWrapper::ImageSize size) {
glCopyImageSubData(
from_handle, GL_TEXTURE_2D, 0, 0, 0, 0, to_handle, GL_TEXTURE_2D, 0, 0, 0, 0, size.width, size.height, 1);
}
void gl_delete_texture(unsigned int& handle) {
glDeleteTextures(1, &handle);
handle = 0;
}
void gl_download_texture_to_vector(
unsigned int handle, ImageWrapper::ImageSize size, ImageWrapper::DataChannels channels, std::vector<byte>& target) {
target.resize(size.width * size.height * 4); // see below
const auto [internalformat, format, type] = getInternalformatFormatType(channels);
// returns RGBA8 and fills unused components with defaults
// https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glGetTextureSubImage.xhtml
// https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glGetTexImage.xhtml
glGetTextureSubImage(handle, 0, 0, 0, 0, size.width, size.height, 1, format, type, target.size(), target.data());
//glGetTextureImage(handle, 0, format, type, target.size(), target.data());
}
void gl_upload_texture_from_vector(unsigned int& handle, ImageWrapper::ImageSize size,
ImageWrapper::DataChannels channels, std::vector<byte> const& source) {
gl_set_and_resize_texture(handle, size, channels, source.data());
}
} // namespace gl_wrapper_impl
gl_texture::~gl_texture() {
if (this->texture != 0) {
gl_wrapper_impl::gl_delete_texture(this->texture);
}
this->clear();
}
void gl_texture::from_image(ImageWrapper const& image) {
this->image_wrapper_ptr = const_cast<ImageWrapper*>(&image);
this->size = image.size;
switch (image.type) {
case WrappedImageType::ByteArray:
gl_wrapper_impl::gl_set_and_resize_texture(
this->texture, image.size, image.channels, conversion::to_vector(image.referenced_image_handle)->data());
this->texture_reference = this->texture;
break;
case WrappedImageType::GLTexureHandle:
this->texture_reference = conversion::to_uint(image.referenced_image_handle);
break;
}
}
void gl_texture::assign(gl_texture const& other, bool take_ownership) {
this->image_wrapper_ptr = other.image_wrapper_ptr;
this->size = other.size;
if (take_ownership) {
this->texture = other.texture;
} else {
if (other.texture != 0) {
auto& image = *this->image_wrapper_ptr;
gl_wrapper_impl::gl_set_and_resize_texture(this->texture, image.size, image.channels);
gl_wrapper_impl::gl_copy_texture(other.texture, this->texture, image.size);
}
}
if (other.texture_reference == other.texture) {
this->texture_reference = this->texture;
} else {
this->texture_reference = other.texture_reference;
}
}
<commit_msg>Update frontend/services/image_presentation/gl/ImageWrapper_to_GLTexture.cpp<commit_after>/*
* ImageWrapper_to_GLTexture.cpp
*
* Copyright (C) 2021 by VISUS (Universitaet Stuttgart).
* Alle Rechte vorbehalten.
*/
#include "ImageWrapper_to_GLTexture.hpp"
#include "ImageWrapper_Conversion_Helpers.hpp"
#include "glad/gl.h"
#include <tuple>
using namespace megamol::frontend_resources;
namespace gl_wrapper_impl {
void gl_init_texture(unsigned int& handle) {
glCreateTextures(GL_TEXTURE_2D, 1, &handle);
}
std::tuple<int, int, int> getInternalformatFormatType(ImageWrapper::DataChannels channels) {
if (channels != ImageWrapper::DataChannels::RGBA8 &&
channels != ImageWrapper::DataChannels::RGB8) {
throw std::runtime_error("[ImageWrapper_to_GLTexture.cpp] Only image with RGBA8 or RGA8 channels supported for now...");
}
const auto internalformat = channels == ImageWrapper::DataChannels::RGB8 ? GL_RGB8 : GL_RGBA8;
const auto format = channels == ImageWrapper::DataChannels::RGB8 ? GL_RGB : GL_RGBA;
const auto type = GL_UNSIGNED_BYTE;
return {internalformat, format, type};
}
void gl_set_and_resize_texture(unsigned int& handle, ImageWrapper::ImageSize size, ImageWrapper::DataChannels channels,
const void* data = nullptr) {
if (!handle)
gl_init_texture(handle);
int old_handle = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_handle);
glBindTexture(GL_TEXTURE_2D, handle);
glTextureParameteri(handle, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTextureParameteri(handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTextureParameteri(handle, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTextureParameteri(handle, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
const auto [internalformat, format, type] = getInternalformatFormatType(channels);
glTexImage2D(GL_TEXTURE_2D, 0, internalformat, size.width, size.height, 0, format, type, data);
glBindTexture(GL_TEXTURE_2D, old_handle);
}
void gl_copy_texture(unsigned int from_handle, unsigned int to_handle, ImageWrapper::ImageSize size) {
glCopyImageSubData(
from_handle, GL_TEXTURE_2D, 0, 0, 0, 0, to_handle, GL_TEXTURE_2D, 0, 0, 0, 0, size.width, size.height, 1);
}
void gl_delete_texture(unsigned int& handle) {
glDeleteTextures(1, &handle);
handle = 0;
}
void gl_download_texture_to_vector(
unsigned int handle, ImageWrapper::ImageSize size, ImageWrapper::DataChannels channels, std::vector<byte>& target) {
target.resize(size.width * size.height * 4); // see below
const auto [internalformat, format, type] = getInternalformatFormatType(channels);
// returns RGBA8 and fills unused components with defaults
// https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glGetTextureSubImage.xhtml
// https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glGetTexImage.xhtml
glGetTextureSubImage(handle, 0, 0, 0, 0, size.width, size.height, 1, format, type, target.size(), target.data());
//glGetTextureImage(handle, 0, format, type, target.size(), target.data());
}
void gl_upload_texture_from_vector(unsigned int& handle, ImageWrapper::ImageSize size,
ImageWrapper::DataChannels channels, std::vector<byte> const& source) {
gl_set_and_resize_texture(handle, size, channels, source.data());
}
} // namespace gl_wrapper_impl
gl_texture::~gl_texture() {
if (this->texture != 0) {
gl_wrapper_impl::gl_delete_texture(this->texture);
}
this->clear();
}
void gl_texture::from_image(ImageWrapper const& image) {
this->image_wrapper_ptr = const_cast<ImageWrapper*>(&image);
this->size = image.size;
switch (image.type) {
case WrappedImageType::ByteArray:
gl_wrapper_impl::gl_set_and_resize_texture(
this->texture, image.size, image.channels, conversion::to_vector(image.referenced_image_handle)->data());
this->texture_reference = this->texture;
break;
case WrappedImageType::GLTexureHandle:
this->texture_reference = conversion::to_uint(image.referenced_image_handle);
break;
}
}
void gl_texture::assign(gl_texture const& other, bool take_ownership) {
this->image_wrapper_ptr = other.image_wrapper_ptr;
this->size = other.size;
if (take_ownership) {
this->texture = other.texture;
} else {
if (other.texture != 0) {
auto& image = *this->image_wrapper_ptr;
gl_wrapper_impl::gl_set_and_resize_texture(this->texture, image.size, image.channels);
gl_wrapper_impl::gl_copy_texture(other.texture, this->texture, image.size);
}
}
if (other.texture_reference == other.texture) {
this->texture_reference = this->texture;
} else {
this->texture_reference = other.texture_reference;
}
}
<|endoftext|> |
<commit_before>/*
* Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h"
#include <cstdint>
#include <cstring>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "modules/video_coding/include/video_error_codes.h"
#include "rtc_base/logging.h"
namespace webrtc {
namespace test {
QualityAnalyzingVideoDecoder::QualityAnalyzingVideoDecoder(
int id,
std::unique_ptr<VideoDecoder> delegate,
EncodedImageIdExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer)
: id_(id),
implementation_name_("AnalyzingDecoder-" +
std::string(delegate_->ImplementationName())),
delegate_(std::move(delegate)),
extractor_(extractor),
analyzer_(analyzer) {
analyzing_callback_ = absl::make_unique<DecoderCallback>(this);
}
QualityAnalyzingVideoDecoder::~QualityAnalyzingVideoDecoder() = default;
int32_t QualityAnalyzingVideoDecoder::InitDecode(
const VideoCodec* codec_settings,
int32_t number_of_cores) {
return delegate_->InitDecode(codec_settings, number_of_cores);
}
int32_t QualityAnalyzingVideoDecoder::Decode(
const EncodedImage& input_image,
bool missing_frames,
const CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) {
// Image extractor extracts id from provided EncodedImage and also returns
// the image with the original buffer. Buffer can be modified in place, so
// owner of original buffer will be responsible for deleting it, or extractor
// can create a new buffer. In such case extractor will be responsible for
// deleting it.
EncodedImageWithId out = extractor_->ExtractId(input_image, id_);
EncodedImage* origin_image;
{
rtc::CritScope crit(&lock_);
// Store id to be able to retrieve it in analyzing callback.
timestamp_to_frame_id_.insert({input_image.Timestamp(), out.id});
// Store encoded image to prevent its destruction while it is used in
// decoder.
origin_image = &(
decoding_images_.insert({out.id, std::move(out.image)}).first->second);
}
// We can safely dereference |origin_image|, because it can be removed from
// the map only after |delegate_| Decode method will be invoked. Image will be
// removed inside DecodedImageCallback, which can be done on separate thread.
analyzer_->OnFrameReceived(out.id, *origin_image);
int32_t result = delegate_->Decode(*origin_image, missing_frames,
codec_specific_info, render_time_ms);
if (result != WEBRTC_VIDEO_CODEC_OK) {
// If delegate decoder failed, then cleanup data for this image.
{
rtc::CritScope crit(&lock_);
timestamp_to_frame_id_.erase(input_image.Timestamp());
decoding_images_.erase(out.id);
}
analyzer_->OnDecoderError(out.id, result);
}
return result;
}
int32_t QualityAnalyzingVideoDecoder::RegisterDecodeCompleteCallback(
DecodedImageCallback* callback) {
analyzing_callback_->SetDelegateCallback(callback);
return delegate_->RegisterDecodeCompleteCallback(analyzing_callback_.get());
}
int32_t QualityAnalyzingVideoDecoder::Release() {
rtc::CritScope crit(&lock_);
analyzing_callback_->SetDelegateCallback(nullptr);
timestamp_to_frame_id_.clear();
decoding_images_.clear();
return delegate_->Release();
}
bool QualityAnalyzingVideoDecoder::PrefersLateDecoding() const {
return delegate_->PrefersLateDecoding();
}
const char* QualityAnalyzingVideoDecoder::ImplementationName() const {
return implementation_name_.c_str();
}
QualityAnalyzingVideoDecoder::DecoderCallback::DecoderCallback(
QualityAnalyzingVideoDecoder* decoder)
: decoder_(decoder), delegate_callback_(nullptr) {}
QualityAnalyzingVideoDecoder::DecoderCallback::~DecoderCallback() = default;
void QualityAnalyzingVideoDecoder::DecoderCallback::SetDelegateCallback(
DecodedImageCallback* delegate) {
rtc::CritScope crit(&callback_lock_);
delegate_callback_ = delegate;
}
// We have to implement all next 3 methods because we don't know which one
// exactly is implemented in |delegate_callback_|, so we need to call the same
// method on |delegate_callback_|, as was called on |this| callback.
int32_t QualityAnalyzingVideoDecoder::DecoderCallback::Decoded(
VideoFrame& decodedImage) {
decoder_->OnFrameDecoded(&decodedImage, /*decode_time_ms=*/absl::nullopt,
/*qp=*/absl::nullopt);
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->Decoded(decodedImage);
}
int32_t QualityAnalyzingVideoDecoder::DecoderCallback::Decoded(
VideoFrame& decodedImage,
int64_t decode_time_ms) {
decoder_->OnFrameDecoded(&decodedImage, decode_time_ms, /*qp=*/absl::nullopt);
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->Decoded(decodedImage, decode_time_ms);
}
void QualityAnalyzingVideoDecoder::DecoderCallback::Decoded(
VideoFrame& decodedImage,
absl::optional<int32_t> decode_time_ms,
absl::optional<uint8_t> qp) {
decoder_->OnFrameDecoded(&decodedImage, decode_time_ms, qp);
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
delegate_callback_->Decoded(decodedImage, decode_time_ms, qp);
}
int32_t
QualityAnalyzingVideoDecoder::DecoderCallback::ReceivedDecodedReferenceFrame(
const uint64_t pictureId) {
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->ReceivedDecodedReferenceFrame(pictureId);
}
int32_t QualityAnalyzingVideoDecoder::DecoderCallback::ReceivedDecodedFrame(
const uint64_t pictureId) {
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->ReceivedDecodedFrame(pictureId);
}
void QualityAnalyzingVideoDecoder::OnFrameDecoded(
VideoFrame* frame,
absl::optional<int32_t> decode_time_ms,
absl::optional<uint8_t> qp) {
uint16_t frame_id;
{
rtc::CritScope crit(&lock_);
auto it = timestamp_to_frame_id_.find(frame->timestamp());
if (it == timestamp_to_frame_id_.end()) {
// Ensure, that we have info about this frame. It can happen that for some
// reasons decoder response, that he failed to decode, when we were
// posting frame to it, but then call the callback for this frame.
RTC_LOG(LS_ERROR) << "QualityAnalyzingVideoDecoder::OnFrameDecoded: No "
"frame id for frame for frame->timestamp()="
<< frame->timestamp();
return;
}
frame_id = it->second;
timestamp_to_frame_id_.erase(it);
decoding_images_.erase(frame_id);
}
// Set frame id to the value, that was extracted from corresponding encoded
// image.
frame->set_id(frame_id);
analyzer_->OnFrameDecoded(*frame, decode_time_ms, qp);
}
QualityAnalyzingVideoDecoderFactory::QualityAnalyzingVideoDecoderFactory(
std::unique_ptr<VideoDecoderFactory> delegate,
IdGenerator<int>* id_generator,
EncodedImageIdExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer)
: delegate_(std::move(delegate)),
id_generator_(id_generator),
extractor_(extractor),
analyzer_(analyzer) {}
QualityAnalyzingVideoDecoderFactory::~QualityAnalyzingVideoDecoderFactory() =
default;
std::vector<SdpVideoFormat>
QualityAnalyzingVideoDecoderFactory::GetSupportedFormats() const {
return delegate_->GetSupportedFormats();
}
std::unique_ptr<VideoDecoder>
QualityAnalyzingVideoDecoderFactory::CreateVideoDecoder(
const SdpVideoFormat& format) {
std::unique_ptr<VideoDecoder> decoder = delegate_->CreateVideoDecoder(format);
return absl::make_unique<QualityAnalyzingVideoDecoder>(
id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
}
std::unique_ptr<VideoDecoder>
QualityAnalyzingVideoDecoderFactory::LegacyCreateVideoDecoder(
const SdpVideoFormat& format,
const std::string& receive_stream_id) {
std::unique_ptr<VideoDecoder> decoder =
delegate_->LegacyCreateVideoDecoder(format, receive_stream_id);
return absl::make_unique<QualityAnalyzingVideoDecoder>(
id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
}
} // namespace test
} // namespace webrtc
<commit_msg>Fix initialization to prevent SIGSEGV<commit_after>/*
* Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "test/pc/e2e/analyzer/video/quality_analyzing_video_decoder.h"
#include <cstdint>
#include <cstring>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "modules/video_coding/include/video_error_codes.h"
#include "rtc_base/logging.h"
namespace webrtc {
namespace test {
QualityAnalyzingVideoDecoder::QualityAnalyzingVideoDecoder(
int id,
std::unique_ptr<VideoDecoder> delegate,
EncodedImageIdExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer)
: id_(id),
implementation_name_("AnalyzingDecoder-" +
std::string(delegate->ImplementationName())),
delegate_(std::move(delegate)),
extractor_(extractor),
analyzer_(analyzer) {
analyzing_callback_ = absl::make_unique<DecoderCallback>(this);
}
QualityAnalyzingVideoDecoder::~QualityAnalyzingVideoDecoder() = default;
int32_t QualityAnalyzingVideoDecoder::InitDecode(
const VideoCodec* codec_settings,
int32_t number_of_cores) {
return delegate_->InitDecode(codec_settings, number_of_cores);
}
int32_t QualityAnalyzingVideoDecoder::Decode(
const EncodedImage& input_image,
bool missing_frames,
const CodecSpecificInfo* codec_specific_info,
int64_t render_time_ms) {
// Image extractor extracts id from provided EncodedImage and also returns
// the image with the original buffer. Buffer can be modified in place, so
// owner of original buffer will be responsible for deleting it, or extractor
// can create a new buffer. In such case extractor will be responsible for
// deleting it.
EncodedImageWithId out = extractor_->ExtractId(input_image, id_);
EncodedImage* origin_image;
{
rtc::CritScope crit(&lock_);
// Store id to be able to retrieve it in analyzing callback.
timestamp_to_frame_id_.insert({input_image.Timestamp(), out.id});
// Store encoded image to prevent its destruction while it is used in
// decoder.
origin_image = &(
decoding_images_.insert({out.id, std::move(out.image)}).first->second);
}
// We can safely dereference |origin_image|, because it can be removed from
// the map only after |delegate_| Decode method will be invoked. Image will be
// removed inside DecodedImageCallback, which can be done on separate thread.
analyzer_->OnFrameReceived(out.id, *origin_image);
int32_t result = delegate_->Decode(*origin_image, missing_frames,
codec_specific_info, render_time_ms);
if (result != WEBRTC_VIDEO_CODEC_OK) {
// If delegate decoder failed, then cleanup data for this image.
{
rtc::CritScope crit(&lock_);
timestamp_to_frame_id_.erase(input_image.Timestamp());
decoding_images_.erase(out.id);
}
analyzer_->OnDecoderError(out.id, result);
}
return result;
}
int32_t QualityAnalyzingVideoDecoder::RegisterDecodeCompleteCallback(
DecodedImageCallback* callback) {
analyzing_callback_->SetDelegateCallback(callback);
return delegate_->RegisterDecodeCompleteCallback(analyzing_callback_.get());
}
int32_t QualityAnalyzingVideoDecoder::Release() {
rtc::CritScope crit(&lock_);
analyzing_callback_->SetDelegateCallback(nullptr);
timestamp_to_frame_id_.clear();
decoding_images_.clear();
return delegate_->Release();
}
bool QualityAnalyzingVideoDecoder::PrefersLateDecoding() const {
return delegate_->PrefersLateDecoding();
}
const char* QualityAnalyzingVideoDecoder::ImplementationName() const {
return implementation_name_.c_str();
}
QualityAnalyzingVideoDecoder::DecoderCallback::DecoderCallback(
QualityAnalyzingVideoDecoder* decoder)
: decoder_(decoder), delegate_callback_(nullptr) {}
QualityAnalyzingVideoDecoder::DecoderCallback::~DecoderCallback() = default;
void QualityAnalyzingVideoDecoder::DecoderCallback::SetDelegateCallback(
DecodedImageCallback* delegate) {
rtc::CritScope crit(&callback_lock_);
delegate_callback_ = delegate;
}
// We have to implement all next 3 methods because we don't know which one
// exactly is implemented in |delegate_callback_|, so we need to call the same
// method on |delegate_callback_|, as was called on |this| callback.
int32_t QualityAnalyzingVideoDecoder::DecoderCallback::Decoded(
VideoFrame& decodedImage) {
decoder_->OnFrameDecoded(&decodedImage, /*decode_time_ms=*/absl::nullopt,
/*qp=*/absl::nullopt);
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->Decoded(decodedImage);
}
int32_t QualityAnalyzingVideoDecoder::DecoderCallback::Decoded(
VideoFrame& decodedImage,
int64_t decode_time_ms) {
decoder_->OnFrameDecoded(&decodedImage, decode_time_ms, /*qp=*/absl::nullopt);
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->Decoded(decodedImage, decode_time_ms);
}
void QualityAnalyzingVideoDecoder::DecoderCallback::Decoded(
VideoFrame& decodedImage,
absl::optional<int32_t> decode_time_ms,
absl::optional<uint8_t> qp) {
decoder_->OnFrameDecoded(&decodedImage, decode_time_ms, qp);
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
delegate_callback_->Decoded(decodedImage, decode_time_ms, qp);
}
int32_t
QualityAnalyzingVideoDecoder::DecoderCallback::ReceivedDecodedReferenceFrame(
const uint64_t pictureId) {
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->ReceivedDecodedReferenceFrame(pictureId);
}
int32_t QualityAnalyzingVideoDecoder::DecoderCallback::ReceivedDecodedFrame(
const uint64_t pictureId) {
rtc::CritScope crit(&callback_lock_);
RTC_DCHECK(delegate_callback_);
return delegate_callback_->ReceivedDecodedFrame(pictureId);
}
void QualityAnalyzingVideoDecoder::OnFrameDecoded(
VideoFrame* frame,
absl::optional<int32_t> decode_time_ms,
absl::optional<uint8_t> qp) {
uint16_t frame_id;
{
rtc::CritScope crit(&lock_);
auto it = timestamp_to_frame_id_.find(frame->timestamp());
if (it == timestamp_to_frame_id_.end()) {
// Ensure, that we have info about this frame. It can happen that for some
// reasons decoder response, that he failed to decode, when we were
// posting frame to it, but then call the callback for this frame.
RTC_LOG(LS_ERROR) << "QualityAnalyzingVideoDecoder::OnFrameDecoded: No "
"frame id for frame for frame->timestamp()="
<< frame->timestamp();
return;
}
frame_id = it->second;
timestamp_to_frame_id_.erase(it);
decoding_images_.erase(frame_id);
}
// Set frame id to the value, that was extracted from corresponding encoded
// image.
frame->set_id(frame_id);
analyzer_->OnFrameDecoded(*frame, decode_time_ms, qp);
}
QualityAnalyzingVideoDecoderFactory::QualityAnalyzingVideoDecoderFactory(
std::unique_ptr<VideoDecoderFactory> delegate,
IdGenerator<int>* id_generator,
EncodedImageIdExtractor* extractor,
VideoQualityAnalyzerInterface* analyzer)
: delegate_(std::move(delegate)),
id_generator_(id_generator),
extractor_(extractor),
analyzer_(analyzer) {}
QualityAnalyzingVideoDecoderFactory::~QualityAnalyzingVideoDecoderFactory() =
default;
std::vector<SdpVideoFormat>
QualityAnalyzingVideoDecoderFactory::GetSupportedFormats() const {
return delegate_->GetSupportedFormats();
}
std::unique_ptr<VideoDecoder>
QualityAnalyzingVideoDecoderFactory::CreateVideoDecoder(
const SdpVideoFormat& format) {
std::unique_ptr<VideoDecoder> decoder = delegate_->CreateVideoDecoder(format);
return absl::make_unique<QualityAnalyzingVideoDecoder>(
id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
}
std::unique_ptr<VideoDecoder>
QualityAnalyzingVideoDecoderFactory::LegacyCreateVideoDecoder(
const SdpVideoFormat& format,
const std::string& receive_stream_id) {
std::unique_ptr<VideoDecoder> decoder =
delegate_->LegacyCreateVideoDecoder(format, receive_stream_id);
return absl::make_unique<QualityAnalyzingVideoDecoder>(
id_generator_->GetNextId(), std::move(decoder), extractor_, analyzer_);
}
} // namespace test
} // namespace webrtc
<|endoftext|> |
<commit_before>#include <Rcpp11>
#include <iostream>
#include <math.h>
#include <numeric>
using namespace Rcpp;
using namespace std;
double loglik(NumericVector eta, NumericVector y, NumericVector weights, Function linkinv, Function devfun)
{
try {
// Compute some values we need for the logLik computation:
NumericVector mu = linkinv(eta);
// Calculate the actual log likelihood:
NumericVector dev_resids = devfun(y, mu, weights);
double ll = sum(dev_resids);
return(ll);
}
catch (...) {
cout << "Error in loglik!" << endl;
cout << "eta: ";
for( auto c : eta)
cout << c << ' ';
cout << endl;
cout << "y: ";
for( auto c : y)
cout << c << ' ';
cout << endl;
cout << "weights: ";
for( auto c : weights)
cout << c << ' ';
cout << endl;
}
return 0.;
}
void gradCalc(NumericVector eta, NumericVector y, NumericVector weights, Function linkinv, NumericVector ldot)
{
// Compute some values we need for the gradient computation:
NumericVector mu = linkinv(eta);
double sumw = sum(weights);
// Calculate the actual log likelihood:
ldot = weights * (mu-y) / sumw;
}
void rcppLinSolver(NumericMatrix X, NumericVector y, NumericVector w, NumericVector adaweights, int nrow, int ncol, int numGroup, NumericMatrix beta, Function linkinv, Function devfun, IntegerVector rangeGroupInd, IntegerVector groupLen, NumericVector lambda, int step, int innerIter, double thresh, NumericVector ldot, NumericVector nullBeta, double gamma, NumericVector eta, IntegerVector betaIsZero, int& groupChange, IntegerVector isActive, IntegerVector useGroup, int reset)
{
NumericVector theta(ncol);
int startInd = 0;
double zeroCheck = 0;
double check = 0;
int count = 0;
double diff = 1;
double norm = 0;
double uOp = 0;
double Lnew = 0;
double Lold = 0;
double sqNormDelta = 0;
double iProd = 0;
NumericVector etaNew(nrow);
NumericVector etaNull(nrow);
NumericVector var(nrow);
for(int i = 0; i < numGroup; i++)
{
if(useGroup[i] == 1)
{
startInd = rangeGroupInd[i];
// Setting up null residuals calc to check if group is 0
// Null residuals means the coefficients of group i are set to zero before computing residuals.
for(int k = 0; k < nrow; k++)
{
etaNull[k] = eta[k];
for(int j = startInd; j < rangeGroupInd[i] + groupLen[i]; j++)
{
etaNull[k] = etaNull[k] - X[k + nrow * j] * beta[step*ncol + j];
}
}
gradCalc(etaNull, y, w, linkinv, ldot);
// Now compute the correlation of this group with the null residuals.
NumericVector grad(groupLen[i]);
for(int j = 0; j < groupLen[i]; j++)
{
grad[j] = 0;
for(int k = 0; k < nrow; k++)
{
grad[j] = grad[j] + X[k + nrow * (j + rangeGroupInd[i])] * ldot[k];
}
}
zeroCheck = sum(pow(grad,2));
// Is this group's correlation with the null residuals smaller than the threshold?
// If so, set the coefficients of the group to zero.
if(zeroCheck <= pow(adaweights[i],2)*pow(lambda[step],2)*groupLen[i])
{
if(betaIsZero[i] == 0)
{
for(int k = 0; k < nrow; k++)
{
for(int j = rangeGroupInd[i]; j < rangeGroupInd[i] + groupLen[i]; j++)
{
eta[k] = eta[k] - X[k + nrow * j] * beta[step*ncol + j];
}
}
}
betaIsZero[i] = 1;
for(int j = 0; j < groupLen[i]; j++)
{
beta[step*ncol + j + rangeGroupInd[i]] = 0;
}
}
else // The group's coefficients are nonzero
{
if(isActive[i] == 0)
{
groupChange = 1;
}
isActive[i] = 1;
// Hold the previous values of the coefficients
for(int k = 0; k < ncol; k++)
{
theta[k] = beta[step*ncol + k];
}
betaIsZero[i] = 0;
NumericVector z(groupLen[i]);
NumericVector U(groupLen[i]);
NumericVector delta(groupLen[i]);
NumericVector betaNew(ncol);
count = 0;
check = 100000;
double t = 1;
// Until convergence, iteratively recompute the group's coefficients:
while(count <= innerIter && check > thresh)
{
count++;
// Compute the working residuals (i.e. residuals at the current coefficient values)
gradCalc(eta, y, w, linkinv, ldot);
// Compute the group's correlation with the working residuals
for(int j = 0; j < groupLen[i]; j++)
{
grad[j] = 0;
for(int k = 0; k < nrow; k++)
{
grad[j] = grad[j] + X[k + nrow * (j + rangeGroupInd[i])] * ldot[k];
}
}
// Compute the log likelihood for the previous coefficient iteration
Lold = loglik(eta, y, w, linkinv, devfun);
// Back-tracking to optimize the step size for gradient descent:
diff = -1;
int optim_steps = 0;
while(diff < 0)
{
optim_steps++;
for(int j = 0; j < groupLen[i]; j++)
{
z[j] = beta[step*ncol + j + rangeGroupInd[i]] - t * grad[j];
}
norm = sum(pow(z, 2));
norm = sqrt(norm);
if(norm != 0){
uOp = (1 - adaweights[i]*lambda[step]*sqrt(double(groupLen[i]))*t/norm); //Or not?
}
else{uOp = 0;}
if(uOp < 0)
{
uOp = 0;
}
for(int j = 0; j < groupLen[i]; j++)
{
U[j] = uOp*z[j];
delta[j] = U[j] - beta[step*ncol + j + rangeGroupInd[i]];
}
// Setting up betaNew and etaNew in direction of Grad for descent momentum
for(int k = 0; k < nrow; k++)
{
etaNew[k] = eta[k];
for(int j = 0; j < groupLen[i]; j++)
{
etaNew[k] = etaNew[k] + delta[j] * X[k + nrow*(rangeGroupInd[i] + j)];
}
}
// Compute log likelihood for the working coefficients
Lnew = loglik(etaNew, y, w, linkinv, devfun);
sqNormDelta = sum(pow(delta, 2));
iProd = sum(grad * delta);
// Check whether the working coefficients reduce the log likelihood
diff = Lold - Lnew + iProd + 0.5/t * sqNormDelta;
// Reduce the step size for the next iteration
t = t * gamma;
}
t = t / gamma;
check = 0;
for(int j = 0; j < groupLen[i]; j++)
{
// Check the difference between iterations of the coefficients
check = check + fabs(theta[j + rangeGroupInd[i]] - U[j]);
// Calculate the null etas (i.e. the etas when group i's coefficients are zero)
for(int k = 0; k < nrow; k++)
{
eta[k] = eta[k] - X[k + nrow * (j + rangeGroupInd[i])]*beta[step*ncol + j + rangeGroupInd[i]];
}
//Apply Nesterov acceleration to calculate the new coefficient values:
beta[step*ncol + j + rangeGroupInd[i]] = U[j] + count/(count+3) * (U[j] - theta[j + rangeGroupInd[i]]);
theta[j + rangeGroupInd[i]] = U[j];
// Compute the new values of eta after iterating group i's coefficients.
for(int k = 0; k < nrow; k++)
{
eta[k] = eta[k] + X[k + nrow * (j + rangeGroupInd[i])]*beta[step*ncol + j + rangeGroupInd[i]];
}
}
}
}
}
}
}
// [[Rcpp::export]]
double killTest(Function ll, double x)
{
NumericVector y = ll(x);
return y[0];
}
// [[Rcpp::export]]
int rcppLinNest(NumericMatrix X, NumericVector y, NumericVector w, NumericVector adaweights, Function linkinv, Function devfun, int nrow, int ncol, int numGroup, IntegerVector rangeGroupInd, IntegerVector groupLen, NumericVector lambda, NumericMatrix beta, int innerIter, int outerIter, double thresh, double outerThresh, NumericVector eta, double gamma, IntegerVector betaIsZero, int reset)
{
NumericVector prob(nrow);
NumericVector nullBeta(ncol);
int n = nrow;
int p = ncol;
NumericVector ldot(n);
IntegerVector isActive(numGroup);
IntegerVector useGroup(numGroup);
IntegerVector tempIsActive(numGroup);
int nlam = lambda.size();
for (int step=0; step<nlam; step++)
{
for(int i=0; i<numGroup; i++)
{
isActive[i] = 0;
useGroup[i] = 1;
}
//Copy the most recent betas into position
if (step>0)
{
int l = step - 1;
for (int i=0; i<ncol; i++)
{
beta[step*ncol + i] = beta[l*ncol + i];
}
}
// outer most loop creating response etc...
int outermostCounter = 0;
double outermostCheck = 100000;
NumericVector outerOldBeta(p);
int groupChange = 1;
while(groupChange == 1)
{
groupChange = 0;
rcppLinSolver(X, y, w, adaweights, nrow, ncol, numGroup, beta, linkinv, devfun, rangeGroupInd, groupLen, lambda, step, innerIter, thresh, ldot, nullBeta, gamma, eta, betaIsZero, groupChange, isActive, useGroup, reset);
while(outermostCounter < outerIter && outermostCheck > outerThresh)
{
outermostCounter ++;
for(int i=0; i<p; i++)
{
outerOldBeta[i] = beta[step*ncol + i];
}
for(int i=0; i<numGroup; i++)
{
tempIsActive[i] = isActive[i];
}
rcppLinSolver(X, y, w, adaweights, nrow, ncol, numGroup, beta, linkinv, devfun, rangeGroupInd, groupLen, lambda, step, innerIter, thresh, ldot, nullBeta, gamma, eta, betaIsZero, groupChange, isActive, tempIsActive, reset);
outermostCheck = 0;
for(int i=0; i<p; i++)
{
outermostCheck = outermostCheck + fabs(outerOldBeta[i] - beta[step*ncol + i]);
}
outermostCheck = outermostCheck / abs(sum(outerOldBeta));
}
}
}
return 1;
}
<commit_msg>added a catch block in gradCalc<commit_after>#include <Rcpp11>
#include <iostream>
#include <math.h>
#include <numeric>
using namespace Rcpp;
using namespace std;
double loglik(NumericVector eta, NumericVector y, NumericVector weights, Function linkinv, Function devfun)
{
try {
// Compute some values we need for the logLik computation:
NumericVector mu = linkinv(eta);
// Calculate the actual log likelihood:
NumericVector dev_resids = devfun(y, mu, weights);
double ll = sum(dev_resids);
return(ll);
}
catch (...) {
cout << "Error in loglik!" << endl;
cout << "eta: ";
for( auto c : eta)
cout << c << ' ';
cout << endl;
cout << "y: ";
for( auto c : y)
cout << c << ' ';
cout << endl;
cout << "weights: ";
for( auto c : weights)
cout << c << ' ';
cout << endl;
}
return 0.;
}
void gradCalc(NumericVector eta, NumericVector y, NumericVector weights, Function linkinv, NumericVector ldot)
{
try {
// Compute some values we need for the gradient computation:
NumericVector mu = linkinv(eta);
double sumw = sum(weights);
// Calculate the actual log likelihood:
ldot = weights * (mu-y) / sumw;
}
catch (...) {
cout << "Error in gradCalc!" << endl;
cout << "eta: ";
for( auto c : eta)
cout << c << ' ';
cout << endl;
cout << "y: ";
for( auto c : y)
cout << c << ' ';
cout << endl;
cout << "weights: ";
for( auto c : weights)
cout << c << ' ';
cout << endl;
cout << "ldot: ";
for( auto c : weights)
cout << c << ' ';
cout << endl;
}
}
void rcppLinSolver(NumericMatrix X, NumericVector y, NumericVector w, NumericVector adaweights, int nrow, int ncol, int numGroup, NumericMatrix beta, Function linkinv, Function devfun, IntegerVector rangeGroupInd, IntegerVector groupLen, NumericVector lambda, int step, int innerIter, double thresh, NumericVector ldot, NumericVector nullBeta, double gamma, NumericVector eta, IntegerVector betaIsZero, int& groupChange, IntegerVector isActive, IntegerVector useGroup, int reset)
{
NumericVector theta(ncol);
int startInd = 0;
double zeroCheck = 0;
double check = 0;
int count = 0;
double diff = 1;
double norm = 0;
double uOp = 0;
double Lnew = 0;
double Lold = 0;
double sqNormDelta = 0;
double iProd = 0;
NumericVector etaNew(nrow);
NumericVector etaNull(nrow);
NumericVector var(nrow);
for(int i = 0; i < numGroup; i++)
{
if(useGroup[i] == 1)
{
startInd = rangeGroupInd[i];
// Setting up null residuals calc to check if group is 0
// Null residuals means the coefficients of group i are set to zero before computing residuals.
for(int k = 0; k < nrow; k++)
{
etaNull[k] = eta[k];
for(int j = startInd; j < rangeGroupInd[i] + groupLen[i]; j++)
{
etaNull[k] = etaNull[k] - X[k + nrow * j] * beta[step*ncol + j];
}
}
gradCalc(etaNull, y, w, linkinv, ldot);
// Now compute the correlation of this group with the null residuals.
NumericVector grad(groupLen[i]);
for(int j = 0; j < groupLen[i]; j++)
{
grad[j] = 0;
for(int k = 0; k < nrow; k++)
{
grad[j] = grad[j] + X[k + nrow * (j + rangeGroupInd[i])] * ldot[k];
}
}
zeroCheck = sum(pow(grad,2));
// Is this group's correlation with the null residuals smaller than the threshold?
// If so, set the coefficients of the group to zero.
if(zeroCheck <= pow(adaweights[i],2)*pow(lambda[step],2)*groupLen[i])
{
if(betaIsZero[i] == 0)
{
for(int k = 0; k < nrow; k++)
{
for(int j = rangeGroupInd[i]; j < rangeGroupInd[i] + groupLen[i]; j++)
{
eta[k] = eta[k] - X[k + nrow * j] * beta[step*ncol + j];
}
}
}
betaIsZero[i] = 1;
for(int j = 0; j < groupLen[i]; j++)
{
beta[step*ncol + j + rangeGroupInd[i]] = 0;
}
}
else // The group's coefficients are nonzero
{
if(isActive[i] == 0)
{
groupChange = 1;
}
isActive[i] = 1;
// Hold the previous values of the coefficients
for(int k = 0; k < ncol; k++)
{
theta[k] = beta[step*ncol + k];
}
betaIsZero[i] = 0;
NumericVector z(groupLen[i]);
NumericVector U(groupLen[i]);
NumericVector delta(groupLen[i]);
NumericVector betaNew(ncol);
count = 0;
check = 100000;
double t = 1;
// Until convergence, iteratively recompute the group's coefficients:
while(count <= innerIter && check > thresh)
{
count++;
// Compute the working residuals (i.e. residuals at the current coefficient values)
gradCalc(eta, y, w, linkinv, ldot);
// Compute the group's correlation with the working residuals
for(int j = 0; j < groupLen[i]; j++)
{
grad[j] = 0;
for(int k = 0; k < nrow; k++)
{
grad[j] = grad[j] + X[k + nrow * (j + rangeGroupInd[i])] * ldot[k];
}
}
// Compute the log likelihood for the previous coefficient iteration
Lold = loglik(eta, y, w, linkinv, devfun);
// Back-tracking to optimize the step size for gradient descent:
diff = -1;
int optim_steps = 0;
while(diff < 0)
{
optim_steps++;
for(int j = 0; j < groupLen[i]; j++)
{
z[j] = beta[step*ncol + j + rangeGroupInd[i]] - t * grad[j];
}
norm = sum(pow(z, 2));
norm = sqrt(norm);
if(norm != 0){
uOp = (1 - adaweights[i]*lambda[step]*sqrt(double(groupLen[i]))*t/norm); //Or not?
}
else{uOp = 0;}
if(uOp < 0)
{
uOp = 0;
}
for(int j = 0; j < groupLen[i]; j++)
{
U[j] = uOp*z[j];
delta[j] = U[j] - beta[step*ncol + j + rangeGroupInd[i]];
}
// Setting up betaNew and etaNew in direction of Grad for descent momentum
for(int k = 0; k < nrow; k++)
{
etaNew[k] = eta[k];
for(int j = 0; j < groupLen[i]; j++)
{
etaNew[k] = etaNew[k] + delta[j] * X[k + nrow*(rangeGroupInd[i] + j)];
}
}
// Compute log likelihood for the working coefficients
Lnew = loglik(etaNew, y, w, linkinv, devfun);
sqNormDelta = sum(pow(delta, 2));
iProd = sum(grad * delta);
// Check whether the working coefficients reduce the log likelihood
diff = Lold - Lnew + iProd + 0.5/t * sqNormDelta;
// Reduce the step size for the next iteration
t = t * gamma;
}
t = t / gamma;
check = 0;
for(int j = 0; j < groupLen[i]; j++)
{
// Check the difference between iterations of the coefficients
check = check + fabs(theta[j + rangeGroupInd[i]] - U[j]);
// Calculate the null etas (i.e. the etas when group i's coefficients are zero)
for(int k = 0; k < nrow; k++)
{
eta[k] = eta[k] - X[k + nrow * (j + rangeGroupInd[i])]*beta[step*ncol + j + rangeGroupInd[i]];
}
//Apply Nesterov acceleration to calculate the new coefficient values:
beta[step*ncol + j + rangeGroupInd[i]] = U[j] + count/(count+3) * (U[j] - theta[j + rangeGroupInd[i]]);
theta[j + rangeGroupInd[i]] = U[j];
// Compute the new values of eta after iterating group i's coefficients.
for(int k = 0; k < nrow; k++)
{
eta[k] = eta[k] + X[k + nrow * (j + rangeGroupInd[i])]*beta[step*ncol + j + rangeGroupInd[i]];
}
}
}
}
}
}
}
// [[Rcpp::export]]
double killTest(Function ll, double x)
{
NumericVector y = ll(x);
return y[0];
}
// [[Rcpp::export]]
int rcppLinNest(NumericMatrix X, NumericVector y, NumericVector w, NumericVector adaweights, Function linkinv, Function devfun, int nrow, int ncol, int numGroup, IntegerVector rangeGroupInd, IntegerVector groupLen, NumericVector lambda, NumericMatrix beta, int innerIter, int outerIter, double thresh, double outerThresh, NumericVector eta, double gamma, IntegerVector betaIsZero, int reset)
{
NumericVector prob(nrow);
NumericVector nullBeta(ncol);
int n = nrow;
int p = ncol;
NumericVector ldot(n);
IntegerVector isActive(numGroup);
IntegerVector useGroup(numGroup);
IntegerVector tempIsActive(numGroup);
int nlam = lambda.size();
for (int step=0; step<nlam; step++)
{
for(int i=0; i<numGroup; i++)
{
isActive[i] = 0;
useGroup[i] = 1;
}
//Copy the most recent betas into position
if (step>0)
{
int l = step - 1;
for (int i=0; i<ncol; i++)
{
beta[step*ncol + i] = beta[l*ncol + i];
}
}
// outer most loop creating response etc...
int outermostCounter = 0;
double outermostCheck = 100000;
NumericVector outerOldBeta(p);
int groupChange = 1;
while(groupChange == 1)
{
groupChange = 0;
rcppLinSolver(X, y, w, adaweights, nrow, ncol, numGroup, beta, linkinv, devfun, rangeGroupInd, groupLen, lambda, step, innerIter, thresh, ldot, nullBeta, gamma, eta, betaIsZero, groupChange, isActive, useGroup, reset);
while(outermostCounter < outerIter && outermostCheck > outerThresh)
{
outermostCounter ++;
for(int i=0; i<p; i++)
{
outerOldBeta[i] = beta[step*ncol + i];
}
for(int i=0; i<numGroup; i++)
{
tempIsActive[i] = isActive[i];
}
rcppLinSolver(X, y, w, adaweights, nrow, ncol, numGroup, beta, linkinv, devfun, rangeGroupInd, groupLen, lambda, step, innerIter, thresh, ldot, nullBeta, gamma, eta, betaIsZero, groupChange, isActive, tempIsActive, reset);
outermostCheck = 0;
for(int i=0; i<p; i++)
{
outermostCheck = outermostCheck + fabs(outerOldBeta[i] - beta[step*ncol + i]);
}
outermostCheck = outermostCheck / abs(sum(outerOldBeta));
}
}
}
return 1;
}
<|endoftext|> |
<commit_before>/*
* Copyright(c) Sophist Solutions, Inc. 1990-2012. All rights reserved
*/
#ifndef _Stroika_Foundation_Execution_CriticalSection_inl_
#define _Stroika_Foundation_Execution_CriticalSection_inl_ 1
/*
********************************************************************************
***************************** Implementation Details ***************************
********************************************************************************
*/
#include "Exceptions.h"
namespace Stroika {
namespace Foundation {
namespace Execution {
// class CriticalSection
inline CriticalSection::CriticalSection ()
{
#if qUseThreads_WindowsNative
memset (&fCritSec, 0, sizeof(CRITICAL_SECTION));
::InitializeCriticalSection (&fCritSec);
#endif
}
inline CriticalSection::~CriticalSection()
{
#if qUseThreads_WindowsNative
IgnoreExceptionsForCall (::DeleteCriticalSection (&fCritSec));
#endif
}
inline void CriticalSection::Lock ()
{
#if qUseThreads_WindowsNative
::EnterCriticalSection (&fCritSec);
#elif qUseThreads_StdCPlusPlus
fMutex_.lock ();
#endif
}
inline void CriticalSection::Unlock()
{
#if qUseThreads_WindowsNative
::LeaveCriticalSection (&fCritSec);
#elif qUseThreads_StdCPlusPlus
fMutex_.unlock ();
#endif
}
// class AutoCriticalSection
template <typename LOCKTYPE>
inline AutoCriticalSectionT<LOCKTYPE>::AutoCriticalSectionT (LOCKTYPE& critSec)
: fCritSec (critSec)
{
fCritSec.Lock ();
}
template <typename LOCKTYPE>
inline AutoCriticalSectionT<LOCKTYPE>::~AutoCriticalSectionT ()
{
fCritSec.Unlock ();
}
}
}
}
#endif /*_Stroika_Foundation_Execution_CriticalSection_inl_*/
<commit_msg>minor code cleanup<commit_after>/*
* Copyright(c) Sophist Solutions, Inc. 1990-2012. All rights reserved
*/
#ifndef _Stroika_Foundation_Execution_CriticalSection_inl_
#define _Stroika_Foundation_Execution_CriticalSection_inl_ 1
/*
********************************************************************************
***************************** Implementation Details ***************************
********************************************************************************
*/
#include "Exceptions.h"
namespace Stroika {
namespace Foundation {
namespace Execution {
// class CriticalSection
inline CriticalSection::CriticalSection ()
{
#if qUseThreads_WindowsNative
memset (&fCritSec, 0, sizeof(fCritSec));
::InitializeCriticalSection (&fCritSec);
#endif
}
inline CriticalSection::~CriticalSection()
{
#if qUseThreads_WindowsNative
IgnoreExceptionsForCall (::DeleteCriticalSection (&fCritSec));
#endif
}
inline void CriticalSection::Lock ()
{
#if qUseThreads_WindowsNative
::EnterCriticalSection (&fCritSec);
#elif qUseThreads_StdCPlusPlus
fMutex_.lock ();
#endif
}
inline void CriticalSection::Unlock()
{
#if qUseThreads_WindowsNative
::LeaveCriticalSection (&fCritSec);
#elif qUseThreads_StdCPlusPlus
fMutex_.unlock ();
#endif
}
// class AutoCriticalSection
template <typename LOCKTYPE>
inline AutoCriticalSectionT<LOCKTYPE>::AutoCriticalSectionT (LOCKTYPE& critSec)
: fCritSec (critSec)
{
fCritSec.Lock ();
}
template <typename LOCKTYPE>
inline AutoCriticalSectionT<LOCKTYPE>::~AutoCriticalSectionT ()
{
fCritSec.Unlock ();
}
}
}
}
#endif /*_Stroika_Foundation_Execution_CriticalSection_inl_*/
<|endoftext|> |
<commit_before>// Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2021 - 2022 by Apex.AI Inc. 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.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef IOX_HOOFS_CXX_VARIANT_INTERNAL_HPP
#define IOX_HOOFS_CXX_VARIANT_INTERNAL_HPP
#include "iceoryx_hoofs/cxx/requires.hpp"
#include <cstdint>
#include <type_traits>
#include <utility>
namespace iox
{
namespace cxx
{
template <uint64_t N>
struct in_place_index;
template <typename T>
struct in_place_type;
namespace internal
{
template <typename N>
struct is_in_place_index : std::false_type
{
};
template <uint64_t N>
struct is_in_place_index<in_place_index<N>> : std::true_type
{
};
template <typename T>
struct is_in_place_type : std::false_type
{
};
template <typename T>
struct is_in_place_type<in_place_type<T>> : std::true_type
{
};
using byte_t = uint8_t;
template <typename TypeToCheck, typename T, typename... Targs>
struct does_contain_type
{
static constexpr bool value =
std::is_same<TypeToCheck, T>::value || does_contain_type<TypeToCheck, Targs...>::value;
};
template <typename TypeToCheck, typename T>
struct does_contain_type<TypeToCheck, T>
{
static constexpr bool value = std::is_same<TypeToCheck, T>::value;
};
template <uint64_t N, typename Type, typename T, typename... Targs>
struct get_index_of_type
{
static constexpr uint64_t index = get_index_of_type<N + 1, Type, Targs...>::index;
};
template <uint64_t N, typename Type, typename... Targs>
struct get_index_of_type<N, Type, Type, Targs...>
{
static constexpr uint64_t index = N;
};
template <uint64_t N, uint64_t Index, typename T, typename... Targs>
struct get_type_at_index
{
using type = typename get_type_at_index<N + 1, Index, Targs...>::type;
};
template <uint64_t N, typename T, typename... Targs>
struct get_type_at_index<N, N, T, Targs...>
{
using type = T;
};
template <uint64_t N, typename T, typename... Targs>
struct call_at_index
{
static void destructor(const uint64_t index, void* ptr) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
reinterpret_cast<T*>(ptr)->~T();
}
else
{
call_at_index<N + 1, Targs...>::destructor(index, ptr);
}
}
static void move(const uint64_t index, void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T*>(destination) = std::move(*reinterpret_cast<T*>(source));
}
else
{
call_at_index<N + 1, Targs...>::move(index, source, destination);
}
}
static void moveConstructor(const uint64_t index, void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(std::move(*reinterpret_cast<T*>(source)));
}
else
{
call_at_index<N + 1, Targs...>::moveConstructor(index, source, destination);
}
}
static void copy(const uint64_t index, const void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T*>(destination) = *reinterpret_cast<const T*>(source);
}
else
{
call_at_index<N + 1, Targs...>::copy(index, source, destination);
}
}
static void copyConstructor(const uint64_t index, const void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(*reinterpret_cast<const T*>(source));
}
else
{
call_at_index<N + 1, Targs...>::copyConstructor(index, source, destination);
}
}
static bool equality(const uint64_t index, const void* lhs, const void* rhs)
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter and encapsulated in this class
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return *reinterpret_cast<const T*>(lhs) == *reinterpret_cast<const T*>(rhs);
}
return call_at_index<N + 1, Targs...>::equality(index, lhs, rhs);
}
};
template <uint64_t N, typename T>
struct call_at_index<N, T>
{
// NOLINTJUSTIFICATION d'tor changes the data to which source is pointing to
// NOLINTNEXTLINE(readability-non-const-parameter)
static void destructor(const uint64_t index, void* ptr) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
reinterpret_cast<T*>(ptr)->~T();
}
else
{
ExpectsWithMsg(false, "Could not call destructor for variant element");
}
}
// NOLINTJUSTIFICATION move c'tor changes the data to which source is pointing to
// NOLINTNEXTLINE(readability-non-const-parameter)
static void move(const uint64_t index, void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T*>(destination) = std::move(*reinterpret_cast<T*>(source));
}
else
{
ExpectsWithMsg(false, "Could not call move assignment for variant element");
}
}
// NOLINTJUSTIFICATION Both 'source' and 'destination' will be changed and can't be const
// NOLINTNEXTLINE(readability-non-const-parameter)
static void moveConstructor(const uint64_t index, void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(std::move(*reinterpret_cast<T*>(source)));
}
else
{
ExpectsWithMsg(false, "Could not call move constructor for variant element");
}
}
static void copy(const uint64_t index, const void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T*>(destination) = *reinterpret_cast<const T*>(source);
}
else
{
ExpectsWithMsg(false, "Could not call copy assignment for variant element");
}
}
// NOLINTJUSTIFICATION 'operator new()' needs non-const 'destination'
// NOLINTNEXTLINE(readability-non-const-parameter)
static void copyConstructor(const uint64_t index, const void* source, void* destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(*reinterpret_cast<const T*>(source));
}
else
{
ExpectsWithMsg(false, "Could not call copy constructor for variant element");
}
}
static bool equality(const uint64_t index, const void* lhs, const void* rhs) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter and encapsulated in this class
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return *reinterpret_cast<const T*>(lhs) == *reinterpret_cast<const T*>(rhs);
}
ExpectsWithMsg(false, "Could not call equality operator for variant element");
return false;
}
};
} // namespace internal
} // namespace cxx
} // namespace iox
#endif // IOX_HOOFS_CXX_VARIANT_INTERNAL_HPP
<commit_msg>iox-#1614 Const correctness in variant_internal.hpp<commit_after>// Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2021 - 2022 by Apex.AI Inc. 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.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef IOX_HOOFS_CXX_VARIANT_INTERNAL_HPP
#define IOX_HOOFS_CXX_VARIANT_INTERNAL_HPP
#include "iceoryx_hoofs/cxx/requires.hpp"
#include <cstdint>
#include <type_traits>
#include <utility>
namespace iox
{
namespace cxx
{
template <uint64_t N>
struct in_place_index;
template <typename T>
struct in_place_type;
namespace internal
{
template <typename N>
struct is_in_place_index : std::false_type
{
};
template <uint64_t N>
struct is_in_place_index<in_place_index<N>> : std::true_type
{
};
template <typename T>
struct is_in_place_type : std::false_type
{
};
template <typename T>
struct is_in_place_type<in_place_type<T>> : std::true_type
{
};
using byte_t = uint8_t;
template <typename TypeToCheck, typename T, typename... Targs>
struct does_contain_type
{
static constexpr bool value =
std::is_same<TypeToCheck, T>::value || does_contain_type<TypeToCheck, Targs...>::value;
};
template <typename TypeToCheck, typename T>
struct does_contain_type<TypeToCheck, T>
{
static constexpr bool value = std::is_same<TypeToCheck, T>::value;
};
template <uint64_t N, typename Type, typename T, typename... Targs>
struct get_index_of_type
{
static constexpr uint64_t index = get_index_of_type<N + 1, Type, Targs...>::index;
};
template <uint64_t N, typename Type, typename... Targs>
struct get_index_of_type<N, Type, Type, Targs...>
{
static constexpr uint64_t index = N;
};
template <uint64_t N, uint64_t Index, typename T, typename... Targs>
struct get_type_at_index
{
using type = typename get_type_at_index<N + 1, Index, Targs...>::type;
};
template <uint64_t N, typename T, typename... Targs>
struct get_type_at_index<N, N, T, Targs...>
{
using type = T;
};
template <uint64_t N, typename T, typename... Targs>
struct call_at_index
{
static void destructor(const uint64_t index, void* ptr) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
reinterpret_cast<T*>(ptr)->~T();
}
else
{
call_at_index<N + 1, Targs...>::destructor(index, ptr);
}
}
static void move(const uint64_t index, void* source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T* const>(destination) = std::move(*reinterpret_cast<T*>(source));
}
else
{
call_at_index<N + 1, Targs...>::move(index, source, destination);
}
}
static void moveConstructor(const uint64_t index, void* source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(std::move(*reinterpret_cast<T*>(source)));
}
else
{
call_at_index<N + 1, Targs...>::moveConstructor(index, source, destination);
}
}
static void copy(const uint64_t index, const void* const source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T* const>(destination) = *reinterpret_cast<const T* const>(source);
}
else
{
call_at_index<N + 1, Targs...>::copy(index, source, destination);
}
}
static void copyConstructor(const uint64_t index, const void* const source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(*reinterpret_cast<const T* const>(source));
}
else
{
call_at_index<N + 1, Targs...>::copyConstructor(index, source, destination);
}
}
static bool equality(const uint64_t index, const void* const lhs, const void* const rhs)
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter and encapsulated in this class
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return *reinterpret_cast<const T* const>(lhs) == *reinterpret_cast<const T* const>(rhs);
}
return call_at_index<N + 1, Targs...>::equality(index, lhs, rhs);
}
};
template <uint64_t N, typename T>
struct call_at_index<N, T>
{
// NOLINTJUSTIFICATION d'tor changes the data to which ptr is pointing to
// NOLINTNEXTLINE(readability-non-const-parameter)
static void destructor(const uint64_t index, void* ptr) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
reinterpret_cast<T*>(ptr)->~T();
}
else
{
ExpectsWithMsg(false, "Could not call destructor for variant element");
}
}
// NOLINTJUSTIFICATION move c'tor changes the data to which source is pointing to
// NOLINTNEXTLINE(readability-non-const-parameter)
static void move(const uint64_t index, void* source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T* const>(destination) = std::move(*reinterpret_cast<T*>(source));
}
else
{
ExpectsWithMsg(false, "Could not call move assignment for variant element");
}
}
// NOLINTJUSTIFICATION Both 'source' and 'destination' will be changed and can't be const
// NOLINTNEXTLINE(readability-non-const-parameter)
static void moveConstructor(const uint64_t index, void* source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(std::move(*reinterpret_cast<T*>(source)));
}
else
{
ExpectsWithMsg(false, "Could not call move constructor for variant element");
}
}
static void copy(const uint64_t index, const void* const source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
*reinterpret_cast<T* const>(destination) = *reinterpret_cast<const T* const>(source);
}
else
{
ExpectsWithMsg(false, "Could not call copy assignment for variant element");
}
}
static void copyConstructor(const uint64_t index, const void* const source, void* const destination) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
new (destination) T(*reinterpret_cast<const T* const>(source));
}
else
{
ExpectsWithMsg(false, "Could not call copy constructor for variant element");
}
}
static bool equality(const uint64_t index, const void* const lhs, const void* const rhs) noexcept
{
if (N == index)
{
// AXIVION Next Construct AutosarC++19_03-A5.2.4 : Type safety ensured through template parameter and encapsulated in this class
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
return *reinterpret_cast<const T* const>(lhs) == *reinterpret_cast<const T* const>(rhs);
}
ExpectsWithMsg(false, "Could not call equality operator for variant element");
return false;
}
};
} // namespace internal
} // namespace cxx
} // namespace iox
#endif // IOX_HOOFS_CXX_VARIANT_INTERNAL_HPP
<|endoftext|> |
<commit_before>// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <util/timer.h>
#include <httpclient/httpclient.h>
#include <util/filereader.h>
#include "client.h"
Client::Client(ClientArguments *args)
: _args(args),
_status(new ClientStatus()),
_reqTimer(new Timer()),
_cycleTimer(new Timer()),
_masterTimer(new Timer()),
_http(new HTTPClient(_args->_hostname, _args->_port,
_args->_keepAlive, _args->_headerBenchmarkdataCoverage,
_args->_extraHeaders, _args->_authority)),
_reader(new FileReader()),
_output(),
_linebufsize(args->_maxLineSize),
_linebuf(new char[_linebufsize]),
_stop(false),
_done(false),
_thread()
{
assert(args != NULL);
_cycleTimer->SetMax(_args->_cycle);
}
Client::~Client()
{
delete [] _linebuf;
}
void Client::runMe(Client * me) {
me->run();
}
void
Client::run()
{
char filename[1024];
char timestr[64];
int linelen;
/// int reslen;
std::this_thread::sleep_for(std::chrono::milliseconds(_args->_delay));
// open query file
snprintf(filename, 1024, _args->_filenamePattern, _args->_myNum);
if (!_reader->Open(filename)) {
printf("Client %d: ERROR: could not open file '%s' [read mode]\n",
_args->_myNum, filename);
_status->SetError("Could not open query file.");
return;
}
if (_args->_outputPattern != NULL) {
snprintf(filename, 1024, _args->_outputPattern, _args->_myNum);
_output = std::make_unique<std::ofstream>(filename, std::ofstream::out | std::ofstream::binary);
if (_output->fail()) {
printf("Client %d: ERROR: could not open file '%s' [write mode]\n",
_args->_myNum, filename);
_status->SetError("Could not open output file.");
return;
}
}
if (_output)
_output->write(FBENCH_DELIMITER + 1, strlen(FBENCH_DELIMITER) - 1);
if (_args->_ignoreCount == 0)
_masterTimer->Start();
// Start reading from offset
if ( _args->_singleQueryFile )
_reader->SetFilePos(_args->_queryfileOffset);
// run queries
while (!_stop) {
_cycleTimer->Start();
linelen = _reader->ReadLine(_linebuf, _linebufsize);
// Read maximum to _queryfileOffsetEnd
if ( _args->_singleQueryFile && _reader->GetBufPos() >= _args->_queryfileBytes ) {
_reader->SetFilePos(_args->_queryfileOffset);
}
if (linelen < 0) {
_reader->Reset();
// Start reading from offset
if ( _args->_singleQueryFile ) {
_reader->SetFilePos(_args->_queryfileOffset);
}
linelen = _reader->ReadLine(_linebuf, _linebufsize);
if (linelen < 0) {
fprintf(stderr, "Client %d: ERROR: could not read any lines from '%s'\n",
_args->_myNum, filename);
_status->SetError("Could not read any lines from query file.");
break;
}
if (_args->_restartLimit == 0) {
break;
} else if (_args->_restartLimit > 0) {
_args->_restartLimit--;
}
}
if (linelen < _linebufsize) {
if (_output) {
_output->write("URL: ", strlen("URL: "));
_output->write(_linebuf, linelen);
_output->write("\n\n", 2);
}
if (linelen + (int)_args->_queryStringToAppend.length() < _linebufsize) {
strcat(_linebuf, _args->_queryStringToAppend.c_str());
}
_reqTimer->Start();
auto fetch_status = _http->Fetch(_linebuf, _output.get());
_reqTimer->Stop();
_status->AddRequestStatus(fetch_status.RequestStatus());
if (fetch_status.Ok() && fetch_status.TotalHitCount() == 0)
++_status->_zeroHitQueries;
if (_output) {
if (!fetch_status.Ok()) {
_output->write("\nFBENCH: URL FETCH FAILED!\n",
strlen("\nFBENCH: URL FETCH FAILED!\n"));
_output->write(FBENCH_DELIMITER + 1, strlen(FBENCH_DELIMITER) - 1);
} else {
sprintf(timestr, "\nTIME USED: %0.4f s\n",
_reqTimer->GetTimespan() / 1000.0);
_output->write(timestr, strlen(timestr));
_output->write(FBENCH_DELIMITER + 1, strlen(FBENCH_DELIMITER) - 1);
}
}
if (fetch_status.ResultSize() >= _args->_byteLimit) {
if (_args->_ignoreCount == 0)
_status->ResponseTime(_reqTimer->GetTimespan());
} else {
if (_args->_ignoreCount == 0)
_status->RequestFailed();
}
} else {
if (_args->_ignoreCount == 0)
_status->SkippedRequest();
}
_cycleTimer->Stop();
if (_args->_cycle < 0) {
std::this_thread::sleep_for(std::chrono::milliseconds(int(_reqTimer->GetTimespan())));
} else {
if (_cycleTimer->GetRemaining() > 0) {
std::this_thread::sleep_for(std::chrono::milliseconds(int(_cycleTimer->GetRemaining())));
} else {
if (_args->_ignoreCount == 0)
_status->OverTime();
}
}
if (_args->_ignoreCount > 0) {
_args->_ignoreCount--;
if (_args->_ignoreCount == 0)
_masterTimer->Start();
}
// Update current time span to calculate Q/s
_status->SetRealTime(_masterTimer->GetCurrent());
}
_masterTimer->Stop();
_status->SetRealTime(_masterTimer->GetTimespan());
_status->SetReuseCount(_http->GetReuseCount());
printf(".");
fflush(stdout);
_done = true;
}
void Client::stop() {
_stop = true;
}
bool Client::done() {
return _done;
}
void Client::start() {
_thread = std::thread(Client::runMe, this);
}
void Client::join() {
_thread.join();
}
<commit_msg>Ensure that you report the correct filename when producing error message.<commit_after>// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include <util/timer.h>
#include <httpclient/httpclient.h>
#include <util/filereader.h>
#include "client.h"
Client::Client(ClientArguments *args)
: _args(args),
_status(new ClientStatus()),
_reqTimer(new Timer()),
_cycleTimer(new Timer()),
_masterTimer(new Timer()),
_http(new HTTPClient(_args->_hostname, _args->_port,
_args->_keepAlive, _args->_headerBenchmarkdataCoverage,
_args->_extraHeaders, _args->_authority)),
_reader(new FileReader()),
_output(),
_linebufsize(args->_maxLineSize),
_linebuf(new char[_linebufsize]),
_stop(false),
_done(false),
_thread()
{
assert(args != NULL);
_cycleTimer->SetMax(_args->_cycle);
}
Client::~Client()
{
delete [] _linebuf;
}
void Client::runMe(Client * me) {
me->run();
}
void
Client::run()
{
char inputFilename[1024];
char outputFilename[1024];
char timestr[64];
int linelen;
/// int reslen;
std::this_thread::sleep_for(std::chrono::milliseconds(_args->_delay));
// open query file
snprintf(inputFilename, 1024, _args->_filenamePattern, _args->_myNum);
if (!_reader->Open(inputFilename)) {
printf("Client %d: ERROR: could not open file '%s' [read mode]\n",
_args->_myNum, inputFilename);
_status->SetError("Could not open query file.");
return;
}
if (_args->_outputPattern != NULL) {
snprintf(outputFilename, 1024, _args->_outputPattern, _args->_myNum);
_output = std::make_unique<std::ofstream>(outputFilename, std::ofstream::out | std::ofstream::binary);
if (_output->fail()) {
printf("Client %d: ERROR: could not open file '%s' [write mode]\n",
_args->_myNum, outputFilename);
_status->SetError("Could not open output file.");
return;
}
}
if (_output)
_output->write(FBENCH_DELIMITER + 1, strlen(FBENCH_DELIMITER) - 1);
if (_args->_ignoreCount == 0)
_masterTimer->Start();
// Start reading from offset
if ( _args->_singleQueryFile )
_reader->SetFilePos(_args->_queryfileOffset);
// run queries
while (!_stop) {
_cycleTimer->Start();
linelen = _reader->ReadLine(_linebuf, _linebufsize);
// Read maximum to _queryfileOffsetEnd
if ( _args->_singleQueryFile && _reader->GetBufPos() >= _args->_queryfileBytes ) {
_reader->SetFilePos(_args->_queryfileOffset);
}
if (linelen < 0) {
_reader->Reset();
// Start reading from offset
if ( _args->_singleQueryFile ) {
_reader->SetFilePos(_args->_queryfileOffset);
}
linelen = _reader->ReadLine(_linebuf, _linebufsize);
if (linelen < 0) {
fprintf(stderr, "Client %d: ERROR: could not read any lines from '%s'\n",
_args->_myNum, inputFilename);
_status->SetError("Could not read any lines from query file.");
break;
}
if (_args->_restartLimit == 0) {
break;
} else if (_args->_restartLimit > 0) {
_args->_restartLimit--;
}
}
if (linelen < _linebufsize) {
if (_output) {
_output->write("URL: ", strlen("URL: "));
_output->write(_linebuf, linelen);
_output->write("\n\n", 2);
}
if (linelen + (int)_args->_queryStringToAppend.length() < _linebufsize) {
strcat(_linebuf, _args->_queryStringToAppend.c_str());
}
_reqTimer->Start();
auto fetch_status = _http->Fetch(_linebuf, _output.get());
_reqTimer->Stop();
_status->AddRequestStatus(fetch_status.RequestStatus());
if (fetch_status.Ok() && fetch_status.TotalHitCount() == 0)
++_status->_zeroHitQueries;
if (_output) {
if (!fetch_status.Ok()) {
_output->write("\nFBENCH: URL FETCH FAILED!\n",
strlen("\nFBENCH: URL FETCH FAILED!\n"));
_output->write(FBENCH_DELIMITER + 1, strlen(FBENCH_DELIMITER) - 1);
} else {
sprintf(timestr, "\nTIME USED: %0.4f s\n",
_reqTimer->GetTimespan() / 1000.0);
_output->write(timestr, strlen(timestr));
_output->write(FBENCH_DELIMITER + 1, strlen(FBENCH_DELIMITER) - 1);
}
}
if (fetch_status.ResultSize() >= _args->_byteLimit) {
if (_args->_ignoreCount == 0)
_status->ResponseTime(_reqTimer->GetTimespan());
} else {
if (_args->_ignoreCount == 0)
_status->RequestFailed();
}
} else {
if (_args->_ignoreCount == 0)
_status->SkippedRequest();
}
_cycleTimer->Stop();
if (_args->_cycle < 0) {
std::this_thread::sleep_for(std::chrono::milliseconds(int(_reqTimer->GetTimespan())));
} else {
if (_cycleTimer->GetRemaining() > 0) {
std::this_thread::sleep_for(std::chrono::milliseconds(int(_cycleTimer->GetRemaining())));
} else {
if (_args->_ignoreCount == 0)
_status->OverTime();
}
}
if (_args->_ignoreCount > 0) {
_args->_ignoreCount--;
if (_args->_ignoreCount == 0)
_masterTimer->Start();
}
// Update current time span to calculate Q/s
_status->SetRealTime(_masterTimer->GetCurrent());
}
_masterTimer->Stop();
_status->SetRealTime(_masterTimer->GetTimespan());
_status->SetReuseCount(_http->GetReuseCount());
printf(".");
fflush(stdout);
_done = true;
}
void Client::stop() {
_stop = true;
}
bool Client::done() {
return _done;
}
void Client::start() {
_thread = std::thread(Client::runMe, this);
}
void Client::join() {
_thread.join();
}
<|endoftext|> |
<commit_before>#include <sstream>
#include <julia.h>
#include "debug.h"
using namespace std;
string nj::getTypeName(jl_value_t *v)
{
string res = "none";
stringstream ss;
if(v)
{
if(jl_is_structtype(v)) ss << "value is struct_type";
if(jl_is_datatype(v)) ss << "value is type datatype";
if(jl_is_expr(v)) ss << "value is expr";
if(jl_is_tuple(v)) ss << "value is tuple";
if(jl_is_vararg_type(v)) ss << "value is vararg";
if(jl_is_func(v)) ss << "value is func";
if(jl_is_byte_string(v)) ss << "value is string";
if(jl_is_uniontype(v)) ss << "value is union";
if(jl_is_typector(v)) ss << "value is ctor";
if(jl_is_symbol(v)) ss << "value is jl_is_symbol";
if(jl_is_lambda_info(v)) ss << "value is jl_is_lambda_info";
if(jl_is_vararg_type(v)) ss << "value is jl_is_vararg_type";
if(jl_is_getfieldnode(v)) ss << "value is jl_is_getfieldnode";
if(jl_is_datatype(jl_typeof(v))) ss << "value is a data type";
string tmp = ss.str();
if(tmp != "") res = tmp;
}
return res;
}
<commit_msg>Commented unneeded jl_is_getfieldnode<commit_after>#include <sstream>
#include <julia.h>
#include "debug.h"
using namespace std;
string nj::getTypeName(jl_value_t *v)
{
string res = "none";
stringstream ss;
if(v)
{
if(jl_is_structtype(v)) ss << "value is struct_type";
if(jl_is_datatype(v)) ss << "value is type datatype";
if(jl_is_expr(v)) ss << "value is expr";
if(jl_is_tuple(v)) ss << "value is tuple";
if(jl_is_vararg_type(v)) ss << "value is vararg";
if(jl_is_func(v)) ss << "value is func";
if(jl_is_byte_string(v)) ss << "value is string";
if(jl_is_uniontype(v)) ss << "value is union";
if(jl_is_typector(v)) ss << "value is ctor";
if(jl_is_symbol(v)) ss << "value is jl_is_symbol";
if(jl_is_lambda_info(v)) ss << "value is jl_is_lambda_info";
if(jl_is_vararg_type(v)) ss << "value is jl_is_vararg_type";
//if(jl_is_getfieldnode(v)) ss << "value is jl_is_getfieldnode";
if(jl_is_datatype(jl_typeof(v))) ss << "value is a data type";
string tmp = ss.str();
if(tmp != "") res = tmp;
}
return res;
}
<|endoftext|> |
<commit_before>#include "model.hpp"
namespace Model {
}
<commit_msg>Added destructor<commit_after>#include "model.hpp"
namespace Model {
model::~model(void) {}
}
<|endoftext|> |
<commit_before>#include "stdafx.h"
#include "CppUnitTest.h"
#include "../dummy_values.h"
#include "internal/operations/erase_operation.h"
#include "internal/operations/post_operation.h"
#include "internal/operations/put_operation.h"
#include "internal/internal_datastore.h"
using Assert = Microsoft::VisualStudio::CppUnitTestFramework::Assert;
namespace You {
namespace DataStore {
namespace UnitTests {
using DataStore = You::DataStore::Internal::DataStore;
/// Unit Test Class for DataStore class
TEST_CLASS(DataStoreTest) {
public:
TEST_METHOD(beginTransaction) {
DataStore& sut = DataStore::get();
Assert::IsTrue(sut.transactionStack.empty());
Transaction t(sut.begin());
Assert::AreEqual(1U, sut.transactionStack.size());
}
TEST_METHOD(pushedOperationsAddedToTransactionOperationsQueue) {
DataStore& sut = DataStore::get();
Transaction t(sut.begin());
sut.post(10, task1);
Assert::AreEqual(1U, t->operationsQueue.size());
sut.put(10, task2);
Assert::AreEqual(2U, t->operationsQueue.size());
sut.erase(10);
Assert::AreEqual(3U, t->operationsQueue.size());
}
TEST_METHOD(commitChangesDocumentTree) {
DataStore& sut = DataStore::get();
sut.document.reset();
sut.saveData();
assert(sut.document.first_child.empty());
Transaction t(sut.begin());
sut.post(10, task1);
// document must not change without commit
Assert::IsTrue(sut.document.first_child().empty());
t.commit();
// document changes after commit
Assert::IsFalse(sut.document.first_child().empty());
Transaction t2(sut.begin());
sut.erase(10);
// document must not change without commit
Assert::IsFalse(sut.document.first_child().empty());
t2.commit();
// document changes after commit
Assert::IsTrue(sut.document.first_child().empty());
}
TEST_METHOD(rollbackCleanUpTransactionStack) {
DataStore& sut = DataStore::get();
Transaction t(sut.begin());
Assert::AreEqual(1U, sut.transactionStack.size());
t.rollback();
Assert::AreEqual(0U, sut.transactionStack.size());
}
TEST_METHOD(getAllTasks) {
DataStore& sut = DataStore::get();
sut.document.append_child(L"task").
append_child(pugi::xml_node_type::node_pcdata).set_value(L"what");
std::vector<SerializedTask> result = sut.getAllTask();
Assert::AreEqual(1U, result.size());
sut.document.reset();
sut.saveData();
}
TEST_METHOD(saveThenLoad) {
DataStore& sut = DataStore::get();
sut.document.append_child(L"task").
append_child(pugi::xml_node_type::node_pcdata).set_value(L"what");
bool result = sut.saveData();
Assert::IsTrue(result);
sut.loadData();
std::wstring value = sut.document.child(L"task").child_value();
Assert::AreEqual(std::wstring(L"what"), value);
sut.document.reset();
sut.saveData();
}
TEST_METHOD(pushOperationToTransactionWithoutDataStore) {
Internal::Transaction sut;
std::unique_ptr<Internal::IOperation> post =
std::make_unique<Internal::PostOperation>(0, task1);
sut.push(std::move(post));
Assert::AreEqual(1U, sut.operationsQueue.size());
std::unique_ptr<Internal::IOperation> put =
std::make_unique<Internal::PutOperation>(0, task1);
sut.push(std::move(put));
Assert::AreEqual(2U, sut.operationsQueue.size());
std::unique_ptr<Internal::IOperation> erase =
std::make_unique<Internal::EraseOperation>(0);
sut.push(std::move(erase));
Assert::AreEqual(3U, sut.operationsQueue.size());
sut.operationsQueue.clear();
}
};
} // namespace UnitTests
} // namespace DataStore
} // namespace You
<commit_msg>Better name for getAllTask test, clean up properly<commit_after>#include "stdafx.h"
#include "CppUnitTest.h"
#include "../dummy_values.h"
#include "internal/operations/erase_operation.h"
#include "internal/operations/post_operation.h"
#include "internal/operations/put_operation.h"
#include "internal/internal_datastore.h"
using Assert = Microsoft::VisualStudio::CppUnitTestFramework::Assert;
namespace You {
namespace DataStore {
namespace UnitTests {
using DataStore = You::DataStore::Internal::DataStore;
/// Unit Test Class for DataStore class
TEST_CLASS(DataStoreTest) {
public:
TEST_METHOD(beginTransactionAddToTransactionStack) {
DataStore& sut = DataStore::get();
Assert::IsTrue(sut.transactionStack.empty());
Transaction t(sut.begin());
Assert::AreEqual(1U, sut.transactionStack.size());
}
TEST_METHOD(pushedOperationsAddedToTransactionOperationsQueue) {
DataStore& sut = DataStore::get();
Transaction t(sut.begin());
sut.post(10, task1);
Assert::AreEqual(1U, t->operationsQueue.size());
sut.put(10, task2);
Assert::AreEqual(2U, t->operationsQueue.size());
sut.erase(10);
Assert::AreEqual(3U, t->operationsQueue.size());
}
TEST_METHOD(commitChangesDocumentTree) {
DataStore& sut = DataStore::get();
sut.document.reset();
sut.saveData();
assert(sut.document.first_child.empty());
Transaction t(sut.begin());
sut.post(10, task1);
// document must not change without commit
Assert::IsTrue(sut.document.first_child().empty());
t.commit();
// document changes after commit
Assert::IsFalse(sut.document.first_child().empty());
Transaction t2(sut.begin());
sut.erase(10);
// document must not change without commit
Assert::IsFalse(sut.document.first_child().empty());
t2.commit();
// document changes after commit
Assert::IsTrue(sut.document.first_child().empty());
}
TEST_METHOD(rollbackCleanUpTransactionStack) {
DataStore& sut = DataStore::get();
Transaction t(sut.begin());
Assert::AreEqual(1U, sut.transactionStack.size());
t.rollback();
Assert::AreEqual(0U, sut.transactionStack.size());
}
TEST_METHOD(getAllTasksFromTreeCorrectly) {
DataStore& sut = DataStore::get();
sut.document.append_child(L"task").
append_child(pugi::xml_node_type::node_pcdata).set_value(L"what");
std::vector<SerializedTask> result = sut.getAllTask();
Assert::AreEqual(1U, result.size());
// Clean up
sut.document.reset();
sut.saveData();
}
TEST_METHOD(saveThenLoad) {
DataStore& sut = DataStore::get();
sut.document.append_child(L"task").
append_child(pugi::xml_node_type::node_pcdata).set_value(L"what");
bool result = sut.saveData();
Assert::IsTrue(result);
sut.loadData();
std::wstring value = sut.document.child(L"task").child_value();
Assert::AreEqual(std::wstring(L"what"), value);
sut.document.reset();
sut.saveData();
}
TEST_METHOD(pushOperationToTransactionWithoutDataStore) {
Internal::Transaction sut;
std::unique_ptr<Internal::IOperation> post =
std::make_unique<Internal::PostOperation>(0, task1);
sut.push(std::move(post));
Assert::AreEqual(1U, sut.operationsQueue.size());
std::unique_ptr<Internal::IOperation> put =
std::make_unique<Internal::PutOperation>(0, task1);
sut.push(std::move(put));
Assert::AreEqual(2U, sut.operationsQueue.size());
std::unique_ptr<Internal::IOperation> erase =
std::make_unique<Internal::EraseOperation>(0);
sut.push(std::move(erase));
Assert::AreEqual(3U, sut.operationsQueue.size());
sut.operationsQueue.clear();
}
};
} // namespace UnitTests
} // namespace DataStore
} // namespace You
<|endoftext|> |
<commit_before>//
// Copyright (c) 2016 CNRS
// Author: NMansard
//
//
// This file is part of hpp-pinocchio
// hpp-pinocchio 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.
//
// hpp-pinocchio 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 Lesser Public License for more details. You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-pinocchio If not, see
// <http://www.gnu.org/licenses/>.
#include <hpp/pinocchio/device.hh>
#include <boost/foreach.hpp>
#include <Eigen/Core>
#include <pinocchio/multibody/model.hpp>
#include <pinocchio/algorithm/center-of-mass.hpp>
#include <pinocchio/algorithm/jacobian.hpp>
#include <pinocchio/algorithm/kinematics.hpp>
#include <pinocchio/algorithm/geometry.hpp>
#include <hpp/pinocchio/fwd.hh>
//#include <hpp/pinocchio/distance-result.hh>
#include <hpp/pinocchio/extra-config-space.hh>
#include <hpp/pinocchio/joint.hh>
namespace hpp {
namespace pinocchio {
Device::
Device(const std::string& name)
: model_(new Model())
, data_ ()
, geomModel_(new GeomModel())
, geomData_ ()
, name_ (name)
, jointVector_()
, computationFlag_ (JOINT_POSITION)
, obstacles_()
, objectVector_ ()
, weakPtr_()
{
invalidate();
}
// static method
DevicePtr_t Device::
create (const std::string & name)
{
DevicePtr_t res = DevicePtr_t(new Device(name)); // init shared ptr
res->init (res);
return res;
}
// static method
DevicePtr_t Device::
createCopy (const DevicePtr_t& device)
{
DevicePtr_t res = Device::create(device->name()); // init shared ptr
res->model(device->modelPtr()); // Copy pointer to pinocchio model
res->createData(); // Create a new data, dont copy the pointer.
return res;
}
// static method
DevicePtr_t Device::
createCopyConst (const DeviceConstPtr_t& device)
{
DevicePtr_t res = Device::create(device->name()); // init shared ptr
/* The copy of Pinocchio::Model is not implemented yet. */
/* We need this feature to finish the implementation of this method. */
assert( false && "TODO: createCopyConst is not implemented yet." );
return res;
}
void Device::init(const DeviceWkPtr_t& weakPtr)
{
weakPtr_ = weakPtr;
DevicePtr_t self (weakPtr_.lock());
jointVector_ = JointVector(self);
obstacles_ = ObjectVector(self,0,INNER);
objectVector_ = DeviceObjectVector(self);
}
void Device::
createData()
{
data_ = DataPtr_t( new Data(*model_) );
// We assume that model is now complete and state can be resized.
resizeState();
}
void Device::
createGeomData()
{
geomData_ = GeomDataPtr_t( new GeomData(*geomModel_) );
se3::computeBodyRadius(*model_,*geomModel_,*geomData_);
}
/* ---------------------------------------------------------------------- */
/* --- JOINT ------------------------------------------------------------ */
/* ---------------------------------------------------------------------- */
JointPtr_t Device::
rootJoint () const
{
return JointPtr_t( new Joint(weakPtr_.lock(),1) );
}
JointPtr_t Device::
getJointAtConfigRank (const size_type& r) const
{
assert(model_);
//BOOST_FOREACH( const se3::JointModel & j, // Skip "universe" joint
//std::make_pair(model_->joints.begin()+1,model_->joints.end()) )
BOOST_FOREACH( const se3::JointModel & j, model_->joints )
{
if( j.id()==0 ) continue; // Skip "universe" joint
const size_type iq = j.idx_q() - r;
if( 0 <= iq && iq < j.nq() ) return JointPtr_t( new Joint(weakPtr_.lock(),j.id()) );
}
assert(false && "The joint at config rank has not been found");
return JointPtr_t();
}
JointPtr_t Device::
getJointAtVelocityRank (const size_type& r) const
{
assert(model_);
BOOST_FOREACH( const se3::JointModel & j,model_->joints )
{
if( j.id()==0 ) continue; // Skip "universe" joint
const size_type iv = j.idx_v() - r;
if( 0 <= iv && iv < j.nv() ) return JointPtr_t( new Joint(weakPtr_.lock(),j.id()) );
}
assert(false && "The joint at velocity rank has not been found");
return JointPtr_t();
}
JointPtr_t Device::
getJointByName (const std::string& name) const
{
assert(model_);
if(! model_->existJointName(name))
throw std::runtime_error ("Device " + name_ +
" does not have any joint named "
+ name);
JointIndex id = model_->getJointId(name);
return JointPtr_t( new Joint(weakPtr_.lock(),id) );
}
JointPtr_t Device::
getJointByBodyName (const std::string& name) const
{
assert(model_);
if (model_->existFrame(name)) {
se3::Model::FrameIndex bodyId = model_->getFrameId(name);
if (model_->frames[bodyId].type == se3::BODY) {
JointIndex jointId = model_->frames[bodyId].parent;
//assert(jointId>=0);
assert((int)jointId<model_->njoint);
return JointPtr_t( new Joint(weakPtr_.lock(),jointId) );
}
}
throw std::runtime_error ("Device " + name_ +
" has no joint with body of name "
+ name);
}
size_type Device::
configSize () const
{
assert(model_);
return model_->nq + extraConfigSpace_.dimension();
}
size_type Device::
numberDof () const
{
assert(model_);
return model_->nv + extraConfigSpace_.dimension();
}
/* ---------------------------------------------------------------------- */
/* --- CONFIG ----------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
/* Previous implementation of resizeState in hpp::model:: was setting the
* new part of the configuration to neutral configuration. This is not
* working but for empty extra-config. The former behavior is therefore not
* propagated here. The configuration is resized without setting the new
* memory.
*/
void Device::
resizeState()
{
// FIXME we should not use neutralConfiguration here.
currentConfiguration_ = neutralConfiguration();
// currentConfiguration_.resize(configSize());
currentVelocity_.resize(numberDof());
currentAcceleration_.resize(numberDof());
}
bool Device::
currentConfiguration (ConfigurationIn_t configuration)
{
if (configuration != currentConfiguration_)
{
invalidate();
currentConfiguration_ = configuration;
return true;
}
return false;
}
Configuration_t Device::
neutralConfiguration () const
{
Configuration_t n (configSize());
n.head(model_->nq) = model().neutralConfiguration;
n.tail(extraConfigSpace_.dimension()).setZero();
return n;
}
const value_type& Device::
mass () const
{
assert(data_);
return data_->mass[0];
}
const vector3_t& Device::
positionCenterOfMass () const
{
assert(data_);
return data_->com[0];
}
const ComJacobian_t& Device::
jacobianCenterOfMass () const
{
assert(data_);
return data_->Jcom;
}
void Device::
computeForwardKinematics ()
{
if(upToDate_) return;
assert(model_);
assert(data_);
// a IMPLIES b === (b || ~a)
// velocity IMPLIES position
assert( (computationFlag_&JOINT_POSITION) || (!(computationFlag_&VELOCITY)) );
// acceleration IMPLIES velocity
assert( (computationFlag_&VELOCITY) || (!(computationFlag_&ACCELERATION)) );
// com IMPLIES position
assert( (computationFlag_&JOINT_POSITION) || (!(computationFlag_&COM)) );
// jacobian IMPLIES position
assert( (computationFlag_&JOINT_POSITION) || (!(computationFlag_&JACOBIAN)) );
const size_type nq = model().nq;
const size_type nv = model().nv;
if (computationFlag_ & ACCELERATION )
se3::forwardKinematics(*model_,*data_,currentConfiguration_.head(nq),
currentVelocity_.head(nv),currentAcceleration_.head(nv));
else if (computationFlag_ & VELOCITY )
se3::forwardKinematics(*model_,*data_,currentConfiguration_.head(nq),
currentVelocity_.head(nv));
else if (computationFlag_ & JOINT_POSITION )
se3::forwardKinematics(*model_,*data_,currentConfiguration_.head(nq));
if (computationFlag_&COM)
{
if (computationFlag_|JACOBIAN)
// TODO: Jcom should not recompute the kinematics (\sa pinocchio issue #219)
se3::jacobianCenterOfMass(*model_,*data_,currentConfiguration_.head(nq),true);
else
se3::centerOfMass(*model_,*data_,currentConfiguration_.head(nq),true,false);
}
if(computationFlag_&JACOBIAN)
se3::computeJacobians(*model_,*data_,currentConfiguration_.head(nq));
}
void Device::
updateGeometryPlacements ()
{
if (!geomUpToDate_) {
se3::updateGeometryPlacements(model(),data(),geomModel(),geomData());
geomUpToDate_ = true;
}
}
std::ostream& Device::
print (std::ostream& os) const
{
for (JointVector::const_iterator it = jointVector_.begin (); it != jointVector_.end (); ++it)
(*it)->display(os);
return os;
}
/* ---------------------------------------------------------------------- */
/* --- COLLISIONS ------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
bool Device::collisionTest (const bool stopAtFirstCollision)
{
/* Following hpp::model API, the forward kinematics (joint placement) is
* supposed to have already been computed. */
updateGeometryPlacements();
return se3::computeCollisions(geomData(),stopAtFirstCollision);
}
void Device::computeDistances ()
{
/* Following hpp::model API, the forward kinematics (joint placement) is
* supposed to have already been computed. */
updateGeometryPlacements();
se3::computeDistances (geomData());
}
const DistanceResults_t& Device::distanceResults () const
{
return geomData().distance_results;
}
} // namespace pinocchio
} // namespace hpp
<commit_msg>Device constructor initilize Data and GeometryData<commit_after>//
// Copyright (c) 2016 CNRS
// Author: NMansard
//
//
// This file is part of hpp-pinocchio
// hpp-pinocchio 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.
//
// hpp-pinocchio 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 Lesser Public License for more details. You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-pinocchio If not, see
// <http://www.gnu.org/licenses/>.
#include <hpp/pinocchio/device.hh>
#include <boost/foreach.hpp>
#include <Eigen/Core>
#include <pinocchio/multibody/model.hpp>
#include <pinocchio/algorithm/center-of-mass.hpp>
#include <pinocchio/algorithm/jacobian.hpp>
#include <pinocchio/algorithm/kinematics.hpp>
#include <pinocchio/algorithm/geometry.hpp>
#include <hpp/pinocchio/fwd.hh>
//#include <hpp/pinocchio/distance-result.hh>
#include <hpp/pinocchio/extra-config-space.hh>
#include <hpp/pinocchio/joint.hh>
namespace hpp {
namespace pinocchio {
Device::
Device(const std::string& name)
: model_(new Model())
, data_ ()
, geomModel_(new GeomModel())
, geomData_ ()
, name_ (name)
, jointVector_()
, computationFlag_ (JOINT_POSITION)
, obstacles_()
, objectVector_ ()
, weakPtr_()
{
invalidate();
createData();
createGeomData();
}
// static method
DevicePtr_t Device::
create (const std::string & name)
{
DevicePtr_t res = DevicePtr_t(new Device(name)); // init shared ptr
res->init (res);
return res;
}
// static method
DevicePtr_t Device::
createCopy (const DevicePtr_t& device)
{
DevicePtr_t res = Device::create(device->name()); // init shared ptr
res->model(device->modelPtr()); // Copy pointer to pinocchio model
res->createData(); // Create a new data, dont copy the pointer.
return res;
}
// static method
DevicePtr_t Device::
createCopyConst (const DeviceConstPtr_t& device)
{
DevicePtr_t res = Device::create(device->name()); // init shared ptr
/* The copy of Pinocchio::Model is not implemented yet. */
/* We need this feature to finish the implementation of this method. */
assert( false && "TODO: createCopyConst is not implemented yet." );
return res;
}
void Device::init(const DeviceWkPtr_t& weakPtr)
{
weakPtr_ = weakPtr;
DevicePtr_t self (weakPtr_.lock());
jointVector_ = JointVector(self);
obstacles_ = ObjectVector(self,0,INNER);
objectVector_ = DeviceObjectVector(self);
}
void Device::
createData()
{
data_ = DataPtr_t( new Data(*model_) );
// We assume that model is now complete and state can be resized.
resizeState();
}
void Device::
createGeomData()
{
geomData_ = GeomDataPtr_t( new GeomData(*geomModel_) );
se3::computeBodyRadius(*model_,*geomModel_,*geomData_);
}
/* ---------------------------------------------------------------------- */
/* --- JOINT ------------------------------------------------------------ */
/* ---------------------------------------------------------------------- */
JointPtr_t Device::
rootJoint () const
{
return JointPtr_t( new Joint(weakPtr_.lock(),1) );
}
JointPtr_t Device::
getJointAtConfigRank (const size_type& r) const
{
assert(model_);
//BOOST_FOREACH( const se3::JointModel & j, // Skip "universe" joint
//std::make_pair(model_->joints.begin()+1,model_->joints.end()) )
BOOST_FOREACH( const se3::JointModel & j, model_->joints )
{
if( j.id()==0 ) continue; // Skip "universe" joint
const size_type iq = j.idx_q() - r;
if( 0 <= iq && iq < j.nq() ) return JointPtr_t( new Joint(weakPtr_.lock(),j.id()) );
}
assert(false && "The joint at config rank has not been found");
return JointPtr_t();
}
JointPtr_t Device::
getJointAtVelocityRank (const size_type& r) const
{
assert(model_);
BOOST_FOREACH( const se3::JointModel & j,model_->joints )
{
if( j.id()==0 ) continue; // Skip "universe" joint
const size_type iv = j.idx_v() - r;
if( 0 <= iv && iv < j.nv() ) return JointPtr_t( new Joint(weakPtr_.lock(),j.id()) );
}
assert(false && "The joint at velocity rank has not been found");
return JointPtr_t();
}
JointPtr_t Device::
getJointByName (const std::string& name) const
{
assert(model_);
if(! model_->existJointName(name))
throw std::runtime_error ("Device " + name_ +
" does not have any joint named "
+ name);
JointIndex id = model_->getJointId(name);
return JointPtr_t( new Joint(weakPtr_.lock(),id) );
}
JointPtr_t Device::
getJointByBodyName (const std::string& name) const
{
assert(model_);
if (model_->existFrame(name)) {
se3::Model::FrameIndex bodyId = model_->getFrameId(name);
if (model_->frames[bodyId].type == se3::BODY) {
JointIndex jointId = model_->frames[bodyId].parent;
//assert(jointId>=0);
assert((int)jointId<model_->njoint);
return JointPtr_t( new Joint(weakPtr_.lock(),jointId) );
}
}
throw std::runtime_error ("Device " + name_ +
" has no joint with body of name "
+ name);
}
size_type Device::
configSize () const
{
assert(model_);
return model_->nq + extraConfigSpace_.dimension();
}
size_type Device::
numberDof () const
{
assert(model_);
return model_->nv + extraConfigSpace_.dimension();
}
/* ---------------------------------------------------------------------- */
/* --- CONFIG ----------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
/* Previous implementation of resizeState in hpp::model:: was setting the
* new part of the configuration to neutral configuration. This is not
* working but for empty extra-config. The former behavior is therefore not
* propagated here. The configuration is resized without setting the new
* memory.
*/
void Device::
resizeState()
{
// FIXME we should not use neutralConfiguration here.
currentConfiguration_ = neutralConfiguration();
// currentConfiguration_.resize(configSize());
currentVelocity_.resize(numberDof());
currentAcceleration_.resize(numberDof());
}
bool Device::
currentConfiguration (ConfigurationIn_t configuration)
{
if (configuration != currentConfiguration_)
{
invalidate();
currentConfiguration_ = configuration;
return true;
}
return false;
}
Configuration_t Device::
neutralConfiguration () const
{
Configuration_t n (configSize());
n.head(model_->nq) = model().neutralConfiguration;
n.tail(extraConfigSpace_.dimension()).setZero();
return n;
}
const value_type& Device::
mass () const
{
assert(data_);
return data_->mass[0];
}
const vector3_t& Device::
positionCenterOfMass () const
{
assert(data_);
return data_->com[0];
}
const ComJacobian_t& Device::
jacobianCenterOfMass () const
{
assert(data_);
return data_->Jcom;
}
void Device::
computeForwardKinematics ()
{
if(upToDate_) return;
assert(model_);
assert(data_);
// a IMPLIES b === (b || ~a)
// velocity IMPLIES position
assert( (computationFlag_&JOINT_POSITION) || (!(computationFlag_&VELOCITY)) );
// acceleration IMPLIES velocity
assert( (computationFlag_&VELOCITY) || (!(computationFlag_&ACCELERATION)) );
// com IMPLIES position
assert( (computationFlag_&JOINT_POSITION) || (!(computationFlag_&COM)) );
// jacobian IMPLIES position
assert( (computationFlag_&JOINT_POSITION) || (!(computationFlag_&JACOBIAN)) );
const size_type nq = model().nq;
const size_type nv = model().nv;
if (computationFlag_ & ACCELERATION )
se3::forwardKinematics(*model_,*data_,currentConfiguration_.head(nq),
currentVelocity_.head(nv),currentAcceleration_.head(nv));
else if (computationFlag_ & VELOCITY )
se3::forwardKinematics(*model_,*data_,currentConfiguration_.head(nq),
currentVelocity_.head(nv));
else if (computationFlag_ & JOINT_POSITION )
se3::forwardKinematics(*model_,*data_,currentConfiguration_.head(nq));
if (computationFlag_&COM)
{
if (computationFlag_|JACOBIAN)
// TODO: Jcom should not recompute the kinematics (\sa pinocchio issue #219)
se3::jacobianCenterOfMass(*model_,*data_,currentConfiguration_.head(nq),true);
else
se3::centerOfMass(*model_,*data_,currentConfiguration_.head(nq),true,false);
}
if(computationFlag_&JACOBIAN)
se3::computeJacobians(*model_,*data_,currentConfiguration_.head(nq));
}
void Device::
updateGeometryPlacements ()
{
if (!geomUpToDate_) {
se3::updateGeometryPlacements(model(),data(),geomModel(),geomData());
geomUpToDate_ = true;
}
}
std::ostream& Device::
print (std::ostream& os) const
{
for (JointVector::const_iterator it = jointVector_.begin (); it != jointVector_.end (); ++it)
(*it)->display(os);
return os;
}
/* ---------------------------------------------------------------------- */
/* --- COLLISIONS ------------------------------------------------------- */
/* ---------------------------------------------------------------------- */
bool Device::collisionTest (const bool stopAtFirstCollision)
{
/* Following hpp::model API, the forward kinematics (joint placement) is
* supposed to have already been computed. */
updateGeometryPlacements();
return se3::computeCollisions(geomData(),stopAtFirstCollision);
}
void Device::computeDistances ()
{
/* Following hpp::model API, the forward kinematics (joint placement) is
* supposed to have already been computed. */
updateGeometryPlacements();
se3::computeDistances (geomData());
}
const DistanceResults_t& Device::distanceResults () const
{
return geomData().distance_results;
}
} // namespace pinocchio
} // namespace hpp
<|endoftext|> |
<commit_before>// The MIT License(MIT)
//
// Copyright 2017 bladez-fate
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "data.h"
#include "music.h"
#include "engine/easy.h"
namespace pilecode {
namespace {
int g_musicIdx = 0;
bool g_musicDisabled = false;
}
void UpdateMusic()
{
if (!g_musicDisabled) {
// switch background music tracks
if (!music::g_background[g_musicIdx].IsPlaying()) {
g_musicIdx = (g_musicIdx + 1) % music::g_backgroundCount;
music::g_background[g_musicIdx].Play(0.2f);
}
}
else {
if (music::g_background[g_musicIdx].IsPlaying()) {
music::g_background[g_musicIdx].Stop();
}
g_musicIdx = (g_musicIdx + 1) % music::g_backgroundCount;
}
}
void ToggleMusic()
{
g_musicDisabled = !g_musicDisabled;
}
}
<commit_msg>newline<commit_after>// The MIT License(MIT)
//
// Copyright 2017 bladez-fate
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files(the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions :
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
#include "data.h"
#include "music.h"
#include "engine/easy.h"
namespace pilecode {
namespace {
int g_musicIdx = 0;
bool g_musicDisabled = false;
}
void UpdateMusic()
{
if (!g_musicDisabled) {
// switch background music tracks
if (!music::g_background[g_musicIdx].IsPlaying()) {
g_musicIdx = (g_musicIdx + 1) % music::g_backgroundCount;
music::g_background[g_musicIdx].Play(0.2f);
}
}
else {
if (music::g_background[g_musicIdx].IsPlaying()) {
music::g_background[g_musicIdx].Stop();
}
g_musicIdx = (g_musicIdx + 1) % music::g_backgroundCount;
}
}
void ToggleMusic()
{
g_musicDisabled = !g_musicDisabled;
}
}
<|endoftext|> |
<commit_before>/*
* Copyright (c) 2017 Darren Smith
*
* wampcc is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
*/
#include "wampcc/kernel.h"
#include "wampcc/io_loop.h"
#include "wampcc/event_loop.h"
#include "wampcc/ssl.h"
#include "wampcc/platform.h"
#include "config.h"
#include <iostream>
namespace wampcc
{
const char* package_name() { return WAMPCC_PACKAGE_NAME; }
const char* package_version() { return WAMPCC_PACKAGE_VERSION; }
const char* package_string() { return WAMPCC_PACKAGE_STRING; }
int major_version() { return WAMPCC_MAJOR_VERSION; }
int minor_version() { return WAMPCC_MINOR_VERSION; }
int micro_version() { return WAMPCC_MICRO_VERSION; }
static const char* level_str(logger::Level l);
std::mutex logger::lockable_console::stream_mutex ;
logger::lockable_console logger::lockable_cout;
config::config()
: socket_buffer_max_size_bytes(65536), socket_max_pending_write_bytes(65536),
ssl(false)
{
}
/* Constructor */
kernel::kernel(config conf, logger nlog)
: m_config(conf),
__logger(nlog)
{
// SSL initialisation can fail, so we start the loops only after it has been
// set up
if (conf.ssl.enable)
m_ssl.reset(new ssl_context(__logger, conf.ssl));
m_io_loop.reset(new io_loop(*this));
m_evl.reset(new event_loop(this));
}
/* Destructor */
kernel::~kernel()
{
/* stop IO loop first, which will include closing all outstanding socket
* resources, and as that happens, events are pushed onto the event queue
* which is still operational */
m_io_loop->sync_stop();
m_evl->sync_stop();
}
io_loop* kernel::get_io() { return m_io_loop.get(); }
event_loop* kernel::get_event_loop() { return m_evl.get(); }
ssl_context* kernel::get_ssl() { return m_ssl.get(); }
int logger::levels_upto(Level l)
{
int r(0);
for (int i = 1; i <= l; i <<= 1)
r |= i;
return r;
}
logger logger::stream(lockable_stream& ostr, int level_mask, bool inc_src)
{
logger my_logger;
my_logger.wants_level =
[level_mask](logger::Level l) { return (l & level_mask) != 0; };
my_logger.write = [&ostr, level_mask, inc_src](logger::Level level,
const std::string& msg,
const char* file, int ln) {
std::ostringstream oss;
oss << wampcc::local_timestamp()
<< wampcc::thread_id() << " "
<< level_str(level) << " "
<< msg;
if (inc_src && file)
oss << " (" << file << ":" << ln << ") ";
ostr.lock();
try {
// std:endl should act directly on the stream object, so that stream can
// detect it and trigger stream sync.
ostr.stream() << oss.str() << std::endl;
} catch (...) {}
ostr.unlock();
};
return my_logger;
}
static const char* level_str(logger::Level l)
{
switch (l) {
case logger::eError:
return "ERROR";
case logger::eWarn:
return " WARN";
case logger::eInfo:
return " INFO";
case logger::eDebug:
return "DEBUG";
case logger::eTrace:
return "TRACE";
}
return "UNKNOWN";
}
logger logger::nolog()
{
logger my_logger;
my_logger.wants_level = [](logger::Level) { return false; };
my_logger.write = [](logger::Level, const std::string&, const char*, int) {};
return my_logger;
}
std::ostream& logger::lockable_console::stream()
{
return std::cout;
}
} // namespace wampcc
<commit_msg>fix log line format issue<commit_after>/*
* Copyright (c) 2017 Darren Smith
*
* wampcc is free software; you can redistribute it and/or modify
* it under the terms of the MIT license. See LICENSE for details.
*/
#include "wampcc/kernel.h"
#include "wampcc/io_loop.h"
#include "wampcc/event_loop.h"
#include "wampcc/ssl.h"
#include "wampcc/platform.h"
#include "config.h"
#include <iostream>
namespace wampcc
{
const char* package_name() { return WAMPCC_PACKAGE_NAME; }
const char* package_version() { return WAMPCC_PACKAGE_VERSION; }
const char* package_string() { return WAMPCC_PACKAGE_STRING; }
int major_version() { return WAMPCC_MAJOR_VERSION; }
int minor_version() { return WAMPCC_MINOR_VERSION; }
int micro_version() { return WAMPCC_MICRO_VERSION; }
static const char* level_str(logger::Level l);
std::mutex logger::lockable_console::stream_mutex ;
logger::lockable_console logger::lockable_cout;
config::config()
: socket_buffer_max_size_bytes(65536), socket_max_pending_write_bytes(65536),
ssl(false)
{
}
/* Constructor */
kernel::kernel(config conf, logger nlog)
: m_config(conf),
__logger(nlog)
{
// SSL initialisation can fail, so we start the loops only after it has been
// set up
if (conf.ssl.enable)
m_ssl.reset(new ssl_context(__logger, conf.ssl));
m_io_loop.reset(new io_loop(*this));
m_evl.reset(new event_loop(this));
}
/* Destructor */
kernel::~kernel()
{
/* stop IO loop first, which will include closing all outstanding socket
* resources, and as that happens, events are pushed onto the event queue
* which is still operational */
m_io_loop->sync_stop();
m_evl->sync_stop();
}
io_loop* kernel::get_io() { return m_io_loop.get(); }
event_loop* kernel::get_event_loop() { return m_evl.get(); }
ssl_context* kernel::get_ssl() { return m_ssl.get(); }
int logger::levels_upto(Level l)
{
int r(0);
for (int i = 1; i <= l; i <<= 1)
r |= i;
return r;
}
logger logger::stream(lockable_stream& ostr, int level_mask, bool inc_src)
{
logger my_logger;
my_logger.wants_level =
[level_mask](logger::Level l) { return (l & level_mask) != 0; };
my_logger.write = [&ostr, level_mask, inc_src](logger::Level level,
const std::string& msg,
const char* file, int ln) {
std::ostringstream oss;
oss << wampcc::local_timestamp() << " "
<< wampcc::thread_id() << " "
<< level_str(level) << " "
<< msg;
if (inc_src && file)
oss << " (" << file << ":" << ln << ") ";
ostr.lock();
try {
// std:endl should act directly on the stream object, so that stream can
// detect it and trigger stream sync.
ostr.stream() << oss.str() << std::endl;
} catch (...) {}
ostr.unlock();
};
return my_logger;
}
static const char* level_str(logger::Level l)
{
switch (l) {
case logger::eError:
return "ERROR";
case logger::eWarn:
return " WARN";
case logger::eInfo:
return " INFO";
case logger::eDebug:
return "DEBUG";
case logger::eTrace:
return "TRACE";
}
return "UNKNOWN";
}
logger logger::nolog()
{
logger my_logger;
my_logger.wants_level = [](logger::Level) { return false; };
my_logger.write = [](logger::Level, const std::string&, const char*, int) {};
return my_logger;
}
std::ostream& logger::lockable_console::stream()
{
return std::cout;
}
} // namespace wampcc
<|endoftext|> |
<commit_before>#include "./nodes.h"
#include <QDebug>
#include <string>
#include <vector>
#include "./utils/persister.h"
#include "./importer.h"
#include "./mesh_node.h"
#include "./label_node.h"
#include "./obb_node.h"
#include "./camera_node.h"
#include "./coordinate_system_node.h"
Nodes::Nodes()
{
addNode(std::make_shared<CoordinateSystemNode>());
}
Nodes::~Nodes()
{
qInfo() << "Destructor of Nodes";
}
std::vector<std::shared_ptr<LabelNode>> Nodes::getLabelNodes()
{
std::vector<std::shared_ptr<LabelNode>> result;
for (auto &node : nodes)
{
std::shared_ptr<LabelNode> labelNode =
std::dynamic_pointer_cast<LabelNode>(node);
if (labelNode.get())
result.push_back(labelNode);
}
return result;
}
void Nodes::addNode(std::shared_ptr<Node> node)
{
nodes.push_back(node);
emit nodesChanged(node);
}
void Nodes::removeNode(std::shared_ptr<Node> node)
{
nodes.erase(std::remove(nodes.begin(), nodes.end(), node), nodes.end());
}
std::vector<std::shared_ptr<Node>> Nodes::getNodes()
{
return nodes;
}
std::shared_ptr<CameraNode> Nodes::getCameraNode()
{
return cameraNode;
}
void Nodes::addSceneNodesFrom(QUrl url)
{
addSceneNodesFrom(url.path().toStdString());
}
void Nodes::addSceneNodesFrom(std::string filename)
{
qDebug() << "Nodes::addSceneNodesFrom" << filename.c_str();
auto loadedNodes =
Persister::load<std::vector<std::shared_ptr<Node>>>(filename);
for (auto &node : loadedNodes)
{
std::shared_ptr<CameraNode> camera =
std::dynamic_pointer_cast<CameraNode>(node);
if (camera.get())
cameraNode = camera;
addNode(node);
}
}
void Nodes::importFrom(std::string filename)
{
Importer importer;
auto meshes = importer.importAll(filename);
for (size_t i = 0; i < meshes.size(); ++i)
{
auto transformation = importer.getTransformationFor(filename, i);
addNode(std::make_shared<MeshNode>(filename, i, meshes[i], transformation));
}
}
void Nodes::importFrom(QUrl url)
{
importFrom(url.path().toStdString());
}
void Nodes::render(Graphics::Gl *gl,
std::shared_ptr<Graphics::Managers> managers,
RenderData renderData)
{
for (auto &node : nodes)
node->render(gl, managers, renderData);
if (showBoundingVolumes)
{
for (auto &node : obbNodes)
node->render(gl, managers, renderData);
}
}
void Nodes::renderLabels(Graphics::Gl *gl,
std::shared_ptr<Graphics::Managers> managers,
RenderData renderData)
{
for (auto labelNode : getLabelNodes())
{
labelNode->renderLabelAndConnector(gl, managers, renderData);
}
}
void Nodes::saveSceneTo(QUrl url)
{
saveSceneTo(url.path().toStdString());
}
void Nodes::saveSceneTo(std::string filename)
{
std::vector<std::shared_ptr<Node>> persistableNodes;
for (auto node : nodes)
if (node->isPersistable())
persistableNodes.push_back(node);
Persister::save(persistableNodes, filename);
}
void Nodes::clear()
{
nodes.clear();
obbNodes.clear();
}
void Nodes::toggleBoundingVolumes()
{
showBoundingVolumes = !showBoundingVolumes;
if (showBoundingVolumes)
{
obbNodes.clear();
for (auto &node : nodes)
{
if (node->getObb().isInitialized())
{
obbNodes.push_back(std::make_shared<ObbNode>(node->getObb()));
}
}
}
}
void Nodes::addForcesVisualizerNode(std::shared_ptr<Node> node)
{
addNode(node);
forcesVisualizerNode = node;
}
void Nodes::removeForcesVisualizerNode()
{
removeNode(forcesVisualizerNode);
}
<commit_msg>Create default CameraNode in Nodes constructor.<commit_after>#include "./nodes.h"
#include <QDebug>
#include <string>
#include <vector>
#include "./utils/persister.h"
#include "./importer.h"
#include "./mesh_node.h"
#include "./label_node.h"
#include "./obb_node.h"
#include "./camera_node.h"
#include "./coordinate_system_node.h"
Nodes::Nodes()
{
addNode(std::make_shared<CoordinateSystemNode>());
cameraNode = std::make_shared<CameraNode>();
addNode(cameraNode);
}
Nodes::~Nodes()
{
qInfo() << "Destructor of Nodes";
}
std::vector<std::shared_ptr<LabelNode>> Nodes::getLabelNodes()
{
std::vector<std::shared_ptr<LabelNode>> result;
for (auto &node : nodes)
{
std::shared_ptr<LabelNode> labelNode =
std::dynamic_pointer_cast<LabelNode>(node);
if (labelNode.get())
result.push_back(labelNode);
}
return result;
}
void Nodes::addNode(std::shared_ptr<Node> node)
{
nodes.push_back(node);
emit nodesChanged(node);
}
void Nodes::removeNode(std::shared_ptr<Node> node)
{
nodes.erase(std::remove(nodes.begin(), nodes.end(), node), nodes.end());
}
std::vector<std::shared_ptr<Node>> Nodes::getNodes()
{
return nodes;
}
std::shared_ptr<CameraNode> Nodes::getCameraNode()
{
return cameraNode;
}
void Nodes::addSceneNodesFrom(QUrl url)
{
addSceneNodesFrom(url.path().toStdString());
}
void Nodes::addSceneNodesFrom(std::string filename)
{
qDebug() << "Nodes::addSceneNodesFrom" << filename.c_str();
auto loadedNodes =
Persister::load<std::vector<std::shared_ptr<Node>>>(filename);
for (auto &node : loadedNodes)
{
std::shared_ptr<CameraNode> camera =
std::dynamic_pointer_cast<CameraNode>(node);
if (camera.get())
cameraNode = camera;
addNode(node);
}
}
void Nodes::importFrom(std::string filename)
{
Importer importer;
auto meshes = importer.importAll(filename);
for (size_t i = 0; i < meshes.size(); ++i)
{
auto transformation = importer.getTransformationFor(filename, i);
addNode(std::make_shared<MeshNode>(filename, i, meshes[i], transformation));
}
}
void Nodes::importFrom(QUrl url)
{
importFrom(url.path().toStdString());
}
void Nodes::render(Graphics::Gl *gl,
std::shared_ptr<Graphics::Managers> managers,
RenderData renderData)
{
for (auto &node : nodes)
node->render(gl, managers, renderData);
if (showBoundingVolumes)
{
for (auto &node : obbNodes)
node->render(gl, managers, renderData);
}
}
void Nodes::renderLabels(Graphics::Gl *gl,
std::shared_ptr<Graphics::Managers> managers,
RenderData renderData)
{
for (auto labelNode : getLabelNodes())
{
labelNode->renderLabelAndConnector(gl, managers, renderData);
}
}
void Nodes::saveSceneTo(QUrl url)
{
saveSceneTo(url.path().toStdString());
}
void Nodes::saveSceneTo(std::string filename)
{
std::vector<std::shared_ptr<Node>> persistableNodes;
for (auto node : nodes)
if (node->isPersistable())
persistableNodes.push_back(node);
Persister::save(persistableNodes, filename);
}
void Nodes::clear()
{
nodes.clear();
obbNodes.clear();
}
void Nodes::toggleBoundingVolumes()
{
showBoundingVolumes = !showBoundingVolumes;
if (showBoundingVolumes)
{
obbNodes.clear();
for (auto &node : nodes)
{
if (node->getObb().isInitialized())
{
obbNodes.push_back(std::make_shared<ObbNode>(node->getObb()));
}
}
}
}
void Nodes::addForcesVisualizerNode(std::shared_ptr<Node> node)
{
addNode(node);
forcesVisualizerNode = node;
}
void Nodes::removeForcesVisualizerNode()
{
removeNode(forcesVisualizerNode);
}
<|endoftext|> |
<commit_before>/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: itkObjectMorphologyImageFilterTest.cxx
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/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 notices for more information.
=========================================================================*/
#include <stdlib.h>
#include <time.h>
#include <itkImage.h>
#include <itkIndex.h>
#include "itkDilateObjectMorphologyImageFilter.h"
#include "itkBinaryErodeImageFilter.h"
#include "itkBinaryDilateImageFilter.h"
#include "itkErodeObjectMorphologyImageFilter.h"
#include <itkBinaryBallStructuringElement.h>
#include <itkImageRegionIterator.h>
#include <itkExceptionObject.h>
int itkObjectMorphologyImageFilterTest(int, char* [] )
{
// Define the dimension of the images
const unsigned int myDimension = 3;
// Define the values of the input images
const unsigned short fgValue = 1;
const unsigned short bgValue = 0;
// Declare the types of the images
typedef itk::Image<unsigned short, myDimension> myImageType;
// Declare the type of the index to access images
typedef itk::Index<myDimension> myIndexType;
// Declare the type of the size
typedef itk::Size<myDimension> mySizeType;
// Declare the type of the Region
typedef itk::ImageRegion<myDimension> myRegionType;
// Create an image
myImageType::Pointer inputImage = myImageType::New();
// Define their size, and start index
mySizeType size;
size[0] = 20;
size[1] = 20;
size[2] = 20;
myIndexType index;
index[0] = 0;
index[1] = 0;
index[2] = 0;
myRegionType region;
region.SetIndex( index );
region.SetSize( size );
// Initialize Image
inputImage->SetRegions( region );
inputImage->Allocate();
// Declare Iterator types apropriated for each image
typedef itk::ImageRegionIterator<myImageType> myIteratorType;
// Initialize the content of Image
inputImage->FillBuffer(bgValue);
myImageType::IndexType ind;
ind[0] = 10;
ind[1] = 10;
ind[2] = 10;
inputImage->SetPixel(ind, fgValue);
ind[0] = 2;
ind[1] = 2;
ind[2] = 8;
inputImage->SetPixel(ind, fgValue);
ind[0] = 9;
ind[1] = 10;
ind[2] = 5;
inputImage->SetPixel(ind, fgValue);
ind[0] = 9;
ind[1] = 0;
ind[2] = 15;
inputImage->SetPixel(ind, fgValue);
ind[0] = 9;
ind[1] = 9;
ind[2] = 7;
inputImage->SetPixel(ind, fgValue);
ind[0] = 0;
ind[1] = 4;
ind[2] = 17;
inputImage->SetPixel(ind, fgValue);
// Declare the type for the structuring element
typedef itk::BinaryBallStructuringElement<unsigned short, myDimension>
myKernelType;
// Declare the type for the morphology Filter
typedef itk::DilateObjectMorphologyImageFilter<myImageType, myImageType,
myKernelType>
myDilateFilterType;
typedef itk::BinaryDilateImageFilter<myImageType, myImageType,
myKernelType>
binDilateFilterType;
typedef itk::ErodeObjectMorphologyImageFilter<myImageType, myImageType,
myKernelType>
myErodeFilterType;
typedef itk::BinaryErodeImageFilter<myImageType, myImageType,
myKernelType>
binErodeFilterType;
// Create the filter
myDilateFilterType::Pointer dilateFilter = myDilateFilterType::New();
myErodeFilterType::Pointer erodeFilter = myErodeFilterType::New();
binDilateFilterType::Pointer binDilateFilter = binDilateFilterType::New();
binErodeFilterType::Pointer binErodeFilter = binErodeFilterType::New();
// Create the structuring element
myKernelType ball;
myKernelType::SizeType ballSize;
ballSize[0] = 5;
ballSize[1] = 4;
ballSize[2] = 3;
ball.SetRadius(ballSize);
ball.CreateStructuringElement();
// Connect the input image
dilateFilter->SetInput( inputImage );
dilateFilter->SetKernel( ball );
dilateFilter->SetObjectValue( fgValue );
myImageType::Pointer outputImage = dilateFilter->GetOutput();
clock_t start, end;
double elapsedTime;
// Execute the filter
try
{
std::cout << "Object Dilate..." << std::endl;
start = clock();
dilateFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during dilate filter Update\n" << e;
return -1;
}
binDilateFilter->SetInput( inputImage );
binDilateFilter->SetKernel( ball );
binDilateFilter->SetDilateValue( fgValue );
myImageType::Pointer outputBinImage = binDilateFilter->GetOutput();
try
{
std::cout << "Binary Dilate..." << std::endl;
start = clock();
binDilateFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during dilate filter Update\n" << e;
return -1;
}
// Create an iterator for going through the image output
myIteratorType itObj(outputImage, outputImage->GetBufferedRegion());
myIteratorType itBin(outputBinImage, outputBinImage->GetBufferedRegion());
std::cout << "Test for Dilate equality..." << std::endl;
start = clock();
itObj.GoToBegin();
itBin.GoToBegin();
int count = 0;
while( !itObj.IsAtEnd() && !itBin.IsAtEnd() )
{
if(itObj.Get() != itBin.Get())
{
std::cerr << "Error: Dilated images differ!" << std::endl;
std::cerr << " Slice = " << count/(size[1]*size[0]) << std::endl;
int x, y;
itk::Index<3> i;
i[2] = count/(size[1]*size[0]);
for(y=0; y<size[1]; y++)
{
i[1] = y;
for(x=0; x<size[0]; x++)
{
i[0] = x;
std::cerr << outputImage->GetPixel(i)
<< outputBinImage->GetPixel(i) << " ";
}
std::cerr << std::endl;
}
return -1;
}
++itObj;
++itBin;
++count;
}
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
ballSize[0] = 2;
ballSize[1] = 2;
ballSize[2] = 2;
ball.SetRadius(ballSize);
ball.CreateStructuringElement();
// Connect the input image
erodeFilter->SetInput( outputImage );
erodeFilter->SetKernel( ball );
erodeFilter->SetObjectValue( fgValue );
erodeFilter->SetBackgroundValue( bgValue );
myImageType::Pointer output2Image = erodeFilter->GetOutput();
// Execute the filter
try
{
std::cout << "Object Erode..." << std::endl;
start = clock();
erodeFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during erode filter Update\n" << e;
return -1;
}
binErodeFilter->SetInput( outputImage );
binErodeFilter->SetKernel( ball );
binErodeFilter->SetErodeValue( fgValue );
myImageType::Pointer outputBin2Image = binErodeFilter->GetOutput();
// Execute the filter
try
{
std::cout << "Binary Erode..." << std::endl;
start = clock();
binErodeFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during erode filter Update\n" << e;
return -1;
}
// Create an iterator for going through the image output
myIteratorType it2Obj(output2Image, output2Image->GetBufferedRegion());
myIteratorType it2Bin(outputBin2Image, outputBin2Image->GetBufferedRegion());
std::cout << "Test for Erode equality..." << std::endl;
start = clock();
count = 0;
while( !it2Obj.IsAtEnd() )
{
if(it2Obj.Get() != it2Bin.Get())
{
std::cout << "As expected: Error: Eroded images differ!" << std::endl;
std::cout << " Please see documentation - ErodeObject and BinaryErode";
std::cout << std::endl << " produce different results" << std::endl;
std::cout << " Slice = " << count/(size[1]*size[0]) << std::endl;
int x, y;
itk::Index<3> i;
i[2] = count/(size[1]*size[0]);
for(y=0; y<size[1]; y++)
{
i[1] = y;
for(x=0; x<size[0]; x++)
{
i[0] = x;
std::cout << output2Image->GetPixel(i)
<< outputBin2Image->GetPixel(i) << " ";
}
std::cout << std::endl;
}
break;
}
++it2Obj;
++it2Bin;
++count;
}
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
// All objects should be automatically destroyed at this point
return 0;
}
<commit_msg>FIX: Resolved signed/unsigned warnings<commit_after>/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: itkObjectMorphologyImageFilterTest.cxx
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/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 notices for more information.
=========================================================================*/
#include <stdlib.h>
#include <time.h>
#include <itkImage.h>
#include <itkIndex.h>
#include "itkDilateObjectMorphologyImageFilter.h"
#include "itkBinaryErodeImageFilter.h"
#include "itkBinaryDilateImageFilter.h"
#include "itkErodeObjectMorphologyImageFilter.h"
#include <itkBinaryBallStructuringElement.h>
#include <itkImageRegionIterator.h>
#include <itkExceptionObject.h>
int itkObjectMorphologyImageFilterTest(int, char* [] )
{
// Define the dimension of the images
const unsigned int myDimension = 3;
// Define the values of the input images
const unsigned short fgValue = 1;
const unsigned short bgValue = 0;
// Declare the types of the images
typedef itk::Image<unsigned short, myDimension> myImageType;
// Declare the type of the index to access images
typedef itk::Index<myDimension> myIndexType;
// Declare the type of the size
typedef itk::Size<myDimension> mySizeType;
// Declare the type of the Region
typedef itk::ImageRegion<myDimension> myRegionType;
// Create an image
myImageType::Pointer inputImage = myImageType::New();
// Define their size, and start index
mySizeType size;
size[0] = 20;
size[1] = 20;
size[2] = 20;
myIndexType index;
index[0] = 0;
index[1] = 0;
index[2] = 0;
myRegionType region;
region.SetIndex( index );
region.SetSize( size );
// Initialize Image
inputImage->SetRegions( region );
inputImage->Allocate();
// Declare Iterator types apropriated for each image
typedef itk::ImageRegionIterator<myImageType> myIteratorType;
// Initialize the content of Image
inputImage->FillBuffer(bgValue);
myImageType::IndexType ind;
ind[0] = 10;
ind[1] = 10;
ind[2] = 10;
inputImage->SetPixel(ind, fgValue);
ind[0] = 2;
ind[1] = 2;
ind[2] = 8;
inputImage->SetPixel(ind, fgValue);
ind[0] = 9;
ind[1] = 10;
ind[2] = 5;
inputImage->SetPixel(ind, fgValue);
ind[0] = 9;
ind[1] = 0;
ind[2] = 15;
inputImage->SetPixel(ind, fgValue);
ind[0] = 9;
ind[1] = 9;
ind[2] = 7;
inputImage->SetPixel(ind, fgValue);
ind[0] = 0;
ind[1] = 4;
ind[2] = 17;
inputImage->SetPixel(ind, fgValue);
// Declare the type for the structuring element
typedef itk::BinaryBallStructuringElement<unsigned short, myDimension>
myKernelType;
// Declare the type for the morphology Filter
typedef itk::DilateObjectMorphologyImageFilter<myImageType, myImageType,
myKernelType>
myDilateFilterType;
typedef itk::BinaryDilateImageFilter<myImageType, myImageType,
myKernelType>
binDilateFilterType;
typedef itk::ErodeObjectMorphologyImageFilter<myImageType, myImageType,
myKernelType>
myErodeFilterType;
typedef itk::BinaryErodeImageFilter<myImageType, myImageType,
myKernelType>
binErodeFilterType;
// Create the filter
myDilateFilterType::Pointer dilateFilter = myDilateFilterType::New();
myErodeFilterType::Pointer erodeFilter = myErodeFilterType::New();
binDilateFilterType::Pointer binDilateFilter = binDilateFilterType::New();
binErodeFilterType::Pointer binErodeFilter = binErodeFilterType::New();
// Create the structuring element
myKernelType ball;
myKernelType::SizeType ballSize;
ballSize[0] = 5;
ballSize[1] = 4;
ballSize[2] = 3;
ball.SetRadius(ballSize);
ball.CreateStructuringElement();
// Connect the input image
dilateFilter->SetInput( inputImage );
dilateFilter->SetKernel( ball );
dilateFilter->SetObjectValue( fgValue );
myImageType::Pointer outputImage = dilateFilter->GetOutput();
clock_t start, end;
double elapsedTime;
// Execute the filter
try
{
std::cout << "Object Dilate..." << std::endl;
start = clock();
dilateFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during dilate filter Update\n" << e;
return -1;
}
binDilateFilter->SetInput( inputImage );
binDilateFilter->SetKernel( ball );
binDilateFilter->SetDilateValue( fgValue );
myImageType::Pointer outputBinImage = binDilateFilter->GetOutput();
try
{
std::cout << "Binary Dilate..." << std::endl;
start = clock();
binDilateFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during dilate filter Update\n" << e;
return -1;
}
// Create an iterator for going through the image output
myIteratorType itObj(outputImage, outputImage->GetBufferedRegion());
myIteratorType itBin(outputBinImage, outputBinImage->GetBufferedRegion());
std::cout << "Test for Dilate equality..." << std::endl;
start = clock();
itObj.GoToBegin();
itBin.GoToBegin();
int count = 0;
while( !itObj.IsAtEnd() && !itBin.IsAtEnd() )
{
if(itObj.Get() != itBin.Get())
{
std::cerr << "Error: Dilated images differ!" << std::endl;
std::cerr << " Slice = " << count/(size[1]*size[0]) << std::endl;
unsigned int x, y;
itk::Index<3> i;
i[2] = count/(size[1]*size[0]);
for(y=0; y<size[1]; y++)
{
i[1] = y;
for(x=0; x<size[0]; x++)
{
i[0] = x;
std::cerr << outputImage->GetPixel(i)
<< outputBinImage->GetPixel(i) << " ";
}
std::cerr << std::endl;
}
return -1;
}
++itObj;
++itBin;
++count;
}
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
ballSize[0] = 2;
ballSize[1] = 2;
ballSize[2] = 2;
ball.SetRadius(ballSize);
ball.CreateStructuringElement();
// Connect the input image
erodeFilter->SetInput( outputImage );
erodeFilter->SetKernel( ball );
erodeFilter->SetObjectValue( fgValue );
erodeFilter->SetBackgroundValue( bgValue );
myImageType::Pointer output2Image = erodeFilter->GetOutput();
// Execute the filter
try
{
std::cout << "Object Erode..." << std::endl;
start = clock();
erodeFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during erode filter Update\n" << e;
return -1;
}
binErodeFilter->SetInput( outputImage );
binErodeFilter->SetKernel( ball );
binErodeFilter->SetErodeValue( fgValue );
myImageType::Pointer outputBin2Image = binErodeFilter->GetOutput();
// Execute the filter
try
{
std::cout << "Binary Erode..." << std::endl;
start = clock();
binErodeFilter->Update();
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
// Print the content of the result image
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
}
catch (itk::ExceptionObject& e)
{
std::cerr << "Exception caught during erode filter Update\n" << e;
return -1;
}
// Create an iterator for going through the image output
myIteratorType it2Obj(output2Image, output2Image->GetBufferedRegion());
myIteratorType it2Bin(outputBin2Image, outputBin2Image->GetBufferedRegion());
std::cout << "Test for Erode equality..." << std::endl;
start = clock();
count = 0;
while( !it2Obj.IsAtEnd() )
{
if(it2Obj.Get() != it2Bin.Get())
{
std::cout << "As expected: Error: Eroded images differ!" << std::endl;
std::cout << " Please see documentation - ErodeObject and BinaryErode";
std::cout << std::endl << " produce different results" << std::endl;
std::cout << " Slice = " << count/(size[1]*size[0]) << std::endl;
unsigned int x, y;
itk::Index<3> i;
i[2] = count/(size[1]*size[0]);
for(y=0; y<size[1]; y++)
{
i[1] = y;
for(x=0; x<size[0]; x++)
{
i[0] = x;
std::cout << output2Image->GetPixel(i)
<< outputBin2Image->GetPixel(i) << " ";
}
std::cout << std::endl;
}
break;
}
++it2Obj;
++it2Bin;
++count;
}
end = clock();
elapsedTime = (end - start) / (double) CLOCKS_PER_SEC;
std::cout << " Success: " << std::endl;
std::cout << " Time = " << elapsedTime << std::endl;
// All objects should be automatically destroyed at this point
return 0;
}
<|endoftext|> |
<commit_before>/*
* IceWM
*
* Copyright (C) 1999-2002 Marko Macek
*/
#include "config.h"
#ifndef NO_CONFIGURE_MENUS
#include "objmenu.h"
#endif
#ifdef CONFIG_TASKBAR
#include "objbar.h"
#include "objbutton.h"
#include "ybutton.h"
#include "prefs.h"
#include "wmtaskbar.h"
#include "wmapp.h"
#include "wpixmaps.h"
#include "yrect.h"
#include "yicon.h"
YColor * ObjectBar::bgColor(NULL);
ref<YFont> ObjectButton::font;
YColor * ObjectButton::bgColor(NULL);
YColor * ObjectButton::fgColor(NULL);
ObjectBar::ObjectBar(YWindow *parent): YWindow(parent) {
if (bgColor == 0)
bgColor = new YColor(clrDefaultTaskBar);
setSize(1, 1);
}
ObjectBar::~ObjectBar() {
}
void ObjectBar::addButton(const ustring &name, ref<YIcon> icon, YButton *button) {
button->setToolTip(name);
#ifndef LITE
if (icon != null) {
button->setIcon(icon, YIcon::smallSize());
button->setSize(button->width() + 4, button->width() + 4);
} else
#endif
button->setText(name);
button->setPosition(width(), 0);
int h = button->height();
if (h < height())
h = height();
if (h < height())
h = height();
button->setSize(button->width(), h);
setSize(width() + button->width(), h);
button->show();
objects.append(button);
}
void ObjectBar::paint(Graphics &g, const YRect &/*r*/) {
#ifdef CONFIG_GRADIENTS
ref<YImage> gradient(parent()->getGradient());
if (gradient != null)
g.drawImage(gradient, this->x(), this->y(), width(), height(), 0, 0);
else
#endif
if (taskbackPixmap != null)
g.fillPixmap(taskbackPixmap, 0, 0, width(), height());
else {
g.setColor(bgColor);
g.fillRect(0, 0, width(), height());
}
}
void ObjectBar::addObject(DObject *object) {
YButton *button = new ObjectButton(this, object);
addButton(object->getName(), object->getIcon(), button);
}
void ObjectBar::addSeparator() {
setSize(width() + 4, height());
objects.append(0);
}
void ObjectBar::addContainer(const ustring &name, ref<YIcon> icon, ObjectContainer *container) {
if (container) {
YButton *button = new ObjectButton(this, (YMenu*) container);
addButton(name, icon, button);
}
}
void ObjectBar::configure(const YRect &r) {
YWindow::configure(r);
int left = 0;
for (int i = 0; i < objects.getCount(); i++) {
YButton *obj = objects[i];
if (obj) {
obj->setGeometry(YRect(left, 0, obj->width(), height()));
left += obj->width();
} else
left += 4;
}
}
ref<YFont> ObjectButton::getFont() {
return font != null ? font : font =
(*toolButtonFontName ? YFont::getFont(XFA(toolButtonFontName))
: YButton::getFont());
}
YColor * ObjectButton::getColor() {
return *clrToolButtonText
? fgColor ? fgColor : fgColor = new YColor(clrToolButtonText)
: YButton::getColor();
}
YSurface ObjectButton::getSurface() {
if (bgColor == 0)
bgColor = new YColor(*clrToolButton ? clrToolButton : clrNormalButton);
#ifdef CONFIG_GRADIENTS
return YSurface(bgColor, toolbuttonPixmap, toolbuttonPixbuf);
#else
return YSurface(bgColor, toolbuttonPixmap);
#endif
}
void ObjectButton::actionPerformed(YAction * action, unsigned modifiers) {
#ifdef CONFIG_GUIEVENTS
wmapp->signalGuiEvent(geLaunchApp);
#endif
if (fObject) fObject->open();
else YButton::actionPerformed(action, modifiers);
}
#endif /* CONFIG_TASKBAR */
#ifndef NO_CONFIGURE_MENUS
ObjectMenu *rootMenu(NULL);
#endif
<commit_msg>use getTaskBarBg().<commit_after>/*
* IceWM
*
* Copyright (C) 1999-2002 Marko Macek
*/
#include "config.h"
#ifndef NO_CONFIGURE_MENUS
#include "objmenu.h"
#endif
#ifdef CONFIG_TASKBAR
#include "objbar.h"
#include "objbutton.h"
#include "ybutton.h"
#include "prefs.h"
#include "wmtaskbar.h"
#include "wmapp.h"
#include "wpixmaps.h"
#include "yrect.h"
#include "yicon.h"
ref<YFont> ObjectButton::font;
YColor * ObjectButton::bgColor(NULL);
YColor * ObjectButton::fgColor(NULL);
ObjectBar::ObjectBar(YWindow *parent): YWindow(parent) {
setSize(1, 1);
}
ObjectBar::~ObjectBar() {
}
void ObjectBar::addButton(const ustring &name, ref<YIcon> icon, YButton *button) {
button->setToolTip(name);
#ifndef LITE
if (icon != null) {
button->setIcon(icon, YIcon::smallSize());
button->setSize(button->width() + 4, button->width() + 4);
} else
#endif
button->setText(name);
button->setPosition(width(), 0);
int h = button->height();
if (h < height())
h = height();
if (h < height())
h = height();
button->setSize(button->width(), h);
setSize(width() + button->width(), h);
button->show();
objects.append(button);
}
void ObjectBar::paint(Graphics &g, const YRect &/*r*/) {
#ifdef CONFIG_GRADIENTS
ref<YImage> gradient(parent()->getGradient());
if (gradient != null)
g.drawImage(gradient, this->x(), this->y(), width(), height(), 0, 0);
else
#endif
if (taskbackPixmap != null)
g.fillPixmap(taskbackPixmap, 0, 0, width(), height());
else {
g.setColor(getTaskBarBg());
g.fillRect(0, 0, width(), height());
}
}
void ObjectBar::addObject(DObject *object) {
YButton *button = new ObjectButton(this, object);
addButton(object->getName(), object->getIcon(), button);
}
void ObjectBar::addSeparator() {
setSize(width() + 4, height());
objects.append(0);
}
void ObjectBar::addContainer(const ustring &name, ref<YIcon> icon, ObjectContainer *container) {
if (container) {
YButton *button = new ObjectButton(this, (YMenu*) container);
addButton(name, icon, button);
}
}
void ObjectBar::configure(const YRect &r) {
YWindow::configure(r);
int left = 0;
for (int i = 0; i < objects.getCount(); i++) {
YButton *obj = objects[i];
if (obj) {
obj->setGeometry(YRect(left, 0, obj->width(), height()));
left += obj->width();
} else
left += 4;
}
}
ref<YFont> ObjectButton::getFont() {
return font != null ? font : font =
(*toolButtonFontName ? YFont::getFont(XFA(toolButtonFontName))
: YButton::getFont());
}
YColor * ObjectButton::getColor() {
return *clrToolButtonText
? fgColor ? fgColor : fgColor = new YColor(clrToolButtonText)
: YButton::getColor();
}
YSurface ObjectButton::getSurface() {
if (bgColor == 0)
bgColor = new YColor(*clrToolButton ? clrToolButton : clrNormalButton);
#ifdef CONFIG_GRADIENTS
return YSurface(bgColor, toolbuttonPixmap, toolbuttonPixbuf);
#else
return YSurface(bgColor, toolbuttonPixmap);
#endif
}
void ObjectButton::actionPerformed(YAction * action, unsigned modifiers) {
#ifdef CONFIG_GUIEVENTS
wmapp->signalGuiEvent(geLaunchApp);
#endif
if (fObject) fObject->open();
else YButton::actionPerformed(action, modifiers);
}
#endif /* CONFIG_TASKBAR */
#ifndef NO_CONFIGURE_MENUS
ObjectMenu *rootMenu(NULL);
#endif
<|endoftext|> |
<commit_before>#include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup()
{
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetLogLevel("ofThread", OF_LOG_ERROR);
ofEnableAlphaBlending();
doDrawInfo = true;
targetWidth = 640;
targetHeight = 480;
#if defined(TARGET_OPENGLES)
consoleListener.setup(this);
omxCameraSettings.width = targetWidth;
omxCameraSettings.height = targetHeight;
omxCameraSettings.framerate = 15;
omxCameraSettings.enableTexture = true;
videoGrabber.setup(omxCameraSettings);
filterCollection.setup();
ofSetVerticalSync(false);
shader.load("shaderRpi");
#else
videoGrabber.setDeviceID(0);
videoGrabber.setDesiredFrameRate(30);
videoGrabber.setup(targetWidth, targetHeight);
ofSetVerticalSync(true);
shader.load("shaderDesktop");
#endif
doShader = true;
iEffect = 2;
fbo.allocate(targetWidth, targetHeight);
fbo.begin();
ofClear(0, 0, 0, 0);
fbo.end();
// selfberry
colorGifEncoder.setup(targetWidth, targetHeight, .2, 256);
ofAddListener(ofxGifEncoder::OFX_GIF_SAVE_FINISHED, this, &ofApp::onGifSaved);
videoTexture.allocate(targetWidth, targetHeight, GL_RGB);
bufferDir = "buffer";
timeZero = ofGetElapsedTimeMicros();
frameNumber = 0;
slotRecording = 255;
slotAmount = 4;
if (dirSRC.doesDirectoryExist(bufferDir)) {
dirSRC.removeDirectory(bufferDir, true);
}
if (!dirSRC.doesDirectoryExist("slot1")) {
dirSRC.createDirectory("slot1");
}
if (!dirSRC.doesDirectoryExist("slot2")) {
dirSRC.createDirectory("slot2");
}
if (!dirSRC.doesDirectoryExist("slot3")) {
dirSRC.createDirectory("slot3");
}
if (!dirSRC.doesDirectoryExist("slot4")) {
dirSRC.createDirectory("slot4");
}
if (!dirSRC.doesDirectoryExist("tmp")) {
dirSRC.createDirectory("tmp");
}
if (!dirSRC.doesDirectoryExist("gif")) {
dirSRC.createDirectory("gif");
}
dirSRC.createDirectory(bufferDir);
indexSavedPhoto = 0;
isRecording = false;
amountOfFrames = 10;
maxFrames = 10;
if (settings.loadFile("settings.xml") == false) {
ofLog() << "XML ERROR, possibly quit";
}
settings.pushTag("settings");
slotDir = "slot";
for (int i = 0; i < settings.getNumTags("slot"); i++) {
settings.pushTag("slot", i);
videoGrid[i].init(settings.getValue("id", i), settings.getValue("x", 700), settings.getValue("y", 500), &slotDir, settings.getValue("key", 0));
settings.popTag();
}
lastSpot = 0;
currentDisplaySlot = 1;
bkgLayer.loadImage("ui.png");
sourisitepajoli.loadImage("sourisitepajoli.png");
trois.loadImage("trois.png");
deux.loadImage("deux.png");
un.loadImage("un.png");
}
//--------------------------------------------------------------
void ofApp::update()
{
#if defined(TARGET_OPENGLES)
#else
videoGrabber.update();
#endif
if (!doShader || !videoGrabber.isFrameNew())
{
//ofLogNotice("update() !videoGrabber.isFrameNew return");
return;
}
//ofLogNotice("update() fbo begin");
fbo.begin();
ofClear(1, 1, 0, 0);
shader.begin();
shader.setUniform1f("time", ofGetElapsedTimef());
shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
shader.setUniform3f("iResolution", ofGetWidth(), ofGetHeight(), 0);
shader.setUniform2f("iMouse", indexSavedPhoto, indexSavedPhoto);
shader.setUniform1f("iGlobalTime", ofGetElapsedTimef());
shader.setUniform4f("iDate", ofGetYear(), ofGetMonth(), ofGetDay(), ofGetSeconds());
shader.setUniform1i("iEffect", iEffect);// floor(ofRandom(0, 4.9)));
shader.setUniform1f("iChromatic", ofRandom(-1, 1));
shader.setUniform1f("iShift", ofRandom(-1.0, 1.0));
shader.setUniform1f("iGlitch", ofRandom(0.0, 1.0));
shader.setUniform1f("iPixelate", ofRandom(0.7, 1.0));
#if defined(TARGET_OPENGLES)
shader.setUniformTexture("tex0", videoGrabber.getTextureReference(), videoGrabber.getTextureID());
videoGrabber.draw();
#else
shader.setUniformTexture("tex0", videoGrabber.getTexture(), 0);// 0 or 1?
videoGrabber.draw(0, 0);
#endif
shader.end();
fbo.end();
//ofLogNotice("update() fbo end");
if (isRecording == true) {
ofLogNotice("update() rec");
finalCountdown = ofGetSeconds() - currentSecond;
if (finalCountdown > 2) {
dirSRC.createDirectory(bufferDir);
dirSRC.listDir(bufferDir);
recordedFramesAmount = dirSRC.size();
ofLogNotice("AMOUNT OF FILES: " + ofToString(recordedFramesAmount) + "/" + ofToString(maxFrames));
if (recordedFramesAmount == maxFrames) {
isRecording = false;
indexSavedPhoto = 0;
ofLogNotice("update() stop recording");
}
else {
if (videoGrabber.isFrameNew()) {
ofLogNotice("update() isFrameNew");
string filename;
if (indexSavedPhoto < 10) filename = "slot" + ofToString(currentDisplaySlot) + "//seq00" + ofToString(indexSavedPhoto) + ".tga";
if (indexSavedPhoto >= 10 && indexSavedPhoto < 100) filename = "slot" + ofToString(currentDisplaySlot) + "//seq0" + ofToString(indexSavedPhoto) + ".tga";
if (indexSavedPhoto >= 100 && indexSavedPhoto < 1000) filename = "slot" + ofToString(currentDisplaySlot) + "//seq" + ofToString(indexSavedPhoto) + ".tga";
// fbo to pixels
fbo.readToPixels(pix);
fbo.draw(0, 0, targetWidth, targetHeight);
ofLogNotice("AMOUNT OF FILES: " + ofToString(recordedFramesAmount) + "/" + ofToString(maxFrames));
//pix.resize(targetWidth, targetHeight, OF_INTERPOLATE_NEAREST_NEIGHBOR);
savedImage.setFromPixels(pix);
savedImage.setImageType(OF_IMAGE_COLOR);
savedImage.saveImage(filename);
ofLogNotice("update() currentDisplaySlot " + ofToString(currentDisplaySlot));
savedImage.saveImage(bufferDir + "//" + filename + ".tga");
//omxCameraSettings.width, omxCameraSettings.height
// add frame to gif encoder
colorGifEncoder.addFrame(
pix.getPixels(),
targetWidth,
targetHeight,
pix.getBitsPerPixel()/*,
.1f duration */
);
recordedFramesAmount++;
pix.clear();
savedImage.clear();
indexSavedPhoto++;
if (indexSavedPhoto == amountOfFrames) {
ofLogNotice("Stop recording: " + ofToString(indexSavedPhoto) + "/" + ofToString(amountOfFrames));
isRecording = false;
indexSavedPhoto = 0;
saveGif();
}
}
}
}
}
for (i = 1; i < slotAmount; i++) {
videoGrid[i].loadFrameNumber(frameNumber);
}
frameNumber++;
if (frameNumber == maxFrames) {
frameNumber = 0;
}
}
void ofApp::saveGif()
{
string fileName = ofToString(ofGetMonth()) + "-" + ofToString(ofGetDay()) + "-" + ofToString(ofGetHours()) + "-" + ofToString(ofGetMinutes()) + "-" + ofToString(ofGetSeconds());
ofLogNotice("saveGif: " + fileName);
colorGifEncoder.save("gif//" + fileName + ".gif");
ofLogNotice("saveGif end");
}
void ofApp::onGifSaved(string & fileName) {
cout << "gif saved as " << fileName << endl;
ofLogNotice("onGifSaved: " + fileName);
colorGifEncoder.reset();
ofLogNotice("onGifSaved reset");
}
//--------------------------------------------------------------
void ofApp::draw() {
ofClear(0, 0, 0, 0);
stringstream info;
info << "APP FPS: " << ofGetFrameRate() << "\n";
info << "SHADER ENABLED: " << doShader << "\n";
if (doShader)
{
#if defined(TARGET_OPENGLES)
fbo.draw(330, 13);
#else
videoGrabber.draw(330, 13);
#endif
}
else
{
#if defined(TARGET_OPENGLES)
videoGrabber.draw();
#else
videoGrabber.draw(330, 13);
#endif
}
for (int i = 1; i < slotAmount; i++) {
videoGrid[i].draw();
}
#if defined(TARGET_OPENGLES)
info << "Resolution Camera: " << videoGrabber.getWidth() << "x" << videoGrabber.getHeight() << " @ " << videoGrabber.getFrameRate() << "FPS" << "\n";
info << "FILTRE: " << filterCollection.getCurrentFilterName() << "\n";
#endif
info << "\n";
info << "VERT: changement de filtre" << "\n";
info << "ROUGE: enregistrer" << "\n";
bkgLayer.draw(0, 0);
if (isRecording) {
sourisitepajoli.draw(400, 0);
switch (finalCountdown) {
case 0:
trois.draw(400, 0);
break;
case 1:
deux.draw(400, 0);
break;
case 2:
un.draw(400, 0);
break;
}
}
if (doDrawInfo) {
ofDrawBitmapStringHighlight(info.str(), 50, 940, ofColor::black, ofColor::yellow);
}
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key)
{
//ofLog(OF_LOG_VERBOSE, "%c keyPressed", key);
ofLogNotice("PRESSED KEY: " + ofToString(key));
/*RED 13 10
WHITE 127 126
YELLOW 54
GREEN 357 65
BLUE 50*/
switch (key) {
case 65:
case 357:
#if defined(TARGET_OPENGLES)
videoGrabber.setImageFilter(filterCollection.getNextFilter());
#endif
break;
case 10:
case 13:
if (!isRecording) {
isRecording = true;
indexSavedPhoto = 0;
currentDisplaySlot++;
if (currentDisplaySlot > 4) currentDisplaySlot = 1;
bufferDir = ofToString(ofGetMonth()) + "-" + ofToString(ofGetDay()) + "-" + ofToString(ofGetHours()) + "-" + ofToString(ofGetMinutes()) + "-" + ofToString(ofGetSeconds());
currentSecond = ofGetSeconds();
}
break;
case 126:
doDrawInfo = !doDrawInfo;
iEffect = 3;
currentDisplaySlot++;
if (currentDisplaySlot > 4) currentDisplaySlot = 1;
break;
case 67: // jaune
iEffect = 1;
case 66: // bleu
iEffect = 2;
case 50:
case 359:
currentDisplaySlot = 1;
//doShader = !doShader;
break;
}
}
#if defined(TARGET_OPENGLES)
void ofApp::onCharacterReceived(KeyListenerEventData& e)
{
keyPressed((int)e.character);
}
#endif
<commit_msg>TODO inutile?<commit_after>#include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup()
{
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetLogLevel("ofThread", OF_LOG_ERROR);
ofEnableAlphaBlending();
doDrawInfo = true;
targetWidth = 640;
targetHeight = 480;
#if defined(TARGET_OPENGLES)
consoleListener.setup(this);
omxCameraSettings.width = targetWidth;
omxCameraSettings.height = targetHeight;
omxCameraSettings.framerate = 15;
omxCameraSettings.enableTexture = true;
videoGrabber.setup(omxCameraSettings);
filterCollection.setup();
ofSetVerticalSync(false);
shader.load("shaderRpi");
#else
videoGrabber.setDeviceID(0);
videoGrabber.setDesiredFrameRate(30);
videoGrabber.setup(targetWidth, targetHeight);
ofSetVerticalSync(true);
shader.load("shaderDesktop");
#endif
doShader = true;
iEffect = 2;
fbo.allocate(targetWidth, targetHeight);
fbo.begin();
ofClear(0, 0, 0, 0);
fbo.end();
// selfberry
colorGifEncoder.setup(targetWidth, targetHeight, .2, 256);
ofAddListener(ofxGifEncoder::OFX_GIF_SAVE_FINISHED, this, &ofApp::onGifSaved);
videoTexture.allocate(targetWidth, targetHeight, GL_RGB);
bufferDir = "buffer";
timeZero = ofGetElapsedTimeMicros();
frameNumber = 0;
slotRecording = 255;
slotAmount = 4;
if (dirSRC.doesDirectoryExist(bufferDir)) {
dirSRC.removeDirectory(bufferDir, true);
}
if (!dirSRC.doesDirectoryExist("slot1")) {
dirSRC.createDirectory("slot1");
}
if (!dirSRC.doesDirectoryExist("slot2")) {
dirSRC.createDirectory("slot2");
}
if (!dirSRC.doesDirectoryExist("slot3")) {
dirSRC.createDirectory("slot3");
}
if (!dirSRC.doesDirectoryExist("slot4")) {
dirSRC.createDirectory("slot4");
}
if (!dirSRC.doesDirectoryExist("tmp")) {
dirSRC.createDirectory("tmp");
}
if (!dirSRC.doesDirectoryExist("gif")) {
dirSRC.createDirectory("gif");
}
dirSRC.createDirectory(bufferDir);
indexSavedPhoto = 0;
isRecording = false;
amountOfFrames = 10;
maxFrames = 10;
if (settings.loadFile("settings.xml") == false) {
ofLog() << "XML ERROR, possibly quit";
}
settings.pushTag("settings");
slotDir = "slot";
for (int i = 0; i < settings.getNumTags("slot"); i++) {
settings.pushTag("slot", i);
videoGrid[i].init(settings.getValue("id", i), settings.getValue("x", 700), settings.getValue("y", 500), &slotDir, settings.getValue("key", 0));
settings.popTag();
}
lastSpot = 0;
currentDisplaySlot = 1;
bkgLayer.loadImage("ui.png");
sourisitepajoli.loadImage("sourisitepajoli.png");
trois.loadImage("trois.png");
deux.loadImage("deux.png");
un.loadImage("un.png");
}
//--------------------------------------------------------------
void ofApp::update()
{
#if defined(TARGET_OPENGLES)
#else
videoGrabber.update();
#endif
if (!doShader || !videoGrabber.isFrameNew())
{
//ofLogNotice("update() !videoGrabber.isFrameNew return");
return;
}
//ofLogNotice("update() fbo begin");
fbo.begin();
ofClear(1, 1, 0, 0);
shader.begin();
shader.setUniform1f("time", ofGetElapsedTimef());
shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
shader.setUniform3f("iResolution", ofGetWidth(), ofGetHeight(), 0);
shader.setUniform2f("iMouse", indexSavedPhoto, indexSavedPhoto);
shader.setUniform1f("iGlobalTime", ofGetElapsedTimef());
shader.setUniform4f("iDate", ofGetYear(), ofGetMonth(), ofGetDay(), ofGetSeconds());
shader.setUniform1i("iEffect", iEffect);// floor(ofRandom(0, 4.9)));
shader.setUniform1f("iChromatic", ofRandom(-1, 1));
shader.setUniform1f("iShift", ofRandom(-1.0, 1.0));
shader.setUniform1f("iGlitch", ofRandom(0.0, 1.0));
shader.setUniform1f("iPixelate", ofRandom(0.7, 1.0));
#if defined(TARGET_OPENGLES)
shader.setUniformTexture("tex0", videoGrabber.getTextureReference(), videoGrabber.getTextureID());
videoGrabber.draw();
#else
shader.setUniformTexture("tex0", videoGrabber.getTexture(), 0);// 0 or 1?
videoGrabber.draw(0, 0);
#endif
shader.end();
fbo.end();
//ofLogNotice("update() fbo end");
if (isRecording == true) {
ofLogNotice("update() rec");
finalCountdown = ofGetSeconds() - currentSecond;
if (finalCountdown > 2) {
dirSRC.createDirectory(bufferDir);
dirSRC.listDir(bufferDir);
recordedFramesAmount = dirSRC.size();
ofLogNotice("AMOUNT OF FILES: " + ofToString(recordedFramesAmount) + "/" + ofToString(maxFrames));
if (recordedFramesAmount == maxFrames) {
isRecording = false;
indexSavedPhoto = 0;
ofLogNotice("update() stop recording");
}
else {
if (videoGrabber.isFrameNew()) {
ofLogNotice("update() isFrameNew");
string filename;
if (indexSavedPhoto < 10) filename = "slot" + ofToString(currentDisplaySlot) + "//seq00" + ofToString(indexSavedPhoto) + ".tga";
if (indexSavedPhoto >= 10 && indexSavedPhoto < 100) filename = "slot" + ofToString(currentDisplaySlot) + "//seq0" + ofToString(indexSavedPhoto) + ".tga";
if (indexSavedPhoto >= 100 && indexSavedPhoto < 1000) filename = "slot" + ofToString(currentDisplaySlot) + "//seq" + ofToString(indexSavedPhoto) + ".tga";
// fbo to pixels
fbo.readToPixels(pix);
fbo.draw(0, 0, targetWidth, targetHeight);
ofLogNotice("AMOUNT OF FILES: " + ofToString(recordedFramesAmount) + "/" + ofToString(maxFrames));
//pix.resize(targetWidth, targetHeight, OF_INTERPOLATE_NEAREST_NEIGHBOR);
savedImage.setFromPixels(pix);
savedImage.setImageType(OF_IMAGE_COLOR);
savedImage.saveImage(filename);
ofLogNotice("update() currentDisplaySlot " + ofToString(currentDisplaySlot));
// TODO verif chemin + fichier savedImage.saveImage(bufferDir + "//" + filename + ".tga");
//omxCameraSettings.width, omxCameraSettings.height
// add frame to gif encoder
colorGifEncoder.addFrame(
pix.getPixels(),
targetWidth,
targetHeight,
pix.getBitsPerPixel()/*,
.1f duration */
);
recordedFramesAmount++;
pix.clear();
savedImage.clear();
indexSavedPhoto++;
if (indexSavedPhoto == amountOfFrames) {
ofLogNotice("Stop recording: " + ofToString(indexSavedPhoto) + "/" + ofToString(amountOfFrames));
isRecording = false;
indexSavedPhoto = 0;
saveGif();
}
}
}
}
}
for (i = 1; i < slotAmount; i++) {
videoGrid[i].loadFrameNumber(frameNumber);
}
frameNumber++;
if (frameNumber == maxFrames) {
frameNumber = 0;
}
}
void ofApp::saveGif()
{
string fileName = ofToString(ofGetMonth()) + "-" + ofToString(ofGetDay()) + "-" + ofToString(ofGetHours()) + "-" + ofToString(ofGetMinutes()) + "-" + ofToString(ofGetSeconds());
ofLogNotice("saveGif: " + fileName);
colorGifEncoder.save("gif//" + fileName + ".gif");
ofLogNotice("saveGif end");
}
void ofApp::onGifSaved(string & fileName) {
cout << "gif saved as " << fileName << endl;
ofLogNotice("onGifSaved: " + fileName);
colorGifEncoder.reset();
ofLogNotice("onGifSaved reset");
}
//--------------------------------------------------------------
void ofApp::draw() {
ofClear(0, 0, 0, 0);
stringstream info;
info << "APP FPS: " << ofGetFrameRate() << "\n";
info << "SHADER ENABLED: " << doShader << "\n";
if (doShader)
{
#if defined(TARGET_OPENGLES)
fbo.draw(330, 13);
#else
videoGrabber.draw(330, 13);
#endif
}
else
{
#if defined(TARGET_OPENGLES)
videoGrabber.draw();
#else
videoGrabber.draw(330, 13);
#endif
}
for (int i = 1; i < slotAmount; i++) {
videoGrid[i].draw();
}
#if defined(TARGET_OPENGLES)
info << "Resolution Camera: " << videoGrabber.getWidth() << "x" << videoGrabber.getHeight() << " @ " << videoGrabber.getFrameRate() << "FPS" << "\n";
info << "FILTRE: " << filterCollection.getCurrentFilterName() << "\n";
#endif
info << "\n";
info << "VERT: changement de filtre" << "\n";
info << "ROUGE: enregistrer" << "\n";
bkgLayer.draw(0, 0);
if (isRecording) {
sourisitepajoli.draw(400, 0);
switch (finalCountdown) {
case 0:
trois.draw(400, 0);
break;
case 1:
deux.draw(400, 0);
break;
case 2:
un.draw(400, 0);
break;
}
}
if (doDrawInfo) {
ofDrawBitmapStringHighlight(info.str(), 50, 940, ofColor::black, ofColor::yellow);
}
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key)
{
//ofLog(OF_LOG_VERBOSE, "%c keyPressed", key);
ofLogNotice("PRESSED KEY: " + ofToString(key));
/*RED 13 10
WHITE 127 126
YELLOW 54
GREEN 357 65
BLUE 50*/
switch (key) {
case 65:
case 357:
#if defined(TARGET_OPENGLES)
videoGrabber.setImageFilter(filterCollection.getNextFilter());
#endif
break;
case 10:
case 13:
if (!isRecording) {
isRecording = true;
indexSavedPhoto = 0;
currentDisplaySlot++;
if (currentDisplaySlot > 4) currentDisplaySlot = 1;
bufferDir = ofToString(ofGetMonth()) + "-" + ofToString(ofGetDay()) + "-" + ofToString(ofGetHours()) + "-" + ofToString(ofGetMinutes()) + "-" + ofToString(ofGetSeconds());
currentSecond = ofGetSeconds();
}
break;
case 126:
doDrawInfo = !doDrawInfo;
iEffect = 3;
currentDisplaySlot++;
if (currentDisplaySlot > 4) currentDisplaySlot = 1;
break;
case 67: // jaune
iEffect = 1;
case 66: // bleu
iEffect = 2;
case 50:
case 359:
currentDisplaySlot = 1;
//doShader = !doShader;
break;
}
}
#if defined(TARGET_OPENGLES)
void ofApp::onCharacterReceived(KeyListenerEventData& e)
{
keyPressed((int)e.character);
}
#endif
<|endoftext|> |
<commit_before>#include "opencv2/highgui/highgui.hpp"
#include "opencv2/opencv.hpp"
#include <iostream>
#include <stdio.h>
#include <sstream>
#include <string>
using namespace std;
//using namespace cv;
int H_MIN = 0;
int H_MAX = 256;
int S_MIN = 0;
int S_MAX = 256;
int V_MIN = 0;
int V_MAX = 256;
//Things I want to do:
//Make a window for the HSV trackbars
//Make a window for the position in the video with button for play/pause
void on_HSV_trackbar( int position, void* ){
}
void createTrackbarsWindow(){
string trackbarWindowName = "Adjust me!";
cv::namedWindow(trackbarWindowName,0);
char TrackbarName[50];
cv::createTrackbar( "H_MIN", trackbarWindowName, &H_MIN, H_MAX, on_HSV_trackbar);
cv::createTrackbar( "H_MAX", trackbarWindowName, &H_MAX, H_MAX, on_HSV_trackbar);
cv::createTrackbar( "S_MIN", trackbarWindowName, &S_MIN, S_MAX, on_HSV_trackbar);
cv::createTrackbar( "S_MAX", trackbarWindowName, &S_MAX, S_MAX, on_HSV_trackbar);
cv::createTrackbar( "V_MIN", trackbarWindowName, &V_MIN, V_MAX, on_HSV_trackbar);
cv::createTrackbar( "V_MAX", trackbarWindowName, &V_MAX, V_MAX, on_HSV_trackbar);
}
int main(int argc, char* argv[]){
//Declaring local variables for the main function
string videoFileName = "juggle.mov";
//Opening the video file
cv::VideoCapture video(videoFileName);
if(!video.isOpened()){
cout << "Cannot open the file" << endl;
return -1;
}
//Creating the other windows
createTrackbarsWindow();
while(1){
//Declaring the local variables for the video loop
cv::Mat frame, out, temp, gray;
//Reads a new frame from the video and verifies it
bool readVideoSuccess = video.read(frame);
if (!readVideoSuccess){
cout << "Cannot read from file" << endl;
break;
}
//Where the image manipulation happens
//cv::GaussianBlur( frame, out, Size(5,5), 3, 3);
cv::pyrDown(frame, temp);
cv::cvtColor(temp, gray, CV_BGR2HSV);
//imshow("MyVideo", frame); //show the frame in "MyVideo" window
cv::inRange(gray, cv::Scalar(H_MIN,S_MIN,V_MIN),cv::Scalar(H_MAX,S_MAX,V_MAX),out);
cv::inRange(gray, cv::Scalar(165,105,170),cv::Scalar(230,256,205),out);
//morphOps(out);
cv::vector<cv::Vec3f> circles;
cv::HoughCircles(out, circles, CV_HOUGH_GRADIENT, 1, out.rows/2, 20, 10, 0, 0 );
for( size_t i = 0; i < circles.size(); i++ )
{
cv::Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
// draw the circle center
circle( temp, center, 3, cv::Scalar(0,255,0), -1, 8, 0 );
// draw the circle outline
circle( temp, center, radius, cv::Scalar(0,0,255), 3, 8, 0 );
}
cv::imshow("output", out); //show the frame in "MyVideo" window
if(cv::waitKey(30) == 27) //wait for 'esc' key press for 30 ms. If 'esc' key is pressed, break loop
{
cout << "esc key is pressed by user" << endl;
break;
}
}
return 0;
}
<commit_msg>Update juggle.cpp<commit_after>#include "opencv2/highgui/highgui.hpp"
#include "opencv2/opencv.hpp"
#include <iostream>
#include <stdio.h>
#include <sstream>
#include <string>
using namespace std;
//using namespace cv;
int H_MIN = 0;
int H_MAX = 256;
int S_MIN = 0;
int S_MAX = 256;
int V_MIN = 0;
int V_MAX = 256;
//Things I want to do:
//Make a window for the HSV trackbars
//Make a window for the position in the video with button for play/pause
void onHSVTrackbarSlide(int position, void*){
}
void createHSVTrackbarsWindow(){
string trackbarWindowName = "Adjust me!";
cv::namedWindow(trackbarWindowName,0);
char TrackbarName[50];
cv::createTrackbar( "H_MIN", trackbarWindowName, &H_MIN, H_MAX, onHSVTrackbarSlide);
cv::createTrackbar( "H_MAX", trackbarWindowName, &H_MAX, H_MAX, onHSVTrackbarSlide);
cv::createTrackbar( "S_MIN", trackbarWindowName, &S_MIN, S_MAX, onHSVTrackbarSlide);
cv::createTrackbar( "S_MAX", trackbarWindowName, &S_MAX, S_MAX, onHSVTrackbarSlide);
cv::createTrackbar( "V_MIN", trackbarWindowName, &V_MIN, V_MAX, onHSVTrackbarSlide);
cv::createTrackbar( "V_MAX", trackbarWindowName, &V_MAX, V_MAX, onHSVTrackbarSlide);
}
void onPositionTrackbarSlide(int position, void*){
}
void createPositionTrackbarWindow(){
}
void manipulateImage(){
}
int main(int argc, char* argv[]){
//Declaring local variables for the main function
string videoFileName = "juggle.mov";
//Opening the video file
cv::VideoCapture video(videoFileName);
if(!video.isOpened()){
cout << "Cannot open the file" << endl;
return -1;
}
//Creating the other windows
createHSVTrackbarsWindow();
while(1){
//Declaring the local variables for the video loop
cv::Mat frame, out, temp, gray;
//Reads a new frame from the video and verifies it
bool readVideoSuccess = video.read(frame);
if (!readVideoSuccess){
cout << "Cannot read from file" << endl;
break;
}
//Where the image manipulation happens
//wait for 'esc' key press for 30 ms. If 'esc' key is pressed, break loop
if(cv::waitKey(30) == 27){
cout << "esc key is pressed by user" << endl;
break;
}
//cv::GaussianBlur( frame, out, Size(5,5), 3, 3);
cv::pyrDown(frame, temp);
cv::cvtColor(temp, gray, CV_BGR2HSV);
//imshow("MyVideo", frame); //show the frame in "MyVideo" window
cv::inRange(gray, cv::Scalar(H_MIN,S_MIN,V_MIN),cv::Scalar(H_MAX,S_MAX,V_MAX),out);
cv::inRange(gray, cv::Scalar(165,105,170),cv::Scalar(230,256,205),out);
//morphOps(out);
cv::vector<cv::Vec3f> circles;
cv::HoughCircles(out, circles, CV_HOUGH_GRADIENT, 1, out.rows/2, 20, 10, 0, 0 );
for( size_t i = 0; i < circles.size(); i++ )
{
cv::Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
// draw the circle center
circle( temp, center, 3, cv::Scalar(0,255,0), -1, 8, 0 );
// draw the circle outline
circle( temp, center, radius, cv::Scalar(0,0,255), 3, 8, 0 );
}
cv::imshow("output", out); //show the frame in "MyVideo" window
}
return 0;
}
<|endoftext|> |
<commit_before>////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
/// @author Achim Brandt
////////////////////////////////////////////////////////////////////////////////
#ifdef _WIN32
#include "Basics/win-utils.h"
#endif
#include "Scheduler.h"
#include <velocypack/Builder.h>
#include <velocypack/velocypack-aliases.h>
#include "Basics/MutexLocker.h"
#include "Basics/StringUtils.h"
#include "Basics/Thread.h"
#include "Logger/Logger.h"
#include "Rest/GeneralResponse.h"
#include "Scheduler/JobQueue.h"
#include "Scheduler/Task.h"
using namespace arangodb;
using namespace arangodb::basics;
using namespace arangodb::rest;
// -----------------------------------------------------------------------------
// --SECTION-- SchedulerManagerThread
// -----------------------------------------------------------------------------
namespace {
class SchedulerManagerThread : public Thread {
public:
SchedulerManagerThread(Scheduler* scheduler, boost::asio::io_service* service)
: Thread("SchedulerManager"), _scheduler(scheduler), _service(service) {}
~SchedulerManagerThread() { shutdown(); }
public:
void run() {
while (!_scheduler->isStopping()) {
try {
_service->run_one();
_scheduler->deleteOldThreads();
} catch (...) {
LOG_TOPIC(ERR, Logger::THREADS)
<< "manager loop caught an error, restarting";
}
}
_scheduler->threadDone(this);
}
private:
Scheduler* _scheduler;
boost::asio::io_service* _service;
};
}
// -----------------------------------------------------------------------------
// --SECTION-- SchedulerThread
// -----------------------------------------------------------------------------
namespace {
class SchedulerThread : public Thread {
public:
SchedulerThread(Scheduler* scheduler, boost::asio::io_service* service)
: Thread("Scheduler"), _scheduler(scheduler), _service(service) {}
~SchedulerThread() { shutdown(); }
public:
void run() {
_scheduler->incRunning();
LOG_TOPIC(DEBUG, Logger::THREADS) << "running (" << _scheduler->infoStatus()
<< ")";
auto start = std::chrono::steady_clock::now();
try {
static size_t EVERY_LOOP = 1000;
static double MIN_SECONDS = 30;
size_t counter = 0;
while (!_scheduler->isStopping()) {
_service->run_one();
if (++counter > EVERY_LOOP) {
auto now = std::chrono::steady_clock::now();
std::chrono::duration<double> diff = now - start;
if (diff.count() > MIN_SECONDS) {
if (_scheduler->stopThread()) {
auto n = _scheduler->decRunning();
if (n <= 2) {
_scheduler->incRunning();
} else {
break;
}
}
start = std::chrono::steady_clock::now();
}
}
}
LOG_TOPIC(DEBUG, Logger::THREADS) << "stopped ("
<< _scheduler->infoStatus() << ")";
} catch (...) {
LOG_TOPIC(ERR, Logger::THREADS)
<< "scheduler loop caught an error, restarting";
_scheduler->decRunning();
_scheduler->startNewThread();
}
_scheduler->threadDone(this);
}
private:
Scheduler* _scheduler;
boost::asio::io_service* _service;
};
}
// -----------------------------------------------------------------------------
// --SECTION-- Scheduler
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// --SECTION-- constructors and destructors
// -----------------------------------------------------------------------------
Scheduler::Scheduler(size_t nrThreads, size_t maxQueueSize)
: _nrThreads(nrThreads),
_maxQueueSize(maxQueueSize),
_stopping(false),
_nrBusy(0),
_nrWorking(0),
_nrBlocked(0),
_nrRunning(0),
_nrMinimal(0),
_nrMaximal(0),
_nrRealMaximum(0),
_lastThreadWarning(0) {
// setup signal handlers
initializeSignalHandlers();
}
Scheduler::~Scheduler() {
if (_threadManager != nullptr) {
_threadManager->cancel();
}
deleteOldThreads();
}
// -----------------------------------------------------------------------------
// --SECTION-- constructors and destructors
// -----------------------------------------------------------------------------
bool Scheduler::start(ConditionVariable* cv) {
// start the I/O
startIoService();
// initialize thread handling
if (_nrMaximal <= 0) {
_nrMaximal = _nrThreads;
}
if (_nrRealMaximum <= 0) {
_nrRealMaximum = 4 * _nrMaximal;
}
for (size_t i = 0; i < 2; ++i) {
startNewThread();
}
startManagerThread();
startRebalancer();
// initialize the queue handling
_jobQueue.reset(new JobQueue(_maxQueueSize, _ioService.get()));
_jobQueue->start();
// done
LOG(TRACE) << "all scheduler threads are up and running";
return true;
}
void Scheduler::startIoService() {
_ioService.reset(new boost::asio::io_service());
_serviceGuard.reset(new boost::asio::io_service::work(*_ioService));
_managerService.reset(new boost::asio::io_service());
_managerGuard.reset(new boost::asio::io_service::work(*_managerService));
}
void Scheduler::startRebalancer() {
std::chrono::milliseconds interval(500);
_threadManager.reset(new boost::asio::steady_timer(*_managerService));
_threadHandler = [this, interval](const boost::system::error_code& error) {
if (error || isStopping()) {
return;
}
rebalanceThreads();
_threadManager->expires_from_now(interval);
_threadManager->async_wait(_threadHandler);
};
_threadManager->expires_from_now(interval);
_threadManager->async_wait(_threadHandler);
_lastThreadWarning.store(TRI_microtime());
}
void Scheduler::startManagerThread() {
MUTEX_LOCKER(guard, _threadsLock);
auto thread = new SchedulerManagerThread(this, _managerService.get());
_threads.emplace(thread);
thread->start();
}
void Scheduler::startNewThread() {
MUTEX_LOCKER(guard, _threadsLock);
auto thread = new SchedulerThread(this, _ioService.get());
_threads.emplace(thread);
thread->start();
}
bool Scheduler::stopThread() {
if (_nrRunning <= _nrMinimal) {
return false;
}
if (_nrRunning >= 3) {
int64_t low = ((_nrRunning <= 4) ? 0 : (_nrRunning * 1 / 4)) - _nrBlocked;
if (_nrBusy <= low && _nrWorking <= low) {
return true;
}
}
return false;
}
void Scheduler::threadDone(Thread* thread) {
MUTEX_LOCKER(guard, _threadsLock);
_threads.erase(thread);
_deadThreads.insert(thread);
}
void Scheduler::deleteOldThreads() {
// delete old thread objects
std::unordered_set<Thread*> deadThreads;
{
MUTEX_LOCKER(guard, _threadsLock);
if (_deadThreads.empty()) {
return;
}
deadThreads.swap(_deadThreads);
}
for (auto thread : deadThreads) {
try {
delete thread;
} catch (...) {
LOG_TOPIC(ERR, Logger::THREADS) << "cannot delete thread";
}
}
}
void Scheduler::rebalanceThreads() {
static double const MIN_WARN_INTERVAL = 10;
static double const MIN_ERR_INTERVAL = 300;
int64_t high = (_nrRunning <= 4) ? 1 : (_nrRunning * 11 / 16);
int64_t working = (_nrBusy > _nrWorking) ? _nrBusy : _nrWorking;
LOG_TOPIC(DEBUG, Logger::THREADS) << "rebalancing threads, high: " << high
<< ", working: " << working << " ("
<< infoStatus() << ")";
if (working >= high) {
if (_nrRunning < _nrMaximal + _nrBlocked &&
_nrRunning < _nrRealMaximum) { // added by Max 22.12.2016
// otherwise we exceed the total maximum
startNewThread();
return;
}
}
if (working >= _nrMaximal + _nrBlocked || _nrRunning < _nrMinimal) {
double ltw = _lastThreadWarning.load();
double now = TRI_microtime();
if (_nrRunning >= _nrRealMaximum) {
if (ltw - now > MIN_ERR_INTERVAL) {
LOG_TOPIC(ERR, Logger::THREADS) << "too many threads (" << infoStatus()
<< ")";
_lastThreadWarning.store(now);
}
} else {
if (_nrRunning >= _nrRealMaximum * 3 / 4) {
if (ltw - now > MIN_WARN_INTERVAL) {
LOG_TOPIC(WARN, Logger::THREADS)
<< "number of threads is reaching a critical limit ("
<< infoStatus() << ")";
_lastThreadWarning.store(now);
}
}
LOG_TOPIC(DEBUG, Logger::THREADS) << "overloading threads ("
<< infoStatus() << ")";
startNewThread();
}
}
}
void Scheduler::beginShutdown() {
if (_stopping) {
return;
}
_jobQueue->beginShutdown();
_threadManager.reset();
_managerGuard.reset();
_managerService->stop();
_serviceGuard.reset();
_ioService->stop();
// set the flag AFTER stopping the threads
_stopping = true;
}
void Scheduler::shutdown() {
bool done = false;
while (!done) {
MUTEX_LOCKER(guard, _threadsLock);
done = _threads.empty();
}
deleteOldThreads();
_managerService.reset();
_ioService.reset();
}
void Scheduler::initializeSignalHandlers() {
#ifdef _WIN32
// Windows does not support POSIX signal handling
#else
struct sigaction action;
memset(&action, 0, sizeof(action));
sigfillset(&action.sa_mask);
// ignore broken pipes
action.sa_handler = SIG_IGN;
int res = sigaction(SIGPIPE, &action, 0);
if (res < 0) {
LOG(ERR) << "cannot initialize signal handlers for pipe";
}
#endif
}
<commit_msg>don't throw in dtor<commit_after>////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
/// @author Achim Brandt
////////////////////////////////////////////////////////////////////////////////
#ifdef _WIN32
#include "Basics/win-utils.h"
#endif
#include "Scheduler.h"
#include <velocypack/Builder.h>
#include <velocypack/velocypack-aliases.h>
#include "Basics/MutexLocker.h"
#include "Basics/StringUtils.h"
#include "Basics/Thread.h"
#include "Logger/Logger.h"
#include "Rest/GeneralResponse.h"
#include "Scheduler/JobQueue.h"
#include "Scheduler/Task.h"
using namespace arangodb;
using namespace arangodb::basics;
using namespace arangodb::rest;
// -----------------------------------------------------------------------------
// --SECTION-- SchedulerManagerThread
// -----------------------------------------------------------------------------
namespace {
class SchedulerManagerThread : public Thread {
public:
SchedulerManagerThread(Scheduler* scheduler, boost::asio::io_service* service)
: Thread("SchedulerManager"), _scheduler(scheduler), _service(service) {}
~SchedulerManagerThread() { shutdown(); }
public:
void run() {
while (!_scheduler->isStopping()) {
try {
_service->run_one();
_scheduler->deleteOldThreads();
} catch (...) {
LOG_TOPIC(ERR, Logger::THREADS)
<< "manager loop caught an error, restarting";
}
}
_scheduler->threadDone(this);
}
private:
Scheduler* _scheduler;
boost::asio::io_service* _service;
};
}
// -----------------------------------------------------------------------------
// --SECTION-- SchedulerThread
// -----------------------------------------------------------------------------
namespace {
class SchedulerThread : public Thread {
public:
SchedulerThread(Scheduler* scheduler, boost::asio::io_service* service)
: Thread("Scheduler"), _scheduler(scheduler), _service(service) {}
~SchedulerThread() { shutdown(); }
public:
void run() {
_scheduler->incRunning();
LOG_TOPIC(DEBUG, Logger::THREADS) << "running (" << _scheduler->infoStatus()
<< ")";
auto start = std::chrono::steady_clock::now();
try {
static size_t EVERY_LOOP = 1000;
static double MIN_SECONDS = 30;
size_t counter = 0;
while (!_scheduler->isStopping()) {
_service->run_one();
if (++counter > EVERY_LOOP) {
auto now = std::chrono::steady_clock::now();
std::chrono::duration<double> diff = now - start;
if (diff.count() > MIN_SECONDS) {
if (_scheduler->stopThread()) {
auto n = _scheduler->decRunning();
if (n <= 2) {
_scheduler->incRunning();
} else {
break;
}
}
start = std::chrono::steady_clock::now();
}
}
}
LOG_TOPIC(DEBUG, Logger::THREADS) << "stopped ("
<< _scheduler->infoStatus() << ")";
} catch (...) {
LOG_TOPIC(ERR, Logger::THREADS)
<< "scheduler loop caught an error, restarting";
_scheduler->decRunning();
_scheduler->startNewThread();
}
_scheduler->threadDone(this);
}
private:
Scheduler* _scheduler;
boost::asio::io_service* _service;
};
}
// -----------------------------------------------------------------------------
// --SECTION-- Scheduler
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// --SECTION-- constructors and destructors
// -----------------------------------------------------------------------------
Scheduler::Scheduler(size_t nrThreads, size_t maxQueueSize)
: _nrThreads(nrThreads),
_maxQueueSize(maxQueueSize),
_stopping(false),
_nrBusy(0),
_nrWorking(0),
_nrBlocked(0),
_nrRunning(0),
_nrMinimal(0),
_nrMaximal(0),
_nrRealMaximum(0),
_lastThreadWarning(0) {
// setup signal handlers
initializeSignalHandlers();
}
Scheduler::~Scheduler() {
if (_threadManager != nullptr) {
try {
_threadManager->cancel();
} catch (...) {
// must not throw in the dtor
}
}
try {
deleteOldThreads();
} catch (...) {
// probably out of memory here...
// must not throw in the dtor
LOG(ERR) << "unable to delete old scheduler threads";
}
}
// -----------------------------------------------------------------------------
// --SECTION-- constructors and destructors
// -----------------------------------------------------------------------------
bool Scheduler::start(ConditionVariable* cv) {
// start the I/O
startIoService();
// initialize thread handling
if (_nrMaximal <= 0) {
_nrMaximal = _nrThreads;
}
if (_nrRealMaximum <= 0) {
_nrRealMaximum = 4 * _nrMaximal;
}
for (size_t i = 0; i < 2; ++i) {
startNewThread();
}
startManagerThread();
startRebalancer();
// initialize the queue handling
_jobQueue.reset(new JobQueue(_maxQueueSize, _ioService.get()));
_jobQueue->start();
// done
LOG(TRACE) << "all scheduler threads are up and running";
return true;
}
void Scheduler::startIoService() {
_ioService.reset(new boost::asio::io_service());
_serviceGuard.reset(new boost::asio::io_service::work(*_ioService));
_managerService.reset(new boost::asio::io_service());
_managerGuard.reset(new boost::asio::io_service::work(*_managerService));
}
void Scheduler::startRebalancer() {
std::chrono::milliseconds interval(500);
_threadManager.reset(new boost::asio::steady_timer(*_managerService));
_threadHandler = [this, interval](const boost::system::error_code& error) {
if (error || isStopping()) {
return;
}
rebalanceThreads();
_threadManager->expires_from_now(interval);
_threadManager->async_wait(_threadHandler);
};
_threadManager->expires_from_now(interval);
_threadManager->async_wait(_threadHandler);
_lastThreadWarning.store(TRI_microtime());
}
void Scheduler::startManagerThread() {
MUTEX_LOCKER(guard, _threadsLock);
auto thread = new SchedulerManagerThread(this, _managerService.get());
_threads.emplace(thread);
thread->start();
}
void Scheduler::startNewThread() {
MUTEX_LOCKER(guard, _threadsLock);
auto thread = new SchedulerThread(this, _ioService.get());
_threads.emplace(thread);
thread->start();
}
bool Scheduler::stopThread() {
if (_nrRunning <= _nrMinimal) {
return false;
}
if (_nrRunning >= 3) {
int64_t low = ((_nrRunning <= 4) ? 0 : (_nrRunning * 1 / 4)) - _nrBlocked;
if (_nrBusy <= low && _nrWorking <= low) {
return true;
}
}
return false;
}
void Scheduler::threadDone(Thread* thread) {
MUTEX_LOCKER(guard, _threadsLock);
_threads.erase(thread);
_deadThreads.insert(thread);
}
void Scheduler::deleteOldThreads() {
// delete old thread objects
std::unordered_set<Thread*> deadThreads;
{
MUTEX_LOCKER(guard, _threadsLock);
if (_deadThreads.empty()) {
return;
}
deadThreads.swap(_deadThreads);
}
for (auto thread : deadThreads) {
try {
delete thread;
} catch (...) {
LOG_TOPIC(ERR, Logger::THREADS) << "cannot delete thread";
}
}
}
void Scheduler::rebalanceThreads() {
static double const MIN_WARN_INTERVAL = 10;
static double const MIN_ERR_INTERVAL = 300;
int64_t high = (_nrRunning <= 4) ? 1 : (_nrRunning * 11 / 16);
int64_t working = (_nrBusy > _nrWorking) ? _nrBusy : _nrWorking;
LOG_TOPIC(DEBUG, Logger::THREADS) << "rebalancing threads, high: " << high
<< ", working: " << working << " ("
<< infoStatus() << ")";
if (working >= high) {
if (_nrRunning < _nrMaximal + _nrBlocked &&
_nrRunning < _nrRealMaximum) { // added by Max 22.12.2016
// otherwise we exceed the total maximum
startNewThread();
return;
}
}
if (working >= _nrMaximal + _nrBlocked || _nrRunning < _nrMinimal) {
double ltw = _lastThreadWarning.load();
double now = TRI_microtime();
if (_nrRunning >= _nrRealMaximum) {
if (ltw - now > MIN_ERR_INTERVAL) {
LOG_TOPIC(ERR, Logger::THREADS) << "too many threads (" << infoStatus()
<< ")";
_lastThreadWarning.store(now);
}
} else {
if (_nrRunning >= _nrRealMaximum * 3 / 4) {
if (ltw - now > MIN_WARN_INTERVAL) {
LOG_TOPIC(WARN, Logger::THREADS)
<< "number of threads is reaching a critical limit ("
<< infoStatus() << ")";
_lastThreadWarning.store(now);
}
}
LOG_TOPIC(DEBUG, Logger::THREADS) << "overloading threads ("
<< infoStatus() << ")";
startNewThread();
}
}
}
void Scheduler::beginShutdown() {
if (_stopping) {
return;
}
_jobQueue->beginShutdown();
_threadManager.reset();
_managerGuard.reset();
_managerService->stop();
_serviceGuard.reset();
_ioService->stop();
// set the flag AFTER stopping the threads
_stopping = true;
}
void Scheduler::shutdown() {
bool done = false;
while (!done) {
MUTEX_LOCKER(guard, _threadsLock);
done = _threads.empty();
}
deleteOldThreads();
_managerService.reset();
_ioService.reset();
}
void Scheduler::initializeSignalHandlers() {
#ifdef _WIN32
// Windows does not support POSIX signal handling
#else
struct sigaction action;
memset(&action, 0, sizeof(action));
sigfillset(&action.sa_mask);
// ignore broken pipes
action.sa_handler = SIG_IGN;
int res = sigaction(SIGPIPE, &action, 0);
if (res < 0) {
LOG(ERR) << "cannot initialize signal handlers for pipe";
}
#endif
}
<|endoftext|> |
<commit_before>/*
Copyright (c) 2003, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "libtorrent/pch.hpp"
#include <algorithm>
#include <iostream>
#include <iomanip>
#include "libtorrent/entry.hpp"
#include "libtorrent/config.hpp"
#if defined(_MSC_VER)
namespace std
{
using ::isprint;
}
#define for if (false) {} else for
#endif
namespace
{
template <class T>
void call_destructor(T* o)
{
TORRENT_ASSERT(o);
o->~T();
}
struct compare_string
{
compare_string(char const* s): m_str(s) {}
bool operator()(
std::pair<std::string
, libtorrent::entry> const& e) const
{
return m_str && e.first == m_str;
}
char const* m_str;
};
}
namespace libtorrent
{
namespace detail
{
TORRENT_EXPORT char const* integer_to_str(char* buf, int size, entry::integer_type val)
{
int sign = 0;
if (val < 0)
{
sign = 1;
val = -val;
}
buf[--size] = '\0';
if (val == 0) buf[--size] = '0';
for (; size > sign && val != 0;)
{
buf[--size] = '0' + char(val % 10);
val /= 10;
}
if (sign) buf[--size] = '-';
return buf + size;
}
}
entry& entry::operator[](char const* key)
{
dictionary_type::iterator i = dict().find(key);
if (i != dict().end()) return i->second;
dictionary_type::iterator ret = dict().insert(
dict().begin()
, std::make_pair(std::string(key), entry()));
return ret->second;
}
entry& entry::operator[](std::string const& key)
{
return (*this)[key.c_str()];
}
entry* entry::find_key(char const* key)
{
dictionary_type::iterator i = std::find_if(
dict().begin()
, dict().end()
, compare_string(key));
if (i == dict().end()) return 0;
return &i->second;
}
entry const* entry::find_key(char const* key) const
{
dictionary_type::const_iterator i = dict().find(key);
if (i == dict().end()) return 0;
return &i->second;
}
#ifndef BOOST_NO_EXCEPTIONS
const entry& entry::operator[](char const* key) const
{
dictionary_type::const_iterator i = dict().find(key);
if (i == dict().end()) throw type_error(
(std::string("key not found: ") + key).c_str());
return i->second;
}
const entry& entry::operator[](std::string const& key) const
{
return (*this)[key.c_str()];
}
#endif
entry::entry(): m_type(undefined_t)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
}
entry::entry(data_type t): m_type(t)
{
construct(t);
#ifndef NDEBUG
m_type_queried = true;
#endif
}
entry::entry(const entry& e)
{
copy(e);
#ifndef NDEBUG
m_type_queried = e.m_type_queried;
#endif
}
entry::entry(dictionary_type const& v)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) dictionary_type(v);
m_type = dictionary_t;
}
entry::entry(string_type const& v)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) string_type(v);
m_type = string_t;
}
entry::entry(list_type const& v)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) list_type(v);
m_type = list_t;
}
entry::entry(integer_type const& v)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) integer_type(v);
m_type = int_t;
}
void entry::operator=(dictionary_type const& v)
{
destruct();
new(data) dictionary_type(v);
m_type = dictionary_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::operator=(string_type const& v)
{
destruct();
new(data) string_type(v);
m_type = string_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::operator=(list_type const& v)
{
destruct();
new(data) list_type(v);
m_type = list_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::operator=(integer_type const& v)
{
destruct();
new(data) integer_type(v);
m_type = int_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
bool entry::operator==(entry const& e) const
{
if (m_type != e.m_type) return false;
switch(m_type)
{
case int_t:
return integer() == e.integer();
case string_t:
return string() == e.string();
case list_t:
return list() == e.list();
case dictionary_t:
return dict() == e.dict();
default:
TORRENT_ASSERT(m_type == undefined_t);
return true;
}
}
void entry::construct(data_type t)
{
m_type = t;
switch(m_type)
{
case int_t:
new(data) integer_type;
break;
case string_t:
new(data) string_type;
break;
case list_t:
new(data) list_type;
break;
case dictionary_t:
new (data) dictionary_type;
break;
default:
TORRENT_ASSERT(m_type == undefined_t);
m_type = undefined_t;
}
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::copy(entry const& e)
{
m_type = e.type();
switch(m_type)
{
case int_t:
new(data) integer_type(e.integer());
break;
case string_t:
new(data) string_type(e.string());
break;
case list_t:
new(data) list_type(e.list());
break;
case dictionary_t:
new (data) dictionary_type(e.dict());
break;
default:
m_type = undefined_t;
}
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::destruct()
{
switch(m_type)
{
case int_t:
call_destructor(reinterpret_cast<integer_type*>(data));
break;
case string_t:
call_destructor(reinterpret_cast<string_type*>(data));
break;
case list_t:
call_destructor(reinterpret_cast<list_type*>(data));
break;
case dictionary_t:
call_destructor(reinterpret_cast<dictionary_type*>(data));
break;
default:
TORRENT_ASSERT(m_type == undefined_t);
break;
}
#ifndef NDEBUG
m_type_queried = false;
#endif
}
void entry::swap(entry& e)
{
// not implemented
TORRENT_ASSERT(false);
}
void entry::print(std::ostream& os, int indent) const
{
TORRENT_ASSERT(indent >= 0);
for (int i = 0; i < indent; ++i) os << " ";
switch (m_type)
{
case int_t:
os << integer() << "\n";
break;
case string_t:
{
bool binary_string = false;
for (std::string::const_iterator i = string().begin(); i != string().end(); ++i)
{
if (!std::isprint(static_cast<unsigned char>(*i)))
{
binary_string = true;
break;
}
}
if (binary_string)
{
os.unsetf(std::ios_base::dec);
os.setf(std::ios_base::hex);
for (std::string::const_iterator i = string().begin(); i != string().end(); ++i)
os << std::setfill('0') << std::setw(2)
<< static_cast<unsigned int>((unsigned char)*i);
os.unsetf(std::ios_base::hex);
os.setf(std::ios_base::dec);
os << "\n";
}
else
{
os << string() << "\n";
}
} break;
case list_t:
{
os << "list\n";
for (list_type::const_iterator i = list().begin(); i != list().end(); ++i)
{
i->print(os, indent+1);
}
} break;
case dictionary_t:
{
os << "dictionary\n";
for (dictionary_type::const_iterator i = dict().begin(); i != dict().end(); ++i)
{
for (int j = 0; j < indent+1; ++j) os << " ";
os << "[" << i->first << "]";
if (i->second.type() != entry::string_t
&& i->second.type() != entry::int_t)
os << "\n";
else os << " ";
i->second.print(os, indent+2);
}
} break;
default:
os << "<uninitialized>\n";
}
}
}
<commit_msg>exception safety fixes to entry.cpp<commit_after>/*
Copyright (c) 2003, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "libtorrent/pch.hpp"
#include <algorithm>
#include <iostream>
#include <iomanip>
#include "libtorrent/entry.hpp"
#include "libtorrent/config.hpp"
#if defined(_MSC_VER)
namespace std
{
using ::isprint;
}
#define for if (false) {} else for
#endif
namespace
{
template <class T>
void call_destructor(T* o)
{
TORRENT_ASSERT(o);
o->~T();
}
struct compare_string
{
compare_string(char const* s): m_str(s) {}
bool operator()(
std::pair<std::string
, libtorrent::entry> const& e) const
{
return m_str && e.first == m_str;
}
char const* m_str;
};
}
namespace libtorrent
{
namespace detail
{
TORRENT_EXPORT char const* integer_to_str(char* buf, int size, entry::integer_type val)
{
int sign = 0;
if (val < 0)
{
sign = 1;
val = -val;
}
buf[--size] = '\0';
if (val == 0) buf[--size] = '0';
for (; size > sign && val != 0;)
{
buf[--size] = '0' + char(val % 10);
val /= 10;
}
if (sign) buf[--size] = '-';
return buf + size;
}
}
entry& entry::operator[](char const* key)
{
dictionary_type::iterator i = dict().find(key);
if (i != dict().end()) return i->second;
dictionary_type::iterator ret = dict().insert(
dict().begin()
, std::make_pair(std::string(key), entry()));
return ret->second;
}
entry& entry::operator[](std::string const& key)
{
return (*this)[key.c_str()];
}
entry* entry::find_key(char const* key)
{
dictionary_type::iterator i = std::find_if(
dict().begin()
, dict().end()
, compare_string(key));
if (i == dict().end()) return 0;
return &i->second;
}
entry const* entry::find_key(char const* key) const
{
dictionary_type::const_iterator i = dict().find(key);
if (i == dict().end()) return 0;
return &i->second;
}
#ifndef BOOST_NO_EXCEPTIONS
const entry& entry::operator[](char const* key) const
{
dictionary_type::const_iterator i = dict().find(key);
if (i == dict().end()) throw type_error(
(std::string("key not found: ") + key).c_str());
return i->second;
}
const entry& entry::operator[](std::string const& key) const
{
return (*this)[key.c_str()];
}
#endif
entry::entry()
: m_type(undefined_t)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
}
entry::entry(data_type t)
: m_type(undefined_t)
{
construct(t);
#ifndef NDEBUG
m_type_queried = true;
#endif
}
entry::entry(const entry& e)
: m_type(undefined_t)
{
copy(e);
#ifndef NDEBUG
m_type_queried = e.m_type_queried;
#endif
}
entry::entry(dictionary_type const& v)
: m_type(undefined_t)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) dictionary_type(v);
m_type = dictionary_t;
}
entry::entry(string_type const& v)
: m_type(undefined_t)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) string_type(v);
m_type = string_t;
}
entry::entry(list_type const& v)
: m_type(undefined_t)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) list_type(v);
m_type = list_t;
}
entry::entry(integer_type const& v)
: m_type(undefined_t)
{
#ifndef NDEBUG
m_type_queried = true;
#endif
new(data) integer_type(v);
m_type = int_t;
}
void entry::operator=(dictionary_type const& v)
{
destruct();
new(data) dictionary_type(v);
m_type = dictionary_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::operator=(string_type const& v)
{
destruct();
new(data) string_type(v);
m_type = string_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::operator=(list_type const& v)
{
destruct();
new(data) list_type(v);
m_type = list_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::operator=(integer_type const& v)
{
destruct();
new(data) integer_type(v);
m_type = int_t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
bool entry::operator==(entry const& e) const
{
if (m_type != e.m_type) return false;
switch(m_type)
{
case int_t:
return integer() == e.integer();
case string_t:
return string() == e.string();
case list_t:
return list() == e.list();
case dictionary_t:
return dict() == e.dict();
default:
TORRENT_ASSERT(m_type == undefined_t);
return true;
}
}
void entry::construct(data_type t)
{
switch(t)
{
case int_t:
new(data) integer_type;
break;
case string_t:
new(data) string_type;
break;
case list_t:
new(data) list_type;
break;
case dictionary_t:
new (data) dictionary_type;
break;
default:
TORRENT_ASSERT(t == undefined_t);
}
m_type = t;
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::copy(entry const& e)
{
switch (e.type())
{
case int_t:
new(data) integer_type(e.integer());
break;
case string_t:
new(data) string_type(e.string());
break;
case list_t:
new(data) list_type(e.list());
break;
case dictionary_t:
new (data) dictionary_type(e.dict());
break;
default:
TORRENT_ASSERT(e.type() == undefined_t);
}
m_type = e.type();
#ifndef NDEBUG
m_type_queried = true;
#endif
}
void entry::destruct()
{
switch(m_type)
{
case int_t:
call_destructor(reinterpret_cast<integer_type*>(data));
break;
case string_t:
call_destructor(reinterpret_cast<string_type*>(data));
break;
case list_t:
call_destructor(reinterpret_cast<list_type*>(data));
break;
case dictionary_t:
call_destructor(reinterpret_cast<dictionary_type*>(data));
break;
default:
TORRENT_ASSERT(m_type == undefined_t);
break;
}
m_type = undefined_t;
#ifndef NDEBUG
m_type_queried = false;
#endif
}
void entry::swap(entry& e)
{
// not implemented
TORRENT_ASSERT(false);
}
void entry::print(std::ostream& os, int indent) const
{
TORRENT_ASSERT(indent >= 0);
for (int i = 0; i < indent; ++i) os << " ";
switch (m_type)
{
case int_t:
os << integer() << "\n";
break;
case string_t:
{
bool binary_string = false;
for (std::string::const_iterator i = string().begin(); i != string().end(); ++i)
{
if (!std::isprint(static_cast<unsigned char>(*i)))
{
binary_string = true;
break;
}
}
if (binary_string)
{
os.unsetf(std::ios_base::dec);
os.setf(std::ios_base::hex);
for (std::string::const_iterator i = string().begin(); i != string().end(); ++i)
os << std::setfill('0') << std::setw(2)
<< static_cast<unsigned int>((unsigned char)*i);
os.unsetf(std::ios_base::hex);
os.setf(std::ios_base::dec);
os << "\n";
}
else
{
os << string() << "\n";
}
} break;
case list_t:
{
os << "list\n";
for (list_type::const_iterator i = list().begin(); i != list().end(); ++i)
{
i->print(os, indent+1);
}
} break;
case dictionary_t:
{
os << "dictionary\n";
for (dictionary_type::const_iterator i = dict().begin(); i != dict().end(); ++i)
{
for (int j = 0; j < indent+1; ++j) os << " ";
os << "[" << i->first << "]";
if (i->second.type() != entry::string_t
&& i->second.type() != entry::int_t)
os << "\n";
else os << " ";
i->second.print(os, indent+2);
}
} break;
default:
os << "<uninitialized>\n";
}
}
}
<|endoftext|> |
<commit_before>#include "mmap_reader.hpp"
#include "../std/target_os.hpp"
#include "../std/memcpy.hpp"
// @TODO we don't support windows at the moment
#ifndef OMIM_OS_WINDOWS
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <unistd.h>
#endif
class MmapReader::MmapData
{
int m_fd;
public:
uint8_t * m_memory;
uint64_t m_size;
MmapData(string const & fileName)
{
// @TODO add windows support
#ifndef OMIM_OS_WINDOWS
m_fd = open(fileName.c_str(), O_RDONLY | O_NONBLOCK);
if (m_fd == -1)
MYTHROW(OpenException, ("open failed for file", fileName));
struct stat s;
if (-1 == fstat(m_fd, &s))
MYTHROW(OpenException, ("fstat failed for file", fileName));
m_size = s.st_size;
m_memory = (uint8_t *)mmap(0, m_size, PROT_READ, MAP_SHARED, m_fd, 0);
if (m_memory == MAP_FAILED)
{
close(m_fd);
MYTHROW(OpenException, ("mmap failed for file", fileName));
}
#endif
}
~MmapData()
{
// @TODO add windows support
#ifndef OMIM_OS_WINDOWS
munmap(m_memory, m_size);
close(m_fd);
#endif
}
};
MmapReader::MmapReader(string const & fileName)
: base_type(fileName), m_offset(0)
{
m_data = shared_ptr<MmapData>(new MmapData(fileName));
m_size = m_data->m_size;
}
MmapReader::MmapReader(MmapReader const & reader, uint64_t offset, uint64_t size)
: base_type(reader.GetName()), m_data(reader.m_data),
m_offset(offset), m_size(size)
{
}
uint64_t MmapReader::Size() const
{
return m_size;
}
void MmapReader::Read(uint64_t pos, void * p, size_t size) const
{
ASSERT_LESS_OR_EQUAL(pos + size, Size(), (pos, size));
memcpy(p, m_data->m_memory + m_offset + pos, size);
}
MmapReader * MmapReader::CreateSubReader(uint64_t pos, uint64_t size) const
{
ASSERT_LESS_OR_EQUAL(pos + size, Size(), (pos, size));
return new MmapReader(*this, m_offset + pos, size);
}
uint8_t * MmapReader::Data() const
{
return m_data->m_memory;
}
<commit_msg>[android] Compilation fixes<commit_after>#include "mmap_reader.hpp"
#include "../std/target_os.hpp"
#include "../std/memcpy.hpp"
// @TODO we don't support windows at the moment
#ifndef OMIM_OS_WINDOWS
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#ifdef OMIM_OS_ANDROID
#include <fcntl.h>
#else
#include <sys/fcntl.h>
#endif
#endif
class MmapReader::MmapData
{
int m_fd;
public:
uint8_t * m_memory;
uint64_t m_size;
MmapData(string const & fileName)
{
// @TODO add windows support
#ifndef OMIM_OS_WINDOWS
m_fd = open(fileName.c_str(), O_RDONLY | O_NONBLOCK);
if (m_fd == -1)
MYTHROW(OpenException, ("open failed for file", fileName));
struct stat s;
if (-1 == fstat(m_fd, &s))
MYTHROW(OpenException, ("fstat failed for file", fileName));
m_size = s.st_size;
m_memory = (uint8_t *)mmap(0, m_size, PROT_READ, MAP_SHARED, m_fd, 0);
if (m_memory == MAP_FAILED)
{
close(m_fd);
MYTHROW(OpenException, ("mmap failed for file", fileName));
}
#endif
}
~MmapData()
{
// @TODO add windows support
#ifndef OMIM_OS_WINDOWS
munmap(m_memory, m_size);
close(m_fd);
#endif
}
};
MmapReader::MmapReader(string const & fileName)
: base_type(fileName), m_offset(0)
{
m_data = shared_ptr<MmapData>(new MmapData(fileName));
m_size = m_data->m_size;
}
MmapReader::MmapReader(MmapReader const & reader, uint64_t offset, uint64_t size)
: base_type(reader.GetName()), m_data(reader.m_data),
m_offset(offset), m_size(size)
{
}
uint64_t MmapReader::Size() const
{
return m_size;
}
void MmapReader::Read(uint64_t pos, void * p, size_t size) const
{
ASSERT_LESS_OR_EQUAL(pos + size, Size(), (pos, size));
memcpy(p, m_data->m_memory + m_offset + pos, size);
}
MmapReader * MmapReader::CreateSubReader(uint64_t pos, uint64_t size) const
{
ASSERT_LESS_OR_EQUAL(pos + size, Size(), (pos, size));
return new MmapReader(*this, m_offset + pos, size);
}
uint8_t * MmapReader::Data() const
{
return m_data->m_memory;
}
<|endoftext|> |
<commit_before>/****************************************************************************
**
** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the Qt Script Generator project on Qt Labs.
**
** $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 "setupgenerator.h"
#include "shellgenerator.h"
#include "reporthandler.h"
#include "fileout.h"
//#define Q_SCRIPT_LAZY_GENERATOR
void SetupGenerator::addClass(const QString& package, const AbstractMetaClass *cls)
{
packHash[package].append(cls);
}
void maybeDeclareMetaType(QTextStream &stream, const QString &typeName,
QSet<QString> ®isteredTypeNames);
bool hasDefaultConstructor(const AbstractMetaClass *meta_class);
static QStringList getOperatorCodes(const AbstractMetaClass* cls) {
QSet<QString> operatorCodes;
AbstractMetaFunctionList returned;
AbstractMetaFunctionList functions = cls->functions();
foreach (AbstractMetaFunction *function, functions) {
if (function->originalName().startsWith("operator")) {
QString op = function->originalName().mid(8);
operatorCodes.insert(op);
}
}
QSet<QString> r;
foreach(QString op, operatorCodes.toList()) {
if (op == ">" || op == "<" || op == ">=" || op == "<=" || op == "==" || op == "!=") {
r.insert("PythonQt::Type_RichCompare");
} else if (op == "+") {
r.insert("PythonQt::Type_Add");
} else if (op == "-") {
r.insert("PythonQt::Type_Subtract");
} else if (op == "/") {
r.insert("PythonQt::Type_Divide");
} else if (op == "*") {
r.insert("PythonQt::Type_Multiply");
} else if (op == "%") {
r.insert("PythonQt::Type_Mod");
} else if (op == "&") {
r.insert("PythonQt::Type_And");
} else if (op == "|") {
r.insert("PythonQt::Type_Or");
} else if (op == "^") {
r.insert("PythonQt::Type_Xor");
} else if (op == "~") {
r.insert("PythonQt::Type_Invert");
} else if (op == "+=") {
r.insert("PythonQt::Type_InplaceAdd");
} else if (op == "-=") {
r.insert("PythonQt::Type_InplaceSubtract");
} else if (op == "/=") {
r.insert("PythonQt::Type_InplaceDivide");
} else if (op == "*=") {
r.insert("PythonQt::Type_InplaceMultiply");
} else if (op == "%=") {
r.insert("PythonQt::Type_InplaceMod");
} else if (op == "&=") {
r.insert("PythonQt::Type_InplaceAnd");
} else if (op == "|=") {
r.insert("PythonQt::Type_InplaceOr");
} else if (op == "^=") {
r.insert("PythonQt::Type_InplaceXor");
}
}
if (cls->hasDefaultIsNull()) {
r.insert("PythonQt::Type_NonZero");
}
QStringList result = r.toList();
qSort(result);
return result;
}
static bool class_less_than(const AbstractMetaClass *a, const AbstractMetaClass *b)
{
return a->name() < b->name();
}
void SetupGenerator::generate()
{
AbstractMetaClassList classes_with_polymorphic_id;
{
QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
while (pack.hasNext()) {
pack.next();
QList<const AbstractMetaClass*> list = pack.value();
foreach (const AbstractMetaClass *cls, list) {
if (cls->typeEntry()->isPolymorphicBase()) {
classes_with_polymorphic_id.append((AbstractMetaClass*)cls);
}
}
}
}
qSort(classes_with_polymorphic_id.begin(), classes_with_polymorphic_id.end(), class_less_than);
QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
while (pack.hasNext()) {
pack.next();
QList<const AbstractMetaClass*> list = pack.value();
if (list.isEmpty())
continue;
qSort(list.begin(), list.end(), class_less_than);
QString packKey = pack.key();
QString packName = pack.key();
QStringList components = packName.split("_");
if ((components.size() > 2) && (components.at(0) == "com")
&& (components.at(1) == "trolltech")) {
// kill com.trolltech in key
components.removeAt(0);
components.removeAt(0);
}
QString shortPackName;
foreach (QString comp, components) {
comp[0] = comp[0].toUpper();
shortPackName += comp;
}
// add missing camel case (workaround..)
if (shortPackName == "QtWebkit") {
shortPackName = "QtWebKit";
} else if (shortPackName == "QtXmlpatterns") {
shortPackName = "QtXmlPatterns";
} else if (shortPackName == "QtOpengl") {
shortPackName = "QtOpenGL";
} else if (shortPackName == "QtUitools") {
shortPackName = "QtUiTools";
}
{
QString fileName(packName + "/" + packKey + "_init.cpp");
FileOut initFile(m_out_dir + "/generated_cpp/" + fileName);
ReportHandler::debugSparse(QString("generating: %1").arg(fileName));
QTextStream &s = initFile.stream;
s << "#include <PythonQt.h>" << endl;
for (int i=0; i<(list.count()+MAX_CLASSES_PER_FILE-1) / MAX_CLASSES_PER_FILE; i++) {
s << "#include \"" << packKey << QString::number(i) << ".h\"" << endl;
}
s << endl;
QStringList polymorphicHandlers;
if (!packName.endsWith("_builtin")) {
polymorphicHandlers = writePolymorphicHandler(s, list.at(0)->package(), classes_with_polymorphic_id, list);
s << endl;
}
// declare individual class creation functions
s << "void PythonQt_init_" << shortPackName << "(PyObject* module) {" << endl;
if (shortPackName.endsWith("Builtin")) {
shortPackName = shortPackName.mid(0, shortPackName.length()-strlen("builtin"));
}
QStringList cppClassNames;
foreach (const AbstractMetaClass *cls, list) {
if (cls->qualifiedCppName().contains("Ssl")) {
s << "#ifndef QT_NO_OPENSSL" << endl;
}
AbstractMetaFunctionList ctors = cls->queryFunctions(AbstractMetaClass::Constructors
| AbstractMetaClass::WasVisible
| AbstractMetaClass::NotRemovedFromTargetLang);
QString shellCreator;
if (cls->generateShellClass() && !ctors.isEmpty()) {
shellCreator = ", PythonQtSetInstanceWrapperOnShell<" + ShellGenerator::shellClassName(cls) + ">";
} else {
shellCreator = ", NULL";
}
QString operatorCodes = getOperatorCodes(cls).join("|");
if (operatorCodes.isEmpty()) {
operatorCodes = "0";
}
if (cls->isQObject()) {
s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
} else {
QString baseName = cls->baseClass()?cls->baseClass()->qualifiedCppName():"";
s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
}
foreach(AbstractMetaClass* interface, cls->interfaces()) {
// the interface might be our own class... (e.g. QPaintDevice)
if (interface->qualifiedCppName() != cls->qualifiedCppName()) {
s << "PythonQt::self()->addParentClass(\""<< cls->qualifiedCppName() << "\", \"" << interface->qualifiedCppName() << "\",PythonQtUpcastingOffset<" << cls->qualifiedCppName() <<","<<interface->qualifiedCppName()<<">());" << endl;
}
}
if (cls->qualifiedCppName().contains("Ssl")) {
s << "#endif" << endl;
}
}
s << endl;
foreach (QString handler, polymorphicHandlers) {
s << "PythonQt::self()->addPolymorphicHandler(\""<< handler << "\", polymorphichandler_" << handler << ");" << endl;
}
s << "}";
s << endl;
}
}
}
QStringList SetupGenerator::writePolymorphicHandler(QTextStream &s, const QString &package,
const AbstractMetaClassList &polybase, QList<const AbstractMetaClass*>& allClasses)
{
QStringList handlers;
foreach (AbstractMetaClass *cls, polybase) {
const ComplexTypeEntry *centry = cls->typeEntry();
if (!centry->isPolymorphicBase())
continue;
bool isGraphicsItem = (cls->qualifiedCppName()=="QGraphicsItem");
bool first = true;
foreach (const AbstractMetaClass *clazz, allClasses) {
bool inherits = false;
if (isGraphicsItem) {
const AbstractMetaClass *currentClazz = clazz;
while (!inherits && currentClazz) {
foreach(AbstractMetaClass* interfaze, currentClazz->interfaces()) {
if (interfaze->qualifiedCppName()=="QGraphicsItem") {
inherits = true;
break;
}
}
currentClazz = currentClazz->baseClass();
}
} else {
inherits = clazz->inheritsFrom(cls);
}
if (clazz->package() == package && inherits) {
if (!clazz->typeEntry()->polymorphicIdValue().isEmpty()) {
// On first find, open the function
if (first) {
first = false;
QString handler = cls->name();
handlers.append(handler);
s << "static void* polymorphichandler_" << handler
<< "(const void *ptr, const char **class_name)" << endl
<< "{" << endl
<< " Q_ASSERT(ptr != 0);" << endl
<< " " << cls->qualifiedCppName() << " *object = ("
<< cls->qualifiedCppName() << " *)ptr;" << endl;
}
// For each, add case label
QString polyId = clazz->typeEntry()->polymorphicIdValue();
s << " if ("
<< polyId.replace("%1", "object")
<< ") {" << endl
<< " *class_name = \"" << clazz->name() << "\";" << endl
<< " return (" << clazz->qualifiedCppName() << "*)object;" << endl
<< " }" << endl;
} else {
QString warning = QString("class '%1' inherits from polymorphic class '%2', but has no polymorphic id set")
.arg(clazz->name())
.arg(cls->name());
ReportHandler::warning(warning);
}
}
}
// Close the function if it has been opened
if (!first) {
s << " return NULL;" << endl
<< "}" << endl;
}
}
return handlers;
}
<commit_msg>added support for registering QList/QVector template converters for non-pointer types that are used register aliases for QList/QVector<enum> -> QList<int> <commit_after>/****************************************************************************
**
** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the Qt Script Generator project on Qt Labs.
**
** $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 "setupgenerator.h"
#include "shellgenerator.h"
#include "reporthandler.h"
#include "fileout.h"
void SetupGenerator::addClass(const QString& package, const AbstractMetaClass *cls)
{
packHash[package].append(cls);
}
void maybeDeclareMetaType(QTextStream &stream, const QString &typeName,
QSet<QString> ®isteredTypeNames);
bool hasDefaultConstructor(const AbstractMetaClass *meta_class);
static QStringList getOperatorCodes(const AbstractMetaClass* cls) {
QSet<QString> operatorCodes;
AbstractMetaFunctionList returned;
AbstractMetaFunctionList functions = cls->functions();
foreach (AbstractMetaFunction *function, functions) {
if (function->originalName().startsWith("operator")) {
QString op = function->originalName().mid(8);
operatorCodes.insert(op);
}
}
QSet<QString> r;
foreach(QString op, operatorCodes.toList()) {
if (op == ">" || op == "<" || op == ">=" || op == "<=" || op == "==" || op == "!=") {
r.insert("PythonQt::Type_RichCompare");
} else if (op == "+") {
r.insert("PythonQt::Type_Add");
} else if (op == "-") {
r.insert("PythonQt::Type_Subtract");
} else if (op == "/") {
r.insert("PythonQt::Type_Divide");
} else if (op == "*") {
r.insert("PythonQt::Type_Multiply");
} else if (op == "%") {
r.insert("PythonQt::Type_Mod");
} else if (op == "&") {
r.insert("PythonQt::Type_And");
} else if (op == "|") {
r.insert("PythonQt::Type_Or");
} else if (op == "^") {
r.insert("PythonQt::Type_Xor");
} else if (op == "~") {
r.insert("PythonQt::Type_Invert");
} else if (op == "+=") {
r.insert("PythonQt::Type_InplaceAdd");
} else if (op == "-=") {
r.insert("PythonQt::Type_InplaceSubtract");
} else if (op == "/=") {
r.insert("PythonQt::Type_InplaceDivide");
} else if (op == "*=") {
r.insert("PythonQt::Type_InplaceMultiply");
} else if (op == "%=") {
r.insert("PythonQt::Type_InplaceMod");
} else if (op == "&=") {
r.insert("PythonQt::Type_InplaceAnd");
} else if (op == "|=") {
r.insert("PythonQt::Type_InplaceOr");
} else if (op == "^=") {
r.insert("PythonQt::Type_InplaceXor");
}
}
if (cls->hasDefaultIsNull()) {
r.insert("PythonQt::Type_NonZero");
}
QStringList result = r.toList();
qSort(result);
return result;
}
static bool class_less_than(const AbstractMetaClass *a, const AbstractMetaClass *b)
{
return a->name() < b->name();
}
static QSet<QString> _builtinListTypes = QSet<QString>() << "QByteArray"
<< "QDate"
<< "QTime"
<< "QDateTime"
<< "QUrl"
<< "QLocale"
<< "QRect"
<< "QRectF"
<< "QSize"
<< "QSizeF"
<< "QLine"
<< "QLineF"
<< "QPoint"
<< "QPointF"
<< "QRegExp"
<< "QFont"
<< "QPixmap"
<< "QBrush"
<< "QColor"
<< "QPalette"
<< "QIcon"
<< "QImage"
<< "QPolygon"
<< "QRegion"
<< "QBitmap"
<< "QCursor"
<< "QSizePolicy"
<< "QKeySequence"
<< "QPen"
<< "QTextLength"
<< "QTextFormat"
<< "QMatrix"
<< "QVariant";
static void addListRegistration(AbstractMetaType* type, QSet<QString>& output) {
if (type->instantiations().size() > 0) {
QList<AbstractMetaType *> args = type->instantiations();
/*
QString debugStr;
Q_FOREACH(AbstractMetaType* arg, args) {
debugStr += QString(arg->typeEntry()->isEnum()?"ENUM ":"") + arg->typeEntry()->qualifiedCppName() + ",";
if (arg->typeEntry()->qualifiedCppName() == "QPair") {
debugStr += "(" + arg->instantiations().at(0)->typeEntry()->qualifiedCppName() + ",";
debugStr += arg->instantiations().at(1)->typeEntry()->qualifiedCppName() + ")";
}
}
output.insert(QString("// TEMPLATEARG: ") + type->typeEntry()->qualifiedCppName() + " " + debugStr);
*/
if (args.count() == 1) {
if (args.at(0)->indirections() > 0) {
return;
}
QString typeName = type->typeEntry()->qualifiedCppName();
QString innerName = args.at(0)->typeEntry()->qualifiedCppName();
if (typeName == "QStringList") {
return;
}
if (typeName.startsWith("QVector") || typeName.startsWith("QList")) {
if (args.at(0)->isEnum()) {
output.insert(QString("PythonQtMethodInfo::addParameterTypeAlias(\"") + typeName + "<" + innerName + ">\", \"" + typeName + "<int>\");");
} else if (args.at(0)->instantiations().isEmpty() && innerName.startsWith("Q") && !_builtinListTypes.contains(innerName)) {
QString result = "PythonQtRegisterListTemplateConverterForKnownClass(" + typeName + ", " + innerName + ");";
output.insert(result);
}
if (!innerName.startsWith("Q")) {
// for debugging:
//output.insert(QString("// POD: ") + typeName + " " + innerName);
}
}
}
}
}
void SetupGenerator::generate()
{
AbstractMetaClassList classes_with_polymorphic_id;
{
QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
while (pack.hasNext()) {
pack.next();
QList<const AbstractMetaClass*> list = pack.value();
foreach (const AbstractMetaClass *cls, list) {
if (cls->typeEntry()->isPolymorphicBase()) {
classes_with_polymorphic_id.append((AbstractMetaClass*)cls);
}
}
}
}
qSort(classes_with_polymorphic_id.begin(), classes_with_polymorphic_id.end(), class_less_than);
QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);
while (pack.hasNext()) {
pack.next();
QList<const AbstractMetaClass*> list = pack.value();
if (list.isEmpty())
continue;
qSort(list.begin(), list.end(), class_less_than);
QString packKey = pack.key();
QString packName = pack.key();
QStringList components = packName.split("_");
if ((components.size() > 2) && (components.at(0) == "com")
&& (components.at(1) == "trolltech")) {
// kill com.trolltech in key
components.removeAt(0);
components.removeAt(0);
}
QString shortPackName;
foreach (QString comp, components) {
comp[0] = comp[0].toUpper();
shortPackName += comp;
}
// add missing camel case (workaround..)
if (shortPackName == "QtWebkit") {
shortPackName = "QtWebKit";
} else if (shortPackName == "QtXmlpatterns") {
shortPackName = "QtXmlPatterns";
} else if (shortPackName == "QtOpengl") {
shortPackName = "QtOpenGL";
} else if (shortPackName == "QtUitools") {
shortPackName = "QtUiTools";
}
{
QString fileName(packName + "/" + packKey + "_init.cpp");
FileOut initFile(m_out_dir + "/generated_cpp/" + fileName);
ReportHandler::debugSparse(QString("generating: %1").arg(fileName));
QTextStream &s = initFile.stream;
s << "#include <PythonQt.h>" << endl;
s << "#include <PythonQtConversion.h>" << endl;
for (int i=0; i<(list.count()+MAX_CLASSES_PER_FILE-1) / MAX_CLASSES_PER_FILE; i++) {
s << "#include \"" << packKey << QString::number(i) << ".h\"" << endl;
}
s << endl;
QStringList polymorphicHandlers;
if (!packName.endsWith("_builtin")) {
polymorphicHandlers = writePolymorphicHandler(s, list.at(0)->package(), classes_with_polymorphic_id, list);
s << endl;
}
QSet<QString> listRegistration;
foreach(const AbstractMetaClass *cls, list) {
Q_FOREACH(const AbstractMetaFunction* func, cls->functions()) {
if (func->type() && func->type()->isContainer()) {
addListRegistration(func->type(), listRegistration);
}
Q_FOREACH(const AbstractMetaArgument* arg, func->arguments()) {
if (arg->type() && arg->type()->isContainer()) {
addListRegistration(arg->type(), listRegistration);
}
}
}
}
// declare individual class creation functions
s << "void PythonQt_init_" << shortPackName << "(PyObject* module) {" << endl;
if (shortPackName.endsWith("Builtin")) {
shortPackName = shortPackName.mid(0, shortPackName.length()-strlen("builtin"));
}
foreach (const AbstractMetaClass *cls, list) {
if (cls->qualifiedCppName().contains("Ssl")) {
s << "#ifndef QT_NO_OPENSSL" << endl;
}
AbstractMetaFunctionList ctors = cls->queryFunctions(AbstractMetaClass::Constructors
| AbstractMetaClass::WasVisible
| AbstractMetaClass::NotRemovedFromTargetLang);
QString shellCreator;
if (cls->generateShellClass() && !ctors.isEmpty()) {
shellCreator = ", PythonQtSetInstanceWrapperOnShell<" + ShellGenerator::shellClassName(cls) + ">";
} else {
shellCreator = ", NULL";
}
QString operatorCodes = getOperatorCodes(cls).join("|");
if (operatorCodes.isEmpty()) {
operatorCodes = "0";
}
if (cls->isQObject()) {
s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
} else {
QString baseName = cls->baseClass()?cls->baseClass()->qualifiedCppName():"";
s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;
}
foreach(AbstractMetaClass* interface, cls->interfaces()) {
// the interface might be our own class... (e.g. QPaintDevice)
if (interface->qualifiedCppName() != cls->qualifiedCppName()) {
s << "PythonQt::self()->addParentClass(\""<< cls->qualifiedCppName() << "\", \"" << interface->qualifiedCppName() << "\",PythonQtUpcastingOffset<" << cls->qualifiedCppName() <<","<<interface->qualifiedCppName()<<">());" << endl;
}
}
if (cls->qualifiedCppName().contains("Ssl")) {
s << "#endif" << endl;
}
}
s << endl;
foreach (QString handler, polymorphicHandlers) {
s << "PythonQt::self()->addPolymorphicHandler(\""<< handler << "\", polymorphichandler_" << handler << ");" << endl;
}
s << endl;
QStringList list = listRegistration.toList();
list.sort();
Q_FOREACH(QString name, list) {
if (name.contains("Ssl")) {
s << "#ifndef QT_NO_OPENSSL" << endl;
}
s << name << endl;
if (name.contains("Ssl")) {
s << "#endif" << endl;
}
}
s << "}";
s << endl;
}
}
}
QStringList SetupGenerator::writePolymorphicHandler(QTextStream &s, const QString &package,
const AbstractMetaClassList &polybase, QList<const AbstractMetaClass*>& allClasses)
{
QStringList handlers;
foreach (AbstractMetaClass *cls, polybase) {
const ComplexTypeEntry *centry = cls->typeEntry();
if (!centry->isPolymorphicBase())
continue;
bool isGraphicsItem = (cls->qualifiedCppName()=="QGraphicsItem");
bool first = true;
foreach (const AbstractMetaClass *clazz, allClasses) {
bool inherits = false;
if (isGraphicsItem) {
const AbstractMetaClass *currentClazz = clazz;
while (!inherits && currentClazz) {
foreach(AbstractMetaClass* interfaze, currentClazz->interfaces()) {
if (interfaze->qualifiedCppName()=="QGraphicsItem") {
inherits = true;
break;
}
}
currentClazz = currentClazz->baseClass();
}
} else {
inherits = clazz->inheritsFrom(cls);
}
if (clazz->package() == package && inherits) {
if (!clazz->typeEntry()->polymorphicIdValue().isEmpty()) {
// On first find, open the function
if (first) {
first = false;
QString handler = cls->name();
handlers.append(handler);
s << "static void* polymorphichandler_" << handler
<< "(const void *ptr, const char **class_name)" << endl
<< "{" << endl
<< " Q_ASSERT(ptr != 0);" << endl
<< " " << cls->qualifiedCppName() << " *object = ("
<< cls->qualifiedCppName() << " *)ptr;" << endl;
}
// For each, add case label
QString polyId = clazz->typeEntry()->polymorphicIdValue();
s << " if ("
<< polyId.replace("%1", "object")
<< ") {" << endl
<< " *class_name = \"" << clazz->name() << "\";" << endl
<< " return (" << clazz->qualifiedCppName() << "*)object;" << endl
<< " }" << endl;
} else {
QString warning = QString("class '%1' inherits from polymorphic class '%2', but has no polymorphic id set")
.arg(clazz->name())
.arg(cls->name());
ReportHandler::warning(warning);
}
}
}
// Close the function if it has been opened
if (!first) {
s << " return NULL;" << endl
<< "}" << endl;
}
}
return handlers;
}
<|endoftext|> |
<commit_before>/****************************************************************************
**
** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the Qt Script Generator project on Qt Labs.
**
** $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 "shellgenerator.h"
#include "reporthandler.h"
#include "metaqtscript.h"
bool ShellGenerator::shouldGenerate(const AbstractMetaClass *meta_class) const
{
uint cg = meta_class->typeEntry()->codeGeneration();
if (meta_class->name().startsWith("QtScript")) return false;
if (meta_class->name().startsWith("QFuture")) return false;
if (meta_class->name().startsWith("Global")) return false;
if (meta_class->name().startsWith("QStyleOptionComplex")) return false;
if (meta_class->name().startsWith("QTextLayout")) return false;
//if (meta_class->name().startsWith("QTextStream")) return false; // because of >> operators
//if (meta_class->name().startsWith("QDataStream")) return false; // "
return ((cg & TypeEntry::GenerateCode) != 0);
}
void ShellGenerator::writeTypeInfo(QTextStream &s, const AbstractMetaType *type, Option options)
{
if ((options & OriginalTypeDescription) && !type->originalTypeDescription().isEmpty()) {
s << type->originalTypeDescription();
return;
}
if (type->isArray()) {
writeTypeInfo(s, type->arrayElementType(), options);
if (options & ArrayAsPointer) {
s << "*";
} else {
s << "[" << type->arrayElementCount() << "]";
}
return;
}
const TypeEntry *te = type->typeEntry();
if (type->isConstant() && !(options & ExcludeConst))
s << "const ";
if ((options & EnumAsInts) && (te->isEnum() || te->isFlags())) {
s << "int";
} else if (te->isFlags()) {
s << ((FlagsTypeEntry *) te)->originalName();
} else {
s << fixCppTypeName(te->qualifiedCppName());
}
if (type->instantiations().size() > 0
&& (!type->isContainer()
|| (static_cast<const ContainerTypeEntry *>(te))->type() != ContainerTypeEntry::StringListContainer)) {
s << '<';
QList<AbstractMetaType *> args = type->instantiations();
bool nested_template = false;
for (int i=0; i<args.size(); ++i) {
if (i != 0)
s << ", ";
nested_template |= args.at(i)->isContainer();
writeTypeInfo(s, args.at(i));
}
if (nested_template)
s << ' ';
s << '>';
}
s << QString(type->indirections(), '*');
if (type->isReference() && !(options & ExcludeReference) && !(options & ConvertReferenceToPtr))
s << "&";
if (type->isReference() && (options & ConvertReferenceToPtr)) {
s << "*";
}
if (!(options & SkipName))
s << ' ';
}
void ShellGenerator::writeFunctionArguments(QTextStream &s, const AbstractMetaClass* owner,
const AbstractMetaArgumentList &arguments,
Option option,
int numArguments)
{
if (numArguments < 0) numArguments = arguments.size();
for (int i=0; i<numArguments; ++i) {
if (i != 0)
s << ", ";
AbstractMetaArgument *arg = arguments.at(i);
writeTypeInfo(s, arg->type(), option);
if (!(option & SkipName))
s << " " << arg->argumentName();
if ((option & IncludeDefaultExpression) && !arg->originalDefaultValueExpression().isEmpty()) {
s << " = ";
QString expr = arg->originalDefaultValueExpression();
if (expr != "0") {
QString qualifier;
if (arg->type()->typeEntry()->isEnum() && expr.indexOf("::") < 0) {
qualifier = ((EnumTypeEntry *)arg->type()->typeEntry())->qualifier();
} else if (arg->type()->typeEntry()->isFlags() && expr.indexOf("::") < 0) {
qualifier = ((FlagsTypeEntry *)arg->type()->typeEntry())->originator()->qualifier();
}
if (!qualifier.isEmpty()) {
s << qualifier << "::";
}
}
if (expr.contains("defaultConnection")) {
expr.replace("defaultConnection","QSqlDatabase::defaultConnection");
}
if (expr == "MediaSource()") {
expr = "Phonon::MediaSource()";
}
s << expr;
}
}
}
/*!
* Writes the function \a meta_function signature to the textstream \a s.
*
* The \a name_prefix can be used to give the function name a prefix,
* like "__public_" or "__override_" and \a classname_prefix can
* be used to give the class name a prefix.
*
* The \a option flags can be used to tweak various parameters, such as
* showing static, original vs renamed name, underscores for space etc.
*
* The \a extra_arguments list is a list of extra arguments on the
* form "bool static_call".
*/
void ShellGenerator::writeFunctionSignature(QTextStream &s,
const AbstractMetaFunction *meta_function,
const AbstractMetaClass *implementor,
const QString &name_prefix,
Option option,
const QString &classname_prefix,
const QStringList &extra_arguments,
int numArguments)
{
// ### remove the implementor
AbstractMetaType *function_type = meta_function->type();
if ((option & SkipReturnType) == 0) {
if (function_type) {
writeTypeInfo(s, function_type, option);
s << " ";
} else if (!meta_function->isConstructor()) {
s << "void ";
}
}
if (implementor) {
if (classname_prefix.isEmpty())
s << wrapperClassName(implementor) << "::";
else
s << classname_prefix << implementor->name() << "::";
}
QString function_name;
if (option & OriginalName)
function_name = meta_function->originalName();
else
function_name = meta_function->name();
if (option & UnderscoreSpaces)
function_name = function_name.replace(' ', '_');
if (meta_function->isConstructor())
function_name = meta_function->ownerClass()->name();
if (meta_function->isStatic() && (option & ShowStatic)) {
function_name = "static_" + meta_function->ownerClass()->name() + "_" + function_name;
}
if (function_name.startsWith("operator")) {
function_name = meta_function->name();
}
s << name_prefix << function_name;
if (meta_function->attributes() & AbstractMetaAttributes::SetterFunction)
s << "_setter";
else if (meta_function->attributes() & AbstractMetaAttributes::GetterFunction)
s << "_getter";
s << "(";
if ((option & FirstArgIsWrappedObject) && meta_function->ownerClass() && !meta_function->isConstructor() && !meta_function->isStatic()) {
s << meta_function->ownerClass()->qualifiedCppName() << "* theWrappedObject";
if (meta_function->arguments().size() != 0) {
s << ", ";
}
}
writeFunctionArguments(s, meta_function->ownerClass(), meta_function->arguments(), Option(option & Option(~ConvertReferenceToPtr)), numArguments);
// The extra arguments...
for (int i=0; i<extra_arguments.size(); ++i) {
if (i > 0 || meta_function->arguments().size() != 0)
s << ", ";
s << extra_arguments.at(i);
}
s << ")";
if (meta_function->isConstant())
s << " const";
}
AbstractMetaFunctionList ShellGenerator::getFunctionsToWrap(const AbstractMetaClass* meta_class)
{
AbstractMetaFunctionList functions = meta_class->queryFunctions(
AbstractMetaClass::NormalFunctions | AbstractMetaClass::WasPublic
| AbstractMetaClass::NotRemovedFromTargetLang | AbstractMetaClass::ClassImplements
);
AbstractMetaFunctionList functions2 = meta_class->queryFunctions(
AbstractMetaClass::VirtualFunctions | AbstractMetaClass::WasVisible
| AbstractMetaClass::NotRemovedFromTargetLang | AbstractMetaClass::ClassImplements
);
QSet<AbstractMetaFunction*> set1 = QSet<AbstractMetaFunction*>::fromList(functions);
foreach(AbstractMetaFunction* func, functions2) {
set1.insert(func);
}
AbstractMetaFunctionList resultFunctions;
foreach(AbstractMetaFunction* func, set1.toList()) {
if (!func->isAbstract() && func->implementingClass()==meta_class) {
resultFunctions << func;
}
}
return resultFunctions;
}
AbstractMetaFunctionList ShellGenerator::getVirtualFunctionsForShell(const AbstractMetaClass* meta_class)
{
AbstractMetaFunctionList functions = meta_class->queryFunctions(
AbstractMetaClass::VirtualFunctions | AbstractMetaClass::WasVisible
// | AbstractMetaClass::NotRemovedFromTargetLang
);
return functions;
}
AbstractMetaFunctionList ShellGenerator::getProtectedFunctionsThatNeedPromotion(const AbstractMetaClass* meta_class)
{
AbstractMetaFunctionList functions;
AbstractMetaFunctionList functions1 = getFunctionsToWrap(meta_class);
foreach(AbstractMetaFunction* func, functions1) {
if (!func->isPublic() || func->isVirtual()) {
functions << func;
}
}
return functions;
}
/*!
Writes the include defined by \a inc to \a stream.
*/
void ShellGenerator::writeInclude(QTextStream &stream, const Include &inc)
{
if (inc.name.isEmpty())
return;
if (inc.type == Include::TargetLangImport)
return;
stream << "#include ";
if (inc.type == Include::IncludePath)
stream << "<";
else
stream << "\"";
stream << inc.name;
if (inc.type == Include::IncludePath)
stream << ">";
else
stream << "\"";
stream << endl;
}
/*!
Returns true if the given function \a fun is operator>>() or
operator<<() that streams from/to a Q{Data,Text}Stream, false
otherwise.
*/
bool ShellGenerator::isSpecialStreamingOperator(const AbstractMetaFunction *fun)
{
return ((fun->functionType() == AbstractMetaFunction::GlobalScopeFunction)
&& (fun->arguments().size() == 1)
&& (((fun->originalName() == "operator>>") && (fun->modifiedName() == "readFrom"))
|| ((fun->originalName() == "operator<<") && (fun->modifiedName() == "writeTo"))));
}
bool ShellGenerator::isBuiltIn(const QString& name) {
static QSet<QString> builtIn;
if (builtIn.isEmpty()) {
builtIn.insert("Qt");
builtIn.insert("QFont");
builtIn.insert("QPixmap");
builtIn.insert("QBrush");
builtIn.insert("QBitArray");
builtIn.insert("QPalette");
builtIn.insert("QPen");
builtIn.insert("QIcon");
builtIn.insert("QImage");
builtIn.insert("QPolygon");
builtIn.insert("QRegion");
builtIn.insert("QBitmap");
builtIn.insert("QCursor");
builtIn.insert("QColor");
builtIn.insert("QSizePolicy");
builtIn.insert("QKeySequence");
builtIn.insert("QTextLength");
builtIn.insert("QTextFormat");
builtIn.insert("QMatrix");
builtIn.insert("QDate");
builtIn.insert("QTime");
builtIn.insert("QDateTime");
builtIn.insert("QUrl");
builtIn.insert("QLocale");
builtIn.insert("QRect");
builtIn.insert("QRectF");
builtIn.insert("QSize");
builtIn.insert("QSizeF");
builtIn.insert("QLine");
builtIn.insert("QLineF");
builtIn.insert("QPoint");
builtIn.insert("QPointF");
builtIn.insert("QRegExp");
}
return builtIn.contains(name);
}
<commit_msg>added alphabetic sorting<commit_after>/****************************************************************************
**
** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the Qt Script Generator project on Qt Labs.
**
** $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 "shellgenerator.h"
#include "reporthandler.h"
#include "metaqtscript.h"
bool ShellGenerator::shouldGenerate(const AbstractMetaClass *meta_class) const
{
uint cg = meta_class->typeEntry()->codeGeneration();
if (meta_class->name().startsWith("QtScript")) return false;
if (meta_class->name().startsWith("QFuture")) return false;
if (meta_class->name().startsWith("Global")) return false;
if (meta_class->name().startsWith("QStyleOptionComplex")) return false;
if (meta_class->name().startsWith("QTextLayout")) return false;
//if (meta_class->name().startsWith("QTextStream")) return false; // because of >> operators
//if (meta_class->name().startsWith("QDataStream")) return false; // "
return ((cg & TypeEntry::GenerateCode) != 0);
}
void ShellGenerator::writeTypeInfo(QTextStream &s, const AbstractMetaType *type, Option options)
{
if ((options & OriginalTypeDescription) && !type->originalTypeDescription().isEmpty()) {
s << type->originalTypeDescription();
return;
}
if (type->isArray()) {
writeTypeInfo(s, type->arrayElementType(), options);
if (options & ArrayAsPointer) {
s << "*";
} else {
s << "[" << type->arrayElementCount() << "]";
}
return;
}
const TypeEntry *te = type->typeEntry();
if (type->isConstant() && !(options & ExcludeConst))
s << "const ";
if ((options & EnumAsInts) && (te->isEnum() || te->isFlags())) {
s << "int";
} else if (te->isFlags()) {
s << ((FlagsTypeEntry *) te)->originalName();
} else {
s << fixCppTypeName(te->qualifiedCppName());
}
if (type->instantiations().size() > 0
&& (!type->isContainer()
|| (static_cast<const ContainerTypeEntry *>(te))->type() != ContainerTypeEntry::StringListContainer)) {
s << '<';
QList<AbstractMetaType *> args = type->instantiations();
bool nested_template = false;
for (int i=0; i<args.size(); ++i) {
if (i != 0)
s << ", ";
nested_template |= args.at(i)->isContainer();
writeTypeInfo(s, args.at(i));
}
if (nested_template)
s << ' ';
s << '>';
}
s << QString(type->indirections(), '*');
if (type->isReference() && !(options & ExcludeReference) && !(options & ConvertReferenceToPtr))
s << "&";
if (type->isReference() && (options & ConvertReferenceToPtr)) {
s << "*";
}
if (!(options & SkipName))
s << ' ';
}
void ShellGenerator::writeFunctionArguments(QTextStream &s, const AbstractMetaClass* owner,
const AbstractMetaArgumentList &arguments,
Option option,
int numArguments)
{
if (numArguments < 0) numArguments = arguments.size();
for (int i=0; i<numArguments; ++i) {
if (i != 0)
s << ", ";
AbstractMetaArgument *arg = arguments.at(i);
writeTypeInfo(s, arg->type(), option);
if (!(option & SkipName))
s << " " << arg->argumentName();
if ((option & IncludeDefaultExpression) && !arg->originalDefaultValueExpression().isEmpty()) {
s << " = ";
QString expr = arg->originalDefaultValueExpression();
if (expr != "0") {
QString qualifier;
if (arg->type()->typeEntry()->isEnum() && expr.indexOf("::") < 0) {
qualifier = ((EnumTypeEntry *)arg->type()->typeEntry())->qualifier();
} else if (arg->type()->typeEntry()->isFlags() && expr.indexOf("::") < 0) {
qualifier = ((FlagsTypeEntry *)arg->type()->typeEntry())->originator()->qualifier();
}
if (!qualifier.isEmpty()) {
s << qualifier << "::";
}
}
if (expr.contains("defaultConnection")) {
expr.replace("defaultConnection","QSqlDatabase::defaultConnection");
}
if (expr == "MediaSource()") {
expr = "Phonon::MediaSource()";
}
s << expr;
}
}
}
/*!
* Writes the function \a meta_function signature to the textstream \a s.
*
* The \a name_prefix can be used to give the function name a prefix,
* like "__public_" or "__override_" and \a classname_prefix can
* be used to give the class name a prefix.
*
* The \a option flags can be used to tweak various parameters, such as
* showing static, original vs renamed name, underscores for space etc.
*
* The \a extra_arguments list is a list of extra arguments on the
* form "bool static_call".
*/
void ShellGenerator::writeFunctionSignature(QTextStream &s,
const AbstractMetaFunction *meta_function,
const AbstractMetaClass *implementor,
const QString &name_prefix,
Option option,
const QString &classname_prefix,
const QStringList &extra_arguments,
int numArguments)
{
// ### remove the implementor
AbstractMetaType *function_type = meta_function->type();
if ((option & SkipReturnType) == 0) {
if (function_type) {
writeTypeInfo(s, function_type, option);
s << " ";
} else if (!meta_function->isConstructor()) {
s << "void ";
}
}
if (implementor) {
if (classname_prefix.isEmpty())
s << wrapperClassName(implementor) << "::";
else
s << classname_prefix << implementor->name() << "::";
}
QString function_name;
if (option & OriginalName)
function_name = meta_function->originalName();
else
function_name = meta_function->name();
if (option & UnderscoreSpaces)
function_name = function_name.replace(' ', '_');
if (meta_function->isConstructor())
function_name = meta_function->ownerClass()->name();
if (meta_function->isStatic() && (option & ShowStatic)) {
function_name = "static_" + meta_function->ownerClass()->name() + "_" + function_name;
}
if (function_name.startsWith("operator")) {
function_name = meta_function->name();
}
s << name_prefix << function_name;
if (meta_function->attributes() & AbstractMetaAttributes::SetterFunction)
s << "_setter";
else if (meta_function->attributes() & AbstractMetaAttributes::GetterFunction)
s << "_getter";
s << "(";
if ((option & FirstArgIsWrappedObject) && meta_function->ownerClass() && !meta_function->isConstructor() && !meta_function->isStatic()) {
s << meta_function->ownerClass()->qualifiedCppName() << "* theWrappedObject";
if (meta_function->arguments().size() != 0) {
s << ", ";
}
}
writeFunctionArguments(s, meta_function->ownerClass(), meta_function->arguments(), Option(option & Option(~ConvertReferenceToPtr)), numArguments);
// The extra arguments...
for (int i=0; i<extra_arguments.size(); ++i) {
if (i > 0 || meta_function->arguments().size() != 0)
s << ", ";
s << extra_arguments.at(i);
}
s << ")";
if (meta_function->isConstant())
s << " const";
}
AbstractMetaFunctionList ShellGenerator::getFunctionsToWrap(const AbstractMetaClass* meta_class)
{
AbstractMetaFunctionList functions = meta_class->queryFunctions(
AbstractMetaClass::NormalFunctions | AbstractMetaClass::WasPublic
| AbstractMetaClass::NotRemovedFromTargetLang | AbstractMetaClass::ClassImplements
);
AbstractMetaFunctionList functions2 = meta_class->queryFunctions(
AbstractMetaClass::VirtualFunctions | AbstractMetaClass::WasVisible
| AbstractMetaClass::NotRemovedFromTargetLang | AbstractMetaClass::ClassImplements
);
QSet<AbstractMetaFunction*> set1 = QSet<AbstractMetaFunction*>::fromList(functions);
foreach(AbstractMetaFunction* func, functions2) {
set1.insert(func);
}
AbstractMetaFunctionList resultFunctions;
foreach(AbstractMetaFunction* func, set1.toList()) {
if (!func->isAbstract() && func->implementingClass()==meta_class) {
resultFunctions << func;
}
}
qStableSort(resultFunctions);
return resultFunctions;
}
AbstractMetaFunctionList ShellGenerator::getVirtualFunctionsForShell(const AbstractMetaClass* meta_class)
{
AbstractMetaFunctionList functions = meta_class->queryFunctions(
AbstractMetaClass::VirtualFunctions | AbstractMetaClass::WasVisible
// | AbstractMetaClass::NotRemovedFromTargetLang
);
qStableSort(functions);
return functions;
}
AbstractMetaFunctionList ShellGenerator::getProtectedFunctionsThatNeedPromotion(const AbstractMetaClass* meta_class)
{
AbstractMetaFunctionList functions;
AbstractMetaFunctionList functions1 = getFunctionsToWrap(meta_class);
foreach(AbstractMetaFunction* func, functions1) {
if (!func->isPublic() || func->isVirtual()) {
functions << func;
}
}
qStableSort(functions);
return functions;
}
/*!
Writes the include defined by \a inc to \a stream.
*/
void ShellGenerator::writeInclude(QTextStream &stream, const Include &inc)
{
if (inc.name.isEmpty())
return;
if (inc.type == Include::TargetLangImport)
return;
stream << "#include ";
if (inc.type == Include::IncludePath)
stream << "<";
else
stream << "\"";
stream << inc.name;
if (inc.type == Include::IncludePath)
stream << ">";
else
stream << "\"";
stream << endl;
}
/*!
Returns true if the given function \a fun is operator>>() or
operator<<() that streams from/to a Q{Data,Text}Stream, false
otherwise.
*/
bool ShellGenerator::isSpecialStreamingOperator(const AbstractMetaFunction *fun)
{
return ((fun->functionType() == AbstractMetaFunction::GlobalScopeFunction)
&& (fun->arguments().size() == 1)
&& (((fun->originalName() == "operator>>") && (fun->modifiedName() == "readFrom"))
|| ((fun->originalName() == "operator<<") && (fun->modifiedName() == "writeTo"))));
}
bool ShellGenerator::isBuiltIn(const QString& name) {
static QSet<QString> builtIn;
if (builtIn.isEmpty()) {
builtIn.insert("Qt");
builtIn.insert("QFont");
builtIn.insert("QPixmap");
builtIn.insert("QBrush");
builtIn.insert("QBitArray");
builtIn.insert("QPalette");
builtIn.insert("QPen");
builtIn.insert("QIcon");
builtIn.insert("QImage");
builtIn.insert("QPolygon");
builtIn.insert("QRegion");
builtIn.insert("QBitmap");
builtIn.insert("QCursor");
builtIn.insert("QColor");
builtIn.insert("QSizePolicy");
builtIn.insert("QKeySequence");
builtIn.insert("QTextLength");
builtIn.insert("QTextFormat");
builtIn.insert("QMatrix");
builtIn.insert("QDate");
builtIn.insert("QTime");
builtIn.insert("QDateTime");
builtIn.insert("QUrl");
builtIn.insert("QLocale");
builtIn.insert("QRect");
builtIn.insert("QRectF");
builtIn.insert("QSize");
builtIn.insert("QSizeF");
builtIn.insert("QLine");
builtIn.insert("QLineF");
builtIn.insert("QPoint");
builtIn.insert("QPointF");
builtIn.insert("QRegExp");
}
return builtIn.contains(name);
}
<|endoftext|> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.