text
stringlengths 54
60.6k
|
|---|
<commit_before>#ifndef KGR_INCLUDE_KANGARU_GENERIC_HPP
#define KGR_INCLUDE_KANGARU_GENERIC_HPP
#include "container.hpp"
#include "detail/injected.hpp"
#include "detail/function_traits.hpp"
namespace kgr {
template<typename CRTP, typename Type>
struct GenericService {
friend struct Container;
using Self = CRTP;
GenericService() = default;
GenericService(GenericService&& other) {
emplace(std::move(other.getInstance()));
}
GenericService& operator=(GenericService&& other) {
emplace(std::move(other.getInstance()));
return *this;
}
GenericService(const GenericService& other) {
emplace(other.getInstance());
}
GenericService& operator=(const GenericService& other) {
emplace(other.getInstance());
return *this;
}
template<typename... Args, detail::enable_if_t<detail::is_someway_constructible<Type, Args...>::value, int> = 0>
GenericService(in_place_t, Args&&... args) {
emplace(std::forward<Args>(args)...);
}
~GenericService() {
getInstance().~Type();
}
protected:
template<typename F, typename... Ts>
void autocall(Inject<Ts>... others) {
CRTP::call(getInstance(), F::value, std::forward<Inject<Ts>>(others).forward()...);
}
template<typename F, template<typename> class Map>
void autocall(Inject<ContainerService> cs) {
autocall<Map, F>(detail::tuple_seq<detail::function_arguments_t<typename F::value_type>>{}, std::move(cs));
}
Type& getInstance() {
return *reinterpret_cast<Type*>(&_instance);
}
const Type& getInstance() const {
return *reinterpret_cast<const Type*>(&_instance);
}
private:
template<typename... Args, detail::enable_if_t<std::is_constructible<Type, Args...>::value, int> = 0>
void emplace(Args&&... args) {
new (&_instance) Type(std::forward<Args>(args)...);
}
template<typename... Args, detail::enable_if_t<!std::is_constructible<Type, Args...>::value && detail::is_brace_constructible<Type, Args...>::value, int> = 0>
void emplace(Args&&... args) {
new (&_instance) Type{std::forward<Args>(args)...};
}
template<template<typename> class Map, typename F, std::size_t... S>
void autocall(detail::seq<S...>, Inject<ContainerService> cs) {
cs.forward().invoke<Map>([this](detail::function_argument_t<S, typename F::value_type>... args){
CRTP::call(getInstance(), F::value, std::forward<detail::function_argument_t<S, typename F::value_type>>(args)...);
});
}
typename std::aligned_storage<sizeof(Type), alignof(Type)>::type _instance;
};
} // namespace kgr
#endif // KGR_INCLUDE_KANGARU_GENERIC_HPP
<commit_msg>make autocall private<commit_after>#ifndef KGR_INCLUDE_KANGARU_GENERIC_HPP
#define KGR_INCLUDE_KANGARU_GENERIC_HPP
#include "container.hpp"
#include "detail/injected.hpp"
#include "detail/function_traits.hpp"
namespace kgr {
template<typename CRTP, typename Type>
struct GenericService {
friend struct Container;
using Self = CRTP;
GenericService() = default;
GenericService(GenericService&& other) {
emplace(std::move(other.getInstance()));
}
GenericService& operator=(GenericService&& other) {
emplace(std::move(other.getInstance()));
return *this;
}
GenericService(const GenericService& other) {
emplace(other.getInstance());
}
GenericService& operator=(const GenericService& other) {
emplace(other.getInstance());
return *this;
}
template<typename... Args, detail::enable_if_t<detail::is_someway_constructible<Type, Args...>::value, int> = 0>
GenericService(in_place_t, Args&&... args) {
emplace(std::forward<Args>(args)...);
}
~GenericService() {
getInstance().~Type();
}
protected:
Type& getInstance() {
return *reinterpret_cast<Type*>(&_instance);
}
const Type& getInstance() const {
return *reinterpret_cast<const Type*>(&_instance);
}
private:
template<typename... Args, detail::enable_if_t<std::is_constructible<Type, Args...>::value, int> = 0>
void emplace(Args&&... args) {
new (&_instance) Type(std::forward<Args>(args)...);
}
template<typename... Args, detail::enable_if_t<!std::is_constructible<Type, Args...>::value && detail::is_brace_constructible<Type, Args...>::value, int> = 0>
void emplace(Args&&... args) {
new (&_instance) Type{std::forward<Args>(args)...};
}
template<typename F, typename... Ts>
void autocall(Inject<Ts>... others) {
CRTP::call(getInstance(), F::value, std::forward<Inject<Ts>>(others).forward()...);
}
template<typename F, template<typename> class Map>
void autocall(Inject<ContainerService> cs) {
autocall<Map, F>(detail::tuple_seq<detail::function_arguments_t<typename F::value_type>>{}, std::move(cs));
}
template<template<typename> class Map, typename F, std::size_t... S>
void autocall(detail::seq<S...>, Inject<ContainerService> cs) {
cs.forward().invoke<Map>([this](detail::function_argument_t<S, typename F::value_type>... args){
CRTP::call(getInstance(), F::value, std::forward<detail::function_argument_t<S, typename F::value_type>>(args)...);
});
}
typename std::aligned_storage<sizeof(Type), alignof(Type)>::type _instance;
};
} // namespace kgr
#endif // KGR_INCLUDE_KANGARU_GENERIC_HPP
<|endoftext|>
|
<commit_before>/*
* Copyright (C) 2008-2011, Gostai S.A.S.
*
* This software is provided "as is" without warranty of any kind,
* either expressed or implied, including but not limited to the
* implied warranties of fitness for a particular purpose.
*
* See the LICENSE file for more information.
*/
/// \file libport/compiler.hh
/// \brief Specific features from some compilers.
#ifndef LIBPORT_COMPILER_HH
# define LIBPORT_COMPILER_HH
# include <libport/config.h>
# include <libport/preproc.hh>
# define GCC_VERSION_GE(Major, Minor) \
(defined __GNUC__ \
&& (Major < __GNUC__ \
|| Major == __GNUC__ && Minor <= __GNUC_MINOR__))
/*----------------.
| __attribute__. |
`----------------*/
/* This feature is available in gcc versions 2.5 and later. */
# if !defined __attribute__ && (defined _MSC_VER || ! GCC_VERSION_GE(2, 5))
# define __attribute__(Spec) /* empty */
# endif
/*--------------------------------.
| ATTRIBUTE_DLLEXPORT/DLLIMPORT. |
`--------------------------------*/
// GCC 3 does not seem to support visibility, and generates tons of
// annoying error messages.
# if GCC_VERSION_GE(4, 0)
# define ATTRIBUTE_DLLEXPORT __attribute__((visibility("default")))
# define ATTRIBUTE_DLLIMPORT ATTRIBUTE_DLLEXPORT
# elif defined _MSC_VER && ! defined STATIC_BUILD
# define ATTRIBUTE_DLLEXPORT __declspec(dllexport)
# define ATTRIBUTE_DLLIMPORT __declspec(dllimport)
# else
# define ATTRIBUTE_DLLEXPORT
# define ATTRIBUTE_DLLIMPORT
# endif
/*--------------.
| ATTRIBUTE_*. |
`--------------*/
# if __GNUC__
// GCC 3.4 does not support "always_inline" without "inline".
# define ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
# define ATTRIBUTE_CONST __attribute__((const))
# define ATTRIBUTE_DEPRECATED __attribute__((deprecated))
# define ATTRIBUTE_MALLOC __attribute__((malloc))
# define ATTRIBUTE_NOINLINE __attribute__((noinline))
# define ATTRIBUTE_NORETURN __attribute__((noreturn))
# define ATTRIBUTE_NOTHROW __attribute__((nothrow))
/// Declare a function whose features printf-like arguments.
/// \param Format the number of the printf-like format string.
/// First argument is numbered 1, not 0.
/// In a class, argument 1 is "this", so first visible
/// argument is 2.
/// \param FirstArg The number of the first varargs. Should point to
/// the "..." in the argument list.
# define ATTRIBUTE_PRINTF(Format, FirstArg) \
__attribute__((format(printf, Format, FirstArg)))
# define ATTRIBUTE_PURE __attribute__((pure))
// Only on i386 architectures. Left undefined on purpose for other
// architectures.
# if defined __i386__
# define ATTRIBUTE_STDCALL __attribute__((stdcall))
# endif
# define ATTRIBUTE_UNUSED_RESULT __attribute__((warn_unused_result))
# define ATTRIBUTE_USED __attribute__((used))
# endif
# ifdef _MSC_VER
# define ATTRIBUTE_ALWAYS_INLINE __forceinline
# define ATTRIBUTE_CONST
# define ATTRIBUTE_DEPRECATED __declspec(deprecated)
# define ATTRIBUTE_MALLOC
# define ATTRIBUTE_NOINLINE __declspec(noinline)
# define ATTRIBUTE_NORETURN __declspec(noreturn)
# define ATTRIBUTE_NOTHROW __declspec(nothrow)
# define ATTRIBUTE_PRINTF(Format, FirstArg)
# define ATTRIBUTE_PURE
# define ATTRIBUTE_STDCALL __stdcall
# define ATTRIBUTE_UNUSED_RESULT
# define ATTRIBUTE_USED
# endif // _MSC_VER
/*---------------------------.
| ATTRIBUTE_NOTHROW in C++. |
`---------------------------*/
// For throw() vs. nothrow, see
// http://www.nabble.com/Rest-of-trivial-decorations-td23114765.html
# ifdef __cplusplus
# undef ATTRIBUTE_NOTHROW
# define ATTRIBUTE_NOTHROW throw()
# endif
/*---------------------.
| ATTRIBUTE_COLD/HOT. |
`---------------------*/
// Suggests the compiler that path executing the function annotated with one
// of the following attributes is either unlikely to be executed (cold) or
// likely to be executed (hot). It is hard to determine which functions are
// hot, but cold function can be identified because they handle error,
// fallbacks and that they will never be called in a normal running process.
# if GCC_VERSION_GE(4, 3)
# define ATTRIBUTE_COLD __attribute__((cold))
# define ATTRIBUTE_HOT __attribute__((hot))
# else
# define ATTRIBUTE_COLD
# define ATTRIBUTE_HOT
# endif
/*--------------.
| LIBPORT_NOP. |
`--------------*/
// A no-op for macros that should expand to nothing, but not result in
// warnings such as "warning: empty body in an if-statement".
# define LIBPORT_NOP \
((void) 0)
/*------------------.
| LIBPORT_SECTION. |
`------------------*/
// Each section must be pre-declared with its access rights, to do so,
// include compiler-section.hh.
# ifdef _MSC_VER
# define LIBPORT_SECTION(Name) __declspec(allocate(#Name))
# else
# define LIBPORT_SECTION(Name) __attribute__((section(#Name)))
# endif
/*--------------.
| LIBPORT_USE. |
`--------------*/
// Declare that variables/arguments are used.
//
// LIBPORT_USE(Var1, Var2)
# define LIBPORT_USE(...) \
do { \
BOOST_PP_SEQ_FOR_EACH(LIBPORT_USE_, , \
LIBPORT_LIST(__VA_ARGS__,)) \
} while (false)
# define LIBPORT_USE_(_, __, Var) \
(void) Var;
/*-------------------.
| likely, unlikely. |
`-------------------*/
// Instrumentation of conditionnal values. (hand made profiling)
//
// if (unlikely(condition))
// {
// // Handle fallback, errors and this will never be executed in a
// // normal running process.
// }
# if GCC_VERSION_GE(4, 3)
# define unlikely(expr) __builtin_expect (!!(expr), 0)
# define likely(expr) __builtin_expect (!!(expr), 1)
# else
# define unlikely(expr) expr
# define likely(expr) expr
# endif
/*----------------------.
| __PRETTY_FUNCTION__. |
`----------------------*/
// __PRETTY_FUNCTION__ is a GNU extension. MSVC has something somewhat
// similar although it's less pretty.
# ifdef _MSC_VER
# define __PRETTY_FUNCTION__ __FUNCTION__
# endif // _MSC_VER
#endif // !LIBPORT_COMPILER_HH
<commit_msg>Libport.Compiler: disable ATTRIBUTE_* macros for SWIG.<commit_after>/*
* Copyright (C) 2008-2011, Gostai S.A.S.
*
* This software is provided "as is" without warranty of any kind,
* either expressed or implied, including but not limited to the
* implied warranties of fitness for a particular purpose.
*
* See the LICENSE file for more information.
*/
/// \file libport/compiler.hh
/// \brief Specific features from some compilers.
#ifndef LIBPORT_COMPILER_HH
# define LIBPORT_COMPILER_HH
# include <libport/config.h>
# include <libport/preproc.hh>
# define GCC_VERSION_GE(Major, Minor) \
(defined __GNUC__ \
&& (Major < __GNUC__ \
|| Major == __GNUC__ && Minor <= __GNUC_MINOR__))
/*----------------.
| __attribute__. |
`----------------*/
/* This feature is available in gcc versions 2.5 and later. */
# if !defined __attribute__ && (defined _MSC_VER || ! GCC_VERSION_GE(2, 5))
# define __attribute__(Spec) /* empty */
# endif
/*--------------------------------.
| ATTRIBUTE_DLLEXPORT/DLLIMPORT. |
`--------------------------------*/
// GCC 3 does not seem to support visibility, and generates tons of
// annoying error messages.
# if GCC_VERSION_GE(4, 0)
# define ATTRIBUTE_DLLEXPORT __attribute__((visibility("default")))
# define ATTRIBUTE_DLLIMPORT ATTRIBUTE_DLLEXPORT
# elif defined _MSC_VER && ! defined STATIC_BUILD
# define ATTRIBUTE_DLLEXPORT __declspec(dllexport)
# define ATTRIBUTE_DLLIMPORT __declspec(dllimport)
# else
# define ATTRIBUTE_DLLEXPORT
# define ATTRIBUTE_DLLIMPORT
# endif
/*--------------.
| ATTRIBUTE_*. |
`--------------*/
# if __GNUC__
// GCC 3.4 does not support "always_inline" without "inline".
# define ATTRIBUTE_ALWAYS_INLINE inline __attribute__((always_inline))
# define ATTRIBUTE_CONST __attribute__((const))
# define ATTRIBUTE_DEPRECATED __attribute__((deprecated))
# define ATTRIBUTE_MALLOC __attribute__((malloc))
# define ATTRIBUTE_NOINLINE __attribute__((noinline))
# define ATTRIBUTE_NORETURN __attribute__((noreturn))
# define ATTRIBUTE_NOTHROW __attribute__((nothrow))
/// Declare a function whose features printf-like arguments.
/// \param Format the number of the printf-like format string.
/// First argument is numbered 1, not 0.
/// In a class, argument 1 is "this", so first visible
/// argument is 2.
/// \param FirstArg The number of the first varargs. Should point to
/// the "..." in the argument list.
# define ATTRIBUTE_PRINTF(Format, FirstArg) \
__attribute__((format(printf, Format, FirstArg)))
# define ATTRIBUTE_PURE __attribute__((pure))
// Only on i386 architectures. Left undefined on purpose for other
// architectures.
# if defined __i386__
# define ATTRIBUTE_STDCALL __attribute__((stdcall))
# endif
# define ATTRIBUTE_UNUSED_RESULT __attribute__((warn_unused_result))
# define ATTRIBUTE_USED __attribute__((used))
# elif defined _MSC_VER
# define ATTRIBUTE_ALWAYS_INLINE __forceinline
# define ATTRIBUTE_CONST
# define ATTRIBUTE_DEPRECATED __declspec(deprecated)
# define ATTRIBUTE_MALLOC
# define ATTRIBUTE_NOINLINE __declspec(noinline)
# define ATTRIBUTE_NORETURN __declspec(noreturn)
# define ATTRIBUTE_NOTHROW __declspec(nothrow)
# define ATTRIBUTE_PRINTF(Format, FirstArg)
# define ATTRIBUTE_PURE
# define ATTRIBUTE_STDCALL __stdcall
# define ATTRIBUTE_UNUSED_RESULT
# define ATTRIBUTE_USED
# else // !__GNUC__ && !_MSC_VER, e.g., Swig.
# define ATTRIBUTE_ALWAYS_INLINE
# define ATTRIBUTE_CONST
# define ATTRIBUTE_DEPRECATED
# define ATTRIBUTE_MALLOC
# define ATTRIBUTE_NOINLINE
# define ATTRIBUTE_NORETURN
# define ATTRIBUTE_NOTHROW
# define ATTRIBUTE_PRINTF(Format, FirstArg)
# define ATTRIBUTE_PURE
# define ATTRIBUTE_STDCALL
# define ATTRIBUTE_UNUSED_RESULT
# define ATTRIBUTE_USED
# endif
/*---------------------------.
| ATTRIBUTE_NOTHROW in C++. |
`---------------------------*/
// For throw() vs. nothrow, see
// http://www.nabble.com/Rest-of-trivial-decorations-td23114765.html
# ifdef __cplusplus
# undef ATTRIBUTE_NOTHROW
# define ATTRIBUTE_NOTHROW throw()
# endif
/*---------------------.
| ATTRIBUTE_COLD/HOT. |
`---------------------*/
// Suggests the compiler that path executing the function annotated with one
// of the following attributes is either unlikely to be executed (cold) or
// likely to be executed (hot). It is hard to determine which functions are
// hot, but cold function can be identified because they handle error,
// fallbacks and that they will never be called in a normal running process.
# if GCC_VERSION_GE(4, 3)
# define ATTRIBUTE_COLD __attribute__((cold))
# define ATTRIBUTE_HOT __attribute__((hot))
# else
# define ATTRIBUTE_COLD
# define ATTRIBUTE_HOT
# endif
/*--------------.
| LIBPORT_NOP. |
`--------------*/
// A no-op for macros that should expand to nothing, but not result in
// warnings such as "warning: empty body in an if-statement".
# define LIBPORT_NOP \
((void) 0)
/*------------------.
| LIBPORT_SECTION. |
`------------------*/
// Each section must be pre-declared with its access rights, to do so,
// include compiler-section.hh.
# ifdef _MSC_VER
# define LIBPORT_SECTION(Name) __declspec(allocate(#Name))
# else
# define LIBPORT_SECTION(Name) __attribute__((section(#Name)))
# endif
/*--------------.
| LIBPORT_USE. |
`--------------*/
// Declare that variables/arguments are used.
//
// LIBPORT_USE(Var1, Var2)
# define LIBPORT_USE(...) \
do { \
BOOST_PP_SEQ_FOR_EACH(LIBPORT_USE_, , \
LIBPORT_LIST(__VA_ARGS__,)) \
} while (false)
# define LIBPORT_USE_(_, __, Var) \
(void) Var;
/*-------------------.
| likely, unlikely. |
`-------------------*/
// Instrumentation of conditionnal values. (hand made profiling)
//
// if (unlikely(condition))
// {
// // Handle fallback, errors and this will never be executed in a
// // normal running process.
// }
# if GCC_VERSION_GE(4, 3)
# define unlikely(expr) __builtin_expect (!!(expr), 0)
# define likely(expr) __builtin_expect (!!(expr), 1)
# else
# define unlikely(expr) expr
# define likely(expr) expr
# endif
/*----------------------.
| __PRETTY_FUNCTION__. |
`----------------------*/
// __PRETTY_FUNCTION__ is a GNU extension. MSVC has something somewhat
// similar although it's less pretty.
# ifdef _MSC_VER
# define __PRETTY_FUNCTION__ __FUNCTION__
# endif // _MSC_VER
#endif // !LIBPORT_COMPILER_HH
<|endoftext|>
|
<commit_before>/*
Copyright (c) 2007-2013, 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.
*/
#ifndef TORRENT_UPNP_HPP
#define TORRENT_UPNP_HPP
#include "libtorrent/socket.hpp"
#include "libtorrent/error_code.hpp"
#include "libtorrent/broadcast_socket.hpp"
#include "libtorrent/http_connection.hpp"
#include "libtorrent/connection_queue.hpp"
#include "libtorrent/intrusive_ptr_base.hpp"
#include "libtorrent/thread.hpp"
#include "libtorrent/deadline_timer.hpp"
#include <boost/function/function1.hpp>
#include <boost/function/function4.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <set>
#if defined(TORRENT_UPNP_LOGGING)
#include <fstream>
#endif
namespace libtorrent
{
namespace upnp_errors
{
// error codes for the upnp_error_category. They hold error codes
// returned by UPnP routers when mapping ports
enum error_code_enum
{
// No error
no_error = 0,
// One of the arguments in the request is invalid
invalid_argument = 402,
// The request failed
action_failed = 501,
// The specified value does not exist in the array
value_not_in_array = 714,
// The source IP address cannot be wild-carded, but
// must be fully specified
source_ip_cannot_be_wildcarded = 715,
// The external port cannot be wildcarded, but must
// be specified
external_port_cannot_be_wildcarded = 716,
// The port mapping entry specified conflicts with a
// mapping assigned previously to another client
port_mapping_conflict = 718,
// Internal and external port value must be the same
internal_port_must_match_external = 724,
// The NAT implementation only supports permanent
// lease times on port mappings
only_permanent_leases_supported = 725,
// RemoteHost must be a wildcard and cannot be a
// specific IP addres or DNS name
remote_host_must_be_wildcard = 726,
// ExternalPort must be a wildcard and cannot be a
// specific port
external_port_must_be_wildcard = 727
};
}
boost::system::error_category& get_upnp_category();
// int: port-mapping index
// address: external address as queried from router
// int: external port
// std::string: error message
// an empty string as error means success
// a port-mapping index of -1 means it's
// an informational log message
typedef boost::function<void(int, address, int, error_code const&)> portmap_callback_t;
typedef boost::function<void(char const*)> log_callback_t;
// TODO: support using the windows API for UPnP operations as well
class TORRENT_EXTRA_EXPORT upnp : public intrusive_ptr_base<upnp>
{
public:
upnp(io_service& ios, connection_queue& cc
, address const& listen_interface, std::string const& user_agent
, portmap_callback_t const& cb, log_callback_t const& lcb
, bool ignore_nonrouters, void* state = 0);
~upnp();
void* drain_state();
enum protocol_type { none = 0, udp = 1, tcp = 2 };
// Attempts to add a port mapping for the specified protocol. Valid protocols are
// ``upnp::tcp`` and ``upnp::udp`` for the UPnP class and ``natpmp::tcp`` and
// ``natpmp::udp`` for the NAT-PMP class.
//
// ``external_port`` is the port on the external address that will be mapped. This
// is a hint, you are not guaranteed that this port will be available, and it may
// end up being something else. In the portmap_alert_ notification, the actual
// external port is reported.
//
// ``local_port`` is the port in the local machine that the mapping should forward
// to.
//
// The return value is an index that identifies this port mapping. This is used
// to refer to mappings that fails or succeeds in the portmap_error_alert_ and
// portmap_alert_ respectively. If The mapping fails immediately, the return value
// is -1, which means failure. There will not be any error alert notification for
// mappings that fail with a -1 return value.
int add_mapping(protocol_type p, int external_port, int local_port);
// This function removes a port mapping. ``mapping_index`` is the index that refers
// to the mapping you want to remove, which was returned from add_mapping().
void delete_mapping(int mapping_index);
bool get_mapping(int mapping_index, int& local_port, int& external_port, int& protocol) const;
void discover_device();
void close();
// This is only available for UPnP routers. If the model is advertized by
// the router, it can be queried through this function.
std::string router_model()
{
mutex::scoped_lock l(m_mutex);
return m_model;
}
private:
void discover_device_impl(mutex::scoped_lock& l);
static address_v4 upnp_multicast_address;
static udp::endpoint upnp_multicast_endpoint;
// there are routers that's don't support timed
// port maps, without returning error 725. It seems
// safer to always assume that we have to ask for
// permanent leases
enum { default_lease_time = 0 };
void resend_request(error_code const& e);
void on_reply(udp::endpoint const& from, char* buffer
, std::size_t bytes_transferred);
struct rootdevice;
void next(rootdevice& d, int i, mutex::scoped_lock& l);
void update_map(rootdevice& d, int i, mutex::scoped_lock& l);
void on_upnp_xml(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, http_connection& c);
void on_upnp_get_ip_address_response(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, http_connection& c);
void on_upnp_map_response(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, int mapping, http_connection& c);
void on_upnp_unmap_response(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, int mapping, http_connection& c);
void on_expire(error_code const& e);
void disable(error_code const& ec, mutex::scoped_lock& l);
void return_error(int mapping, int code, mutex::scoped_lock& l);
void log(char const* msg, mutex::scoped_lock& l);
void get_ip_address(rootdevice& d);
void delete_port_mapping(rootdevice& d, int i);
void create_port_mapping(http_connection& c, rootdevice& d, int i);
void post(upnp::rootdevice const& d, char const* soap
, char const* soap_action, mutex::scoped_lock& l);
int num_mappings() const { return int(m_mappings.size()); }
struct global_mapping_t
{
global_mapping_t()
: protocol(none)
, external_port(0)
, local_port(0)
{}
int protocol;
int external_port;
int local_port;
};
struct mapping_t
{
enum action_t { action_none, action_add, action_delete };
mapping_t()
: action(action_none)
, local_port(0)
, external_port(0)
, protocol(none)
, failcount(0)
{}
// the time the port mapping will expire
ptime expires;
int action;
// the local port for this mapping. If this is set
// to 0, the mapping is not in use
int local_port;
// the external (on the NAT router) port
// for the mapping. This is the port we
// should announce to others
int external_port;
// 2 = udp, 1 = tcp
int protocol;
// the number of times this mapping has failed
int failcount;
};
struct rootdevice
{
rootdevice(): service_namespace(0)
, port(0)
, lease_duration(default_lease_time)
, supports_specific_external(true)
, disabled(false)
{
#if TORRENT_USE_ASSERTS
magic = 1337;
#endif
}
#if TORRENT_USE_ASSERTS
~rootdevice()
{
TORRENT_ASSERT(magic == 1337);
magic = 0;
}
#endif
// the interface url, through which the list of
// supported interfaces are fetched
std::string url;
// the url to the WANIP or WANPPP interface
std::string control_url;
// either the WANIP namespace or the WANPPP namespace
char const* service_namespace;
std::vector<mapping_t> mapping;
// this is the hostname, port and path
// component of the url or the control_url
// if it has been found
std::string hostname;
int port;
std::string path;
address external_ip;
int lease_duration;
// true if the device supports specifying a
// specific external port, false if it doesn't
bool supports_specific_external;
bool disabled;
mutable boost::shared_ptr<http_connection> upnp_connection;
#if TORRENT_USE_ASSERTS
int magic;
#endif
void close() const
{
TORRENT_ASSERT(magic == 1337);
if (!upnp_connection) return;
upnp_connection->close();
upnp_connection.reset();
}
bool operator<(rootdevice const& rhs) const
{ return url < rhs.url; }
};
struct upnp_state_t
{
std::vector<global_mapping_t> mappings;
std::set<rootdevice> devices;
};
std::vector<global_mapping_t> m_mappings;
std::string const& m_user_agent;
// the set of devices we've found
std::set<rootdevice> m_devices;
portmap_callback_t m_callback;
log_callback_t m_log_callback;
// current retry count
int m_retry_count;
io_service& m_io_service;
// the udp socket used to send and receive
// multicast messages on the network
broadcast_socket m_socket;
// used to resend udp packets in case
// they time out
deadline_timer m_broadcast_timer;
// timer used to refresh mappings
deadline_timer m_refresh_timer;
bool m_disabled;
bool m_closing;
bool m_ignore_non_routers;
connection_queue& m_cc;
mutex m_mutex;
std::string m_model;
};
}
#endif
<commit_msg>fix export of upnp error category function<commit_after>/*
Copyright (c) 2007-2013, 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.
*/
#ifndef TORRENT_UPNP_HPP
#define TORRENT_UPNP_HPP
#include "libtorrent/socket.hpp"
#include "libtorrent/error_code.hpp"
#include "libtorrent/broadcast_socket.hpp"
#include "libtorrent/http_connection.hpp"
#include "libtorrent/connection_queue.hpp"
#include "libtorrent/intrusive_ptr_base.hpp"
#include "libtorrent/thread.hpp"
#include "libtorrent/deadline_timer.hpp"
#include <boost/function/function1.hpp>
#include <boost/function/function4.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <set>
#if defined(TORRENT_UPNP_LOGGING)
#include <fstream>
#endif
namespace libtorrent
{
namespace upnp_errors
{
// error codes for the upnp_error_category. They hold error codes
// returned by UPnP routers when mapping ports
enum error_code_enum
{
// No error
no_error = 0,
// One of the arguments in the request is invalid
invalid_argument = 402,
// The request failed
action_failed = 501,
// The specified value does not exist in the array
value_not_in_array = 714,
// The source IP address cannot be wild-carded, but
// must be fully specified
source_ip_cannot_be_wildcarded = 715,
// The external port cannot be wildcarded, but must
// be specified
external_port_cannot_be_wildcarded = 716,
// The port mapping entry specified conflicts with a
// mapping assigned previously to another client
port_mapping_conflict = 718,
// Internal and external port value must be the same
internal_port_must_match_external = 724,
// The NAT implementation only supports permanent
// lease times on port mappings
only_permanent_leases_supported = 725,
// RemoteHost must be a wildcard and cannot be a
// specific IP addres or DNS name
remote_host_must_be_wildcard = 726,
// ExternalPort must be a wildcard and cannot be a
// specific port
external_port_must_be_wildcard = 727
};
}
TORRENT_EXPORT boost::system::error_category& get_upnp_category();
// int: port-mapping index
// address: external address as queried from router
// int: external port
// std::string: error message
// an empty string as error means success
// a port-mapping index of -1 means it's
// an informational log message
typedef boost::function<void(int, address, int, error_code const&)> portmap_callback_t;
typedef boost::function<void(char const*)> log_callback_t;
// TODO: support using the windows API for UPnP operations as well
class TORRENT_EXTRA_EXPORT upnp : public intrusive_ptr_base<upnp>
{
public:
upnp(io_service& ios, connection_queue& cc
, address const& listen_interface, std::string const& user_agent
, portmap_callback_t const& cb, log_callback_t const& lcb
, bool ignore_nonrouters, void* state = 0);
~upnp();
void* drain_state();
enum protocol_type { none = 0, udp = 1, tcp = 2 };
// Attempts to add a port mapping for the specified protocol. Valid protocols are
// ``upnp::tcp`` and ``upnp::udp`` for the UPnP class and ``natpmp::tcp`` and
// ``natpmp::udp`` for the NAT-PMP class.
//
// ``external_port`` is the port on the external address that will be mapped. This
// is a hint, you are not guaranteed that this port will be available, and it may
// end up being something else. In the portmap_alert_ notification, the actual
// external port is reported.
//
// ``local_port`` is the port in the local machine that the mapping should forward
// to.
//
// The return value is an index that identifies this port mapping. This is used
// to refer to mappings that fails or succeeds in the portmap_error_alert_ and
// portmap_alert_ respectively. If The mapping fails immediately, the return value
// is -1, which means failure. There will not be any error alert notification for
// mappings that fail with a -1 return value.
int add_mapping(protocol_type p, int external_port, int local_port);
// This function removes a port mapping. ``mapping_index`` is the index that refers
// to the mapping you want to remove, which was returned from add_mapping().
void delete_mapping(int mapping_index);
bool get_mapping(int mapping_index, int& local_port, int& external_port, int& protocol) const;
void discover_device();
void close();
// This is only available for UPnP routers. If the model is advertized by
// the router, it can be queried through this function.
std::string router_model()
{
mutex::scoped_lock l(m_mutex);
return m_model;
}
private:
void discover_device_impl(mutex::scoped_lock& l);
static address_v4 upnp_multicast_address;
static udp::endpoint upnp_multicast_endpoint;
// there are routers that's don't support timed
// port maps, without returning error 725. It seems
// safer to always assume that we have to ask for
// permanent leases
enum { default_lease_time = 0 };
void resend_request(error_code const& e);
void on_reply(udp::endpoint const& from, char* buffer
, std::size_t bytes_transferred);
struct rootdevice;
void next(rootdevice& d, int i, mutex::scoped_lock& l);
void update_map(rootdevice& d, int i, mutex::scoped_lock& l);
void on_upnp_xml(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, http_connection& c);
void on_upnp_get_ip_address_response(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, http_connection& c);
void on_upnp_map_response(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, int mapping, http_connection& c);
void on_upnp_unmap_response(error_code const& e
, libtorrent::http_parser const& p, rootdevice& d
, int mapping, http_connection& c);
void on_expire(error_code const& e);
void disable(error_code const& ec, mutex::scoped_lock& l);
void return_error(int mapping, int code, mutex::scoped_lock& l);
void log(char const* msg, mutex::scoped_lock& l);
void get_ip_address(rootdevice& d);
void delete_port_mapping(rootdevice& d, int i);
void create_port_mapping(http_connection& c, rootdevice& d, int i);
void post(upnp::rootdevice const& d, char const* soap
, char const* soap_action, mutex::scoped_lock& l);
int num_mappings() const { return int(m_mappings.size()); }
struct global_mapping_t
{
global_mapping_t()
: protocol(none)
, external_port(0)
, local_port(0)
{}
int protocol;
int external_port;
int local_port;
};
struct mapping_t
{
enum action_t { action_none, action_add, action_delete };
mapping_t()
: action(action_none)
, local_port(0)
, external_port(0)
, protocol(none)
, failcount(0)
{}
// the time the port mapping will expire
ptime expires;
int action;
// the local port for this mapping. If this is set
// to 0, the mapping is not in use
int local_port;
// the external (on the NAT router) port
// for the mapping. This is the port we
// should announce to others
int external_port;
// 2 = udp, 1 = tcp
int protocol;
// the number of times this mapping has failed
int failcount;
};
struct rootdevice
{
rootdevice(): service_namespace(0)
, port(0)
, lease_duration(default_lease_time)
, supports_specific_external(true)
, disabled(false)
{
#if TORRENT_USE_ASSERTS
magic = 1337;
#endif
}
#if TORRENT_USE_ASSERTS
~rootdevice()
{
TORRENT_ASSERT(magic == 1337);
magic = 0;
}
#endif
// the interface url, through which the list of
// supported interfaces are fetched
std::string url;
// the url to the WANIP or WANPPP interface
std::string control_url;
// either the WANIP namespace or the WANPPP namespace
char const* service_namespace;
std::vector<mapping_t> mapping;
// this is the hostname, port and path
// component of the url or the control_url
// if it has been found
std::string hostname;
int port;
std::string path;
address external_ip;
int lease_duration;
// true if the device supports specifying a
// specific external port, false if it doesn't
bool supports_specific_external;
bool disabled;
mutable boost::shared_ptr<http_connection> upnp_connection;
#if TORRENT_USE_ASSERTS
int magic;
#endif
void close() const
{
TORRENT_ASSERT(magic == 1337);
if (!upnp_connection) return;
upnp_connection->close();
upnp_connection.reset();
}
bool operator<(rootdevice const& rhs) const
{ return url < rhs.url; }
};
struct upnp_state_t
{
std::vector<global_mapping_t> mappings;
std::set<rootdevice> devices;
};
std::vector<global_mapping_t> m_mappings;
std::string const& m_user_agent;
// the set of devices we've found
std::set<rootdevice> m_devices;
portmap_callback_t m_callback;
log_callback_t m_log_callback;
// current retry count
int m_retry_count;
io_service& m_io_service;
// the udp socket used to send and receive
// multicast messages on the network
broadcast_socket m_socket;
// used to resend udp packets in case
// they time out
deadline_timer m_broadcast_timer;
// timer used to refresh mappings
deadline_timer m_refresh_timer;
bool m_disabled;
bool m_closing;
bool m_ignore_non_routers;
connection_queue& m_cc;
mutex m_mutex;
std::string m_model;
};
}
#endif
<|endoftext|>
|
<commit_before>
#include "LatticePathCollection.h"
void LatticePathCollection::Prune(size_t newSize)
{
assert( m_collection.size() == m_uniquePath.size() );
if (m_collection.size() <= newSize)
return; // don't need to prune
CollectionType::reverse_iterator iterRev;
for (iterRev = m_collection.rbegin() ; iterRev != m_collection.rend() ; ++iterRev)
{
LatticePath *latticePath = *iterRev;
// delete path in m_uniquePath
delete latticePath;
if (m_collection.size() == newSize)
break;
}
// delete path in m_collection
CollectionType::iterator iter = m_collection.begin();
for (size_t i = 0 ; i < newSize ; ++i)
iter++;
m_collection.erase(iter, m_collection.end());
assert( m_collection.size() == m_uniquePath.size() );
}
<commit_msg>compile error<commit_after>
#include "LatticePathCollection.h"
void LatticePathCollection::Prune(size_t newSize)
{
if (m_collection.size() <= newSize)
return; // don't need to prune
CollectionType::reverse_iterator iterRev;
for (iterRev = m_collection.rbegin() ; iterRev != m_collection.rend() ; ++iterRev)
{
LatticePath *latticePath = *iterRev;
// delete path in m_uniquePath
delete latticePath;
if (m_collection.size() == newSize)
break;
}
// delete path in m_collection
CollectionType::iterator iter = m_collection.begin();
for (size_t i = 0 ; i < newSize ; ++i)
iter++;
m_collection.erase(iter, m_collection.end());
}
<|endoftext|>
|
<commit_before>#pragma once
#include "world.hh"
#include "ability.hh"
#include "common.hh"
#define NO_AI false
#define EVIL_ACTORS (Actor::IMP | Actor::DEMON | Actor::ARCHDEMON | Actor::POSSESSED)
#define GOOD_ACTORS (Actor::ANGEL | Actor::ARCHANGEL | Actor::CLOAKEDANGEL)
class World;
class Actor: boost::noncopyable {
public:
enum Type { HUMAN = 1, ANGEL = 2, ARCHANGEL = 4, CLOAKEDANGEL = 8,
IMP = 16, DEMON = 32, ARCHDEMON = 64, POSSESSED = 128, ALL = 255 } type;
Type realType;
Actor(Type type, bool ai = true): type(type), realType(type), x(), y(), targetx(), targety(),
viewDist(10), useAI(ai), confirmAction(false), exp(), blessed(), possessed(NULL), possessing(NULL),
forceRedrawUI(false), killed_enemies(), killed_humans(), moves(), msgs(20), world() {
setInitialHealth();
abilities.push_back(newAbility(Ability_OpenDoor));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_DetectEvil));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_TouchOfGod));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_Bless));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_HealSelf));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_ConcealDivinity));
if (type & (EVIL_ACTORS)) abilities.push_back(newAbility(Ability_DetectDivinity));
if (type & (EVIL_ACTORS)) abilities.push_back(newAbility(Ability_Possess));
if (type & (EVIL_ACTORS)) abilities.push_back(newAbility(Ability_DemonFire));
abilities.push_back(newAbility(Ability_CloseDoor));
}
~Actor() { abilities.clear(); }
void setWorld(World* wd) {
world = wd;
// Construct view array
int w = world->getWidth();
int h = world->getHeight();
for (int j = 0; j < h; j++) {
tilerow row;
for (int i = 0; i < w; i++) row.push_back(Tile());
view.push_back(row);
}
}
void AI() {
switch (realType) {
case HUMAN: AI_human(); break;
case ANGEL: case ARCHANGEL: case CLOAKEDANGEL: AI_angel(); break;
case IMP: case DEMON: case ARCHDEMON: case POSSESSED: AI_demon(); break;
case ALL: break;
}
}
bool possession() {
int odds = 6;
if (realType == DEMON) odds += 6;
if (realType == ARCHDEMON) odds += 6;
if (randint(odds) == 0) {
this->move(randint(-1,1),randint(-1,1));
return false;
}
return true;
}
void idle() { moves++; }
bool move(int dx, int dy) {
if (dx == 0 && dy == 0) return false;
int tx = x+dx, ty = y+dy;
if (world->isFreeTile(tx, ty)) {
world->getTilePtr(x, y)->actor = NULL;
x = tx; y = ty;
world->getTilePtr(x, y)->actor = this;
msgs.push_back(world->getTile(x, y).desc + ".");
moves++;
return true;
} else {
Actor* target = world->getTilePtr(tx, ty)->actor;
for (Abilities::iterator it = abilities.begin(); it != abilities.end(); ++it) {
if (target) {
if ((*it)(this, target)) { moves++; return true; }
} else {
if ((*it)(this, world->getTilePtr(tx, ty))) { moves++; return true; }
}
}
}
return false;
}
bool position(int newx, int newy) {
if (world->isFreeTile(newx, newy)) {
world->getTilePtr(x, y)->actor = NULL;
x = newx; y = newy;
world->getTilePtr(x, y)->actor = this;
return true;
}
return false;
}
/// Function: getType
/// Returns the apparant type taking into account askers side.
Type getType(const Actor* asker = NULL) {
if (asker && type == HUMAN) { // Handle same side
if (asker->realType & GOOD_ACTORS && realType & GOOD_ACTORS) return realType;
else if (asker->realType & EVIL_ACTORS && realType & EVIL_ACTORS) return realType;
}
// Normally, just return the apparant type
return type;
}
char getChar() const {
if (type & (HUMAN | POSSESSED | CLOAKEDANGEL)) return '@';
switch(type) {
case ANGEL: return 'a';
case ARCHANGEL: return 'A';
case IMP: return 'i';
case DEMON: return 'd';
case ARCHDEMON: return 'D';
default: return '\0';
}
}
int getColor(const Actor* asker = NULL) const {
// Note: Bold colors are reserved for player
if (asker && type == HUMAN) { // Handle same side
if (asker->realType & GOOD_ACTORS && realType & GOOD_ACTORS) return COLOR_WHITE;
else if (asker->realType & EVIL_ACTORS && realType & EVIL_ACTORS) return COLOR_RED;
}
if (type & HUMAN) return COLOR_YELLOW;
else if (type & GOOD_ACTORS) return COLOR_WHITE;
else if (type & EVIL_ACTORS) return COLOR_RED;
return -1;
}
std::string getTypeName(bool real = false) const {
switch(real ? realType : type) {
case HUMAN: return "Human";
case CLOAKEDANGEL: return "Angel in disguise";
case ANGEL: return "Angel";
case ARCHANGEL: return "Archangel";
case POSSESSED: return "Possessed";
case IMP: return "Imp";
case DEMON: return "Demon";
case ARCHDEMON: return "Archdemon";
case ALL: return "";
}
return "";
}
void setInitialHealth() {
switch (realType) {
case HUMAN: maxhealth = randint(4,7); break;
case ANGEL: maxhealth = 16; break;
case ARCHANGEL: maxhealth = 28; break;
case IMP: maxhealth = randint(8,9); break;
case DEMON: maxhealth = randint(14,16); break;
case ARCHDEMON: maxhealth = randint(24,27); break;
default: break;
}
health = maxhealth;
}
tilearray& getView() { return view; }
const tilearray& getConstView() const { return view; }
Tile* getTilePtr() { return world->getTilePtr(x,y); }
const WorldPtr getConstWorldPtr() const { return world; }
bool hasExplored(int x, int y) const {
if (x < 0 || y < 0 || x >= world->getWidth() || y >= world->getHeight()) return false;
return view[y][x].explored;
}
bool hurt(int dmg) {
health -= dmg;
dmg = clamp(dmg, 0, maxhealth);
if (isDead()) {
// Free possessed
if (possessing) {
possessing->possessed = NULL;
possessing->x = x;
possessing->y = y;
possessing->getTilePtr()->actor = possessing;
}
return true;
}
return false;
}
void addExp(int howmuch) {
exp += howmuch;
if (exp >= getNextExpLevel()) {
exp = getNextExpLevel();
if (realType == IMP) evolve(DEMON);
else if (realType == DEMON) evolve(ARCHDEMON);
else if (realType == ANGEL) evolve(ARCHANGEL);
else if (realType & (ARCHANGEL | ARCHDEMON)) {
// Ascension, handled in winner();
}
}
}
void evolve(Type toType) {
realType = toType;
type = realType;
msgs.push_back(std::string("You've been promoted to ") + getTypeName() + "!");
if (possessing) { // Kill possessed
possessing->hurt(1000);
possessing = NULL;
msgs.push_back("Your ascension destroyed your vessel.");
killed_humans++;
}
setInitialHealth();
exp = 0;
forceRedrawUI = true;
}
int getNextExpLevel() const {
if (realType == HUMAN);
else if (realType == IMP) return 6;
else if (realType == DEMON) return 10;
else if (realType == ANGEL) return 16;
else if (realType == ARCHANGEL) return 16;
else if (realType == ARCHDEMON) return 16;
return 1000;
}
bool isDead() const { return health <= 0; }
void dumpDebugInfo() const {
Logger log("ACTOR");
log("Type: %s", getTypeName().c_str());
log("Visible_actors: (count = %d)", visible_actors.size());
for (ActorPtrs::const_iterator it = visible_actors.begin(); it != visible_actors.end(); ++it)
log((*it)->getTypeName().c_str());
}
int x;
int y;
int targetx;
int targety;
int viewDist;
bool useAI;
bool confirmAction;
int exp;
int blessed;
Actor* possessed;
Actor* possessing;
bool forceRedrawUI;
int killed_enemies;
int killed_humans;
int moves;
ActorPtrs visible_actors;
Abilities abilities;
MsgBuffer msgs;
int getExp() const { return exp; }
int getHealth() const { return health; }
int getMaxHealth() const { return maxhealth; }
float getCond() const { return float(health) / maxhealth; }
Actor* getClosestActor(int types = ALL);
private:
int countActors(int types = ALL) const;
bool moveTowards(int tx, int ty);
void moveAway(int tx, int ty);
void AI_angel();
void AI_human();
void AI_demon();
void AI_generic();
WorldPtr world;
tilearray view;
int maxhealth;
int health;
};
<commit_msg>Possession revolting tweaks.<commit_after>#pragma once
#include "world.hh"
#include "ability.hh"
#include "common.hh"
#define NO_AI false
#define EVIL_ACTORS (Actor::IMP | Actor::DEMON | Actor::ARCHDEMON | Actor::POSSESSED)
#define GOOD_ACTORS (Actor::ANGEL | Actor::ARCHANGEL | Actor::CLOAKEDANGEL)
class World;
class Actor: boost::noncopyable {
public:
enum Type { HUMAN = 1, ANGEL = 2, ARCHANGEL = 4, CLOAKEDANGEL = 8,
IMP = 16, DEMON = 32, ARCHDEMON = 64, POSSESSED = 128, ALL = 255 } type;
Type realType;
Actor(Type type, bool ai = true): type(type), realType(type), x(), y(), targetx(), targety(),
viewDist(10), useAI(ai), confirmAction(false), exp(), blessed(), possessed(NULL), possessing(NULL),
forceRedrawUI(false), killed_enemies(), killed_humans(), moves(), msgs(20), world() {
setInitialHealth();
abilities.push_back(newAbility(Ability_OpenDoor));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_DetectEvil));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_TouchOfGod));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_Bless));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_HealSelf));
if (type & (GOOD_ACTORS)) abilities.push_back(newAbility(Ability_ConcealDivinity));
if (type & (EVIL_ACTORS)) abilities.push_back(newAbility(Ability_DetectDivinity));
if (type & (EVIL_ACTORS)) abilities.push_back(newAbility(Ability_Possess));
if (type & (EVIL_ACTORS)) abilities.push_back(newAbility(Ability_DemonFire));
abilities.push_back(newAbility(Ability_CloseDoor));
}
~Actor() { abilities.clear(); }
void setWorld(World* wd) {
world = wd;
// Construct view array
int w = world->getWidth();
int h = world->getHeight();
for (int j = 0; j < h; j++) {
tilerow row;
for (int i = 0; i < w; i++) row.push_back(Tile());
view.push_back(row);
}
}
void AI() {
switch (realType) {
case HUMAN: AI_human(); break;
case ANGEL: case ARCHANGEL: case CLOAKEDANGEL: AI_angel(); break;
case IMP: case DEMON: case ARCHDEMON: case POSSESSED: AI_demon(); break;
case ALL: break;
}
}
bool possession() {
if (realType == ARCHDEMON) return true;
int odds = (realType == DEMON ? 24 : 6);
if (randint(odds) == 0) {
this->move(randint(-1,1),randint(-1,1));
return false;
}
return true;
}
void idle() { moves++; }
bool move(int dx, int dy) {
if (dx == 0 && dy == 0) return false;
int tx = x+dx, ty = y+dy;
if (world->isFreeTile(tx, ty)) {
world->getTilePtr(x, y)->actor = NULL;
x = tx; y = ty;
world->getTilePtr(x, y)->actor = this;
msgs.push_back(world->getTile(x, y).desc + ".");
moves++;
return true;
} else {
Actor* target = world->getTilePtr(tx, ty)->actor;
for (Abilities::iterator it = abilities.begin(); it != abilities.end(); ++it) {
if (target) {
if ((*it)(this, target)) { moves++; return true; }
} else {
if ((*it)(this, world->getTilePtr(tx, ty))) { moves++; return true; }
}
}
}
return false;
}
bool position(int newx, int newy) {
if (world->isFreeTile(newx, newy)) {
world->getTilePtr(x, y)->actor = NULL;
x = newx; y = newy;
world->getTilePtr(x, y)->actor = this;
return true;
}
return false;
}
/// Function: getType
/// Returns the apparant type taking into account askers side.
Type getType(const Actor* asker = NULL) {
if (asker && type == HUMAN) { // Handle same side
if (asker->realType & GOOD_ACTORS && realType & GOOD_ACTORS) return realType;
else if (asker->realType & EVIL_ACTORS && realType & EVIL_ACTORS) return realType;
}
// Normally, just return the apparant type
return type;
}
char getChar() const {
if (type & (HUMAN | POSSESSED | CLOAKEDANGEL)) return '@';
switch(type) {
case ANGEL: return 'a';
case ARCHANGEL: return 'A';
case IMP: return 'i';
case DEMON: return 'd';
case ARCHDEMON: return 'D';
default: return '\0';
}
}
int getColor(const Actor* asker = NULL) const {
// Note: Bold colors are reserved for player
if (asker && type == HUMAN) { // Handle same side
if (asker->realType & GOOD_ACTORS && realType & GOOD_ACTORS) return COLOR_WHITE;
else if (asker->realType & EVIL_ACTORS && realType & EVIL_ACTORS) return COLOR_RED;
}
if (type & HUMAN) return COLOR_YELLOW;
else if (type & GOOD_ACTORS) return COLOR_WHITE;
else if (type & EVIL_ACTORS) return COLOR_RED;
return -1;
}
std::string getTypeName(bool real = false) const {
switch(real ? realType : type) {
case HUMAN: return "Human";
case CLOAKEDANGEL: return "Angel in disguise";
case ANGEL: return "Angel";
case ARCHANGEL: return "Archangel";
case POSSESSED: return "Possessed";
case IMP: return "Imp";
case DEMON: return "Demon";
case ARCHDEMON: return "Archdemon";
case ALL: return "";
}
return "";
}
void setInitialHealth() {
switch (realType) {
case HUMAN: maxhealth = randint(4,7); break;
case ANGEL: maxhealth = 16; break;
case ARCHANGEL: maxhealth = 28; break;
case IMP: maxhealth = randint(8,9); break;
case DEMON: maxhealth = randint(14,16); break;
case ARCHDEMON: maxhealth = randint(24,27); break;
default: break;
}
health = maxhealth;
}
tilearray& getView() { return view; }
const tilearray& getConstView() const { return view; }
Tile* getTilePtr() { return world->getTilePtr(x,y); }
const WorldPtr getConstWorldPtr() const { return world; }
bool hasExplored(int x, int y) const {
if (x < 0 || y < 0 || x >= world->getWidth() || y >= world->getHeight()) return false;
return view[y][x].explored;
}
bool hurt(int dmg) {
health -= dmg;
dmg = clamp(dmg, 0, maxhealth);
if (isDead()) {
// Free possessed
if (possessing) {
possessing->possessed = NULL;
possessing->x = x;
possessing->y = y;
possessing->getTilePtr()->actor = possessing;
}
return true;
}
return false;
}
void addExp(int howmuch) {
exp += howmuch;
if (exp >= getNextExpLevel()) {
exp = getNextExpLevel();
if (realType == IMP) evolve(DEMON);
else if (realType == DEMON) evolve(ARCHDEMON);
else if (realType == ANGEL) evolve(ARCHANGEL);
else if (realType & (ARCHANGEL | ARCHDEMON)) {
// Ascension, handled in winner();
}
}
}
void evolve(Type toType) {
realType = toType;
type = realType;
msgs.push_back(std::string("You've been promoted to ") + getTypeName() + "!");
if (possessing) { // Kill possessed
possessing->hurt(1000);
possessing = NULL;
msgs.push_back("Your ascension destroyed your vessel.");
killed_humans++;
}
setInitialHealth();
exp = 0;
forceRedrawUI = true;
}
int getNextExpLevel() const {
if (realType == HUMAN);
else if (realType == IMP) return 6;
else if (realType == DEMON) return 10;
else if (realType == ANGEL) return 16;
else if (realType == ARCHANGEL) return 16;
else if (realType == ARCHDEMON) return 16;
return 1000;
}
bool isDead() const { return health <= 0; }
void dumpDebugInfo() const {
Logger log("ACTOR");
log("Type: %s", getTypeName().c_str());
log("Visible_actors: (count = %d)", visible_actors.size());
for (ActorPtrs::const_iterator it = visible_actors.begin(); it != visible_actors.end(); ++it)
log((*it)->getTypeName().c_str());
}
int x;
int y;
int targetx;
int targety;
int viewDist;
bool useAI;
bool confirmAction;
int exp;
int blessed;
Actor* possessed;
Actor* possessing;
bool forceRedrawUI;
int killed_enemies;
int killed_humans;
int moves;
ActorPtrs visible_actors;
Abilities abilities;
MsgBuffer msgs;
int getExp() const { return exp; }
int getHealth() const { return health; }
int getMaxHealth() const { return maxhealth; }
float getCond() const { return float(health) / maxhealth; }
Actor* getClosestActor(int types = ALL);
private:
int countActors(int types = ALL) const;
bool moveTowards(int tx, int ty);
void moveAway(int tx, int ty);
void AI_angel();
void AI_human();
void AI_demon();
void AI_generic();
WorldPtr world;
tilearray view;
int maxhealth;
int health;
};
<|endoftext|>
|
<commit_before>
#include "event_loop.h"
#include "kernel.h"
#include "topic.h"
#include "IOLoop.h"
#include "IOHandle.h"
#include "io_connector.h"
#include "wamp_session.h"
#include "log_macros.h"
#include <sstream>
#include <condition_variable>
#include <mutex>
#include <queue>
#include <list>
#include <iostream>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
#include <getopt.h> /* for getopt_long; standard getopt is in unistd.h */
auto __logger = XXX::logger::stdlog(std::cout,
XXX::logger::levels_upto(XXX::logger::eInfo), 1);
std::unique_ptr<XXX::kernel> g_kernel;
struct user_options
{
std::string addr;
std::string port;
std::string cmd;
std::list< std::string > cmdargs;
std::list< std::string > subscribe_topics;
std::string publish_topic;
std::string publish_message;
std::string register_procedure;
std::string call_procedure;
int verbose;
user_options()
: verbose(0)
{
}
} uopts;
std::mutex g_active_session_mutex;
std::condition_variable g_active_session_condition;
bool g_active_session_notifed = false;
enum AdminEvent
{
eNone,
eRPCSent,
eReplyReceived,
};
std::mutex event_queue_mutex;
std::condition_variable event_queue_condition;
std::queue< AdminEvent > event_queue;
struct callback_t
{
callback_t(XXX::kernel* s, const char* d)
: svc(s),
request(d)
{
}
XXX::kernel* svc;
const char* request;
};
void procedure_cb(XXX::invoke_details& invocation)
{
const callback_t* cbdata = (callback_t*) invocation.user;
/* called when a procedure within a CALLEE is triggered */
LOG_INFO ("CALLEE has procuedure '"<< invocation.uri << "' invoked, args: " << invocation.args.args_list
<< ", user:" << cbdata->request );
// rconn->publish("call", jalson::json_object(), XXX::wamp_args());
auto my_args = invocation.args;
my_args.args_list = jalson::json_array();
jalson::json_array & arr = my_args.args_list.as_array();
arr.push_back("hello");
arr.push_back("back");
invocation.yield_fn(my_args);
}
void call_cb(XXX::wamp_call_result r)
{
const char* msg = ( const char* ) r.user;
if (r.was_error)
{
LOG_INFO( "received error, error=" << r.error_uri << ", args="
<< r.args.args_list << ", cb_user_data: " << msg
<< ", reqid: " << r.reqid
<< ", proc:" << r.procedure );
}
else
{
LOG_INFO( "received result, args="
<< r.args.args_list << ", cb_user_data: " << msg
<< ", reqid: " << r.reqid
<< ", proc:" << r.procedure );
}
std::unique_lock< std::mutex > guard( event_queue_mutex );
event_queue.push( eReplyReceived );
event_queue_condition.notify_one();
}
/* called upon subscribed and update events */
void subscribe_cb(XXX::subscription_event_type evtype,
const std::string& /* uri */,
const jalson::json_object& /* details */,
const jalson::json_array& args_list,
const jalson::json_object& args_dict,
void* /*user*/)
{
std::cout << "received topic update!!! evtype: " << evtype << ", args_list: " << args_list
<< ", args_dict:" << args_dict << "\n";
}
bool g_handshake_success = false;
void router_connection_cb(int errcode,
bool is_open)
{
std::lock_guard<std::mutex> guard(g_active_session_mutex);
if (!is_open)
std::cout << "WAMP session closed, errcode " << errcode << std::endl;
else
g_handshake_success = true;
g_active_session_notifed = true;
g_active_session_condition.notify_all();
}
static void die(const char* e)
{
std::cout << e << std::endl;
exit( 1 );
}
static void usage()
{
exit(0);
}
static void version()
{
// std::cout << PACKAGE_VERSION << std::endl; exit(0)l
exit(0);
}
static void process_options(int argc, char** argv)
{
/*
struct option
{
const char *name;
int has_arg;
int *flag;
int val;
};
*/
// int digit_optind = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"subscribe", required_argument, 0, 's'},
{"publish", required_argument, 0, 'p'},
{"register", required_argument, 0, 'r'},
{"call", required_argument, 0, 'c'},
{"msg", required_argument, 0, 'm'},
{NULL, 0, NULL, 0}
};
const char* optstr="hvds:p:m:r:c:";
::opterr=1;
while (true)
{
/* "optind" is the index of the next element to be processed in argv. It
is defined in the getopts header, and the system initializes this value
to 1. The caller can reset it to 1 to restart scanning of the same
argv, or when scanning a new argument vector. */
// take a copy to remember value for after return from getopt_long()
//int this_option_optind = ::optind ? ::optind : 1;
int long_index = 0;
int c = getopt_long(argc, argv,
optstr,
long_options, &long_index);
if (c == -1) break;
switch(c)
{
case 0 : /* got long option */; break;
case 'd' : uopts.verbose++; break;
case 'h' : usage();
case 'v' : version();
case 's' : uopts.subscribe_topics.push_back(optarg); break;
case 'p' : uopts.publish_topic = optarg; break;
case 'm' : uopts.publish_message = optarg; break;
case 'r' : uopts.register_procedure = optarg; break;
case 'c' : uopts.call_procedure = optarg; break;
case '?' : exit(1); // invalid option
default:
{
std::cout << "getopt_long() returned (dec) " << (unsigned int)(c) << "\n";
exit(1);
}
}
} //while
if (optind < argc) uopts.addr = argv[optind++];
if (optind < argc) uopts.port = argv[optind++];
if (optind < argc) uopts.cmd = argv[optind++];
while (optind < argc) uopts.cmdargs.push_back(argv[optind++]);
}
std::string get_timestamp()
{
// get current time
timeval now;
struct timezone * const tz = NULL; /* not used on Linux */
gettimeofday(&now, tz);
struct tm _tm;
localtime_r(&now.tv_sec, &_tm);
std::ostringstream os;
os << _tm.tm_hour << ":" << _tm.tm_min << ":" << _tm.tm_sec;
return os.str();
}
int main(int argc, char** argv)
{
process_options(argc, argv);
g_kernel.reset( new XXX::kernel({}, __logger));
g_kernel->start();
/* Create a socket connector. This will immediately make an attempt to
* connect to the target end point. The connector object is a source of async
* events (the connect and disconnect call back), and so must be managed
* asynchronously. */
std::shared_ptr<XXX::io_connector> conn
= g_kernel->get_io()->add_connection("t420", "55555", false);
auto connect_fut = conn->get_future();
std::unique_ptr<XXX::IOHandle> up_handle;
try
{
/* Wait until the connector has got a result. The result can be successful,
* in which case a socket is available, or result could be a failure, in
* which case either an exception will be available or a null pointer. */
std::future_status status;
do
{
status = connect_fut.wait_for(std::chrono::seconds(5));
if (status == std::future_status::timeout)
{
std::cout << "timed out when trying to connect, cancelling" << std::endl;
conn->async_cancel();
}
} while (status != std::future_status::ready);
/* A result is available; our socket connection could be available. */
up_handle = connect_fut.get();
if (!up_handle)
{
std::cout << "connect failed\n";
return 1;
}
}
catch (std::exception & e)
{
std::cout << "connect failed : " << e.what() << std::endl;
return 1;
}
XXX::client_credentials credentials;
credentials.realm="default_realm";
credentials.authid="peter";
credentials.authmethods = {"wampcra"};
credentials.secret_fn = []() -> std::string { return "secret2"; };
/* We have obtained a socket. It's not yet being read from. We now create a
* wamp_session that takes ownership of the socket, and initiates socket read
* events. The wamp_session will commence the WAMP handshake; connection
* success is delivered via the callback. */
auto fn = [](XXX::session_handle wp, bool is_open){
if (auto sp = wp.lock())
router_connection_cb(0, is_open);
};
std::shared_ptr<XXX::wamp_session> ws
= XXX::wamp_session::create(*g_kernel.get(),
std::move(up_handle),
false,
fn);
ws->initiate_handshake(credentials);
/* Wait for the WAMP session to authenticate and become open */
auto wait_interval = std::chrono::seconds(50);
{
std::unique_lock<std::mutex> guard(g_active_session_mutex);
bool hasevent = g_active_session_condition.wait_for(guard,
wait_interval,
[](){ return g_active_session_notifed; });
if (!hasevent) die("failed to obtain remote connection");
}
if (!g_handshake_success)
{
std::cout << "Unable to connect" << std::endl;
exit(1);
}
/* WAMP session is now open */
std::cout << "WAMP session open" << std::endl;
// TODO: take CALL parameters from command line
XXX::wamp_args args;
jalson::json_array ja;
ja.push_back( "hello" );
ja.push_back( "world" );
args.args_list = ja ;
bool long_wait = false;
bool wait_reply = false;
// TODO: next, find a way to easily print out the list after each update
XXX::basic_list_target basic_list;
XXX::basic_list_subscription_handler<XXX::basic_list_target> h( basic_list );
XXX::model_subscription< XXX::basic_list_subscription_handler<XXX::basic_list_target> >
sub_planets(ws, "planets", h );
// subscribe
jalson::json_object sub_options;
sub_options["_p"]=1;
if (! uopts.subscribe_topics.empty()) long_wait = true;
for (auto & topic : uopts.subscribe_topics)
ws->subscribe(topic, sub_options, subscribe_cb, nullptr);
// register
std::unique_ptr<callback_t> cb1( new callback_t(g_kernel.get(),"my_hello") );
if (!uopts.register_procedure.empty())
{
ws->provide(uopts.register_procedure,
jalson::json_object(),
procedure_cb,
(void*) cb1.get());
long_wait = true;
}
// publish
if (!uopts.publish_topic.empty())
{
// XXX::wamp_args pub_args;
// pub_args.args_list = jalson::json_value::make_array();
// pub_args.args_list.as_array().push_back(uopts.publish_message);
// ws->publish(uopts.publish_topic,
// jalson::json_object(),
// pub_args);
XXX::basic_text_model tm;
XXX::topic publisher(uopts.publish_topic, &tm);
publisher.add_wamp_session(ws);
tm.set_value("hello world");
}
// call
if (!uopts.call_procedure.empty())
{
ws->call(uopts.call_procedure,
jalson::json_object(),
args,
[](XXX::wamp_call_result r)
{ call_cb(r);},
(void*)"I_called_the_proc");
wait_reply = true;
}
while (long_wait || wait_reply)
{
std::unique_lock< std::mutex > guard( event_queue_mutex );
/*bool hasevent =*/ event_queue_condition.wait_for(guard, wait_interval,
[](){ return !event_queue.empty(); });
while (!event_queue.empty())
{
AdminEvent aev = event_queue.front();
event_queue.pop();
switch (aev)
{
case eNone : break;
case eRPCSent : break; /* resets the timer */
case eReplyReceived : wait_reply = false; ;break;
}
}
}
int sleep_time = 3;
std::cout << "sleeping for " << sleep_time << " before shutdown\n";
sleep(sleep_time); // TODO: think I need this, to give publish time to complete
/* Commence orderly shutdown of the wamp_session. Shutdown is an asychronous
* operation so we start the request and then wait for the request to
* complete. Once complete, we shall not receive anymore events from the
* wamp_session object (and thus is safe to delete). */
std::cout << "requesting wamp_session closure\n";
auto fut_closed = ws->close();
fut_closed.wait();
// while (1) sleep(10);
/* We must be mindful to free the kernel and logger only after all sessions
are closed (e.g. sessions might attempt logging during their
destruction) */
g_kernel.reset();
return 0;
}
<commit_msg>check user URIs for strictness<commit_after>
#include "event_loop.h"
#include "kernel.h"
#include "topic.h"
#include "IOLoop.h"
#include "IOHandle.h"
#include "io_connector.h"
#include "wamp_session.h"
#include "log_macros.h"
#include <sstream>
#include <condition_variable>
#include <mutex>
#include <queue>
#include <list>
#include <iostream>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>
#include <getopt.h> /* for getopt_long; standard getopt is in unistd.h */
auto __logger = XXX::logger::stdlog(std::cout,
XXX::logger::levels_upto(XXX::logger::eInfo), 1);
std::unique_ptr<XXX::kernel> g_kernel;
struct user_options
{
std::string addr;
std::string port;
std::string cmd;
std::list< std::string > cmdargs;
std::list< std::string > subscribe_topics;
std::string publish_topic;
std::string publish_message;
std::string register_procedure;
std::string call_procedure;
int verbose;
user_options()
: verbose(0)
{
}
} uopts;
std::mutex g_active_session_mutex;
std::condition_variable g_active_session_condition;
bool g_active_session_notifed = false;
enum AdminEvent
{
eNone,
eRPCSent,
eReplyReceived,
};
std::mutex event_queue_mutex;
std::condition_variable event_queue_condition;
std::queue< AdminEvent > event_queue;
struct callback_t
{
callback_t(XXX::kernel* s, const char* d)
: svc(s),
request(d)
{
}
XXX::kernel* svc;
const char* request;
};
void procedure_cb(XXX::invoke_details& invocation)
{
const callback_t* cbdata = (callback_t*) invocation.user;
/* called when a procedure within a CALLEE is triggered */
LOG_INFO ("CALLEE has procuedure '"<< invocation.uri << "' invoked, args: " << invocation.args.args_list
<< ", user:" << cbdata->request );
// rconn->publish("call", jalson::json_object(), XXX::wamp_args());
auto my_args = invocation.args;
my_args.args_list = jalson::json_array();
jalson::json_array & arr = my_args.args_list.as_array();
arr.push_back("hello");
arr.push_back("back");
invocation.yield_fn(my_args);
}
void call_cb(XXX::wamp_call_result r)
{
const char* msg = ( const char* ) r.user;
if (r.was_error)
{
LOG_INFO( "received error, error=" << r.error_uri << ", args="
<< r.args.args_list << ", cb_user_data: " << msg
<< ", reqid: " << r.reqid
<< ", proc:" << r.procedure );
}
else
{
LOG_INFO( "received result, args="
<< r.args.args_list << ", cb_user_data: " << msg
<< ", reqid: " << r.reqid
<< ", proc:" << r.procedure );
}
std::unique_lock< std::mutex > guard( event_queue_mutex );
event_queue.push( eReplyReceived );
event_queue_condition.notify_one();
}
/* called upon subscribed and update events */
void subscribe_cb(XXX::subscription_event_type evtype,
const std::string& /* uri */,
const jalson::json_object& /* details */,
const jalson::json_array& args_list,
const jalson::json_object& args_dict,
void* /*user*/)
{
std::cout << "received topic update!!! evtype: " << evtype << ", args_list: " << args_list
<< ", args_dict:" << args_dict << "\n";
}
bool g_handshake_success = false;
void router_connection_cb(int errcode,
bool is_open)
{
std::lock_guard<std::mutex> guard(g_active_session_mutex);
if (!is_open)
std::cout << "WAMP session closed, errcode " << errcode << std::endl;
else
g_handshake_success = true;
g_active_session_notifed = true;
g_active_session_condition.notify_all();
}
static void die(const char* e)
{
std::cout << e << std::endl;
exit( 1 );
}
static void usage()
{
exit(0);
}
static void version()
{
// std::cout << PACKAGE_VERSION << std::endl; exit(0)l
exit(0);
}
static void process_options(int argc, char** argv)
{
/*
struct option
{
const char *name;
int has_arg;
int *flag;
int val;
};
*/
// int digit_optind = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"subscribe", required_argument, 0, 's'},
{"publish", required_argument, 0, 'p'},
{"register", required_argument, 0, 'r'},
{"call", required_argument, 0, 'c'},
{"msg", required_argument, 0, 'm'},
{NULL, 0, NULL, 0}
};
const char* optstr="hvds:p:m:r:c:";
::opterr=1;
while (true)
{
/* "optind" is the index of the next element to be processed in argv. It
is defined in the getopts header, and the system initializes this value
to 1. The caller can reset it to 1 to restart scanning of the same
argv, or when scanning a new argument vector. */
// take a copy to remember value for after return from getopt_long()
//int this_option_optind = ::optind ? ::optind : 1;
int long_index = 0;
int c = getopt_long(argc, argv,
optstr,
long_options, &long_index);
if (c == -1) break;
switch(c)
{
case 0 : /* got long option */; break;
case 'd' : uopts.verbose++; break;
case 'h' : usage();
case 'v' : version();
case 's' : uopts.subscribe_topics.push_back(optarg); break;
case 'p' : uopts.publish_topic = optarg; break;
case 'm' : uopts.publish_message = optarg; break;
case 'r' : uopts.register_procedure = optarg; break;
case 'c' : uopts.call_procedure = optarg; break;
case '?' : exit(1); // invalid option
default:
{
std::cout << "getopt_long() returned (dec) " << (unsigned int)(c) << "\n";
exit(1);
}
}
} //while
if (optind < argc) uopts.addr = argv[optind++];
if (optind < argc) uopts.port = argv[optind++];
if (optind < argc) uopts.cmd = argv[optind++];
while (optind < argc) uopts.cmdargs.push_back(argv[optind++]);
// check topics
XXX::uri_regex uri_check;
for (auto & i : uopts.subscribe_topics)
if (not uri_check.is_strict_uri(i.c_str()))
{
std::cout << "not strict uri: " << i << std::endl;
exit(1);
}
}
std::string get_timestamp()
{
// get current time
timeval now;
struct timezone * const tz = NULL; /* not used on Linux */
gettimeofday(&now, tz);
struct tm _tm;
localtime_r(&now.tv_sec, &_tm);
std::ostringstream os;
os << _tm.tm_hour << ":" << _tm.tm_min << ":" << _tm.tm_sec;
return os.str();
}
int main(int argc, char** argv)
{
process_options(argc, argv);
g_kernel.reset( new XXX::kernel({}, __logger));
g_kernel->start();
/* Create a socket connector. This will immediately make an attempt to
* connect to the target end point. The connector object is a source of async
* events (the connect and disconnect call back), and so must be managed
* asynchronously. */
std::shared_ptr<XXX::io_connector> conn
= g_kernel->get_io()->add_connection("t420", "55555", false);
auto connect_fut = conn->get_future();
std::unique_ptr<XXX::IOHandle> up_handle;
try
{
/* Wait until the connector has got a result. The result can be successful,
* in which case a socket is available, or result could be a failure, in
* which case either an exception will be available or a null pointer. */
std::future_status status;
do
{
status = connect_fut.wait_for(std::chrono::seconds(5));
if (status == std::future_status::timeout)
{
std::cout << "timed out when trying to connect, cancelling" << std::endl;
conn->async_cancel();
}
} while (status != std::future_status::ready);
/* A result is available; our socket connection could be available. */
up_handle = connect_fut.get();
if (!up_handle)
{
std::cout << "connect failed\n";
return 1;
}
}
catch (std::exception & e)
{
std::cout << "connect failed : " << e.what() << std::endl;
return 1;
}
XXX::client_credentials credentials;
credentials.realm="default_realm";
credentials.authid="peter";
credentials.authmethods = {"wampcra"};
credentials.secret_fn = []() -> std::string { return "secret2"; };
/* We have obtained a socket. It's not yet being read from. We now create a
* wamp_session that takes ownership of the socket, and initiates socket read
* events. The wamp_session will commence the WAMP handshake; connection
* success is delivered via the callback. */
auto fn = [](XXX::session_handle wp, bool is_open){
if (auto sp = wp.lock())
router_connection_cb(0, is_open);
};
std::shared_ptr<XXX::wamp_session> ws
= XXX::wamp_session::create(*g_kernel.get(),
std::move(up_handle),
false,
fn);
ws->initiate_handshake(credentials);
/* Wait for the WAMP session to authenticate and become open */
auto wait_interval = std::chrono::seconds(50);
{
std::unique_lock<std::mutex> guard(g_active_session_mutex);
bool hasevent = g_active_session_condition.wait_for(guard,
wait_interval,
[](){ return g_active_session_notifed; });
if (!hasevent) die("failed to obtain remote connection");
}
if (!g_handshake_success)
{
std::cout << "Unable to connect" << std::endl;
exit(1);
}
/* WAMP session is now open */
std::cout << "WAMP session open" << std::endl;
// TODO: take CALL parameters from command line
XXX::wamp_args args;
jalson::json_array ja;
ja.push_back( "hello" );
ja.push_back( "world" );
args.args_list = ja ;
bool long_wait = false;
bool wait_reply = false;
// TODO: next, find a way to easily print out the list after each update
XXX::basic_list_target basic_list;
XXX::basic_list_subscription_handler<XXX::basic_list_target> h( basic_list );
XXX::model_subscription< XXX::basic_list_subscription_handler<XXX::basic_list_target> >
sub_planets(ws, "planets", h );
// subscribe
jalson::json_object sub_options;
sub_options["_p"]=1;
if (! uopts.subscribe_topics.empty()) long_wait = true;
for (auto & topic : uopts.subscribe_topics)
ws->subscribe(topic, sub_options, subscribe_cb, nullptr);
// register
std::unique_ptr<callback_t> cb1( new callback_t(g_kernel.get(),"my_hello") );
if (!uopts.register_procedure.empty())
{
ws->provide(uopts.register_procedure,
jalson::json_object(),
procedure_cb,
(void*) cb1.get());
long_wait = true;
}
// publish
if (!uopts.publish_topic.empty())
{
// XXX::wamp_args pub_args;
// pub_args.args_list = jalson::json_value::make_array();
// pub_args.args_list.as_array().push_back(uopts.publish_message);
// ws->publish(uopts.publish_topic,
// jalson::json_object(),
// pub_args);
XXX::basic_text_model tm;
XXX::topic publisher(uopts.publish_topic, &tm);
publisher.add_wamp_session(ws);
tm.set_value("hello world");
}
// call
if (!uopts.call_procedure.empty())
{
ws->call(uopts.call_procedure,
jalson::json_object(),
args,
[](XXX::wamp_call_result r)
{ call_cb(r);},
(void*)"I_called_the_proc");
wait_reply = true;
}
while (long_wait || wait_reply)
{
std::unique_lock< std::mutex > guard( event_queue_mutex );
/*bool hasevent =*/ event_queue_condition.wait_for(guard, wait_interval,
[](){ return !event_queue.empty(); });
while (!event_queue.empty())
{
AdminEvent aev = event_queue.front();
event_queue.pop();
switch (aev)
{
case eNone : break;
case eRPCSent : break; /* resets the timer */
case eReplyReceived : wait_reply = false; ;break;
}
}
}
int sleep_time = 3;
std::cout << "sleeping for " << sleep_time << " before shutdown\n";
sleep(sleep_time); // TODO: think I need this, to give publish time to complete
/* Commence orderly shutdown of the wamp_session. Shutdown is an asychronous
* operation so we start the request and then wait for the request to
* complete. Once complete, we shall not receive anymore events from the
* wamp_session object (and thus is safe to delete). */
std::cout << "requesting wamp_session closure\n";
auto fut_closed = ws->close();
fut_closed.wait();
// while (1) sleep(10);
/* We must be mindful to free the kernel and logger only after all sessions
are closed (e.g. sessions might attempt logging during their
destruction) */
g_kernel.reset();
return 0;
}
<|endoftext|>
|
<commit_before>//=======================================================================
// Copyright Baptiste Wicht 2011-2012.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef MTAC_CALL_GRAPH_H
#define MTAC_CALL_GRAPH_H
#include<vector>
#include<memory>
#include<unordered_map>
#include<unordered_set>
#include "../Function.hpp"
namespace std {
std::hash<std::string> hasher;
template<>
class hash<std::reference_wrapper<eddic::Function>> {
public:
size_t operator()(const std::reference_wrapper<eddic::Function>& val) const {
return hasher(val.get().mangled_name());
}
};
}
namespace eddic {
class Function;
namespace mtac {
typedef std::unordered_set<std::reference_wrapper<eddic::Function>> Reachable;
struct Program;
struct call_graph_node;
typedef std::shared_ptr<call_graph_node> call_graph_node_p;
struct call_graph_edge {
call_graph_node_p source;
call_graph_node_p target;
std::size_t count;
call_graph_edge(call_graph_node_p source, call_graph_node_p target) : source(source), target(target), count(0){
//Nothing to init
}
};
typedef std::shared_ptr<call_graph_edge> call_graph_edge_p;
struct call_graph_node {
eddic::Function& function;
std::vector<call_graph_edge_p> out_edges;
std::vector<call_graph_edge_p> in_edges;
call_graph_node(eddic::Function& function) : function(function){
//Nothing to init
}
};
class call_graph {
public:
call_graph_node_p entry = nullptr;
call_graph_node_p node(eddic::Function& function);
void add_edge(eddic::Function& source, eddic::Function& target);
call_graph_edge_p edge(eddic::Function& source, eddic::Function& target);
void compute_reachable();
void release_reachable();
bool is_reachable(eddic::Function& function);
private:
std::unordered_map<std::string, call_graph_node_p> nodes;
Reachable reachable;
};
void build_call_graph(mtac::Program& program);
} //end of mtac
} //end of eddic
#endif
<commit_msg>Avoid multiple definitions<commit_after>//=======================================================================
// Copyright Baptiste Wicht 2011-2012.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef MTAC_CALL_GRAPH_H
#define MTAC_CALL_GRAPH_H
#include<vector>
#include<memory>
#include<unordered_map>
#include<unordered_set>
#include "../Function.hpp"
namespace std {
template<>
class hash<std::reference_wrapper<eddic::Function>> {
private:
std::hash<std::string> hasher;
public:
size_t operator()(const std::reference_wrapper<eddic::Function>& val) const {
return hasher(val.get().mangled_name());
}
};
}
namespace eddic {
class Function;
namespace mtac {
typedef std::unordered_set<std::reference_wrapper<eddic::Function>> Reachable;
struct Program;
struct call_graph_node;
typedef std::shared_ptr<call_graph_node> call_graph_node_p;
struct call_graph_edge {
call_graph_node_p source;
call_graph_node_p target;
std::size_t count;
call_graph_edge(call_graph_node_p source, call_graph_node_p target) : source(source), target(target), count(0){
//Nothing to init
}
};
typedef std::shared_ptr<call_graph_edge> call_graph_edge_p;
struct call_graph_node {
eddic::Function& function;
std::vector<call_graph_edge_p> out_edges;
std::vector<call_graph_edge_p> in_edges;
call_graph_node(eddic::Function& function) : function(function){
//Nothing to init
}
};
class call_graph {
public:
call_graph_node_p entry = nullptr;
call_graph_node_p node(eddic::Function& function);
void add_edge(eddic::Function& source, eddic::Function& target);
call_graph_edge_p edge(eddic::Function& source, eddic::Function& target);
void compute_reachable();
void release_reachable();
bool is_reachable(eddic::Function& function);
private:
std::unordered_map<std::string, call_graph_node_p> nodes;
Reachable reachable;
};
void build_call_graph(mtac::Program& program);
} //end of mtac
} //end of eddic
#endif
<|endoftext|>
|
<commit_before>/*************************************************************************
*
* $RCSfile: componentdatahelper.hxx,v $
*
* $Revision: 1.8 $
*
* last change: $Author: vg $ $Date: 2005-03-23 08:46:26 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
/* PLEASE DON'T DELETE ANY COMMENT LINES, ALSO IT'S UNNECESSARY. */
#ifndef CONFIGMGR_BACKEND_COMPONENTDATAHELPER_HXX
#define CONFIGMGR_BACKEND_COMPONENTDATAHELPER_HXX
#ifndef _CONFIGMGR_TREE_VALUENODE_HXX
#include "valuenode.hxx"
#endif
#ifndef CONFIGMGR_UTILITY_HXX_
#include "utility.hxx"
#endif
#ifndef CONFIGMGR_STACK_HXX_
#include "stack.hxx"
#endif
#ifndef _COM_SUN_STAR_CONFIGURATION_BACKEND_TEMPLATEIDENTIFIER_HPP_
#include <com/sun/star/configuration/backend/TemplateIdentifier.hpp>
#endif
#ifndef _COM_SUN_STAR_CONFIGURATION_BACKEND_MALFORMEDDATAEXCEPTION_HPP_
#include <com/sun/star/configuration/backend/MalformedDataException.hpp>
#endif
#ifndef _COM_SUN_STAR_UNO_RUNTIMEEXCEPTION_HPP_
#include <com/sun/star/uno/RuntimeException.hpp>
#endif
#ifndef INCLUDED_MEMORY
#include <memory>
#define INCLUDED_MEMORY
#endif
#ifndef CONFIGMGR_BACKEND_MERGEDDATAPROVIDER_HXX
#include "mergeddataprovider.hxx"
#endif
#ifndef CONFIGMGR_LOGGER_HXX_
#include "logger.hxx"
#endif
#ifndef CONFIGMGR_BACKEND_REQUEST_HXX_
#include "request.hxx"
#endif
namespace configmgr
{
// -----------------------------------------------------------------------------
class OTreeNodeFactory;
// -----------------------------------------------------------------------------
namespace backend
{
// -----------------------------------------------------------------------------
namespace uno = ::com::sun::star::uno;
namespace backenduno = ::com::sun::star::configuration::backend;
using backenduno::TemplateIdentifier;
using ::rtl::OUString;
// -----------------------------------------------------------------------------
class DataBuilderContext
{
Logger m_aLogger;
Stack< ISubtree * > m_aParentStack;
OUString m_aActiveComponent;
uno::XInterface * m_pContext;
OUString m_aExpectedComponentName;
ITemplateDataProvider * m_aTemplateProvider;
public:
typedef uno::Reference< uno::XComponentContext > UnoContext;
explicit DataBuilderContext(UnoContext const & xContext);
DataBuilderContext(UnoContext const & xContext, uno::XInterface * _pContext , ITemplateDataProvider* aTemplateProvider = NULL);
DataBuilderContext(UnoContext const & xContext, uno::XInterface * _pContext, const OUString& aExpectedComponentName,ITemplateDataProvider* aTemplateProvider = NULL );
DataBuilderContext(DataBuilderContext const & aBaseContext, uno::XInterface * _pContext);
~DataBuilderContext();
bool isDone() const;
bool hasActiveComponent() const { return m_aActiveComponent.getLength() != 0; }
OUString getActiveComponent() const { return m_aActiveComponent; }
ISubtree & getCurrentParent()
CFG_UNO_THROW1( configuration::backend::MalformedDataException )
{ return implGetCurrentParent(); }
ISubtree const & getCurrentParent() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException )
{ return implGetCurrentParent(); }
node::Attributes getCurrentAttributes() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException )
{ return implGetCurrentParent().getAttributes(); }
ITemplateDataProvider * getTemplateProvider() const
{ return m_aTemplateProvider; }
OUString getTemplateComponent(TemplateIdentifier const & aItemType ) const;
TemplateIdentifier stripComponent (TemplateIdentifier const & aItemType ) const;
TemplateIdentifier completeComponent(TemplateIdentifier const & aItemType ) const;
TemplateIdentifier getCurrentItemType() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
TemplateIdentifier getValidItemType(TemplateIdentifier const & aItemType) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void startActiveComponent(OUString const & _aComponent)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void endActiveComponent()
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
bool isProperty(INode * pProp) const
CFG_UNO_THROW_RTE();
bool isNode(INode * pNode) const CFG_UNO_THROW_RTE()
{ return !isProperty(pNode); }
void pushNode(ISubtree * pTree)
CFG_UNO_THROW_RTE();
void popNode()
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
INode * findProperty(OUString const & _aName)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
ISubtree * findNode(OUString const & _aName)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
bool isWritable(INode const * pNode) const
CFG_NOTHROW( );
bool isRemovable(ISubtree const * pItem) const
CFG_NOTHROW( );
ISubtree * addNodeToCurrent(std::auto_ptr<ISubtree> _aNode)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
ISubtree * addLocalizedToCurrent(std::auto_ptr<ISubtree> _aNode)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
ValueNode * addPropertyToCurrent(std::auto_ptr<ValueNode> _aNode, bool _bMayReplace = false)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void markCurrentMerged();
// Logging support
Logger const & getLogger() const { return m_aLogger; }
OUString getNodeParentagePath() const;
OUString getNodePath(OUString const & aNodeName) const;
// Exception support
void raiseMalformedDataException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseNoSupportException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseIllegalAccessException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseIllegalArgumentException (sal_Char const * _pText, sal_Int16 _nPos = 0) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseElementExistException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseNoSuchElementException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseUnknownPropertyException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raisePropertyExistException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseIllegalTypeException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
TemplateResult getTemplateData (TemplateRequest const & _aRequest );
private:
INode * findChild(OUString const & _aName)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
OUString makeMessageWithPath(sal_Char const * _pText) const
CFG_UNO_THROW_RTE( );
OUString makeMessageWithName(sal_Char const * _pText, OUString const & _aName) const
CFG_UNO_THROW_RTE( );
ISubtree & implGetCurrentParent() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
};
// -----------------------------------------------------------------------------
class ComponentDataFactory
{
OTreeNodeFactory & m_rNodeFactory;
public:
ComponentDataFactory();
ComponentDataFactory(OTreeNodeFactory & _rNodeFactory)
: m_rNodeFactory(_rNodeFactory)
{}
public:
OTreeNodeFactory& getNodeFactory() const { return m_rNodeFactory; }
std::auto_ptr<ISubtree> createGroup(OUString const & _aName,
bool _bExtensible,
node::Attributes const & _aAttributes) const;
std::auto_ptr<ISubtree> createSet( OUString const & _aName,
TemplateIdentifier const & aItemType,
bool _bExtensible,
node::Attributes const & _aAttributes) const;
std::auto_ptr<ISubtree> createLocalizedContainer(OUString const & _aName,
uno::Type const & _aValueType,
node::Attributes const & _aAttributes) const;
std::auto_ptr<ISubtree> createPlaceHolder(OUString const & _aName,
TemplateIdentifier const & _aInstanceType) const;
static bool isInstancePlaceHolder(ISubtree const & _aInstanceTree);
static TemplateIdentifier getInstanceType(ISubtree const & _aInstanceTree);
};
// -----------------------------------------------------------------------------
} // namespace backend
// -----------------------------------------------------------------------------
} // namespace configmgr
#endif
<commit_msg>INTEGRATION: CWS ooo19126 (1.8.22); FILE MERGED 2005/09/05 17:03:55 rt 1.8.22.1: #i54170# Change license header: remove SISSL<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: componentdatahelper.hxx,v $
*
* $Revision: 1.9 $
*
* last change: $Author: rt $ $Date: 2005-09-08 03:28:18 $
*
* 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
*
************************************************************************/
/* PLEASE DON'T DELETE ANY COMMENT LINES, ALSO IT'S UNNECESSARY. */
#ifndef CONFIGMGR_BACKEND_COMPONENTDATAHELPER_HXX
#define CONFIGMGR_BACKEND_COMPONENTDATAHELPER_HXX
#ifndef _CONFIGMGR_TREE_VALUENODE_HXX
#include "valuenode.hxx"
#endif
#ifndef CONFIGMGR_UTILITY_HXX_
#include "utility.hxx"
#endif
#ifndef CONFIGMGR_STACK_HXX_
#include "stack.hxx"
#endif
#ifndef _COM_SUN_STAR_CONFIGURATION_BACKEND_TEMPLATEIDENTIFIER_HPP_
#include <com/sun/star/configuration/backend/TemplateIdentifier.hpp>
#endif
#ifndef _COM_SUN_STAR_CONFIGURATION_BACKEND_MALFORMEDDATAEXCEPTION_HPP_
#include <com/sun/star/configuration/backend/MalformedDataException.hpp>
#endif
#ifndef _COM_SUN_STAR_UNO_RUNTIMEEXCEPTION_HPP_
#include <com/sun/star/uno/RuntimeException.hpp>
#endif
#ifndef INCLUDED_MEMORY
#include <memory>
#define INCLUDED_MEMORY
#endif
#ifndef CONFIGMGR_BACKEND_MERGEDDATAPROVIDER_HXX
#include "mergeddataprovider.hxx"
#endif
#ifndef CONFIGMGR_LOGGER_HXX_
#include "logger.hxx"
#endif
#ifndef CONFIGMGR_BACKEND_REQUEST_HXX_
#include "request.hxx"
#endif
namespace configmgr
{
// -----------------------------------------------------------------------------
class OTreeNodeFactory;
// -----------------------------------------------------------------------------
namespace backend
{
// -----------------------------------------------------------------------------
namespace uno = ::com::sun::star::uno;
namespace backenduno = ::com::sun::star::configuration::backend;
using backenduno::TemplateIdentifier;
using ::rtl::OUString;
// -----------------------------------------------------------------------------
class DataBuilderContext
{
Logger m_aLogger;
Stack< ISubtree * > m_aParentStack;
OUString m_aActiveComponent;
uno::XInterface * m_pContext;
OUString m_aExpectedComponentName;
ITemplateDataProvider * m_aTemplateProvider;
public:
typedef uno::Reference< uno::XComponentContext > UnoContext;
explicit DataBuilderContext(UnoContext const & xContext);
DataBuilderContext(UnoContext const & xContext, uno::XInterface * _pContext , ITemplateDataProvider* aTemplateProvider = NULL);
DataBuilderContext(UnoContext const & xContext, uno::XInterface * _pContext, const OUString& aExpectedComponentName,ITemplateDataProvider* aTemplateProvider = NULL );
DataBuilderContext(DataBuilderContext const & aBaseContext, uno::XInterface * _pContext);
~DataBuilderContext();
bool isDone() const;
bool hasActiveComponent() const { return m_aActiveComponent.getLength() != 0; }
OUString getActiveComponent() const { return m_aActiveComponent; }
ISubtree & getCurrentParent()
CFG_UNO_THROW1( configuration::backend::MalformedDataException )
{ return implGetCurrentParent(); }
ISubtree const & getCurrentParent() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException )
{ return implGetCurrentParent(); }
node::Attributes getCurrentAttributes() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException )
{ return implGetCurrentParent().getAttributes(); }
ITemplateDataProvider * getTemplateProvider() const
{ return m_aTemplateProvider; }
OUString getTemplateComponent(TemplateIdentifier const & aItemType ) const;
TemplateIdentifier stripComponent (TemplateIdentifier const & aItemType ) const;
TemplateIdentifier completeComponent(TemplateIdentifier const & aItemType ) const;
TemplateIdentifier getCurrentItemType() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
TemplateIdentifier getValidItemType(TemplateIdentifier const & aItemType) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void startActiveComponent(OUString const & _aComponent)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void endActiveComponent()
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
bool isProperty(INode * pProp) const
CFG_UNO_THROW_RTE();
bool isNode(INode * pNode) const CFG_UNO_THROW_RTE()
{ return !isProperty(pNode); }
void pushNode(ISubtree * pTree)
CFG_UNO_THROW_RTE();
void popNode()
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
INode * findProperty(OUString const & _aName)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
ISubtree * findNode(OUString const & _aName)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
bool isWritable(INode const * pNode) const
CFG_NOTHROW( );
bool isRemovable(ISubtree const * pItem) const
CFG_NOTHROW( );
ISubtree * addNodeToCurrent(std::auto_ptr<ISubtree> _aNode)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
ISubtree * addLocalizedToCurrent(std::auto_ptr<ISubtree> _aNode)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
ValueNode * addPropertyToCurrent(std::auto_ptr<ValueNode> _aNode, bool _bMayReplace = false)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void markCurrentMerged();
// Logging support
Logger const & getLogger() const { return m_aLogger; }
OUString getNodeParentagePath() const;
OUString getNodePath(OUString const & aNodeName) const;
// Exception support
void raiseMalformedDataException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseNoSupportException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseIllegalAccessException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseIllegalArgumentException (sal_Char const * _pText, sal_Int16 _nPos = 0) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseElementExistException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseNoSuchElementException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseUnknownPropertyException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raisePropertyExistException (sal_Char const * _pText, OUString const & _sElement) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
void raiseIllegalTypeException (sal_Char const * _pText) const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
TemplateResult getTemplateData (TemplateRequest const & _aRequest );
private:
INode * findChild(OUString const & _aName)
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
OUString makeMessageWithPath(sal_Char const * _pText) const
CFG_UNO_THROW_RTE( );
OUString makeMessageWithName(sal_Char const * _pText, OUString const & _aName) const
CFG_UNO_THROW_RTE( );
ISubtree & implGetCurrentParent() const
CFG_UNO_THROW1( configuration::backend::MalformedDataException );
};
// -----------------------------------------------------------------------------
class ComponentDataFactory
{
OTreeNodeFactory & m_rNodeFactory;
public:
ComponentDataFactory();
ComponentDataFactory(OTreeNodeFactory & _rNodeFactory)
: m_rNodeFactory(_rNodeFactory)
{}
public:
OTreeNodeFactory& getNodeFactory() const { return m_rNodeFactory; }
std::auto_ptr<ISubtree> createGroup(OUString const & _aName,
bool _bExtensible,
node::Attributes const & _aAttributes) const;
std::auto_ptr<ISubtree> createSet( OUString const & _aName,
TemplateIdentifier const & aItemType,
bool _bExtensible,
node::Attributes const & _aAttributes) const;
std::auto_ptr<ISubtree> createLocalizedContainer(OUString const & _aName,
uno::Type const & _aValueType,
node::Attributes const & _aAttributes) const;
std::auto_ptr<ISubtree> createPlaceHolder(OUString const & _aName,
TemplateIdentifier const & _aInstanceType) const;
static bool isInstancePlaceHolder(ISubtree const & _aInstanceTree);
static TemplateIdentifier getInstanceType(ISubtree const & _aInstanceTree);
};
// -----------------------------------------------------------------------------
} // namespace backend
// -----------------------------------------------------------------------------
} // namespace configmgr
#endif
<|endoftext|>
|
<commit_before>/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef INCLUDED_XMLOFF_XMLPRMAP_HXX
#define INCLUDED_XMLOFF_XMLPRMAP_HXX
#include <sal/config.h>
#include <xmloff/dllapi.h>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <vector>
#include <xmloff/uniref.hxx>
#include <xmloff/maptype.hxx>
#include <xmloff/xmltypes.hxx>
#include <xmloff/prhdlfac.hxx>
#include <tools/debug.hxx>
class SvXMLUnitConverter;
class XMLPropertyHandler;
///////////////////////////////////////////////////////////////////////////
//
/** Helper-class for XML-im/export:
- Holds a pointer to a given array of XMLPropertyMapEntry
- Provides several methods to access data from this array
- Holds a Sequence of XML-names (for properties)
- The filter takes all properties of the XPropertySet which are also
in the XMLPropertyMapEntry and which are have not a default value
and put them into a vector of XMLPropertyStae
- this class knows how to compare, im/export properties
Attention: At all methods, which get an index as parameter, there is no
range validation to save runtime !!
*/
struct XMLPropertySetMapperEntry_Impl
{
OUString sXMLAttributeName;
OUString sAPIPropertyName;
sal_Int32 nType;
sal_uInt16 nXMLNameSpace;
sal_Int16 nContextId;
SvtSaveOptions::ODFDefaultVersion nEarliestODFVersionForExport;
const XMLPropertyHandler *pHdl;
XMLPropertySetMapperEntry_Impl(
const XMLPropertyMapEntry& rMapEntry,
const UniReference< XMLPropertyHandlerFactory >& rFactory );
XMLPropertySetMapperEntry_Impl(
const XMLPropertySetMapperEntry_Impl& rEntry );
sal_uInt32 GetPropType() const { return nType & XML_TYPE_PROP_MASK; }
};
class XMLOFF_DLLPUBLIC XMLPropertySetMapper : public UniRefBase
{
::std::vector< XMLPropertySetMapperEntry_Impl > aMapEntries;
::std::vector< UniReference < XMLPropertyHandlerFactory > > aHdlFactories;
public:
/** The last element of the XMLPropertyMapEntry-array must contain NULL-values */
XMLPropertySetMapper(
const XMLPropertyMapEntry* pEntries,
const UniReference< XMLPropertyHandlerFactory >& rFactory );
virtual ~XMLPropertySetMapper();
void AddMapperEntry( const UniReference < XMLPropertySetMapper >& rMapper );
/** Return number of entries in input-array */
sal_Int32 GetEntryCount() const { return aMapEntries.size(); }
/** Returns the flags of an entry */
sal_uInt32 GetEntryFlags( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].nType & ~MID_FLAG_MASK;
}
/** Returns the type of an entry */
sal_uInt32 GetEntryType( sal_Int32 nIndex,
sal_Bool bWithFlags = sal_True ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
sal_uInt32 nType = aMapEntries[nIndex].nType;
if( !bWithFlags )
nType = nType & MID_FLAG_MASK;
return nType;
}
/** Returns the namespace-key of an entry */
sal_uInt16 GetEntryNameSpace( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].nXMLNameSpace;
}
/** Returns the 'local' XML-name of the entry */
const OUString& GetEntryXMLName( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].sXMLAttributeName;
}
/** Returns the entry API name */
const OUString& GetEntryAPIName( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].sAPIPropertyName;
}
/** returns the entry context id. -1 is a valid index here. */
sal_Int16 GetEntryContextId( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= -1) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return nIndex == -1 ? 0 : aMapEntries[nIndex].nContextId;
}
/** returns the earliest odf version for which this property should be exported. */
SvtSaveOptions::ODFDefaultVersion GetEarliestODFVersionForExport( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= -1) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return nIndex == -1 ? SvtSaveOptions::ODFVER_UNKNOWN : aMapEntries[nIndex].nEarliestODFVersionForExport;
}
/** Returns the index of an entry with the given XML-name and namespace
If there is no matching entry the method returns -1 */
sal_Int32 GetEntryIndex( sal_uInt16 nNamespace,
const OUString& rStrName,
sal_uInt32 nPropType,
sal_Int32 nStartAt = -1 ) const;
/** Retrieves a PropertyHandler for that property which placed at nIndex in the XMLPropertyMapEntry-array */
const XMLPropertyHandler* GetPropertyHandler( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].pHdl;
}
/** import/export
This methods calls the respective im/export-method of the respective PropertyHandler. */
virtual sal_Bool exportXML( OUString& rStrExpValue,
const XMLPropertyState& rProperty,
const SvXMLUnitConverter& rUnitConverter ) const;
virtual sal_Bool importXML( const OUString& rStrImpValue,
XMLPropertyState& rProperty,
const SvXMLUnitConverter& rUnitConverter ) const;
/** searches for an entry that matches the given api name, namespace and local name or -1 if nothing found */
sal_Int32 FindEntryIndex( const sal_Char* sApiName,
sal_uInt16 nNameSpace,
const OUString& sXMLName ) const;
/** searches for an entry that matches the given ContextId or gives -1 if nothing found */
sal_Int32 FindEntryIndex( const sal_Int16 nContextId ) const;
/** Remove an entry */
void RemoveEntry( sal_Int32 nIndex );
};
#endif // INCLUDED_XMLOFF_XMLPRMAP_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
<commit_msg>just beautify this a little<commit_after>/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef INCLUDED_XMLOFF_XMLPRMAP_HXX
#define INCLUDED_XMLOFF_XMLPRMAP_HXX
#include <sal/config.h>
#include <xmloff/dllapi.h>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <vector>
#include <xmloff/uniref.hxx>
#include <xmloff/maptype.hxx>
#include <xmloff/xmltypes.hxx>
#include <xmloff/prhdlfac.hxx>
#include <tools/debug.hxx>
class SvXMLUnitConverter;
class XMLPropertyHandler;
///////////////////////////////////////////////////////////////////////////
//
/** Helper-class for XML-im/export:
- Holds a pointer to a given array of XMLPropertyMapEntry
- Provides several methods to access data from this array
- Holds a Sequence of XML-names (for properties)
- The filter takes all properties of the XPropertySet which are also
in the XMLPropertyMapEntry and which are have not a default value
and put them into a vector of XMLPropertyStae
- this class knows how to compare, im/export properties
Attention: At all methods, which get an index as parameter, there is no
range validation to save runtime !!
*/
struct XMLPropertySetMapperEntry_Impl
{
OUString sXMLAttributeName;
OUString sAPIPropertyName;
sal_Int32 nType;
sal_uInt16 nXMLNameSpace;
sal_Int16 nContextId;
SvtSaveOptions::ODFDefaultVersion nEarliestODFVersionForExport;
const XMLPropertyHandler *pHdl;
XMLPropertySetMapperEntry_Impl(
const XMLPropertyMapEntry& rMapEntry,
const UniReference< XMLPropertyHandlerFactory >& rFactory );
XMLPropertySetMapperEntry_Impl(
const XMLPropertySetMapperEntry_Impl& rEntry );
sal_uInt32 GetPropType() const { return nType & XML_TYPE_PROP_MASK; }
};
class XMLOFF_DLLPUBLIC XMLPropertySetMapper : public UniRefBase
{
::std::vector< XMLPropertySetMapperEntry_Impl > aMapEntries;
::std::vector< UniReference < XMLPropertyHandlerFactory > > aHdlFactories;
public:
/** The last element of the XMLPropertyMapEntry-array must contain NULL-values */
XMLPropertySetMapper(
const XMLPropertyMapEntry* pEntries,
const UniReference< XMLPropertyHandlerFactory >& rFactory );
virtual ~XMLPropertySetMapper();
void AddMapperEntry( const UniReference < XMLPropertySetMapper >& rMapper );
/** Return number of entries in input-array */
sal_Int32 GetEntryCount() const { return aMapEntries.size(); }
/** Returns the flags of an entry */
sal_uInt32 GetEntryFlags( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].nType & ~MID_FLAG_MASK;
}
/** Returns the type of an entry */
sal_uInt32 GetEntryType( sal_Int32 nIndex,
sal_Bool bWithFlags = sal_True ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
sal_uInt32 nType = aMapEntries[nIndex].nType;
if( !bWithFlags )
nType = nType & MID_FLAG_MASK;
return nType;
}
/** Returns the namespace-key of an entry */
sal_uInt16 GetEntryNameSpace( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].nXMLNameSpace;
}
/** Returns the 'local' XML-name of the entry */
const OUString& GetEntryXMLName( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].sXMLAttributeName;
}
/** Returns the entry API name */
const OUString& GetEntryAPIName( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].sAPIPropertyName;
}
/** returns the entry context id. -1 is a valid index here. */
sal_Int16 GetEntryContextId( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= -1) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return nIndex == -1 ? 0 : aMapEntries[nIndex].nContextId;
}
/** returns the earliest odf version for which this property should be exported. */
SvtSaveOptions::ODFDefaultVersion GetEarliestODFVersionForExport( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= -1) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return nIndex == -1 ? SvtSaveOptions::ODFVER_UNKNOWN : aMapEntries[nIndex].nEarliestODFVersionForExport;
}
/** Returns the index of an entry with the given XML-name and namespace
If there is no matching entry the method returns -1 */
sal_Int32 GetEntryIndex( sal_uInt16 nNamespace,
const OUString& rStrName,
sal_uInt32 nPropType,
sal_Int32 nStartAt = -1 ) const;
/** Retrieves a PropertyHandler for that property which placed at nIndex in the XMLPropertyMapEntry-array */
const XMLPropertyHandler* GetPropertyHandler( sal_Int32 nIndex ) const
{
DBG_ASSERT( (nIndex >= 0) && (nIndex < (sal_Int32)aMapEntries.size() ), "illegal access to invalid entry!" );
return aMapEntries[nIndex].pHdl;
}
/** import/export
This methods calls the respective im/export-method of the respective PropertyHandler. */
virtual sal_Bool exportXML( OUString& rStrExpValue,
const XMLPropertyState& rProperty,
const SvXMLUnitConverter& rUnitConverter ) const;
virtual sal_Bool importXML( const OUString& rStrImpValue,
XMLPropertyState& rProperty,
const SvXMLUnitConverter& rUnitConverter ) const;
/** searches for an entry that matches the given api name, namespace and local name or -1 if nothing found */
sal_Int32 FindEntryIndex( const sal_Char* sApiName,
sal_uInt16 nNameSpace,
const OUString& sXMLName ) const;
/** searches for an entry that matches the given ContextId or gives -1 if nothing found */
sal_Int32 FindEntryIndex( const sal_Int16 nContextId ) const;
/** Remove an entry */
void RemoveEntry( sal_Int32 nIndex );
};
#endif // INCLUDED_XMLOFF_XMLPRMAP_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
<|endoftext|>
|
<commit_before>/**
* @file exoflickr
* @brief Lightweight wrapper around the Flickr API for signing and such
*
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
* Copyright (C) 2012 Katharine Berry
*
* 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;
* version 2.1 of the License only.
*
* 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.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "llbufferstream.h"
#include "lluri.h"
#include "llhttpclient.h"
#include "llxmltree.h"
#include "llsdserialize.h"
#include "llviewercontrol.h"
#include "llbase64.h"
#include "reader.h" // Json
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include "exoflickr.h"
class exoFlickrResponse : public LLHTTPClient::Responder
{
public:
exoFlickrResponse(exoFlickr::response_callback_t &callback);
/* virtual */ void completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
private:
exoFlickr::response_callback_t mCallback;
};
class exoFlickrUploadResponse : public LLHTTPClient::Responder
{
public:
exoFlickrUploadResponse(exoFlickr::response_callback_t &callback);
/* virtual */ void completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
private:
exoFlickr::response_callback_t mCallback;
};
//static
void exoFlickr::request(const std::string& method, const LLSD& args, response_callback_t callback)
{
LLSD params(args);
params["format"] = "json";
params["method"] = method;
params["nojsoncallback"] = 1;
signRequest(params, "GET", "http://api.flickr.com/services/rest/");
LLHTTPClient::get("http://api.flickr.com/services/rest/", params, new exoFlickrResponse(callback));
}
void exoFlickr::signRequest(LLSD& params, std::string method, std::string url)
{
// Oauth junk
params["oauth_consumer_key"] = EXO_FLICKR_API_KEY;
std::string oauth_token = gSavedPerAccountSettings.getString("ExodusFlickrToken");
if(oauth_token.length())
{
params["oauth_token"] = oauth_token;
}
params["oauth_signature_method"] = "HMAC-SHA1";
params["oauth_timestamp"] = (LLSD::Integer)time(NULL);
params["oauth_nonce"] = ll_rand();
params["oauth_version"] = "1.0";
params["oauth_signature"] = getSignatureForCall(params, url, method); // This must be the last one set.
}
//static
void exoFlickr::uploadPhoto(const LLSD& args, LLImageFormatted *image, response_callback_t callback)
{
LLSD params(args);
signRequest(params, "POST", "http://api.flickr.com/services/upload/");
// It would be nice if there was an easy way to do multipart form data. Oh well.
const std::string boundary = "------------abcdefgh012345";
std::ostringstream post_stream;
post_stream << "--" << boundary;
// Add all the parameters from LLSD to the query.
for(LLSD::map_const_iterator itr = params.beginMap(); itr != params.endMap(); ++itr)
{
post_stream << "\r\nContent-Disposition: form-data; name=\"" << itr->first << "\"";
post_stream << "\r\n\r\n" << itr->second.asString();
post_stream << "\r\n" << "--" << boundary;
}
// Headers for the photo
post_stream << "\r\nContent-Disposition: form-data; name=\"photo\"; filename=\"snapshot." << image->getExtension() << "\"";
post_stream << "\r\nContent-Type: ";
// Apparently LLImageFormatted doesn't know what mimetype it has.
if(image->getExtension() == "jpg")
{
post_stream << "image/jpeg";
}
else if(image->getExtension() == "png")
{
post_stream << "image/png";
}
else // This will (probably) only happen if someone decides to put the BMP entry back in the format selection floater.
{ // I wonder if Flickr would do the right thing.
post_stream << "application/x-wtf";
LL_WARNS("FlickrAPI") << "Uploading unknown image type." << LL_ENDL;
}
post_stream << "\r\n\r\n";
// Now we build the postdata array, including the photo in the middle of it.
std::string post_str = post_stream.str();
size_t total_data_size = image->getDataSize() + post_str.length() + boundary.length() + 6; // + 6 = "\r\n" + "--" + "--"
char* post_data = new char[total_data_size + 1];
memcpy(post_data, post_str.data(), post_str.length());
char* address = post_data + post_str.length();
memcpy(address, image->getData(), image->getDataSize());
address += image->getDataSize();
std::string post_tail = "\r\n--" + boundary + "--";
memcpy(address, post_tail.data(), post_tail.length());
address += post_tail.length();
llassert(address <= post_data + total_data_size /* After all that, check we didn't overrun */);
// We have a post body! Now we can go about building the actual request...
LLSD headers;
headers["Content-Type"] = "multipart/form-data; boundary=" + boundary;
// <FS:TS> Patch from Exodus:
// The default timeout (one minute) isn't enough for a large picture.
// 10 minutes is arbitrary, but should be long enough.
LLHTTPClient::postRaw("http://api.flickr.com/services/upload/", (U8*)post_data, total_data_size, new exoFlickrUploadResponse(callback), headers, 600);
// </FS:TS>
// The HTTP client takes ownership of our post_data array,
// and will delete it when it's done.
}
//static
std::string exoFlickr::getSignatureForCall(const LLSD& parameters, std::string url, std::string method)
{
std::vector<std::string> keys;
for(LLSD::map_const_iterator itr = parameters.beginMap(); itr != parameters.endMap(); ++itr)
{
keys.push_back(itr->first);
}
std::sort(keys.begin(), keys.end());
std::ostringstream q;
q << LLURI::escape(method);
q << "&" << LLURI::escape(url) << "&";
for(std::vector<std::string>::const_iterator itr = keys.begin(); itr != keys.end(); ++itr)
{
if(itr != keys.begin())
{
q << "%26";
}
q << LLURI::escape(*itr);
q << "%3D" << LLURI::escape(LLURI::escape(parameters[*itr]));
}
unsigned char data[EVP_MAX_MD_SIZE];
unsigned int length;
std::string key = std::string(EXO_FLICKR_API_SECRET) + "&" + gSavedPerAccountSettings.getString("ExodusFlickrTokenSecret");
std::string to_hash = q.str();
HMAC(EVP_sha1(), (void*)key.c_str(), key.length(), (unsigned char*)to_hash.c_str(), to_hash.length(), data, &length);
std::string signature = LLBase64::encode((U8*)data, length);
return signature;
}
exoFlickrUploadResponse::exoFlickrUploadResponse(exoFlickr::response_callback_t &callback)
: mCallback(callback)
{
}
void exoFlickrUploadResponse::completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLBufferStream istr(channels, buffer.get());
std::stringstream strstrm;
strstrm << istr.rdbuf();
std::string result = std::string(strstrm.str());
LLSD output;
bool success;
LLXmlTree tree;
if(!tree.parseString(result))
{
LL_WARNS("FlickrAPI") << "Couldn't parse flickr response(" << status << "): " << result << LL_ENDL;
mCallback(false, LLSD());
return;
}
LLXmlTreeNode* root = tree.getRoot();
if(!root->hasName("rsp"))
{
LL_WARNS("FlickrAPI") << "Bad root node: " << root->getName() << LL_ENDL;
mCallback(false, LLSD());
return;
}
std::string stat;
root->getAttributeString("stat", stat);
output["stat"] = stat;
if(stat == "ok")
{
success = true;
LLXmlTreeNode* photoid_node = root->getChildByName("photoid");
if(photoid_node)
{
output["photoid"] = photoid_node->getContents();
}
}
else
{
success = false;
LLXmlTreeNode* err_node = root->getChildByName("err");
if(err_node)
{
S32 code;
std::string msg;
err_node->getAttributeS32("code", code);
err_node->getAttributeString("msg", msg);
output["code"] = code;
output["msg"] = msg;
}
}
mCallback(success, output);
}
static void JsonToLLSD(const Json::Value &root, LLSD &output)
{
if(root.isObject())
{
Json::Value::Members keys = root.getMemberNames();
for(Json::Value::Members::const_iterator itr = keys.begin(); itr != keys.end(); ++itr)
{
LLSD elem;
JsonToLLSD(root[*itr], elem);
output[*itr] = elem;
}
}
else if(root.isArray())
{
for(Json::Value::const_iterator itr = root.begin(); itr != root.end(); ++itr)
{
LLSD elem;
JsonToLLSD(*itr, elem);
output.append(elem);
}
}
else
{
switch(root.type())
{
case Json::intValue:
output = root.asInt();
break;
case Json::realValue:
case Json::uintValue:
output = root.asDouble();
break;
case Json::stringValue:
output = root.asString();
break;
case Json::booleanValue:
output = root.asBool();
break;
case Json::nullValue:
output = NULL;
break;
default:
break;
}
}
}
exoFlickrResponse::exoFlickrResponse(exoFlickr::response_callback_t &callback) :
mCallback(callback)
{
}
void exoFlickrResponse::completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLBufferStream istr(channels, buffer.get());
std::stringstream strstrm;
strstrm << istr.rdbuf();
std::string result = strstrm.str();
Json::Value root;
Json::Reader reader;
bool success = reader.parse(result, root);
if(!success)
{
mCallback(false, LLSD());
return;
}
else
{
LL_INFOS("FlickrAPI") << "Got response string: " << result << LL_ENDL;
LLSD response;
JsonToLLSD(root, response);
mCallback(isGoodStatus(status), response);
}
}
<commit_msg>Fix for Linux compilation.<commit_after>/**
* @file exoflickr
* @brief Lightweight wrapper around the Flickr API for signing and such
*
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
* Copyright (C) 2012 Katharine Berry
*
* 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;
* version 2.1 of the License only.
*
* 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.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "llbufferstream.h"
#include "lluri.h"
#include "llhttpclient.h"
#include "llxmltree.h"
#include "llsdserialize.h"
#include "llviewercontrol.h"
#include "llbase64.h"
#include "reader.h" // Json
#include <openssl/hmac.h>
#include <openssl/evp.h>
#include "exoflickr.h"
class exoFlickrResponse : public LLHTTPClient::Responder
{
public:
exoFlickrResponse(exoFlickr::response_callback_t &callback);
/* virtual */ void completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
private:
exoFlickr::response_callback_t mCallback;
};
class exoFlickrUploadResponse : public LLHTTPClient::Responder
{
public:
exoFlickrUploadResponse(exoFlickr::response_callback_t &callback);
/* virtual */ void completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
private:
exoFlickr::response_callback_t mCallback;
};
//static
void exoFlickr::request(const std::string& method, const LLSD& args, response_callback_t callback)
{
LLSD params(args);
params["format"] = "json";
params["method"] = method;
params["nojsoncallback"] = 1;
signRequest(params, "GET", "http://api.flickr.com/services/rest/");
LLHTTPClient::get("http://api.flickr.com/services/rest/", params, new exoFlickrResponse(callback));
}
void exoFlickr::signRequest(LLSD& params, std::string method, std::string url)
{
// Oauth junk
params["oauth_consumer_key"] = EXO_FLICKR_API_KEY;
std::string oauth_token = gSavedPerAccountSettings.getString("ExodusFlickrToken");
if(oauth_token.length())
{
params["oauth_token"] = oauth_token;
}
params["oauth_signature_method"] = "HMAC-SHA1";
params["oauth_timestamp"] = (LLSD::Integer)time(NULL);
params["oauth_nonce"] = ll_rand();
params["oauth_version"] = "1.0";
params["oauth_signature"] = getSignatureForCall(params, url, method); // This must be the last one set.
}
//static
void exoFlickr::uploadPhoto(const LLSD& args, LLImageFormatted *image, response_callback_t callback)
{
LLSD params(args);
signRequest(params, "POST", "http://api.flickr.com/services/upload/");
// It would be nice if there was an easy way to do multipart form data. Oh well.
const std::string boundary = "------------abcdefgh012345";
std::ostringstream post_stream;
post_stream << "--" << boundary;
// Add all the parameters from LLSD to the query.
for(LLSD::map_const_iterator itr = params.beginMap(); itr != params.endMap(); ++itr)
{
post_stream << "\r\nContent-Disposition: form-data; name=\"" << itr->first << "\"";
post_stream << "\r\n\r\n" << itr->second.asString();
post_stream << "\r\n" << "--" << boundary;
}
// Headers for the photo
post_stream << "\r\nContent-Disposition: form-data; name=\"photo\"; filename=\"snapshot." << image->getExtension() << "\"";
post_stream << "\r\nContent-Type: ";
// Apparently LLImageFormatted doesn't know what mimetype it has.
if(image->getExtension() == "jpg")
{
post_stream << "image/jpeg";
}
else if(image->getExtension() == "png")
{
post_stream << "image/png";
}
else // This will (probably) only happen if someone decides to put the BMP entry back in the format selection floater.
{ // I wonder if Flickr would do the right thing.
post_stream << "application/x-wtf";
LL_WARNS("FlickrAPI") << "Uploading unknown image type." << LL_ENDL;
}
post_stream << "\r\n\r\n";
// Now we build the postdata array, including the photo in the middle of it.
std::string post_str = post_stream.str();
size_t total_data_size = image->getDataSize() + post_str.length() + boundary.length() + 6; // + 6 = "\r\n" + "--" + "--"
char* post_data = new char[total_data_size + 1];
memcpy(post_data, post_str.data(), post_str.length());
char* address = post_data + post_str.length();
memcpy(address, image->getData(), image->getDataSize());
address += image->getDataSize();
std::string post_tail = "\r\n--" + boundary + "--";
memcpy(address, post_tail.data(), post_tail.length());
address += post_tail.length();
llassert(address <= post_data + total_data_size /* After all that, check we didn't overrun */);
// We have a post body! Now we can go about building the actual request...
LLSD headers;
headers["Content-Type"] = "multipart/form-data; boundary=" + boundary;
// <FS:TS> Patch from Exodus:
// The default timeout (one minute) isn't enough for a large picture.
// 10 minutes is arbitrary, but should be long enough.
LLHTTPClient::postRaw("http://api.flickr.com/services/upload/", (U8*)post_data, total_data_size, new exoFlickrUploadResponse(callback), headers, 600);
// </FS:TS>
// The HTTP client takes ownership of our post_data array,
// and will delete it when it's done.
}
//static
std::string exoFlickr::getSignatureForCall(const LLSD& parameters, std::string url, std::string method)
{
std::vector<std::string> keys;
for(LLSD::map_const_iterator itr = parameters.beginMap(); itr != parameters.endMap(); ++itr)
{
keys.push_back(itr->first);
}
std::sort(keys.begin(), keys.end());
std::ostringstream q;
q << LLURI::escape(method);
q << "&" << LLURI::escape(url) << "&";
for(std::vector<std::string>::const_iterator itr = keys.begin(); itr != keys.end(); ++itr)
{
if(itr != keys.begin())
{
q << "%26";
}
q << LLURI::escape(*itr);
q << "%3D" << LLURI::escape(LLURI::escape(parameters[*itr]));
}
unsigned char data[EVP_MAX_MD_SIZE];
unsigned int length;
std::string key = std::string(EXO_FLICKR_API_SECRET) + "&" + gSavedPerAccountSettings.getString("ExodusFlickrTokenSecret");
std::string to_hash = q.str();
HMAC(EVP_sha1(), (void*)key.c_str(), key.length(), (unsigned char*)to_hash.c_str(), to_hash.length(), data, &length);
std::string signature = LLBase64::encode((U8*)data, length);
return signature;
}
exoFlickrUploadResponse::exoFlickrUploadResponse(exoFlickr::response_callback_t &callback)
: mCallback(callback)
{
}
void exoFlickrUploadResponse::completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLBufferStream istr(channels, buffer.get());
std::stringstream strstrm;
strstrm << istr.rdbuf();
std::string result = std::string(strstrm.str());
LLSD output;
bool success;
LLXmlTree tree;
if(!tree.parseString(result))
{
LL_WARNS("FlickrAPI") << "Couldn't parse flickr response(" << status << "): " << result << LL_ENDL;
mCallback(false, LLSD());
return;
}
LLXmlTreeNode* root = tree.getRoot();
if(!root->hasName("rsp"))
{
LL_WARNS("FlickrAPI") << "Bad root node: " << root->getName() << LL_ENDL;
mCallback(false, LLSD());
return;
}
std::string stat;
root->getAttributeString("stat", stat);
output["stat"] = stat;
if(stat == "ok")
{
success = true;
LLXmlTreeNode* photoid_node = root->getChildByName("photoid");
if(photoid_node)
{
output["photoid"] = photoid_node->getContents();
}
}
else
{
success = false;
LLXmlTreeNode* err_node = root->getChildByName("err");
if(err_node)
{
S32 code;
std::string msg;
err_node->getAttributeS32("code", code);
err_node->getAttributeString("msg", msg);
output["code"] = code;
output["msg"] = msg;
}
}
mCallback(success, output);
}
static void JsonToLLSD(const Json::Value &root, LLSD &output)
{
if(root.isObject())
{
Json::Value::Members keys = root.getMemberNames();
for(Json::Value::Members::const_iterator itr = keys.begin(); itr != keys.end(); ++itr)
{
LLSD elem;
JsonToLLSD(root[*itr], elem);
output[*itr] = elem;
}
}
else if(root.isArray())
{
for(Json::Value::const_iterator itr = root.begin(); itr != root.end(); ++itr)
{
LLSD elem;
JsonToLLSD(*itr, elem);
output.append(elem);
}
}
else
{
switch(root.type())
{
case Json::intValue:
output = root.asInt();
break;
case Json::realValue:
case Json::uintValue:
output = root.asDouble();
break;
case Json::stringValue:
output = root.asString();
break;
case Json::booleanValue:
output = root.asBool();
break;
case Json::nullValue:
output = LLSD();
break;
default:
break;
}
}
}
exoFlickrResponse::exoFlickrResponse(exoFlickr::response_callback_t &callback) :
mCallback(callback)
{
}
void exoFlickrResponse::completedRaw(
U32 status,
const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLBufferStream istr(channels, buffer.get());
std::stringstream strstrm;
strstrm << istr.rdbuf();
std::string result = strstrm.str();
Json::Value root;
Json::Reader reader;
bool success = reader.parse(result, root);
if(!success)
{
mCallback(false, LLSD());
return;
}
else
{
LL_INFOS("FlickrAPI") << "Got response string: " << result << LL_ENDL;
LLSD response;
JsonToLLSD(root, response);
mCallback(isGoodStatus(status), response);
}
}
<|endoftext|>
|
<commit_before>// AddTaskDmesonJetCorr.C
AliAnalysisTaskDmesonJetCorrelations* AddTaskDmesonJetCorr(AliAnalysisTaskDmesonJetCorrelations::ECandidateType cand = AliAnalysisTaskDmesonJetCorrelations::kDstartoKpipi,
const char *cutfname = "",
const char *ntracks = "Tracks",
const char *nclusters = "CaloClusters",
const char *njets = "Jets",
const char *nrho = "Rho",
Double_t jetradius = 0.2,
Double_t jetptcut = 1,
Double_t jetareacut = 0.557,
const char *cutType = "TPC",
Int_t leadhadtype = 0,
const char *taskname = "AliAnalysisTaskDmesonJetCorrelations",
const char *suffix = ""
)
{
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddTaskDmesonJetCorr", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskDmesonJetCorr", "This task requires an input event handler");
return NULL;
}
//-------------------------------------------------------
// Init the task and do settings
//-------------------------------------------------------
TString cutsname;
TString candname;
switch (cand) {
case AliAnalysisTaskDmesonJetCorrelations::kD0toKpi :
candname = "D0";
cutsname = "D0toKpiCuts";
break;
case AliAnalysisTaskDmesonJetCorrelations::kDstartoKpipi :
candname = "DStar";
cutsname = "DStartoKpipiCuts";
break;
default :
::Error("AddTaskDmesonJetCorr", "Candidate type %d not recognized!",cand);
return NULL;
}
TString name(Form("%s_%s", taskname, candname.Data()));
if (strcmp(suffix,"")) {
name += "_";
name += suffix;
}
if (strcmp(njets,"")) {
name += "_";
name += njets;
}
if (strcmp(nrho,"")) {
name += "_";
name += nrho;
}
name += "_";
name += cutType;
AliRDHFCuts* analysiscuts = 0;
TFile* filecuts = 0;
if (strcmp(cutfname, "")) {
filecuts = TFile::Open(cutfname);
if (!filecuts || filecuts->IsZombie()) {
::Warning("AddTaskDmesonJetCorr", "Input file not found: use std cuts.");
filecuts = 0;
}
}
else {
::Info("AddTaskDmesonJetCorr", "No input file provided: use std cuts.");
}
if (filecuts) {
analysiscuts = dynamic_cast<AliRDHFCuts*>(filecuts->Get(cutsname));
if (!analysiscuts) {
::Warning("AddTaskDmesonJetCorr", "Could not find analysis cuts '%s' in '%s'. Using std cuts.", cutsname.Data(), cutfname);
}
}
if (!analysiscuts) {
switch (cand) {
case AliAnalysisTaskDmesonJetCorrelations::kD0toKpi :
analysiscuts = new AliRDHFCutsD0toKpi();
break;
case AliAnalysisTaskDmesonJetCorrelations::kDstartoKpipi :
analysiscuts = new AliRDHFCutsDStartoKpipi();
break;
default :
break;
}
analysiscuts->SetStandardCutsPP2010();
analysiscuts->SetName(cutsname);
}
AliAnalysisTaskDmesonJetCorrelations* jetTask = new AliAnalysisTaskDmesonJetCorrelations(name, analysiscuts, cand);
jetTask->SetVzRange(-10,10);
jetTask->SetNeedEmcalGeom(kFALSE);
AliParticleContainer* trackCont = jetTask->AddParticleContainer(ntracks);
AliClusterContainer* clusterCont = jetTask->AddClusterContainer(nclusters);
AliJetContainer* jetCont = jetTask->AddJetContainer(njets, cutType, jetradius);
if (jetCont) {
jetCont->SetRhoName(nrho);
jetCont->SetPercAreaCut(jetareacut);
jetCont->SetJetPtCut(jetptcut);
jetCont->ConnectParticleContainer(trackCont);
jetCont->ConnectClusterContainer(clusterCont);
jetCont->SetLeadingHadronType(leadhadtype);
jetCont->SetMaxTrackPt(1000);
}
//-------------------------------------------------------
// Final settings, pass to manager and set the containers
//-------------------------------------------------------
mgr->AddTask(jetTask);
// Create containers for input/output
AliAnalysisDataContainer* cinput1 = mgr->GetCommonInputContainer();
TString contname1(name);
contname1 += "_histos";
AliAnalysisDataContainer* coutput1 = mgr->CreateContainer(contname1.Data(),
TList::Class(), AliAnalysisManager::kOutputContainer,
Form("%s", AliAnalysisManager::GetCommonFileName()));
TString contname2(name);
contname2 += "_cuts";
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(contname2.Data(),
AliRDHFCuts::Class(), AliAnalysisManager::kOutputContainer,
Form("%s", AliAnalysisManager::GetCommonFileName()));
TString nameContainerFC2("Dcandidates");
TString nameContainerFC3("DSBcandidates");
nameContainerFC2 += candname;
nameContainerFC3 += candname;
nameContainerFC2 += suffix;
nameContainerFC3 += suffix;
TObjArray* cnt = mgr->GetContainers();
AliAnalysisDataContainer* coutputFC2 = static_cast<AliAnalysisDataContainer*>(cnt->FindObject(nameContainerFC2));
if (!coutputFC2) {
::Error("AddTaskDmesonJetCorr", "Could not find input container '%s'! This task needs the D meson filter task!", nameContainerFC2.Data());
return NULL;
}
AliAnalysisDataContainer* coutputFC3 = static_cast<AliAnalysisDataContainer*>(cnt->FindObject(nameContainerFC3));
if (!coutputFC3) {
::Warning("AddTaskDmesonJetCorr", "Could not find input container '%s'! This task needs the D meson filter task!", nameContainerFC3.Data());
}
mgr->ConnectInput(jetTask, 0, cinput1);
mgr->ConnectInput(jetTask, 1, coutputFC2);
if (coutputFC3) mgr->ConnectInput(jetTask, 2, coutputFC3);
mgr->ConnectOutput(jetTask, 1, coutput1);
mgr->ConnectOutput(jetTask, 2, coutput2);
return jetTask;
}
<commit_msg>Group output in separate directory<commit_after>// AddTaskDmesonJetCorr.C
AliAnalysisTaskDmesonJetCorrelations* AddTaskDmesonJetCorr(AliAnalysisTaskDmesonJetCorrelations::ECandidateType cand = AliAnalysisTaskDmesonJetCorrelations::kDstartoKpipi,
const char *cutfname = "",
const char *ntracks = "Tracks",
const char *nclusters = "CaloClusters",
const char *njets = "Jets",
const char *nrho = "Rho",
Double_t jetradius = 0.2,
Double_t jetptcut = 1,
Double_t jetareacut = 0.557,
const char *cutType = "TPC",
Int_t leadhadtype = 0,
const char *taskname = "AliAnalysisTaskDmesonJetCorrelations",
const char *suffix = ""
)
{
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddTaskDmesonJetCorr", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskDmesonJetCorr", "This task requires an input event handler");
return NULL;
}
//-------------------------------------------------------
// Init the task and do settings
//-------------------------------------------------------
TString cutsname;
TString candname;
switch (cand) {
case AliAnalysisTaskDmesonJetCorrelations::kD0toKpi :
candname = "D0";
cutsname = "D0toKpiCuts";
break;
case AliAnalysisTaskDmesonJetCorrelations::kDstartoKpipi :
candname = "DStar";
cutsname = "DStartoKpipiCuts";
break;
default :
::Error("AddTaskDmesonJetCorr", "Candidate type %d not recognized!",cand);
return NULL;
}
TString name(Form("%s_%s", taskname, candname.Data()));
if (strcmp(suffix,"")) {
name += "_";
name += suffix;
}
if (strcmp(njets,"")) {
name += "_";
name += njets;
}
if (strcmp(nrho,"")) {
name += "_";
name += nrho;
}
name += "_";
name += cutType;
AliRDHFCuts* analysiscuts = 0;
TFile* filecuts = 0;
if (strcmp(cutfname, "")) {
filecuts = TFile::Open(cutfname);
if (!filecuts || filecuts->IsZombie()) {
::Warning("AddTaskDmesonJetCorr", "Input file not found: use std cuts.");
filecuts = 0;
}
}
else {
::Info("AddTaskDmesonJetCorr", "No input file provided: use std cuts.");
}
if (filecuts) {
analysiscuts = dynamic_cast<AliRDHFCuts*>(filecuts->Get(cutsname));
if (!analysiscuts) {
::Warning("AddTaskDmesonJetCorr", "Could not find analysis cuts '%s' in '%s'. Using std cuts.", cutsname.Data(), cutfname);
}
}
if (!analysiscuts) {
switch (cand) {
case AliAnalysisTaskDmesonJetCorrelations::kD0toKpi :
analysiscuts = new AliRDHFCutsD0toKpi();
break;
case AliAnalysisTaskDmesonJetCorrelations::kDstartoKpipi :
analysiscuts = new AliRDHFCutsDStartoKpipi();
break;
default :
break;
}
analysiscuts->SetStandardCutsPP2010();
analysiscuts->SetName(cutsname);
}
AliAnalysisTaskDmesonJetCorrelations* jetTask = new AliAnalysisTaskDmesonJetCorrelations(name, analysiscuts, cand);
jetTask->SetVzRange(-10,10);
jetTask->SetNeedEmcalGeom(kFALSE);
AliParticleContainer* trackCont = jetTask->AddParticleContainer(ntracks);
AliClusterContainer* clusterCont = jetTask->AddClusterContainer(nclusters);
AliJetContainer* jetCont = jetTask->AddJetContainer(njets, cutType, jetradius);
if (jetCont) {
jetCont->SetRhoName(nrho);
jetCont->SetPercAreaCut(jetareacut);
jetCont->SetJetPtCut(jetptcut);
jetCont->ConnectParticleContainer(trackCont);
jetCont->ConnectClusterContainer(clusterCont);
jetCont->SetLeadingHadronType(leadhadtype);
jetCont->SetMaxTrackPt(1000);
}
//-------------------------------------------------------
// Final settings, pass to manager and set the containers
//-------------------------------------------------------
mgr->AddTask(jetTask);
// Create containers for input/output
AliAnalysisDataContainer* cinput1 = mgr->GetCommonInputContainer();
TString contname1(name);
contname1 += "_histos";
AliAnalysisDataContainer* coutput1 = mgr->CreateContainer(contname1.Data(),
TList::Class(), AliAnalysisManager::kOutputContainer,
Form("%s:SA_DmesonJetCorr", AliAnalysisManager::GetCommonFileName()));
TString contname2(name);
contname2 += "_cuts";
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(contname2.Data(),
AliRDHFCuts::Class(), AliAnalysisManager::kOutputContainer,
Form("%s:SA_DmesonJetCorr", AliAnalysisManager::GetCommonFileName()));
TString nameContainerFC2("Dcandidates");
TString nameContainerFC3("DSBcandidates");
nameContainerFC2 += candname;
nameContainerFC3 += candname;
nameContainerFC2 += suffix;
nameContainerFC3 += suffix;
TObjArray* cnt = mgr->GetContainers();
AliAnalysisDataContainer* coutputFC2 = static_cast<AliAnalysisDataContainer*>(cnt->FindObject(nameContainerFC2));
if (!coutputFC2) {
::Error("AddTaskDmesonJetCorr", "Could not find input container '%s'! This task needs the D meson filter task!", nameContainerFC2.Data());
return NULL;
}
AliAnalysisDataContainer* coutputFC3 = static_cast<AliAnalysisDataContainer*>(cnt->FindObject(nameContainerFC3));
if (!coutputFC3) {
::Warning("AddTaskDmesonJetCorr", "Could not find input container '%s'! This task needs the D meson filter task!", nameContainerFC3.Data());
}
mgr->ConnectInput(jetTask, 0, cinput1);
mgr->ConnectInput(jetTask, 1, coutputFC2);
if (coutputFC3) mgr->ConnectInput(jetTask, 2, coutputFC3);
mgr->ConnectOutput(jetTask, 1, coutput1);
mgr->ConnectOutput(jetTask, 2, coutput2);
return jetTask;
}
<|endoftext|>
|
<commit_before>#include "libadb.h"
#include "adb_prot.h"
#include "rxx.h"
str
dbrec_to_str (ptr<dbrec> dbr, int i)
{
//we aren't storing a null terminator.
// add it here or the conversion grabs trailing garbage
char buf[128];
int ncpy = (dbr->len > 127) ? 127 : dbr->len;
memcpy (buf, dbr->value, dbr->len);
buf[ncpy] = 0;
// cache:abc03313ff
rxx m("^([^!]+)!([0-9a-f]+)", "m");
m.search (buf);
if (!m.success ()) {
fatal << "dbrec_to_str expected match from '" << buf << "' but didn't get one\n";
}
return m[i];
}
chordID
dbrec_to_id (ptr<dbrec> dbr)
{
str id = dbrec_to_str (dbr, 2);
chordID ret (id, 16);
return ret;
}
str
dbrec_to_name (ptr<dbrec> dbr)
{
str name = dbrec_to_str(dbr, 1);
return name;
}
ptr<dbrec>
id_to_dbrec (chordID key, str name_space)
{
//pad out all keys to 20 bytes so that they sort correctly
str keystr = strbuf () << key;
while (keystr.len () < 20)
keystr = strbuf () << "0" << keystr;
str c = strbuf () << name_space << "!" << keystr;
return New refcounted<dbrec> (c.cstr (), c.len ());
}
adb::adb (str sock_name, str name) : name_space (name)
{
int fd = unixsocket_connect (sock_name);
if (fd < 0) {
fatal ("adb_connect: Error connecting to %s: %s\n",
sock_name.cstr (), strerror (errno));
}
c = aclnt::alloc (axprt_unix::alloc (fd, 1024*1025),
adb_program_1);
}
void
adb::store (chordID key, str data, cbi cb)
{
adb_storearg arg;
arg.key = key;
arg.name = name_space;
arg.data.setsize (data.len ());
memcpy (arg.data.base (), data.cstr (), data.len ());
adb_status *res = New adb_status ();
c->call (ADBPROC_STORE, &arg, res,
wrap (this, &adb::store_cb, res, cb));
return;
}
void
adb::store_cb (adb_status *res, cbi cb, clnt_stat err)
{
if (cb)
if (err || !res)
cb (err);
else
cb (*res);
delete res;
}
void
adb::fetch (chordID key, cb_fetch cb)
{
adb_fetcharg arg;
arg.key = key;
arg.name = name_space;
adb_fetchres *res = New adb_fetchres (ADB_OK);
c->call (ADBPROC_FETCH, &arg, res,
wrap (this, &adb::fetch_cb, res, key, cb));
}
void
adb::fetch_cb (adb_fetchres *res, chordID key, cb_fetch cb, clnt_stat err)
{
if (err || (res && res->status)) {
str nodata = "";
cb (ADB_ERR, key, nodata);
} else {
assert (key == res->resok->key);
str data (res->resok->data.base (), res->resok->data.size ());
cb (ADB_OK, res->resok->key, data);
}
delete res;
return;
}
void
adb::getkeys (chordID start, cb_getkeys cb)
{
adb_getkeysarg arg;
arg.start = start;
arg.name = name_space;
adb_getkeysres *res = New adb_getkeysres ();
c->call (ADBPROC_GETKEYS, &arg, res,
wrap (this, &adb::getkeys_cb, res, cb));
}
void
adb::getkeys_cb (adb_getkeysres *res, cb_getkeys cb, clnt_stat err)
{
if (err || (res && res->status)) {
vec<chordID> nokeys;
cb (ADB_ERR, nokeys);
} else {
vec<chordID> keys;
for (unsigned int i = 0; i < res->resok->keys.size (); i++)
keys.push_back (res->resok->keys[i]);
adb_status ret = (res->resok->complete) ? ADB_COMPLETE : ADB_OK;
cb (ret, keys);
}
delete res;
}
void
adb::remove (chordID key, cbi cb)
{
adb_storearg arg;
arg.name = name_space;
arg.key = key;
adb_status *stat = New adb_status ();
c->call (ADBPROC_DELETE, &arg, stat,
wrap (this, &adb::delete_cb, stat, cb));
}
void
adb::delete_cb (adb_status *stat, cbi cb, clnt_stat err)
{
if (err) cb (err);
else cb (*stat);
delete stat;
}
<commit_msg>make the async data base asynchronous<commit_after>#include "libadb.h"
#include "adb_prot.h"
#include "rxx.h"
str
dbrec_to_str (ptr<dbrec> dbr, int i)
{
//we aren't storing a null terminator.
// add it here or the conversion grabs trailing garbage
char buf[128];
int ncpy = (dbr->len > 127) ? 127 : dbr->len;
memcpy (buf, dbr->value, dbr->len);
buf[ncpy] = 0;
// cache:abc03313ff
rxx m("^([^!]+)!([0-9a-f]+)", "m");
m.search (buf);
if (!m.success ()) {
fatal << "dbrec_to_str expected match from '" << buf << "' but didn't get one\n";
}
return m[i];
}
chordID
dbrec_to_id (ptr<dbrec> dbr)
{
str id = dbrec_to_str (dbr, 2);
chordID ret (id, 16);
return ret;
}
str
dbrec_to_name (ptr<dbrec> dbr)
{
str name = dbrec_to_str(dbr, 1);
return name;
}
ptr<dbrec>
id_to_dbrec (chordID key, str name_space)
{
//pad out all keys to 20 bytes so that they sort correctly
str keystr = strbuf () << key;
while (keystr.len () < 20)
keystr = strbuf () << "0" << keystr;
str c = strbuf () << name_space << "!" << keystr;
return New refcounted<dbrec> (c.cstr (), c.len ());
}
adb::adb (str sock_name, str name) : name_space (name)
{
int fd = unixsocket_connect (sock_name);
if (fd < 0) {
fatal ("adb_connect: Error connecting to %s: %s\n",
sock_name.cstr (), strerror (errno));
}
make_async (fd);
c = aclnt::alloc (axprt_unix::alloc (fd, 1024*1025),
adb_program_1);
}
void
adb::store (chordID key, str data, cbi cb)
{
adb_storearg arg;
arg.key = key;
arg.name = name_space;
arg.data.setsize (data.len ());
memcpy (arg.data.base (), data.cstr (), data.len ());
adb_status *res = New adb_status ();
c->call (ADBPROC_STORE, &arg, res,
wrap (this, &adb::store_cb, res, cb));
return;
}
void
adb::store_cb (adb_status *res, cbi cb, clnt_stat err)
{
if (cb)
if (err || !res)
cb (err);
else
cb (*res);
delete res;
}
void
adb::fetch (chordID key, cb_fetch cb)
{
adb_fetcharg arg;
arg.key = key;
arg.name = name_space;
adb_fetchres *res = New adb_fetchres (ADB_OK);
c->call (ADBPROC_FETCH, &arg, res,
wrap (this, &adb::fetch_cb, res, key, cb));
}
void
adb::fetch_cb (adb_fetchres *res, chordID key, cb_fetch cb, clnt_stat err)
{
if (err || (res && res->status)) {
str nodata = "";
cb (ADB_ERR, key, nodata);
} else {
assert (key == res->resok->key);
str data (res->resok->data.base (), res->resok->data.size ());
cb (ADB_OK, res->resok->key, data);
}
delete res;
return;
}
void
adb::getkeys (chordID start, cb_getkeys cb)
{
adb_getkeysarg arg;
arg.start = start;
arg.name = name_space;
adb_getkeysres *res = New adb_getkeysres ();
c->call (ADBPROC_GETKEYS, &arg, res,
wrap (this, &adb::getkeys_cb, res, cb));
}
void
adb::getkeys_cb (adb_getkeysres *res, cb_getkeys cb, clnt_stat err)
{
if (err || (res && res->status)) {
vec<chordID> nokeys;
cb (ADB_ERR, nokeys);
} else {
vec<chordID> keys;
for (unsigned int i = 0; i < res->resok->keys.size (); i++)
keys.push_back (res->resok->keys[i]);
adb_status ret = (res->resok->complete) ? ADB_COMPLETE : ADB_OK;
cb (ret, keys);
}
delete res;
}
void
adb::remove (chordID key, cbi cb)
{
adb_storearg arg;
arg.name = name_space;
arg.key = key;
adb_status *stat = New adb_status ();
c->call (ADBPROC_DELETE, &arg, stat,
wrap (this, &adb::delete_cb, stat, cb));
}
void
adb::delete_cb (adb_status *stat, cbi cb, clnt_stat err)
{
if (err) cb (err);
else cb (*stat);
delete stat;
}
<|endoftext|>
|
<commit_before><commit_msg>Remove unused file dcp_flush_executor.cc<commit_after><|endoftext|>
|
<commit_before>// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "v8_binding.h"
#include "AtomicString.h"
#include "CString.h"
#include "MathExtras.h"
#include "PlatformString.h"
#include "StringBuffer.h"
#include <v8.h>
namespace WebCore {
// WebCoreStringResource is a helper class for v8ExternalString. It is used
// to manage the life-cycle of the underlying buffer of the external string.
class WebCoreStringResource: public v8::String::ExternalStringResource {
public:
explicit WebCoreStringResource(const String& str)
: impl_(str.impl()) { }
virtual ~WebCoreStringResource() {}
const uint16_t* data() const {
return reinterpret_cast<const uint16_t*>(impl_.characters());
}
size_t length() const { return impl_.length(); }
String webcore_string() { return impl_; }
private:
// A shallow copy of the string.
// Keeps the string buffer alive until the V8 engine garbage collects it.
String impl_;
};
String v8StringToWebCoreString(
v8::Handle<v8::String> v8_str, bool externalize) {
WebCoreStringResource* str_resource = static_cast<WebCoreStringResource*>(
v8_str->GetExternalStringResource());
if (str_resource) {
return str_resource->webcore_string();
}
int length = v8_str->Length();
if (length == 0) {
// Avoid trying to morph empty strings, as they do not have enough room to
// contain the external reference.
return StringImpl::empty();
}
UChar* buffer;
String result = String::createUninitialized(length, buffer);
v8_str->Write(reinterpret_cast<uint16_t*>(buffer), 0, length);
if (externalize) {
WebCoreStringResource* resource = new WebCoreStringResource(result);
if (!v8_str->MakeExternal(resource)) {
// In case of a failure delete the external resource as it was not used.
delete resource;
}
}
return result;
}
String v8ValueToWebCoreString(v8::Handle<v8::Value> obj) {
if (obj->IsString()) {
v8::Handle<v8::String> v8_str = v8::Handle<v8::String>::Cast(obj);
String webCoreString = v8StringToWebCoreString(v8_str, true);
return webCoreString;
} else if (obj->IsInt32()) {
int value = obj->Int32Value();
// Most numbers used are <= 100. Even if they aren't used
// there's very little in using the space.
const int kLowNumbers = 100;
static AtomicString lowNumbers[kLowNumbers + 1];
String webCoreString;
if (0 <= value && value <= kLowNumbers) {
webCoreString = lowNumbers[value];
if (!webCoreString) {
AtomicString valueString = AtomicString(String::number(value));
lowNumbers[value] = valueString;
webCoreString = valueString;
}
} else {
webCoreString = String::number(value);
}
return webCoreString;
} else {
v8::TryCatch block;
v8::Handle<v8::String> v8_str = obj->ToString();
return v8StringToWebCoreString(v8_str, false);
}
}
AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String> v8_str) {
String str = v8StringToWebCoreString(v8_str, true);
return AtomicString(str);
}
AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> v8_str) {
String str = v8ValueToWebCoreString(v8_str);
return AtomicString(str);
}
v8::Handle<v8::String> v8String(const String& str) {
if (!str.length())
return v8::String::Empty();
return v8::String::NewExternal(new WebCoreStringResource(str));
}
v8::Local<v8::String> v8ExternalString(const String& str) {
if (!str.length())
return v8::String::Empty();
return v8::String::NewExternal(new WebCoreStringResource(str));
}
} // namespace WebCore
<commit_msg>Re-introduce check for empty handles after calling toString when converting a JavaScript object to a WebCore string.<commit_after>// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "v8_binding.h"
#include "AtomicString.h"
#include "CString.h"
#include "MathExtras.h"
#include "PlatformString.h"
#include "StringBuffer.h"
#include <v8.h>
namespace WebCore {
// WebCoreStringResource is a helper class for v8ExternalString. It is used
// to manage the life-cycle of the underlying buffer of the external string.
class WebCoreStringResource: public v8::String::ExternalStringResource {
public:
explicit WebCoreStringResource(const String& str)
: impl_(str.impl()) { }
virtual ~WebCoreStringResource() {}
const uint16_t* data() const {
return reinterpret_cast<const uint16_t*>(impl_.characters());
}
size_t length() const { return impl_.length(); }
String webcore_string() { return impl_; }
private:
// A shallow copy of the string.
// Keeps the string buffer alive until the V8 engine garbage collects it.
String impl_;
};
String v8StringToWebCoreString(
v8::Handle<v8::String> v8_str, bool externalize) {
WebCoreStringResource* str_resource = static_cast<WebCoreStringResource*>(
v8_str->GetExternalStringResource());
if (str_resource) {
return str_resource->webcore_string();
}
int length = v8_str->Length();
if (length == 0) {
// Avoid trying to morph empty strings, as they do not have enough room to
// contain the external reference.
return StringImpl::empty();
}
UChar* buffer;
String result = String::createUninitialized(length, buffer);
v8_str->Write(reinterpret_cast<uint16_t*>(buffer), 0, length);
if (externalize) {
WebCoreStringResource* resource = new WebCoreStringResource(result);
if (!v8_str->MakeExternal(resource)) {
// In case of a failure delete the external resource as it was not used.
delete resource;
}
}
return result;
}
String v8ValueToWebCoreString(v8::Handle<v8::Value> obj) {
if (obj->IsString()) {
v8::Handle<v8::String> v8_str = v8::Handle<v8::String>::Cast(obj);
String webCoreString = v8StringToWebCoreString(v8_str, true);
return webCoreString;
} else if (obj->IsInt32()) {
int value = obj->Int32Value();
// Most numbers used are <= 100. Even if they aren't used
// there's very little in using the space.
const int kLowNumbers = 100;
static AtomicString lowNumbers[kLowNumbers + 1];
String webCoreString;
if (0 <= value && value <= kLowNumbers) {
webCoreString = lowNumbers[value];
if (!webCoreString) {
AtomicString valueString = AtomicString(String::number(value));
lowNumbers[value] = valueString;
webCoreString = valueString;
}
} else {
webCoreString = String::number(value);
}
return webCoreString;
} else {
v8::TryCatch block;
v8::Handle<v8::String> v8_str = obj->ToString();
// Check for empty handles to handle the case where an exception
// is thrown as part of invoking toString on the object.
if (v8_str.IsEmpty())
return StringImpl::empty();
return v8StringToWebCoreString(v8_str, false);
}
}
AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String> v8_str) {
String str = v8StringToWebCoreString(v8_str, true);
return AtomicString(str);
}
AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value> v8_str) {
String str = v8ValueToWebCoreString(v8_str);
return AtomicString(str);
}
v8::Handle<v8::String> v8String(const String& str) {
if (!str.length())
return v8::String::Empty();
return v8::String::NewExternal(new WebCoreStringResource(str));
}
v8::Local<v8::String> v8ExternalString(const String& str) {
if (!str.length())
return v8::String::Empty();
return v8::String::NewExternal(new WebCoreStringResource(str));
}
} // namespace WebCore
<|endoftext|>
|
<commit_before>// brpc - A framework to host and access services throughout Baidu.
// Copyright (c) 2018 BiliBili, Inc.
// Date: Tue Oct 9 20:27:18 CST 2018
#include <gflags/gflags.h>
#include <gtest/gtest.h>
#include "bthread/bthread.h"
#include "butil/atomicops.h"
#include "brpc/policy/http_rpc_protocol.h"
#include "brpc/policy/http2_rpc_protocol.h"
#include "butil/gperftools_profiler.h"
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
TEST(H2UnsentMessage, request_throughput) {
brpc::Controller cntl;
butil::IOBuf request_buf;
cntl.http_request().uri() = "0.0.0.0:8010/HttpService/Echo";
brpc::policy::SerializeHttpRequest(&request_buf, &cntl, NULL);
brpc::SocketId id;
brpc::SocketUniquePtr h2_client_sock;
brpc::SocketOptions h2_client_options;
h2_client_options.user = brpc::get_client_side_messenger();
EXPECT_EQ(0, brpc::Socket::Create(h2_client_options, &id));
EXPECT_EQ(0, brpc::Socket::Address(id, &h2_client_sock));
brpc::policy::H2Context* ctx =
new brpc::policy::H2Context(h2_client_sock.get(), NULL);
CHECK_EQ(ctx->Init(), 0);
h2_client_sock->initialize_parsing_context(&ctx);
ctx->_last_client_stream_id = 0;
ctx->_remote_window_left = brpc::H2Settings::MAX_WINDOW_SIZE;
int64_t ntotal = 1000000;
// calc H2UnsentRequest throughput
std::vector<brpc::policy::H2UnsentRequest*> req_msgs;
req_msgs.resize(ntotal);
for (int i = 0; i < ntotal; ++i) {
req_msgs[i] = brpc::policy::H2UnsentRequest::New(&cntl);
}
butil::IOBuf dummy_buf;
ProfilerStart("h2_unsent_req.prof");
int64_t start_us = butil::gettimeofday_us();
for (int i = 0; i < ntotal; ++i) {
req_msgs[i]->AppendAndDestroySelf(&dummy_buf, h2_client_sock.get());
}
int64_t end_us = butil::gettimeofday_us();
ProfilerStop();
int64_t elapsed = end_us - start_us;
LOG(INFO) << "H2UnsentRequest average qps="
<< (ntotal * 1000000L) / elapsed << "/s, data throughput="
<< dummy_buf.size() * 1000000L / elapsed;
req_msgs.clear();
// calc H2UnsentResponse throughput
std::vector<brpc::policy::H2UnsentResponse*> res_msgs;
res_msgs.resize(ntotal);
for (int i = 0; i < ntotal; ++i) {
cntl.http_response().set_content_type("text/plain");
cntl.response_attachment().append("0123456789abcedef");
res_msgs[i] = brpc::policy::H2UnsentResponse::New(&cntl, 0, false);
}
dummy_buf.clear();
start_us = butil::gettimeofday_us();
for (int i = 0; i < ntotal; ++i) {
res_msgs[i]->AppendAndDestroySelf(&dummy_buf, h2_client_sock.get());
}
end_us = butil::gettimeofday_us();
elapsed = end_us - start_us;
LOG(INFO) << "H2UnsentResponse average qps="
<< (ntotal * 1000000L) / elapsed << "/s, data throughput="
<< dummy_buf.size() * 1000000L / elapsed;
res_msgs.clear();
}
<commit_msg>Directly allocate unsent message instead of preparing them first<commit_after>// brpc - A framework to host and access services throughout Baidu.
// Copyright (c) 2018 BiliBili, Inc.
// Date: Tue Oct 9 20:27:18 CST 2018
#include <gflags/gflags.h>
#include <gtest/gtest.h>
#include "bthread/bthread.h"
#include "butil/atomicops.h"
#include "brpc/policy/http_rpc_protocol.h"
#include "brpc/policy/http2_rpc_protocol.h"
#include "butil/gperftools_profiler.h"
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
TEST(H2UnsentMessage, request_throughput) {
brpc::Controller cntl;
butil::IOBuf request_buf;
cntl.http_request().uri() = "0.0.0.0:8010/HttpService/Echo";
brpc::policy::SerializeHttpRequest(&request_buf, &cntl, NULL);
brpc::SocketId id;
brpc::SocketUniquePtr h2_client_sock;
brpc::SocketOptions h2_client_options;
h2_client_options.user = brpc::get_client_side_messenger();
EXPECT_EQ(0, brpc::Socket::Create(h2_client_options, &id));
EXPECT_EQ(0, brpc::Socket::Address(id, &h2_client_sock));
brpc::policy::H2Context* ctx =
new brpc::policy::H2Context(h2_client_sock.get(), NULL);
CHECK_EQ(ctx->Init(), 0);
h2_client_sock->initialize_parsing_context(&ctx);
ctx->_last_client_stream_id = 0;
ctx->_remote_window_left = brpc::H2Settings::MAX_WINDOW_SIZE;
int64_t ntotal = 5000000;
// calc H2UnsentRequest throughput
butil::IOBuf dummy_buf;
ProfilerStart("h2_unsent_req.prof");
int64_t start_us = butil::gettimeofday_us();
for (int i = 0; i < ntotal; ++i) {
brpc::policy::H2UnsentRequest* req = brpc::policy::H2UnsentRequest::New(&cntl);
req->AppendAndDestroySelf(&dummy_buf, h2_client_sock.get());
}
int64_t end_us = butil::gettimeofday_us();
ProfilerStop();
int64_t elapsed = end_us - start_us;
LOG(INFO) << "H2UnsentRequest average qps="
<< (ntotal * 1000000L) / elapsed << "/s, data throughput="
<< dummy_buf.size() * 1000000L / elapsed << "/s";
// calc H2UnsentResponse throughput
dummy_buf.clear();
start_us = butil::gettimeofday_us();
for (int i = 0; i < ntotal; ++i) {
// H2UnsentResponse::New would release cntl.http_response() and swap
// cntl.response_attachment()
cntl.http_response().set_content_type("text/plain");
cntl.response_attachment().append("0123456789abcedef");
brpc::policy::H2UnsentResponse* res = brpc::policy::H2UnsentResponse::New(&cntl, 0, false);
res->AppendAndDestroySelf(&dummy_buf, h2_client_sock.get());
}
end_us = butil::gettimeofday_us();
elapsed = end_us - start_us;
LOG(INFO) << "H2UnsentResponse average qps="
<< (ntotal * 1000000L) / elapsed << "/s, data throughput="
<< dummy_buf.size() * 1000000L / elapsed << "/s";
}
<|endoftext|>
|
<commit_before>/*
* reswin.hpp
* ChessPlusPlus
*
* Created by Ronak Gajrawala on 12/01/13.
* Copyright (c) 2013 Ronak Gajrawala. All rights reserved.
*/
#ifndef ChessPlusPlus_reswin_hpp
#define ChessPlusPlus_reswin_hpp
const std::string ResourcePath = "res/"; /**< The resource path has to be set manually by the user in Windows. */
const std::string GetResource(const std::string file) {
return ResourcePath + file;
}
#endif
<commit_msg>Update reswin.hpp<commit_after>/*
* reswin.hpp
* SimpleChess
*
* Created by Ronak Gajrawala on 12/01/13.
* Copyright (c) 2013 Ronak Gajrawala. All rights reserved.
*/
#ifndef SimpleChess_reswin_hpp
#define SimpleChess_reswin_hpp
const std::string ResourcePath = "res/"; /**< The resource path has to be set manually by the user in Windows. */
const std::string GetResource(const std::string file) {
return ResourcePath + file;
}
#endif
<|endoftext|>
|
<commit_before>/*
* n_point_naive_multi_main.cc
*
*
* Created by William March on 6/9/10.
* Copyright 2010 __MyCompanyName__. All rights reserved.
*
*/
#include "fastlib/fastlib.h"
#include "n_point_perm_free.h"
#include "n_point.h"
bool IncIndex(ArrayList<index_t>& new_ind,
const ArrayList<index_t>& orig_ind,
index_t k, int tensor_rank_, int num_bins_) {
if (k >= tensor_rank_) {
return true;
}
new_ind[k]++;
if (new_ind[k] >= num_bins_) {
new_ind[k] = orig_ind[k];
return IncIndex(new_ind, orig_ind, k+1, tensor_rank_, num_bins_);
}
else {
return false;
}
} // IncrementIndex
int main(int argc, char* argv[]) {
fx_init(argc, argv, NULL);
int n = fx_param_int_req(NULL, "n");
int n_choose_2 = n_point_impl::NChooseR(n, 2);
Matrix data;
const char* data_file = fx_param_str_req(NULL, "data");
data::Load(data_file, &data);
Matrix lower_bounds;
lower_bounds.Init(n, n);
lower_bounds.SetAll(0.0);
double min_band = fx_param_double_req(NULL, "min_band");
double max_band = fx_param_double_req(NULL, "max_band");
double num_bands = fx_param_int_req(NULL, "num_bands");
ArrayList<double> dists;
dists.Init(num_bands);
double this_dist = min_band;
double dist_step = (max_band - min_band) / (double)(num_bands-1);
//printf("dist_step = %g\n", dist_step);
// TODO: double check this
for (index_t i = 0; i < num_bands; i++) {
dists[i] = this_dist;
this_dist += dist_step;
}
ArrayList<index_t> indices;
indices.InitRepeat(0, n_choose_2);
ArrayList<index_t> indices_copy;
indices_copy.InitCopy(indices);
// form each matcher
bool done = false;
fx_timer_start(NULL, "n_point_time");
while (!done) {
Matrix this_matcher;
this_matcher.Init(n, n);
index_t row_ind = 0;
index_t col_ind = 1;
for (index_t i = 0; i < indices.size(); i++) {
double entry = dists[indices_copy[i]];
this_matcher.set(row_ind, col_ind, entry);
this_matcher.set(col_ind, row_ind, entry);
col_ind++;
if (col_ind >= n) {
this_matcher.set(row_ind, row_ind, 0.0);
row_ind++;
col_ind = row_ind + 1;
}
} // fill in the matcher's matrix
this_matcher.set(n - 1, n - 1, 0.0);
done = IncIndex(indices_copy, indices, 0, n_choose_2, num_bands);
// make the alg, run it
NPointPermFree perm_free_alg;
fx_module* submod = fx_submodule(NULL, "perm_free_mod");
//this_matcher.PrintDebug("This matcher");
perm_free_alg.Init(data, lower_bounds, this_matcher, n, submod);
perm_free_alg.Compute();
} // while
fx_timer_stop(NULL, "n_point_time");
fx_done(NULL);
return 0;
} // main<commit_msg>fixed small error in naive multi main<commit_after>/*
* n_point_naive_multi_main.cc
*
*
* Created by William March on 6/9/10.
* Copyright 2010 __MyCompanyName__. All rights reserved.
*
*/
#include "fastlib/fastlib.h"
#include "n_point_perm_free.h"
#include "n_point.h"
bool IncIndex(ArrayList<index_t>& new_ind,
const ArrayList<index_t>& orig_ind,
index_t k, int tensor_rank_, int num_bins_) {
if (k >= tensor_rank_) {
return true;
}
new_ind[k]++;
if (new_ind[k] >= num_bins_) {
new_ind[k] = orig_ind[k];
return IncIndex(new_ind, orig_ind, k+1, tensor_rank_, num_bins_);
}
else {
return false;
}
} // IncrementIndex
int main(int argc, char* argv[]) {
fx_init(argc, argv, NULL);
int n = fx_param_int_req(NULL, "n");
int n_choose_2 = n_point_impl::NChooseR(n, 2);
Matrix data;
const char* data_file = fx_param_str_req(NULL, "data");
data::Load(data_file, &data);
Matrix lower_bounds;
lower_bounds.Init(n, n);
lower_bounds.SetAll(0.0);
double min_band = fx_param_double_req(NULL, "min_band");
double max_band = fx_param_double_req(NULL, "max_band");
int num_bands = fx_param_int_req(NULL, "num_bands");
ArrayList<double> dists;
dists.Init(num_bands);
double this_dist = min_band;
double dist_step = (max_band - min_band) / (double)(num_bands-1);
//printf("dist_step = %g\n", dist_step);
// TODO: double check this
for (index_t i = 0; i < num_bands; i++) {
dists[i] = this_dist;
this_dist += dist_step;
}
ArrayList<index_t> indices;
indices.InitRepeat(0, n_choose_2);
ArrayList<index_t> indices_copy;
indices_copy.InitCopy(indices);
// form each matcher
bool done = false;
fx_timer_start(NULL, "n_point_time");
while (!done) {
Matrix this_matcher;
this_matcher.Init(n, n);
index_t row_ind = 0;
index_t col_ind = 1;
for (index_t i = 0; i < indices.size(); i++) {
double entry = dists[indices_copy[i]];
this_matcher.set(row_ind, col_ind, entry);
this_matcher.set(col_ind, row_ind, entry);
col_ind++;
if (col_ind >= n) {
this_matcher.set(row_ind, row_ind, 0.0);
row_ind++;
col_ind = row_ind + 1;
}
} // fill in the matcher's matrix
this_matcher.set(n - 1, n - 1, 0.0);
done = IncIndex(indices_copy, indices, 0, n_choose_2, num_bands);
// make the alg, run it
NPointPermFree perm_free_alg;
fx_module* submod = fx_submodule(NULL, "perm_free_mod");
//this_matcher.PrintDebug("This matcher");
perm_free_alg.Init(data, lower_bounds, this_matcher, n, submod);
perm_free_alg.Compute();
} // while
fx_timer_stop(NULL, "n_point_time");
fx_done(NULL);
return 0;
} // main
<|endoftext|>
|
<commit_before>
//
// This source file is part of appleseed.
// Visit http://appleseedhq.net/ for additional information and resources.
//
// This software is released under the MIT license.
//
// Copyright (c) 2015 Esteban Tovagliari, 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.
//
// appleseed.renderer headers.
#include "renderer/kernel/shading/shadingpoint.h"
#include "renderer/kernel/shading/shadingpointbuilder.h"
#include "renderer/modeling/bssrdf/bssrdf.h"
#include "renderer/modeling/bssrdf/directionaldipolebssrdf.h"
#include "renderer/modeling/bssrdf/sss.h"
// appleseed.foundation headers.
#include "foundation/math/rng/distribution.h"
#include "foundation/math/rng/mersennetwister.h"
#include "foundation/math/fresnel.h"
#include "foundation/math/scalar.h"
#include "foundation/utility/gnuplotfile.h"
#include "foundation/utility/string.h"
#include "foundation/utility/test.h"
// Standard headers.
#include <algorithm>
#include <cstddef>
#include <vector>
using namespace foundation;
using namespace renderer;
using namespace std;
TEST_SUITE(Renderer_Modeling_BSSRDF_SSS)
{
double rd_alpha_prime_roundtrip(
const double rd,
const double eta)
{
const double two_c1 = fresnel_moment_two_c1(eta);
const double three_c2 = fresnel_moment_three_c2(eta);
const double alpha_prime = compute_alpha_prime(rd, two_c1, three_c2);
return compute_rd(alpha_prime, two_c1, three_c2);
}
TEST_CASE(Rd_AlphaPrime_Roundtrip)
{
EXPECT_FEQ_EPS(0.0, rd_alpha_prime_roundtrip(0.0, 1.6), 0.001);
EXPECT_FEQ_EPS(0.1, rd_alpha_prime_roundtrip(0.1, 1.3), 0.001);
EXPECT_FEQ_EPS(0.2, rd_alpha_prime_roundtrip(0.2, 1.2), 0.001);
EXPECT_FEQ_EPS(0.4, rd_alpha_prime_roundtrip(0.4, 1.3), 0.001);
EXPECT_FEQ_EPS(0.6, rd_alpha_prime_roundtrip(0.6, 1.4), 0.001);
EXPECT_FEQ_EPS(0.8, rd_alpha_prime_roundtrip(0.8, 1.3), 0.001);
EXPECT_FEQ_EPS(1.0, rd_alpha_prime_roundtrip(1.0, 1.5), 0.001);
}
const double NormalizedDiffusionTestEps = 0.0001;
TEST_CASE(NormalizedDiffusionA)
{
static const double Expected[] =
{
4.68592, 4.11466, 3.77984, 3.60498, 3.52856, 3.5041, 3.50008,
3.50002, 3.5024, 3.52074, 3.58352, 3.73426, 4.03144, 4.54858,
5.37416, 6.6117, 8.37968, 10.8116, 14.056, 18.2763, 23.6511
};
for (size_t i = 0, e = countof(Expected); i < e; ++i)
{
const double s = normalized_diffusion_s(static_cast<double>(i) * 0.05);
EXPECT_FEQ_EPS(Expected[i], s, NormalizedDiffusionTestEps);
}
}
TEST_CASE(NormalizedDiffusionR)
{
static const double Expected[] =
{
2.53511, 0.674967, 0.327967, 0.192204, 0.124137, 0.0852575,
0.0611367, 0.0452741, 0.0343737, 0.0266197, 0.0209473, 0.0167009,
0.0134603, 0.0109471, 0.00897108, 0.00739936, 0.00613676, 0.00511384,
0.00427902, 0.0035934, 0.00302721
};
for (size_t i = 0, e = countof(Expected); i < e; ++i)
{
const double r =
normalized_diffusion_r(
static_cast<double>(i) * 0.1 + 0.05,
1.0,
3.583521,
0.5);
EXPECT_FEQ_EPS(Expected[i], r, NormalizedDiffusionTestEps);
}
}
TEST_CASE(NormalizedDiffusionCdf)
{
static const double Expected[] =
{
0.282838, 0.598244, 0.760091, 0.85267, 0.908478, 0.942885, 0.964293,
0.97766, 0.98602, 0.99125, 0.994523, 0.996572, 0.997854, 0.998657,
0.999159, 0.999474, 0.999671, 0.999794, 0.999871, 0.999919, 0.999949,
0.999968, 0.99998, 0.999988, 0.999992, 0.999995, 0.999997, 0.999998,
0.999999, 0.999999, 1
};
for (size_t i = 0, e = countof(Expected); i < e; ++i)
{
const double L = 1.0; // mean free path
const double S = 14.056001; // scaling factor s for A = 0.9
const double cdf =
normalized_diffusion_cdf(
static_cast<double>(i) * 0.1 + 0.05,
L,
S);
EXPECT_FEQ_EPS(Expected[i], cdf, NormalizedDiffusionTestEps);
}
}
/*
TEST_CASE(NormalizedDiffusionCdfPdf)
{
const double ndiff_step = 0.0001;
MersenneTwister rng;
for (size_t i = 0; i < 50; ++i)
{
const double a = rand_double1(rng);
const double l = rand_double1(rng, 0.0001, 10.0);
const double s = normalized_diffusion_s(a);
const double r = rand_double1(rng, 0.0001, 20.0);
const double pdf = normalized_diffusion_pdf(r, l, s);
const double pdf_ndiff =
(normalized_diffusion_cdf(r + ndiff_step, l, s) -
normalized_diffusion_cdf(r, l, s)) / ndiff_step;
EXPECT_FEQ_EPS(pdf, pdf_ndiff, ndiff_step);
}
}
*/
TEST_CASE(NormalizedDiffusionSample)
{
MersenneTwister rng;
for (size_t i = 0; i < 1000; ++i)
{
const double u = rand_double1(rng);
const double a = rand_double1(rng);
const double l = rand_double1(rng, 0.001, 10.0);
const double s = normalized_diffusion_s(a);
const double r = normalized_diffusion_sample(u, l, s);
EXPECT_FEQ_EPS(u, normalized_diffusion_cdf(r, l, s), NormalizedDiffusionTestEps);
}
}
TEST_CASE(PlotNormalizedDiffusionS)
{
GnuplotFile plotfile;
plotfile.set_title("dmfp functional approximation");
plotfile.set_xlabel("A");
plotfile.set_ylabel("S(A)");
const size_t N = 1000;
vector<Vector2d> points;
for (size_t j = 0; j < N; ++j)
{
const double a = fit<size_t, double>(j, 0, N - 1, 0.0, 1.0);
const double s = normalized_diffusion_s(a);
points.push_back(Vector2d(a, s));
}
plotfile.new_plot().set_points(points);
plotfile.write("unit tests/outputs/test_sss_normalized_diffusion_s.gnuplot");
}
TEST_CASE(PlotNormalizedDiffusionR)
{
GnuplotFile plotfile;
plotfile.set_title("Searchlight Configuration with dmfp Parameterization");
plotfile.set_xlabel("r");
plotfile.set_ylabel("r R(r)");
plotfile.set_xrange(0.0, 8.0);
plotfile.set_yrange(0.001, 1.0);
plotfile.set_logscale_y();
for (size_t i = 9; i >= 1; --i)
{
const double a = static_cast<double>(i) / 10.0;
const double s = normalized_diffusion_s(a);
const size_t N = 1000;
vector<Vector2d> points;
for (size_t j = 0; j < N; ++j)
{
const double r = max(fit<size_t, double>(j, 0, N - 1, 0.0, 8.0), 0.0001);
const double y = r * normalized_diffusion_r(r, 1.0, s, a);
points.push_back(Vector2d(r, y));
}
static const char* Colors[9] =
{
"gray",
"orange",
"black",
"brown",
"cyan",
"magenta",
"blue",
"green",
"red"
};
plotfile
.new_plot()
.set_points(points)
.set_title("A = " + to_string(a))
.set_color(Colors[i - 1]);
}
plotfile.write("unit tests/outputs/test_sss_normalized_diffusion_r.gnuplot");
}
void plot_dirpole_rd(
const char* filename,
const char* title,
const double sigma_a,
const double ymin,
const double ymax)
{
GnuplotFile plotfile;
plotfile.set_title(title);
plotfile.set_xlabel("x[cm]");
plotfile.set_ylabel("Rd(x)");
plotfile.set_logscale_y();
plotfile.set_xrange(-16, 16);
plotfile.set_yrange(ymin, ymax);
auto_release_ptr<BSSRDF> bssrdf(
DirectionalDipoleBSSRDFFactory().create("dirpole", ParamArray()));
DirectionalDipoleBSSRDFInputValues values;
values.m_inside_ior = 1.0;
values.m_outside_ior = 1.0;
values.m_anisotropy = 0.0;
values.m_sigma_a = Color3f(static_cast<float>(sigma_a));
values.m_sigma_s_prime = Color3f(1.0f); // We assume g == 0.
const Vector3d normal(0.0, 1.0, 0.0);
ShadingPoint outgoing;
ShadingPointBuilder outgoing_builder(outgoing);
outgoing_builder.set_primitive_type(ShadingPoint::PrimitiveTriangle);
outgoing_builder.set_point(Vector3d(0.0, 0.0, 0.0));
outgoing_builder.set_shading_basis(Basis3d(normal));
ShadingPoint incoming;
ShadingPointBuilder incoming_builder(incoming);
incoming_builder.set_primitive_type(ShadingPoint::PrimitiveTriangle);
incoming_builder.set_shading_basis(Basis3d(normal));
const size_t N = 1000;
vector<Vector2d> points;
for (size_t i = 0; i < N; ++i)
{
const double x = fit<size_t, double>(i, 0, N - 1, -16.0, 16.0);
incoming_builder.set_point(Vector3d(x, 0, 0));
Spectrum result;
bssrdf->evaluate(
&values,
outgoing,
normal,
incoming,
normal,
result);
points.push_back(Vector2d(x, result[0] * Pi));
}
plotfile
.new_plot()
.set_points(points);
plotfile.write(filename);
}
TEST_CASE(PlotDirectionalDipoleRd)
{
plot_dirpole_rd(
"unit tests/outputs/test_sss_dirpole_rd_a_001.gnuplot",
"Directional dipole diffuse reflectance (sigma_a == 0.01)",
0.01,
1e-5,
1e+1);
plot_dirpole_rd(
"unit tests/outputs/test_sss_dirpole_rd_a_01.gnuplot",
"Directional dipole diffuse reflectance (sigma_a == 0.1)",
0.1,
1e-8,
1e+1);
plot_dirpole_rd(
"unit tests/outputs/test_sss_dirpole_rd_a_1.gnuplot",
"Directional dipole diffuse reflectance (sigma_a == 1)",
1,
1e-16,
1e+1);
}
}
<commit_msg>Addressed PR comments<commit_after>
//
// This source file is part of appleseed.
// Visit http://appleseedhq.net/ for additional information and resources.
//
// This software is released under the MIT license.
//
// Copyright (c) 2015 Esteban Tovagliari, 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.
//
// appleseed.renderer headers.
#include "renderer/kernel/shading/shadingpoint.h"
#include "renderer/kernel/shading/shadingpointbuilder.h"
#include "renderer/modeling/bssrdf/bssrdf.h"
#include "renderer/modeling/bssrdf/directionaldipolebssrdf.h"
#include "renderer/modeling/bssrdf/sss.h"
#include "renderer/utility/paramarray.h"
// appleseed.foundation headers.
#include "foundation/image/color.h"
#include "foundation/math/rng/distribution.h"
#include "foundation/math/rng/mersennetwister.h"
#include "foundation/math/basis.h"
#include "foundation/math/fresnel.h"
#include "foundation/math/scalar.h"
#include "foundation/utility/autoreleaseptr.h"
#include "foundation/utility/gnuplotfile.h"
#include "foundation/utility/string.h"
#include "foundation/utility/test.h"
// Standard headers.
#include <algorithm>
#include <cstddef>
#include <vector>
using namespace foundation;
using namespace renderer;
using namespace std;
TEST_SUITE(Renderer_Modeling_BSSRDF_SSS)
{
double rd_alpha_prime_roundtrip(
const double rd,
const double eta)
{
const double two_c1 = fresnel_moment_two_c1(eta);
const double three_c2 = fresnel_moment_three_c2(eta);
const double alpha_prime = compute_alpha_prime(rd, two_c1, three_c2);
return compute_rd(alpha_prime, two_c1, three_c2);
}
TEST_CASE(Rd_AlphaPrime_Roundtrip)
{
EXPECT_FEQ_EPS(0.0, rd_alpha_prime_roundtrip(0.0, 1.6), 0.001);
EXPECT_FEQ_EPS(0.1, rd_alpha_prime_roundtrip(0.1, 1.3), 0.001);
EXPECT_FEQ_EPS(0.2, rd_alpha_prime_roundtrip(0.2, 1.2), 0.001);
EXPECT_FEQ_EPS(0.4, rd_alpha_prime_roundtrip(0.4, 1.3), 0.001);
EXPECT_FEQ_EPS(0.6, rd_alpha_prime_roundtrip(0.6, 1.4), 0.001);
EXPECT_FEQ_EPS(0.8, rd_alpha_prime_roundtrip(0.8, 1.3), 0.001);
EXPECT_FEQ_EPS(1.0, rd_alpha_prime_roundtrip(1.0, 1.5), 0.001);
}
const double NormalizedDiffusionTestEps = 0.0001;
TEST_CASE(NormalizedDiffusionA)
{
static const double Expected[] =
{
4.68592, 4.11466, 3.77984, 3.60498, 3.52856, 3.5041, 3.50008,
3.50002, 3.5024, 3.52074, 3.58352, 3.73426, 4.03144, 4.54858,
5.37416, 6.6117, 8.37968, 10.8116, 14.056, 18.2763, 23.6511
};
for (size_t i = 0, e = countof(Expected); i < e; ++i)
{
const double s = normalized_diffusion_s(static_cast<double>(i) * 0.05);
EXPECT_FEQ_EPS(Expected[i], s, NormalizedDiffusionTestEps);
}
}
TEST_CASE(NormalizedDiffusionR)
{
static const double Expected[] =
{
2.53511, 0.674967, 0.327967, 0.192204, 0.124137, 0.0852575,
0.0611367, 0.0452741, 0.0343737, 0.0266197, 0.0209473, 0.0167009,
0.0134603, 0.0109471, 0.00897108, 0.00739936, 0.00613676, 0.00511384,
0.00427902, 0.0035934, 0.00302721
};
for (size_t i = 0, e = countof(Expected); i < e; ++i)
{
const double r =
normalized_diffusion_r(
static_cast<double>(i) * 0.1 + 0.05,
1.0,
3.583521,
0.5);
EXPECT_FEQ_EPS(Expected[i], r, NormalizedDiffusionTestEps);
}
}
TEST_CASE(NormalizedDiffusionCdf)
{
static const double Expected[] =
{
0.282838, 0.598244, 0.760091, 0.85267, 0.908478, 0.942885, 0.964293,
0.97766, 0.98602, 0.99125, 0.994523, 0.996572, 0.997854, 0.998657,
0.999159, 0.999474, 0.999671, 0.999794, 0.999871, 0.999919, 0.999949,
0.999968, 0.99998, 0.999988, 0.999992, 0.999995, 0.999997, 0.999998,
0.999999, 0.999999, 1
};
for (size_t i = 0, e = countof(Expected); i < e; ++i)
{
const double L = 1.0; // mean free path
const double S = 14.056001; // scaling factor s for A = 0.9
const double cdf =
normalized_diffusion_cdf(
static_cast<double>(i) * 0.1 + 0.05,
L,
S);
EXPECT_FEQ_EPS(Expected[i], cdf, NormalizedDiffusionTestEps);
}
}
/*
TEST_CASE(NormalizedDiffusionCdfPdf)
{
const double ndiff_step = 0.0001;
MersenneTwister rng;
for (size_t i = 0; i < 50; ++i)
{
const double a = rand_double1(rng);
const double l = rand_double1(rng, 0.0001, 10.0);
const double s = normalized_diffusion_s(a);
const double r = rand_double1(rng, 0.0001, 20.0);
const double pdf = normalized_diffusion_pdf(r, l, s);
const double pdf_ndiff =
(normalized_diffusion_cdf(r + ndiff_step, l, s) -
normalized_diffusion_cdf(r, l, s)) / ndiff_step;
EXPECT_FEQ_EPS(pdf, pdf_ndiff, ndiff_step);
}
}
*/
TEST_CASE(NormalizedDiffusionSample)
{
MersenneTwister rng;
for (size_t i = 0; i < 1000; ++i)
{
const double u = rand_double1(rng);
const double a = rand_double1(rng);
const double l = rand_double1(rng, 0.001, 10.0);
const double s = normalized_diffusion_s(a);
const double r = normalized_diffusion_sample(u, l, s);
EXPECT_FEQ_EPS(u, normalized_diffusion_cdf(r, l, s), NormalizedDiffusionTestEps);
}
}
TEST_CASE(PlotNormalizedDiffusionS)
{
GnuplotFile plotfile;
plotfile.set_title("dmfp functional approximation");
plotfile.set_xlabel("A");
plotfile.set_ylabel("s(A)");
const size_t N = 1000;
vector<Vector2d> points;
for (size_t j = 0; j < N; ++j)
{
const double a = fit<size_t, double>(j, 0, N - 1, 0.0, 1.0);
const double s = normalized_diffusion_s(a);
points.push_back(Vector2d(a, s));
}
plotfile.new_plot().set_points(points);
plotfile.write("unit tests/outputs/test_sss_normalized_diffusion_s.gnuplot");
}
TEST_CASE(PlotNormalizedDiffusionR)
{
GnuplotFile plotfile;
plotfile.set_title("Searchlight Configuration with dmfp Parameterization");
plotfile.set_xlabel("r");
plotfile.set_ylabel("r R(r)");
plotfile.set_xrange(0.0, 8.0);
plotfile.set_yrange(0.001, 1.0);
plotfile.set_logscale_y();
for (size_t i = 9; i >= 1; --i)
{
const double a = static_cast<double>(i) / 10.0;
const double s = normalized_diffusion_s(a);
const size_t N = 1000;
vector<Vector2d> points;
for (size_t j = 0; j < N; ++j)
{
const double r = max(fit<size_t, double>(j, 0, N - 1, 0.0, 8.0), 0.0001);
const double y = r * normalized_diffusion_r(r, 1.0, s, a);
points.push_back(Vector2d(r, y));
}
static const char* Colors[9] =
{
"gray",
"orange",
"black",
"brown",
"cyan",
"magenta",
"blue",
"green",
"red"
};
plotfile
.new_plot()
.set_points(points)
.set_title("A = " + to_string(a))
.set_color(Colors[i - 1]);
}
plotfile.write("unit tests/outputs/test_sss_normalized_diffusion_r.gnuplot");
}
void plot_dirpole_rd(
const char* filename,
const char* title,
const double sigma_a,
const double ymin,
const double ymax)
{
GnuplotFile plotfile;
plotfile.set_title(title);
plotfile.set_xlabel("x[cm]");
plotfile.set_ylabel("Rd(x)");
plotfile.set_logscale_y();
plotfile.set_xrange(-16, 16);
plotfile.set_yrange(ymin, ymax);
auto_release_ptr<BSSRDF> bssrdf(
DirectionalDipoleBSSRDFFactory().create("dirpole", ParamArray()));
DirectionalDipoleBSSRDFInputValues values;
values.m_inside_ior = 1.0;
values.m_outside_ior = 1.0;
values.m_anisotropy = 0.0;
values.m_sigma_a = Color3f(static_cast<float>(sigma_a));
values.m_sigma_s_prime = Color3f(1.0f); // We assume g == 0.
const Vector3d normal(0.0, 1.0, 0.0);
ShadingPoint outgoing;
ShadingPointBuilder outgoing_builder(outgoing);
outgoing_builder.set_primitive_type(ShadingPoint::PrimitiveTriangle);
outgoing_builder.set_point(Vector3d(0.0, 0.0, 0.0));
outgoing_builder.set_shading_basis(Basis3d(normal));
ShadingPoint incoming;
ShadingPointBuilder incoming_builder(incoming);
incoming_builder.set_primitive_type(ShadingPoint::PrimitiveTriangle);
incoming_builder.set_shading_basis(Basis3d(normal));
const size_t N = 1000;
vector<Vector2d> points;
for (size_t i = 0; i < N; ++i)
{
const double x = fit<size_t, double>(i, 0, N - 1, -16.0, 16.0);
incoming_builder.set_point(Vector3d(x, 0, 0));
Spectrum result;
bssrdf->evaluate(
&values,
outgoing,
normal,
incoming,
normal,
result);
points.push_back(Vector2d(x, result[0] * Pi));
}
plotfile
.new_plot()
.set_points(points);
plotfile.write(filename);
}
TEST_CASE(PlotDirectionalDipoleRd)
{
plot_dirpole_rd(
"unit tests/outputs/test_sss_dirpole_rd_a_001.gnuplot",
"Directional dipole diffuse reflectance (sigma_a == 0.01)",
0.01,
1e-5,
1e+1);
plot_dirpole_rd(
"unit tests/outputs/test_sss_dirpole_rd_a_01.gnuplot",
"Directional dipole diffuse reflectance (sigma_a == 0.1)",
0.1,
1e-8,
1e+1);
plot_dirpole_rd(
"unit tests/outputs/test_sss_dirpole_rd_a_1.gnuplot",
"Directional dipole diffuse reflectance (sigma_a == 1)",
1,
1e-16,
1e+1);
}
}
<|endoftext|>
|
<commit_before>// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/keygen_handler.h"
#include <string>
#include "base/base64.h"
#include "base/logging.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
TEST(KeygenHandlerTest, SmokeTest) {
KeygenHandler handler(2048, "some challenge");
handler.set_stores_key(false); // Don't leave the key-pair behind
std::string result = handler.GenKeyAndSignChallenge();
LOG(INFO) << "KeygenHandler produced: " << result;
ASSERT_GT(result.length(), 0U);
// Verify it's valid base64:
std::string spkac;
ASSERT_TRUE(base::Base64Decode(result, &spkac));
// In lieu of actually parsing and validating the DER data,
// just check that it exists and has a reasonable length.
// (It's almost always 590 bytes, but the DER encoding of the random key
// and signature could sometimes be a few bytes different.)
ASSERT_GE(spkac.length(), 580U);
ASSERT_LE(spkac.length(), 600U);
// NOTE:
// The value of |result| can be validated by prefixing 'SPKAC=' to it
// and piping it through
// openssl spkac -verify
// whose output should look like:
// Netscape SPKI:
// Public Key Algorithm: rsaEncryption
// RSA Public Key: (2048 bit)
// Modulus (2048 bit):
// 00:b6:cc:14:c9:43:b5:2d:51:65:7e:11:8b:80:9e: .....
// Exponent: 65537 (0x10001)
// Challenge String: some challenge
// Signature Algorithm: md5WithRSAEncryption
// 92:f3:cc:ff:0b:d3:d0:4a:3a:4c:ba:ff:d6:38:7f:a5:4b:b5: .....
// Signature OK
//
// The value of |spkac| can be ASN.1-parsed with:
// openssl asn1parse -inform DER
}
} // namespace
} // namespace net
<commit_msg>TBR: Fix build by marking new Keygen test as flaky.<commit_after>// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/keygen_handler.h"
#include <string>
#include "base/base64.h"
#include "base/logging.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
TEST(KeygenHandlerTest, FLAKY_SmokeTest) {
KeygenHandler handler(2048, "some challenge");
handler.set_stores_key(false); // Don't leave the key-pair behind
std::string result = handler.GenKeyAndSignChallenge();
LOG(INFO) << "KeygenHandler produced: " << result;
ASSERT_GT(result.length(), 0U);
// Verify it's valid base64:
std::string spkac;
ASSERT_TRUE(base::Base64Decode(result, &spkac));
// In lieu of actually parsing and validating the DER data,
// just check that it exists and has a reasonable length.
// (It's almost always 590 bytes, but the DER encoding of the random key
// and signature could sometimes be a few bytes different.)
ASSERT_GE(spkac.length(), 580U);
ASSERT_LE(spkac.length(), 600U);
// NOTE:
// The value of |result| can be validated by prefixing 'SPKAC=' to it
// and piping it through
// openssl spkac -verify
// whose output should look like:
// Netscape SPKI:
// Public Key Algorithm: rsaEncryption
// RSA Public Key: (2048 bit)
// Modulus (2048 bit):
// 00:b6:cc:14:c9:43:b5:2d:51:65:7e:11:8b:80:9e: .....
// Exponent: 65537 (0x10001)
// Challenge String: some challenge
// Signature Algorithm: md5WithRSAEncryption
// 92:f3:cc:ff:0b:d3:d0:4a:3a:4c:ba:ff:d6:38:7f:a5:4b:b5: .....
// Signature OK
//
// The value of |spkac| can be ASN.1-parsed with:
// openssl asn1parse -inform DER
}
} // namespace
} // namespace net
<|endoftext|>
|
<commit_before>#include <array.h>
#include <drivers/vga.hpp>
#include <kernel/cpu/gdt.hpp>
#include <kernel/cpu/idt.hpp>
#include <kernel/vfs/vfs.hpp>
#include <kernel/vfs/file.hpp>
#include <kernel/vfs/ramfs.hpp>
#include <kernel/cpu/reboot.hpp>
#include <kernel/console/console.hpp>
#include <kernel/scheduler/process.hpp>
utils::array<char, 2048> user_stack;
#define switch_to_user() \
asm volatile( \
"pushl %0;" \
"pushl %2;" \
"pushl $0x0;" \
"pushl %1;" \
"push $1f;" \
"iret;" \
"1:" \
"mov %0, %%eax;" \
"mov %%ax, %%ds;" \
"mov %%ax, %%es;" \
"mov %%ax, %%fs;" \
"mov %%ax, %%gs;" \
:: "i" (cpu::segment::user_ds), \
"i" (cpu::segment::user_cs), \
"r" (&user_stack[2048]) \
)
asmlinkage __noreturn void main() {
cpu::gdt::initialize();
cpu::idt::initialize();
scheduler::initialize();
drivers::vga::initialize();
console::initialize(drivers::vga::print);
ramfs::ramfs ramfs;
vfs::initialize(ramfs);
console::print("\nHello World!\n");
switch_to_user();
while (1);
}
<commit_msg>Print boot cmdline in kernel/main<commit_after>#include <array.h>
#include <drivers/vga.hpp>
#include <kernel/boot.hpp>
#include <kernel/cpu/gdt.hpp>
#include <kernel/cpu/idt.hpp>
#include <kernel/vfs/vfs.hpp>
#include <kernel/vfs/file.hpp>
#include <kernel/vfs/ramfs.hpp>
#include <kernel/cpu/reboot.hpp>
#include <kernel/console/console.hpp>
#include <kernel/scheduler/process.hpp>
utils::array<char, 2048> user_stack;
#define switch_to_user() \
asm volatile( \
"pushl %0;" \
"pushl %2;" \
"pushl $0x0;" \
"pushl %1;" \
"push $1f;" \
"iret;" \
"1:" \
"mov %0, %%eax;" \
"mov %%ax, %%ds;" \
"mov %%ax, %%es;" \
"mov %%ax, %%fs;" \
"mov %%ax, %%gs;" \
:: "i" (cpu::segment::user_ds), \
"i" (cpu::segment::user_cs), \
"r" (&user_stack[2048]) \
)
asmlinkage __noreturn void main() {
cpu::gdt::initialize();
cpu::idt::initialize();
scheduler::initialize();
drivers::vga::initialize();
console::initialize(drivers::vga::print);
ramfs::ramfs ramfs;
vfs::initialize(ramfs);
console::print("Boot command-line: ", boot::cmdline, "\n");
console::print("\nHello World!\n");
switch_to_user();
while (1);
}
<|endoftext|>
|
<commit_before>// Copyright 2010-2015 RethinkDB, all rights reserved.
#ifndef CLUSTERING_ADMINISTRATION_ADMIN_OP_EXC_HPP_
#define CLUSTERING_ADMINISTRATION_ADMIN_OP_EXC_HPP_
#include "utils.hpp"
#include "clustering/table_manager/table_meta_client.hpp"
struct admin_err_t {
std::string msg;
query_state_t query_state;
};
// These have to be macros because `rfail` and `rfail_datum` are macros.
#define REQL_RETHROW(X) do { \
rfail((X).query_state == query_state_t::FAILED \
? ql::base_exc_t::OP_FAILED \
: ql::base_exc_t::OP_INDETERMINATE, \
"%s", (X).msg.c_str()); \
} while (0)
#define REQL_RETHROW_DATUM(X) do { \
rfail_datum((X).query_state == query_state_t::FAILED \
? ql::base_exc_t::OP_FAILED \
: ql::base_exc_t::OP_INDETERMINATE, \
"%s", (X).msg.c_str()); \
} while (0)
/* This is a generic class for errors that occur during administrative operations. It has
a string error message which is suitable for presenting to the user. */
class admin_op_exc_t : public std::runtime_error {
public:
explicit admin_op_exc_t(admin_err_t err)
: std::runtime_error(std::move(err.msg)),
query_state(err.query_state) { }
admin_op_exc_t(std::string msg, query_state_t _query_state)
: std::runtime_error(std::move(msg)),
query_state(_query_state) { }
const query_state_t query_state;
};
/* `CATCH_NAME_ERRORS` and `CATCH_OP_ERRORS` are helper macros for catching the
exceptions thrown by the `table_meta_client_t` and producing consistent error messages.
They're designed to be used as follows:
try {
something_that_might_throw()
} CATCH_NAME_ERRORS(db, name, error_out);
TODO: Probably these should re-throw `admin_op_exc_t` instead of setting `*error_out` and
returning `false`. */
#define CATCH_NAME_ERRORS(db, name, error_out) \
catch (const no_such_table_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("Table `%s.%s` does not exist.", (db).c_str(), (name).c_str()), \
query_state_t::FAILED}; \
return false; \
} catch (const ambiguous_table_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("Table `%s.%s` is ambiguous; there are multiple " \
"tables with that name.", (db).c_str(), (name).c_str()), \
query_state_t::FAILED}; \
return false; \
}
/* For read operations, `no_msg` and `maybe_msg` should both be `""`. For write
operations, `no_msg` should be a string literal stating that the operation was not
performed, and `maybe_msg` should be a string literal stating that the operation may or
may not have been performed. */
#define CATCH_OP_ERRORS(db, name, error_out, no_msg, maybe_msg) \
catch (const failed_table_op_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("The server(s) hosting table `%s.%s` are currently " \
"unreachable. " no_msg, (db).c_str(), (name).c_str()), \
query_state_t::FAILED}; \
return false; \
} catch (const maybe_failed_table_op_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("We lost contact with the server(s) hosting table " \
"`%s.%s`. " maybe_msg, (db).c_str(), (name).c_str()), \
query_state_t::INDETERMINATE}; \
return false; \
}
#endif /* CLUSTERING_ADMINISTRATION_ADMIN_OP_EXC_HPP_ */
<commit_msg>Add hint to emergency_repair on reconfigure error<commit_after>// Copyright 2010-2015 RethinkDB, all rights reserved.
#ifndef CLUSTERING_ADMINISTRATION_ADMIN_OP_EXC_HPP_
#define CLUSTERING_ADMINISTRATION_ADMIN_OP_EXC_HPP_
#include "utils.hpp"
#include "clustering/table_manager/table_meta_client.hpp"
struct admin_err_t {
std::string msg;
query_state_t query_state;
};
// These have to be macros because `rfail` and `rfail_datum` are macros.
#define REQL_RETHROW(X) do { \
rfail((X).query_state == query_state_t::FAILED \
? ql::base_exc_t::OP_FAILED \
: ql::base_exc_t::OP_INDETERMINATE, \
"%s", (X).msg.c_str()); \
} while (0)
#define REQL_RETHROW_DATUM(X) do { \
rfail_datum((X).query_state == query_state_t::FAILED \
? ql::base_exc_t::OP_FAILED \
: ql::base_exc_t::OP_INDETERMINATE, \
"%s", (X).msg.c_str()); \
} while (0)
/* This is a generic class for errors that occur during administrative operations. It has
a string error message which is suitable for presenting to the user. */
class admin_op_exc_t : public std::runtime_error {
public:
explicit admin_op_exc_t(admin_err_t err)
: std::runtime_error(std::move(err.msg)),
query_state(err.query_state) { }
admin_op_exc_t(std::string msg, query_state_t _query_state)
: std::runtime_error(std::move(msg)),
query_state(_query_state) { }
const query_state_t query_state;
};
/* `CATCH_NAME_ERRORS` and `CATCH_OP_ERRORS` are helper macros for catching the
exceptions thrown by the `table_meta_client_t` and producing consistent error messages.
They're designed to be used as follows:
try {
something_that_might_throw()
} CATCH_NAME_ERRORS(db, name, error_out);
TODO: Probably these should re-throw `admin_op_exc_t` instead of setting `*error_out` and
returning `false`. */
#define CATCH_NAME_ERRORS(db, name, error_out) \
catch (const no_such_table_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("Table `%s.%s` does not exist.", (db).c_str(), (name).c_str()), \
query_state_t::FAILED}; \
return false; \
} catch (const ambiguous_table_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("Table `%s.%s` is ambiguous; there are multiple " \
"tables with that name.", (db).c_str(), (name).c_str()), \
query_state_t::FAILED}; \
return false; \
}
/* For read operations, `no_msg` and `maybe_msg` should both be `""`. For write
operations, `no_msg` should be a string literal stating that the operation was not
performed, and `maybe_msg` should be a string literal stating that the operation may or
may not have been performed. */
#define CATCH_OP_ERRORS(db, name, error_out, no_msg, maybe_msg) \
catch (const failed_table_op_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("The server(s) hosting table `%s.%s` are currently " \
"unreachable. " no_msg " If you do not expect the server(s) " \
"to recover, you can use `emergency_repair` to restore " \
"availability of the table. " \
"<http://rethinkdb.com/api/javascript/reconfigure/" \
"#emergency-repair-mode>", (db).c_str(), (name).c_str()), \
query_state_t::FAILED}; \
return false; \
} catch (const maybe_failed_table_op_exc_t &) { \
*(error_out) = admin_err_t{ \
strprintf("We lost contact with the server(s) hosting table " \
"`%s.%s`. " maybe_msg, (db).c_str(), (name).c_str()), \
query_state_t::INDETERMINATE}; \
return false; \
}
#endif /* CLUSTERING_ADMINISTRATION_ADMIN_OP_EXC_HPP_ */
<|endoftext|>
|
<commit_before>/*
* This file is part of the Gluon library.
* Copyright 2008 Sacha Schutz <istdasklar@free.fr>
* Copyright 2008 Olivier Gueudelot <gueudelotolive@gmail.com>
* Copyright 2008 Charles Huet <packadal@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this library; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "kglitem.h"
#include <KDebug>
#include <iostream>
using namespace std;
void KGLItem::init()
{
setObjectName(metaObject()->className());
m_isCreated = false;
f_showBoundingBox = false;
f_showCenter = false;
f_textureEnable = true;
m_mode = GL_POLYGON;
m_color = Qt::white;
m_alpha = 1;
m_texture = new KGLTexture;
m_GLCallList = glGenLists(1);
m_texRepeat = QPointF(1,1);
m_program = NULL;
resetTransform();
}
KGLItem::KGLItem(KGLEngine* parent)
: KGLBaseItem()
{
init();
}
KGLItem::KGLItem(const QPolygonF &poly, KGLEngine * parent)
: KGLBaseItem()
{
init();
setObjectName(metaObject()->className());
createPolygon(poly);
}
KGLItem::KGLItem(const QSizeF &box , KGLEngine * parent)
: KGLBaseItem()
{
init();
setObjectName(metaObject()->className());
createBox(box);
}
KGLItem::KGLItem(const QLineF &line, KGLEngine * parent)
: KGLBaseItem()
{
init();
setObjectName(metaObject()->className());
setMode(GL_LINES);
createLine(line);
}
KGLItem::~KGLItem()
{
delete m_texture;
delete m_program;
glDeleteLists(m_GLCallList,1);
}
KGLItem *KGLItem::clone()
{
KGLItem * newItem = new KGLItem;
newItem->setTexture(texture());
newItem->setMatrix(matrix());
newItem->setPosition(position());
foreach(KGLPoint p, pointList())
newItem->addVertex(p);
return newItem;
}
void KGLItem::draw()
{
if (!m_isCreated)
create();
if ( f_showBoundingBox) drawBoundingBox();
m_texture->updateTransform();
glPushMatrix();
glLoadMatrixd(matrix().data());
m_texture->bind();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(GL_FALSE);
glEnable(GL_POLYGON_SMOOTH);
if ( m_program != NULL ){
if ( program()->isValid())
program()->bind();
}
glCallList(m_GLCallList); //CALL THE LIST
if ( m_program != NULL ){
program()->unbind();
}
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
m_texture->unBind();
glDepthMask(GL_TRUE);
if ( f_showCenter) drawCenter();
glPopMatrix();
drawChild();
emit painted();
}
void KGLItem::create()
{
if (m_GLCallList != 0)
{
glDeleteLists(m_GLCallList, 1);
}
glNewList(m_GLCallList, GL_COMPILE);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
/* envoie des donnees */
glVertexPointer(2, GL_FLOAT,sizeof(KGLPoint),pointList().vertexStart());
glTexCoordPointer(2,GL_FLOAT,sizeof(KGLPoint),pointList().texCoordStart());
glColorPointer(4, GL_FLOAT,sizeof(KGLPoint),pointList().colorStart());
// /* rendu indice */
glDrawArrays(m_mode, 0, pointList().size());
/* desactivation des tableaux de sommet */
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
if (f_showCenter)
{
drawCenter();
}
glEndList();
m_isCreated = true;
}
void KGLItem::updateTransform()
{
KGLBaseItem::updateTransform();
if ( m_childItems.size()>0)
{
foreach(KGLItem* item, m_childItems)
item->applyTransform(matrix());
}
}
void KGLItem::drawChild()
{
if ( m_childItems.size()>0)
{
foreach(KGLItem* item, m_childItems)
{
item->draw();
}
}
}
void KGLItem::drawGLPoint(KGLPoint &p)
{
glTexCoord2f(p.texCoordX(), p.texCoordY());
glColor4f(p.red(), p.green(), p.blue(), p.alpha());
glVertex2d(p.x(), p.y());
}
void KGLItem::drawBoundingBox()
{
glBegin(GL_LINE_LOOP);
QRectF rectAround = boundingBox();
glColor3f(100, 100, 100);
glVertex2d(rectAround.x(), rectAround.y());
glVertex2d(rectAround.x() + rectAround.width(), rectAround.y());
glVertex2d(rectAround.x() + rectAround.width(), rectAround.y() + rectAround.height());
glVertex2d(rectAround.x(), rectAround.y() + rectAround.height());
glEnd();
}
void KGLItem::setColor(const QColor &c)
{
m_color = c;
for ( int i=0; i<pointList().size();++i)
pointList()[i].setColor(c);
m_isCreated = false;
}
void KGLItem::setAlpha(const float &a)
{
m_alpha = a;
foreach(KGLPoint p, pointList()) {
p.setAlpha(a);
}
m_isCreated = false;
}
void KGLItem::drawCenter()
{
glPointSize(3);
glBegin(GL_POINTS);
QPointF c = itemCenter();
glColor3f(100, 0, 0);
glVertex2d(c.x(), c.y());
glEnd();
glColor3f(100, 100, 100);
glPointSize(1);
}
<commit_msg>Remove call to glEnable(GL_POLYGON_SMOOTH) as it causes diagonal lines to appear on certain cards.<commit_after>/*
* This file is part of the Gluon library.
* Copyright 2008 Sacha Schutz <istdasklar@free.fr>
* Copyright 2008 Olivier Gueudelot <gueudelotolive@gmail.com>
* Copyright 2008 Charles Huet <packadal@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this library; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "kglitem.h"
#include <KDebug>
#include <iostream>
using namespace std;
void KGLItem::init()
{
setObjectName(metaObject()->className());
m_isCreated = false;
f_showBoundingBox = false;
f_showCenter = false;
f_textureEnable = true;
m_mode = GL_POLYGON;
m_color = Qt::white;
m_alpha = 1;
m_texture = new KGLTexture;
m_GLCallList = glGenLists(1);
m_texRepeat = QPointF(1,1);
m_program = NULL;
resetTransform();
}
KGLItem::KGLItem(KGLEngine* parent)
: KGLBaseItem()
{
init();
}
KGLItem::KGLItem(const QPolygonF &poly, KGLEngine * parent)
: KGLBaseItem()
{
init();
setObjectName(metaObject()->className());
createPolygon(poly);
}
KGLItem::KGLItem(const QSizeF &box , KGLEngine * parent)
: KGLBaseItem()
{
init();
setObjectName(metaObject()->className());
createBox(box);
}
KGLItem::KGLItem(const QLineF &line, KGLEngine * parent)
: KGLBaseItem()
{
init();
setObjectName(metaObject()->className());
setMode(GL_LINES);
createLine(line);
}
KGLItem::~KGLItem()
{
delete m_texture;
delete m_program;
glDeleteLists(m_GLCallList,1);
}
KGLItem *KGLItem::clone()
{
KGLItem * newItem = new KGLItem;
newItem->setTexture(texture());
newItem->setMatrix(matrix());
newItem->setPosition(position());
foreach(KGLPoint p, pointList())
newItem->addVertex(p);
return newItem;
}
void KGLItem::draw()
{
if (!m_isCreated)
create();
if ( f_showBoundingBox) drawBoundingBox();
m_texture->updateTransform();
glPushMatrix();
glLoadMatrixd(matrix().data());
m_texture->bind();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(GL_FALSE);
//Disabled until necessary, causes diagonal lines on ATI cards.
//glEnable(GL_POLYGON_SMOOTH);
if ( m_program != NULL ){
if ( program()->isValid())
program()->bind();
}
glCallList(m_GLCallList); //CALL THE LIST
if ( m_program != NULL ){
program()->unbind();
}
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
m_texture->unBind();
glDepthMask(GL_TRUE);
if ( f_showCenter) drawCenter();
glPopMatrix();
drawChild();
emit painted();
}
void KGLItem::create()
{
if (m_GLCallList != 0)
{
glDeleteLists(m_GLCallList, 1);
}
glNewList(m_GLCallList, GL_COMPILE);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
/* envoie des donnees */
glVertexPointer(2, GL_FLOAT,sizeof(KGLPoint),pointList().vertexStart());
glTexCoordPointer(2,GL_FLOAT,sizeof(KGLPoint),pointList().texCoordStart());
glColorPointer(4, GL_FLOAT,sizeof(KGLPoint),pointList().colorStart());
// /* rendu indice */
glDrawArrays(m_mode, 0, pointList().size());
/* desactivation des tableaux de sommet */
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
if (f_showCenter)
{
drawCenter();
}
glEndList();
m_isCreated = true;
}
void KGLItem::updateTransform()
{
KGLBaseItem::updateTransform();
if ( m_childItems.size()>0)
{
foreach(KGLItem* item, m_childItems)
item->applyTransform(matrix());
}
}
void KGLItem::drawChild()
{
if ( m_childItems.size()>0)
{
foreach(KGLItem* item, m_childItems)
{
item->draw();
}
}
}
void KGLItem::drawGLPoint(KGLPoint &p)
{
glTexCoord2f(p.texCoordX(), p.texCoordY());
glColor4f(p.red(), p.green(), p.blue(), p.alpha());
glVertex2d(p.x(), p.y());
}
void KGLItem::drawBoundingBox()
{
glBegin(GL_LINE_LOOP);
QRectF rectAround = boundingBox();
glColor3f(100, 100, 100);
glVertex2d(rectAround.x(), rectAround.y());
glVertex2d(rectAround.x() + rectAround.width(), rectAround.y());
glVertex2d(rectAround.x() + rectAround.width(), rectAround.y() + rectAround.height());
glVertex2d(rectAround.x(), rectAround.y() + rectAround.height());
glEnd();
}
void KGLItem::setColor(const QColor &c)
{
m_color = c;
for ( int i=0; i<pointList().size();++i)
pointList()[i].setColor(c);
m_isCreated = false;
}
void KGLItem::setAlpha(const float &a)
{
m_alpha = a;
foreach(KGLPoint p, pointList()) {
p.setAlpha(a);
}
m_isCreated = false;
}
void KGLItem::drawCenter()
{
glPointSize(3);
glBegin(GL_POINTS);
QPointF c = itemCenter();
glColor3f(100, 0, 0);
glVertex2d(c.x(), c.y());
glEnd();
glColor3f(100, 100, 100);
glPointSize(1);
}
<|endoftext|>
|
<commit_before>/*
* AdaptiveTimeScaleController.cpp
*
* Created on: Aug 18, 2016
* Author: pschultz
*/
#include "AdaptiveTimeScaleController.hpp"
#include "arch/mpi/mpi.h"
#include "include/pv_common.h"
#include "io/FileStream.hpp"
#include "io/fileio.hpp"
#include "utils/PVLog.hpp"
namespace PV {
AdaptiveTimeScaleController::AdaptiveTimeScaleController(
char const *name,
int batchWidth,
double baseMax,
double baseMin,
double tauFactor,
double growthFactor,
bool writeTimeScales,
bool writeTimeScaleFieldnames,
Communicator *communicator,
bool verifyWrites) {
mName = strdup(name);
mBatchWidth = batchWidth;
mBaseMax = baseMax;
mBaseMin = baseMin;
mTauFactor = tauFactor;
mGrowthFactor = growthFactor;
mWriteTimeScales = writeTimeScales;
mWriteTimeScaleFieldnames = writeTimeScaleFieldnames;
mCommunicator = communicator;
mVerifyWrites = verifyWrites;
mTimeScaleInfo.mTimeScale.assign(mBatchWidth, mBaseMin);
mTimeScaleInfo.mTimeScaleMax.assign(mBatchWidth, mBaseMax);
mTimeScaleInfo.mTimeScaleTrue.assign(mBatchWidth, -1.0);
mOldTimeScale.assign(mBatchWidth, mBaseMin);
mOldTimeScaleTrue.assign(mBatchWidth, -1.0);
}
AdaptiveTimeScaleController::~AdaptiveTimeScaleController() { free(mName); }
int AdaptiveTimeScaleController::registerData(
Checkpointer *checkpointer,
std::string const &objName) {
auto ptr = std::make_shared<CheckpointEntryTimeScaleInfo>(
objName, "timescaleinfo", mCommunicator, &mTimeScaleInfo);
checkpointer->registerCheckpointEntry(ptr);
return PV_SUCCESS;
}
std::vector<double> const &AdaptiveTimeScaleController::calcTimesteps(
double timeValue,
std::vector<double> const &rawTimeScales) {
mOldTimeScaleInfo = mTimeScaleInfo;
mTimeScaleInfo.mTimeScaleTrue = rawTimeScales;
for (int b = 0; b < mBatchWidth; b++) {
double E_dt = mTimeScaleInfo.mTimeScaleTrue[b];
double E_0 = mOldTimeScaleInfo.mTimeScaleTrue[b];
double dE_dt_scaled = (E_0 - E_dt) / mTimeScaleInfo.mTimeScale[b];
if ((dE_dt_scaled <= 0.0) || (E_0 <= 0) || (E_dt <= 0)) {
mTimeScaleInfo.mTimeScale[b] = mBaseMin;
mTimeScaleInfo.mTimeScaleMax[b] = mBaseMax;
}
else {
double tau_eff_scaled = E_0 / dE_dt_scaled;
// dt := mTimeScaleMaxBase * tau_eff
mTimeScaleInfo.mTimeScale[b] = mTauFactor * tau_eff_scaled;
mTimeScaleInfo.mTimeScale[b] =
(mTimeScaleInfo.mTimeScale[b] <= mTimeScaleInfo.mTimeScaleMax[b])
? mTimeScaleInfo.mTimeScale[b]
: mTimeScaleInfo.mTimeScaleMax[b];
mTimeScaleInfo.mTimeScale[b] =
(mTimeScaleInfo.mTimeScale[b] < mBaseMin) ? mBaseMin : mTimeScaleInfo.mTimeScale[b];
if (mTimeScaleInfo.mTimeScale[b] == mTimeScaleInfo.mTimeScaleMax[b]) {
mTimeScaleInfo.mTimeScaleMax[b] = (1 + mGrowthFactor) * mTimeScaleInfo.mTimeScaleMax[b];
}
}
}
return mTimeScaleInfo.mTimeScale;
}
void AdaptiveTimeScaleController::writeTimestepInfo(double timeValue, PrintStream &stream) {
if (mWriteTimeScaleFieldnames) {
stream.printf("sim_time = %f\n", timeValue);
}
else {
stream.printf("%f, ", timeValue);
}
for (int b = 0; b < mBatchWidth; b++) {
if (mWriteTimeScaleFieldnames) {
stream.printf(
"\tbatch = %d, timeScale = %10.8f, timeScaleTrue = %10.8f",
b,
mTimeScaleInfo.mTimeScale[b],
mTimeScaleInfo.mTimeScaleTrue[b]);
}
else {
stream.printf(
"%d, %10.8f, %10.8f",
b,
mTimeScaleInfo.mTimeScale[b],
mTimeScaleInfo.mTimeScaleTrue[b]);
}
if (mWriteTimeScaleFieldnames) {
stream.printf(", timeScaleMax = %10.8f\n", mTimeScaleInfo.mTimeScaleMax[b]);
}
else {
stream.printf(", %10.8f\n", mTimeScaleInfo.mTimeScaleMax[b]);
}
}
stream.flush();
}
void CheckpointEntryTimeScaleInfo::write(
std::string const &checkpointDirectory,
double simTime,
bool verifyWritesFlag) const {
if (getCommunicator()->commRank() == 0) {
int batchWidth = (int)mTimeScaleInfoPtr->mTimeScale.size();
std::string path = generatePath(checkpointDirectory, "bin");
FileStream fileStream{path.c_str(), std::ios_base::out, verifyWritesFlag};
for (int b = 0; b < batchWidth; b++) {
fileStream.write(&mTimeScaleInfoPtr->mTimeScale.at(b), sizeof(double));
fileStream.write(&mTimeScaleInfoPtr->mTimeScaleTrue.at(b), sizeof(double));
fileStream.write(&mTimeScaleInfoPtr->mTimeScaleMax.at(b), sizeof(double));
}
path = generatePath(checkpointDirectory, "txt");
FileStream txtFileStream{path.c_str(), std::ios_base::out, verifyWritesFlag};
int kb0 = getCommunicator()->commBatch() * batchWidth;
for (std::size_t b = 0; b < batchWidth; b++) {
txtFileStream << "batch index = " << b + kb0 << "\n";
txtFileStream << "time = " << simTime << "\n";
txtFileStream << "timeScale = " << mTimeScaleInfoPtr->mTimeScale[b] << "\n";
txtFileStream << "timeScaleTrue = " << mTimeScaleInfoPtr->mTimeScaleTrue[b] << "\n";
txtFileStream << "timeScaleMax = " << mTimeScaleInfoPtr->mTimeScaleMax[b] << "\n";
}
}
}
void CheckpointEntryTimeScaleInfo::remove(std::string const &checkpointDirectory) const {
deleteFile(checkpointDirectory, "bin");
deleteFile(checkpointDirectory, "txt");
}
void CheckpointEntryTimeScaleInfo::read(std::string const &checkpointDirectory, double *simTimePtr)
const {
int batchWidth = (int)mTimeScaleInfoPtr->mTimeScale.size();
if (getCommunicator()->commRank() == 0) {
std::string path = generatePath(checkpointDirectory, "bin");
FileStream fileStream{path.c_str(), std::ios_base::in, false};
for (std::size_t b = 0; b < batchWidth; b++) {
fileStream.read(&mTimeScaleInfoPtr->mTimeScale.at(b), sizeof(double));
fileStream.read(&mTimeScaleInfoPtr->mTimeScaleTrue.at(b), sizeof(double));
fileStream.read(&mTimeScaleInfoPtr->mTimeScaleMax.at(b), sizeof(double));
}
}
MPI_Bcast(
mTimeScaleInfoPtr->mTimeScale.data(),
batchWidth,
MPI_DOUBLE,
0,
getCommunicator()->communicator());
MPI_Bcast(
mTimeScaleInfoPtr->mTimeScaleTrue.data(),
batchWidth,
MPI_DOUBLE,
0,
getCommunicator()->communicator());
MPI_Bcast(
mTimeScaleInfoPtr->mTimeScaleMax.data(),
batchWidth,
MPI_DOUBLE,
0,
getCommunicator()->communicator());
}
} /* namespace PV */
<commit_msg>modified timeScaleController to set a "maximum" time scale at which adaption is slowed by a potentially large factor<commit_after>/*
* AdaptiveTimeScaleController.cpp
*
* Created on: Aug 18, 2016
* Author: pschultz
*/
#include "AdaptiveTimeScaleController.hpp"
#include "arch/mpi/mpi.h"
#include "include/pv_common.h"
#include "io/FileStream.hpp"
#include "io/fileio.hpp"
#include "utils/PVLog.hpp"
namespace PV {
AdaptiveTimeScaleController::AdaptiveTimeScaleController(
char const *name,
int batchWidth,
double baseMax,
double baseMin,
double tauFactor,
double growthFactor,
bool writeTimeScales,
bool writeTimeScaleFieldnames,
Communicator *communicator,
bool verifyWrites) {
mName = strdup(name);
mBatchWidth = batchWidth;
mBaseMax = baseMax;
mBaseMin = baseMin;
mTauFactor = tauFactor;
mGrowthFactor = growthFactor;
mWriteTimeScales = writeTimeScales;
mWriteTimeScaleFieldnames = writeTimeScaleFieldnames;
mCommunicator = communicator;
mVerifyWrites = verifyWrites;
mTimeScaleInfo.mTimeScale.assign(mBatchWidth, mBaseMin);
mTimeScaleInfo.mTimeScaleMax.assign(mBatchWidth, mBaseMax);
mTimeScaleInfo.mTimeScaleTrue.assign(mBatchWidth, -1.0);
mOldTimeScale.assign(mBatchWidth, mBaseMin);
mOldTimeScaleTrue.assign(mBatchWidth, -1.0);
}
AdaptiveTimeScaleController::~AdaptiveTimeScaleController() { free(mName); }
int AdaptiveTimeScaleController::registerData(
Checkpointer *checkpointer,
std::string const &objName) {
auto ptr = std::make_shared<CheckpointEntryTimeScaleInfo>(
objName, "timescaleinfo", mCommunicator, &mTimeScaleInfo);
checkpointer->registerCheckpointEntry(ptr);
return PV_SUCCESS;
}
std::vector<double> const &AdaptiveTimeScaleController::calcTimesteps(
double timeValue,
std::vector<double> const &rawTimeScales) {
mOldTimeScaleInfo = mTimeScaleInfo;
mTimeScaleInfo.mTimeScaleTrue = rawTimeScales;
const float MAX_TIME_SCALE = 0.5;
const float MAX_GROWTH_FACTOR = 0.01;
for (int b = 0; b < mBatchWidth; b++) {
double E_dt = mTimeScaleInfo.mTimeScaleTrue[b];
double E_0 = mOldTimeScaleInfo.mTimeScaleTrue[b];
double dE_dt_scaled = (E_0 - E_dt) / mTimeScaleInfo.mTimeScale[b];
if ((dE_dt_scaled <= 0.0) || (E_0 <= 0) || (E_dt <= 0)) {
mTimeScaleInfo.mTimeScale[b] = mBaseMin;
mTimeScaleInfo.mTimeScaleMax[b] = mBaseMax;
}
else {
double tau_eff_scaled = E_0 / dE_dt_scaled;
// dt := mTimeScaleMaxBase * tau_eff
mTimeScaleInfo.mTimeScale[b] = mTauFactor * tau_eff_scaled;
mTimeScaleInfo.mTimeScale[b] =
(mTimeScaleInfo.mTimeScale[b] <= mTimeScaleInfo.mTimeScaleMax[b])
? mTimeScaleInfo.mTimeScale[b]
: mTimeScaleInfo.mTimeScaleMax[b];
//mTimeScaleInfo.mTimeScale[b] =
// (mTimeScaleInfo.mTimeScale[b] < mBaseMin) ? mBaseMin : mTimeScaleInfo.mTimeScale[b];
if (mTimeScaleInfo.mTimeScale[b] == mTimeScaleInfo.mTimeScaleMax[b]) {
if (mTimeScaleInfo.mTimeScale[b] <= MAX_TIME_SCALE) {
mTimeScaleInfo.mTimeScaleMax[b] = (1 + mGrowthFactor) * mTimeScaleInfo.mTimeScaleMax[b];
}
else{
mTimeScaleInfo.mTimeScaleMax[b] = (1 + MAX_GROWTH_FACTOR*mGrowthFactor) * mTimeScaleInfo.mTimeScaleMax[b];
}
}
}
} // for b < mBatchWidth
return mTimeScaleInfo.mTimeScale;
}
void AdaptiveTimeScaleController::writeTimestepInfo(double timeValue, PrintStream &stream) {
if (mWriteTimeScaleFieldnames) {
stream.printf("sim_time = %f\n", timeValue);
}
else {
stream.printf("%f, ", timeValue);
}
for (int b = 0; b < mBatchWidth; b++) {
if (mWriteTimeScaleFieldnames) {
stream.printf(
"\tbatch = %d, timeScale = %10.8f, timeScaleTrue = %10.8f",
b,
mTimeScaleInfo.mTimeScale[b],
mTimeScaleInfo.mTimeScaleTrue[b]);
}
else {
stream.printf(
"%d, %10.8f, %10.8f",
b,
mTimeScaleInfo.mTimeScale[b],
mTimeScaleInfo.mTimeScaleTrue[b]);
}
if (mWriteTimeScaleFieldnames) {
stream.printf(", timeScaleMax = %10.8f\n", mTimeScaleInfo.mTimeScaleMax[b]);
}
else {
stream.printf(", %10.8f\n", mTimeScaleInfo.mTimeScaleMax[b]);
}
}
stream.flush();
}
void CheckpointEntryTimeScaleInfo::write(
std::string const &checkpointDirectory,
double simTime,
bool verifyWritesFlag) const {
if (getCommunicator()->commRank() == 0) {
int batchWidth = (int)mTimeScaleInfoPtr->mTimeScale.size();
std::string path = generatePath(checkpointDirectory, "bin");
FileStream fileStream{path.c_str(), std::ios_base::out, verifyWritesFlag};
for (int b = 0; b < batchWidth; b++) {
fileStream.write(&mTimeScaleInfoPtr->mTimeScale.at(b), sizeof(double));
fileStream.write(&mTimeScaleInfoPtr->mTimeScaleTrue.at(b), sizeof(double));
fileStream.write(&mTimeScaleInfoPtr->mTimeScaleMax.at(b), sizeof(double));
}
path = generatePath(checkpointDirectory, "txt");
FileStream txtFileStream{path.c_str(), std::ios_base::out, verifyWritesFlag};
int kb0 = getCommunicator()->commBatch() * batchWidth;
for (std::size_t b = 0; b < batchWidth; b++) {
txtFileStream << "batch index = " << b + kb0 << "\n";
txtFileStream << "time = " << simTime << "\n";
txtFileStream << "timeScale = " << mTimeScaleInfoPtr->mTimeScale[b] << "\n";
txtFileStream << "timeScaleTrue = " << mTimeScaleInfoPtr->mTimeScaleTrue[b] << "\n";
txtFileStream << "timeScaleMax = " << mTimeScaleInfoPtr->mTimeScaleMax[b] << "\n";
}
}
}
void CheckpointEntryTimeScaleInfo::remove(std::string const &checkpointDirectory) const {
deleteFile(checkpointDirectory, "bin");
deleteFile(checkpointDirectory, "txt");
}
void CheckpointEntryTimeScaleInfo::read(std::string const &checkpointDirectory, double *simTimePtr)
const {
int batchWidth = (int)mTimeScaleInfoPtr->mTimeScale.size();
if (getCommunicator()->commRank() == 0) {
std::string path = generatePath(checkpointDirectory, "bin");
FileStream fileStream{path.c_str(), std::ios_base::in, false};
for (std::size_t b = 0; b < batchWidth; b++) {
fileStream.read(&mTimeScaleInfoPtr->mTimeScale.at(b), sizeof(double));
fileStream.read(&mTimeScaleInfoPtr->mTimeScaleTrue.at(b), sizeof(double));
fileStream.read(&mTimeScaleInfoPtr->mTimeScaleMax.at(b), sizeof(double));
}
}
MPI_Bcast(
mTimeScaleInfoPtr->mTimeScale.data(),
batchWidth,
MPI_DOUBLE,
0,
getCommunicator()->communicator());
MPI_Bcast(
mTimeScaleInfoPtr->mTimeScaleTrue.data(),
batchWidth,
MPI_DOUBLE,
0,
getCommunicator()->communicator());
MPI_Bcast(
mTimeScaleInfoPtr->mTimeScaleMax.data(),
batchWidth,
MPI_DOUBLE,
0,
getCommunicator()->communicator());
}
} /* namespace PV */
<|endoftext|>
|
<commit_before>#include "canrawsender_p.h"
#include "canrawsender.h"
#include "log.h"
#include <QJsonArray>
void CanRawSenderPrivate::setSimulationState(bool state)
{
_simulationState = state;
for (auto& iter : _lines) {
iter->SetSimulationState(state);
}
}
void CanRawSenderPrivate::saveSettings(QJsonObject& json) const
{
QJsonObject jSortingObject;
QJsonArray lineArray;
writeColumnsOrder(json);
writeSortingRules(jSortingObject);
json["sorting"] = std::move(jSortingObject);
for (const auto& lineItem : _lines) {
QJsonObject lineObject;
lineItem->Line2Json(lineObject);
lineArray.append(std::move(lineObject));
}
json["content"] = std::move(lineArray);
}
int CanRawSenderPrivate::getLineCount() const
{
return _lines.size();
}
void CanRawSenderPrivate::writeColumnsOrder(QJsonObject& json) const
{
QJsonArray columnList;
for (const auto& column : _columnsOrder) {
columnList.append(column);
}
json["senderColumns"] = std::move(columnList);
}
void CanRawSenderPrivate::writeSortingRules(QJsonObject& json) const
{
json["currentIndex"] = _currentIndex;
}
void CanRawSenderPrivate::removeRowsSelectedByMouse()
{
QModelIndexList IndexList = _ui.getSelectedRows();
std::list<QModelIndex> tmp{IndexList.begin(), IndexList.end()};
tmp.sort(); // List must to be sorted and reversed because erasing started from last row
tmp.reverse();
for (QModelIndex n : tmp) {
_tvModel.removeRow(n.row()); // Delete line from table view
_lines.erase(_lines.begin() + n.row()); // Delete lines also from collection
// TODO: check if works when the collums was sorted before
}
}
ComponentInterface::ComponentProperties CanRawSenderPrivate::getSupportedProperties() const
{
return _supportedProps;
}
void CanRawSenderPrivate::addNewItem()
{
QList<QStandardItem*> list{};
_tvModel.appendRow(list);
auto newLine = std::make_unique<NewLineManager>(q_ptr, _simulationState, _nlmFactory);
using It = NewLineManager::ColNameIterator;
for (NewLineManager::ColName ii : It{ NewLineManager::ColName::IdLine }) {
_ui.setIndexWidget(
_tvModel.index(_tvModel.rowCount() - 1, static_cast<int>(ii)), newLine->GetColsWidget(It{ ii }));
}
_lines.push_back(std::move(newLine));
}
bool CanRawSenderPrivate::columnAdopt(QJsonObject const& json)
{
auto columnIter = json.find("senderColumns");
if (columnIter == json.end()) {
cds_error("Columns item not found");
return false;
}
if (columnIter.value().type() != QJsonValue::Array) {
cds_error("Columns format is different than array");
return false;
}
auto colArray = json["senderColumns"].toArray();
if (colArray.size() < 5) {
cds_error("Columns array size is {} - must be at least 5!", std::to_string(colArray.size()));
return false;
}
if (colArray.contains("Id") == false) {
cds_error("Columns array does not contain Id field.");
return false;
}
if (colArray.contains("Data") == false) {
cds_error("Columns array does not contain Data field.");
return false;
}
if (colArray.contains("Remote") == false) {
// Backward compability.
cds_warn("Columns array does not contain Remote field.");
}
if (colArray.contains("Loop") == false) {
cds_error("Columns array does not contain Loop field.");
return false;
}
if (colArray.contains("Interval") == false) {
cds_error("Columns array does not contain Interval field.");
return false;
}
cds_info("Columns validation is finished successfully.");
return true;
}
bool CanRawSenderPrivate::sortingAdopt(QJsonObject const& json)
{
auto sortingIter = json.find("sorting");
if (sortingIter == json.end()) {
cds_error("Sorting item not found");
return false;
}
if (sortingIter.value().type() != QJsonValue::Object) {
cds_error("Sorting format is different than object");
return false;
}
auto sortingObj = json["sorting"].toObject();
if (sortingObj.count() != 1) {
cds_error("Sorting object count {} is different than 1.", std::to_string(sortingObj.count()));
return false;
}
if (sortingObj.contains("currentIndex") == false) {
cds_error("Sorting object does not contain currentIndex.");
return false;
}
if (sortingObj["currentIndex"].isDouble() == false) {
cds_error("currentIndex format in sorting object is incorrect.");
return false;
}
cds_info("Sorting validation is finished successfully.");
auto newIdx = sortingObj["currentIndex"].toInt();
if ((newIdx < 0) || (newIdx > 5)) {
cds_error("currentIndex data '{}' is out of range.", std::to_string(newIdx));
return false;
}
_currentIndex = newIdx;
cds_debug("currentIndex data is adopted new value = {}.", std::to_string(_currentIndex));
return true;
}
bool CanRawSenderPrivate::contentAdopt(QJsonObject const& json)
{
QString data, id, interval;
bool remote = false;
bool loop = false;
bool send = false;
auto contentIter = json.find("content");
if (contentIter == json.end()) {
cds_error("Content item not found");
return false;
}
if (contentIter.value().type() != QJsonValue::Array) {
cds_error("Content format is different than array");
return false;
}
// Lambda expression to restore string field
auto restoreStringField = [] (const QJsonObject& obj, const QString& fieldName, QString& fieldValue) -> bool {
if (obj.contains(fieldName)) {
if (obj[fieldName].isString() == true) {
fieldValue = obj[fieldName].toString();
} else {
cds_error("{} field does not contain a string format.", fieldName.toStdString());
return false;
}
} else {
cds_info("{} is not available.", fieldName.toStdString());
}
return true;
};
// Lambda expression to restore bool field
auto restoreBoolField = [] (const QJsonObject& obj, const QString& fieldName, bool& fieldValue) -> bool {
if (obj.contains(fieldName)) {
if (obj[fieldName].isBool() == true) {
fieldValue = obj[fieldName].toBool();
} else {
cds_error("{} field does not contain a bool format.", fieldName.toStdString());
return false;
}
} else {
cds_info("{} is not available.", fieldName.toStdString());
}
return true;
};
auto contentArray = json["content"].toArray();
for (auto ii = 0; ii < contentArray.count(); ++ii) {
auto line = contentArray[ii].toObject();
data.clear();
id.clear();
interval.clear();
remote = false;
loop = false;
if (!restoreStringField(line, "data", data))
return false;
if (!restoreStringField(line, "id", id))
return false;
if (!restoreStringField(line, "interval", interval))
return false;
if (!restoreBoolField(line, "remote", remote))
return false;
if (!restoreBoolField(line, "loop", loop))
return false;
if (!restoreBoolField(line, "send", send))
return false;
// Add new lines with dependencies
addNewItem();
if (_lines.back()->RestoreLine(id, data, remote, interval, loop, send) == false) {
_tvModel.removeRow(_lines.size() - 1); // Delete line from table view
_lines.erase(_lines.end() - 1); // Delete lines also from collection
cds_warn("Problem with a validation of line occurred.");
} else {
cds_info("New line was adopted correctly.");
}
}
return true;
}
bool CanRawSenderPrivate::restoreConfiguration(const QJsonObject& json)
{
if (columnAdopt(json) == false) {
return false;
}
if (contentAdopt(json) == false) {
return false;
}
if (sortingAdopt(json) == false) {
return false;
}
return true;
}
<commit_msg>Fix typos in canrawsender_p.cpp (#228)<commit_after>#include "canrawsender_p.h"
#include "canrawsender.h"
#include "log.h"
#include <QJsonArray>
void CanRawSenderPrivate::setSimulationState(bool state)
{
_simulationState = state;
for (auto& iter : _lines) {
iter->SetSimulationState(state);
}
}
void CanRawSenderPrivate::saveSettings(QJsonObject& json) const
{
QJsonObject jSortingObject;
QJsonArray lineArray;
writeColumnsOrder(json);
writeSortingRules(jSortingObject);
json["sorting"] = std::move(jSortingObject);
for (const auto& lineItem : _lines) {
QJsonObject lineObject;
lineItem->Line2Json(lineObject);
lineArray.append(std::move(lineObject));
}
json["content"] = std::move(lineArray);
}
int CanRawSenderPrivate::getLineCount() const
{
return _lines.size();
}
void CanRawSenderPrivate::writeColumnsOrder(QJsonObject& json) const
{
QJsonArray columnList;
for (const auto& column : _columnsOrder) {
columnList.append(column);
}
json["senderColumns"] = std::move(columnList);
}
void CanRawSenderPrivate::writeSortingRules(QJsonObject& json) const
{
json["currentIndex"] = _currentIndex;
}
void CanRawSenderPrivate::removeRowsSelectedByMouse()
{
QModelIndexList IndexList = _ui.getSelectedRows();
std::list<QModelIndex> tmp{IndexList.begin(), IndexList.end()};
tmp.sort(); // List must be sorted and reversed because erasing started from last row
tmp.reverse();
for (QModelIndex n : tmp) {
_tvModel.removeRow(n.row()); // Delete line from table view
_lines.erase(_lines.begin() + n.row()); // Delete lines also from collection
// TODO: check if it works when columns were sorted before
}
}
ComponentInterface::ComponentProperties CanRawSenderPrivate::getSupportedProperties() const
{
return _supportedProps;
}
void CanRawSenderPrivate::addNewItem()
{
QList<QStandardItem*> list{};
_tvModel.appendRow(list);
auto newLine = std::make_unique<NewLineManager>(q_ptr, _simulationState, _nlmFactory);
using It = NewLineManager::ColNameIterator;
for (NewLineManager::ColName ii : It{ NewLineManager::ColName::IdLine }) {
_ui.setIndexWidget(
_tvModel.index(_tvModel.rowCount() - 1, static_cast<int>(ii)), newLine->GetColsWidget(It{ ii }));
}
_lines.push_back(std::move(newLine));
}
bool CanRawSenderPrivate::columnAdopt(QJsonObject const& json)
{
auto columnIter = json.find("senderColumns");
if (columnIter == json.end()) {
cds_error("Columns item not found");
return false;
}
if (columnIter.value().type() != QJsonValue::Array) {
cds_error("Columns format is different than array");
return false;
}
auto colArray = json["senderColumns"].toArray();
if (colArray.size() < 5) {
cds_error("Columns array size is {} - must be at least 5!", std::to_string(colArray.size()));
return false;
}
if (colArray.contains("Id") == false) {
cds_error("Columns array does not contain Id field.");
return false;
}
if (colArray.contains("Data") == false) {
cds_error("Columns array does not contain Data field.");
return false;
}
if (colArray.contains("Remote") == false) {
// Backward compatibility.
cds_warn("Columns array does not contain Remote field.");
}
if (colArray.contains("Loop") == false) {
cds_error("Columns array does not contain Loop field.");
return false;
}
if (colArray.contains("Interval") == false) {
cds_error("Columns array does not contain Interval field.");
return false;
}
cds_info("Columns validation finished successfully.");
return true;
}
bool CanRawSenderPrivate::sortingAdopt(QJsonObject const& json)
{
auto sortingIter = json.find("sorting");
if (sortingIter == json.end()) {
cds_error("Sorting item not found");
return false;
}
if (sortingIter.value().type() != QJsonValue::Object) {
cds_error("Sorting format is different than object");
return false;
}
auto sortingObj = json["sorting"].toObject();
if (sortingObj.count() != 1) {
cds_error("Sorting object count {} is different than 1.", std::to_string(sortingObj.count()));
return false;
}
if (sortingObj.contains("currentIndex") == false) {
cds_error("Sorting object does not contain currentIndex.");
return false;
}
if (sortingObj["currentIndex"].isDouble() == false) {
cds_error("currentIndex format in sorting object is incorrect.");
return false;
}
cds_info("Sorting validation is finished successfully.");
auto newIdx = sortingObj["currentIndex"].toInt();
if ((newIdx < 0) || (newIdx > 5)) {
cds_error("currentIndex data '{}' is out of range.", std::to_string(newIdx));
return false;
}
_currentIndex = newIdx;
cds_debug("currentIndex data adopted new value = {}.", std::to_string(_currentIndex));
return true;
}
bool CanRawSenderPrivate::contentAdopt(QJsonObject const& json)
{
QString data, id, interval;
bool remote = false;
bool loop = false;
bool send = false;
auto contentIter = json.find("content");
if (contentIter == json.end()) {
cds_error("Content item not found");
return false;
}
if (contentIter.value().type() != QJsonValue::Array) {
cds_error("Content format is different than array");
return false;
}
// Lambda expression to restore string field
auto restoreStringField = [] (const QJsonObject& obj, const QString& fieldName, QString& fieldValue) -> bool {
if (obj.contains(fieldName)) {
if (obj[fieldName].isString() == true) {
fieldValue = obj[fieldName].toString();
} else {
cds_error("{} field does not contain a string format.", fieldName.toStdString());
return false;
}
} else {
cds_info("{} is not available.", fieldName.toStdString());
}
return true;
};
// Lambda expression to restore bool field
auto restoreBoolField = [] (const QJsonObject& obj, const QString& fieldName, bool& fieldValue) -> bool {
if (obj.contains(fieldName)) {
if (obj[fieldName].isBool() == true) {
fieldValue = obj[fieldName].toBool();
} else {
cds_error("{} field does not contain a bool format.", fieldName.toStdString());
return false;
}
} else {
cds_info("{} is not available.", fieldName.toStdString());
}
return true;
};
auto contentArray = json["content"].toArray();
for (auto ii = 0; ii < contentArray.count(); ++ii) {
auto line = contentArray[ii].toObject();
data.clear();
id.clear();
interval.clear();
remote = false;
loop = false;
if (!restoreStringField(line, "data", data))
return false;
if (!restoreStringField(line, "id", id))
return false;
if (!restoreStringField(line, "interval", interval))
return false;
if (!restoreBoolField(line, "remote", remote))
return false;
if (!restoreBoolField(line, "loop", loop))
return false;
if (!restoreBoolField(line, "send", send))
return false;
// Add new lines with dependencies
addNewItem();
if (_lines.back()->RestoreLine(id, data, remote, interval, loop, send) == false) {
_tvModel.removeRow(_lines.size() - 1); // Delete line from table view
_lines.erase(_lines.end() - 1); // Delete lines also from collection
cds_warn("Problem with a validation of line occurred.");
} else {
cds_info("New line was adopted correctly.");
}
}
return true;
}
bool CanRawSenderPrivate::restoreConfiguration(const QJsonObject& json)
{
if (columnAdopt(json) == false) {
return false;
}
if (contentAdopt(json) == false) {
return false;
}
if (sortingAdopt(json) == false) {
return false;
}
return true;
}
<|endoftext|>
|
<commit_before>
#include "condor_common.h"
#include "compat_classad.h"
#include "condor_version.h"
#include "condor_attributes.h"
#include "file_transfer.h"
#include "dc_cached.h"
DCCached::DCCached(const char * name, const char *pool)
: Daemon( DT_CACHED, name, pool )
{}
int
DCCached::createCacheDir(std::string &cacheName, time_t &expiry, CondorError &err)
{
if (!_addr && !locate())
{
err.push("CACHED", 2, error() && error()[0] ? error() : "Failed to locate remote cached");
return 2;
}
ReliSock *rsock = (ReliSock *)startCommand(
CACHED_CREATE_CACHE_DIR, Stream::reli_sock, 20 );
if (!rsock)
{
err.push("CACHED", 1, "Failed to start command to remote cached");
return 1;
}
// Authenticate the socket
SecMan::authenticate_sock((Sock*)rsock, WRITE, &err);
compat_classad::ClassAd ad;
std::string version = CondorVersion();
ad.InsertAttr("CondorVersion", version);
ad.InsertAttr("LeaseExpiration", expiry);
ad.InsertAttr("CacheName", cacheName);
if (!putClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to send request to remote condor_cached");
return 1;
}
ad.Clear();
rsock->decode();
if (!getClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to get response from remote condor_cached");
return 1;
}
rsock->close();
delete rsock;
int rc;
if (!ad.EvaluateAttrInt(ATTR_ERROR_CODE, rc))
{
err.push("CACHED", 2, "Remote condor_cached did not return error code");
}
if (rc)
{
std::string error_string;
if (!ad.EvaluateAttrString(ATTR_ERROR_STRING, error_string))
{
err.push("CACHED", rc, "Unknown error from remote condor_cached");
}
else
{
err.push("CACHED", rc, error_string.c_str());
}
return rc;
}
std::string new_cacheName;
time_t new_expiry;
if (!ad.EvaluateAttrString("CacheName", new_cacheName) || !ad.EvaluateAttrInt("LeaseExpiration", new_expiry))
{
err.push("CACHED", 1, "Required attributes (CacheName and LeaseExpiration) not set in server response.");
return 1;
}
cacheName = new_cacheName;
expiry = new_expiry;
return 0;
}
int
DCCached::uploadFiles(std::string &cacheName, std::list<std::string> files, CondorError &err)
{
if (!_addr && !locate())
{
err.push("CACHED", 2, error() && error()[0] ? error() : "Failed to locate remote cached");
return 2;
}
ReliSock *rsock = (ReliSock *)startCommand(
CACHED_UPLOAD_FILES, Stream::reli_sock, 20 );
if (!rsock)
{
err.push("CACHED", 1, "Failed to start command to remote cached");
return 1;
}
compat_classad::ClassAd ad;
std::string version = CondorVersion();
ad.InsertAttr("CondorVersion", version);
ad.InsertAttr("CacheName", cacheName);
if (!putClassAd(rsock, ad) || !rsock->end_of_message())
{
// Can't send another response! Must just hang-up.
return 1;
}
ad.Clear();
rsock->decode();
if (!getClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to get response from remote condor_cached");
return 1;
}
int rc;
if (!ad.EvaluateAttrInt(ATTR_ERROR_CODE, rc))
{
err.push("CACHED", 2, "Remote condor_cached did not return error code");
}
if (rc)
{
std::string error_string;
if (!ad.EvaluateAttrString(ATTR_ERROR_STRING, error_string))
{
err.push("CACHED", rc, "Unknown error from remote condor_cached");
}
else
{
err.push("CACHED", rc, error_string.c_str());
}
return rc;
}
compat_classad::ClassAd transfer_ad;
transfer_ad.InsertAttr("CondorVersion", version);
// Expand the files list and add to the classad
StringList inputFiles;
inputFiles.insert("hosts");
char* filelist = inputFiles.print_to_string();
dprintf(D_FULLDEBUG, "Transfer list = %s\n", filelist);
transfer_ad.InsertAttr(ATTR_TRANSFER_INPUT_FILES, filelist);
char current_dir[PATH_MAX];
getcwd(current_dir, PATH_MAX);
transfer_ad.InsertAttr(ATTR_JOB_IWD, current_dir);
dprintf(D_FULLDEBUG, "IWD = %s\n", current_dir);
free(filelist);
// From here on out, this is the file transfer server socket.
FileTransfer ft;
rc = ft.SimpleInit(&transfer_ad, false, false, static_cast<ReliSock*>(rsock));
if (!rc) {
dprintf(D_ALWAYS, "Simple init failed\n");
return 1;
}
ft.setPeerVersion(version.c_str());
//UploadFilesHandler *handler = new UploadFilesHandler(*this, dirname);
//ft.RegisterCallback(static_cast<FileTransferHandlerCpp>(&UploadFilesHandler::handle), handler);
rc = ft.UploadFiles(true);
if (!rc) {
dprintf(D_ALWAYS, "Upload files failed.\n");
return 1;
}
return 0;
}
int
DCCached::downloadFiles(std::string &cacheName, std::string dest, CondorError &err)
{
if (!_addr && !locate())
{
err.push("CACHED", 2, error() && error()[0] ? error() : "Failed to locate remote cached");
return 2;
}
ReliSock *rsock = (ReliSock *)startCommand(
CACHED_DOWNLOAD_FILES, Stream::reli_sock, 20 );
if (!rsock)
{
err.push("CACHED", 1, "Failed to start command to remote cached");
return 1;
}
compat_classad::ClassAd ad;
std::string version = CondorVersion();
ad.InsertAttr("CondorVersion", version);
ad.InsertAttr("CacheName", cacheName);
if (!putClassAd(rsock, ad) || !rsock->end_of_message())
{
// Can't send another response! Must just hang-up.
return 1;
}
ad.Clear();
rsock->decode();
if (!getClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to get response from remote condor_cached");
return 1;
}
int rc;
if (!ad.EvaluateAttrInt(ATTR_ERROR_CODE, rc))
{
err.push("CACHED", 2, "Remote condor_cached did not return error code");
}
if (rc)
{
std::string error_string;
if (!ad.EvaluateAttrString(ATTR_ERROR_STRING, error_string))
{
err.push("CACHED", rc, "Unknown error from remote condor_cached");
}
else
{
err.push("CACHED", rc, error_string.c_str());
}
return rc;
}
compat_classad::ClassAd transfer_ad;
dprintf(D_FULLDEBUG, "Download Files Destination = %s\n", dest.c_str());
transfer_ad.InsertAttr(ATTR_OUTPUT_DESTINATION, dest.c_str());
char current_dir[PATH_MAX];
getcwd(current_dir, PATH_MAX);
transfer_ad.InsertAttr(ATTR_JOB_IWD, current_dir);
dprintf(D_FULLDEBUG, "IWD = %s\n", current_dir);
// From here on out, this is the file transfer server socket.
FileTransfer ft;
rc = ft.SimpleInit(&transfer_ad, false, true, static_cast<ReliSock*>(rsock));
if (!rc) {
dprintf(D_ALWAYS, "Simple init failed\n");
return 1;
}
ft.setPeerVersion(version.c_str());
rc = ft.DownloadFiles(true);
if (!rc) {
dprintf(D_ALWAYS, "Download files failed.\n");
return 1;
}
return 0;
}
<commit_msg>Adding iterator through the file list to the test<commit_after>
#include "condor_common.h"
#include "compat_classad.h"
#include "condor_version.h"
#include "condor_attributes.h"
#include "file_transfer.h"
#include "dc_cached.h"
DCCached::DCCached(const char * name, const char *pool)
: Daemon( DT_CACHED, name, pool )
{}
int
DCCached::createCacheDir(std::string &cacheName, time_t &expiry, CondorError &err)
{
if (!_addr && !locate())
{
err.push("CACHED", 2, error() && error()[0] ? error() : "Failed to locate remote cached");
return 2;
}
ReliSock *rsock = (ReliSock *)startCommand(
CACHED_CREATE_CACHE_DIR, Stream::reli_sock, 20 );
if (!rsock)
{
err.push("CACHED", 1, "Failed to start command to remote cached");
return 1;
}
compat_classad::ClassAd ad;
std::string version = CondorVersion();
ad.InsertAttr("CondorVersion", version);
ad.InsertAttr("LeaseExpiration", expiry);
ad.InsertAttr("CacheName", cacheName);
if (!putClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to send request to remote condor_cached");
return 1;
}
ad.Clear();
rsock->decode();
if (!getClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to get response from remote condor_cached");
return 1;
}
rsock->close();
delete rsock;
int rc;
if (!ad.EvaluateAttrInt(ATTR_ERROR_CODE, rc))
{
err.push("CACHED", 2, "Remote condor_cached did not return error code");
}
if (rc)
{
std::string error_string;
if (!ad.EvaluateAttrString(ATTR_ERROR_STRING, error_string))
{
err.push("CACHED", rc, "Unknown error from remote condor_cached");
}
else
{
err.push("CACHED", rc, error_string.c_str());
}
return rc;
}
std::string new_cacheName;
time_t new_expiry;
if (!ad.EvaluateAttrString("CacheName", new_cacheName) || !ad.EvaluateAttrInt("LeaseExpiration", new_expiry))
{
err.push("CACHED", 1, "Required attributes (CacheName and LeaseExpiration) not set in server response.");
return 1;
}
cacheName = new_cacheName;
expiry = new_expiry;
return 0;
}
int
DCCached::uploadFiles(std::string &cacheName, std::list<std::string> files, CondorError &err)
{
if (!_addr && !locate())
{
err.push("CACHED", 2, error() && error()[0] ? error() : "Failed to locate remote cached");
return 2;
}
ReliSock *rsock = (ReliSock *)startCommand(
CACHED_UPLOAD_FILES, Stream::reli_sock, 20 );
if (!rsock)
{
err.push("CACHED", 1, "Failed to start command to remote cached");
return 1;
}
compat_classad::ClassAd ad;
std::string version = CondorVersion();
ad.InsertAttr("CondorVersion", version);
ad.InsertAttr("CacheName", cacheName);
if (!putClassAd(rsock, ad) || !rsock->end_of_message())
{
// Can't send another response! Must just hang-up.
return 1;
}
ad.Clear();
rsock->decode();
if (!getClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to get response from remote condor_cached");
return 1;
}
int rc;
if (!ad.EvaluateAttrInt(ATTR_ERROR_CODE, rc))
{
err.push("CACHED", 2, "Remote condor_cached did not return error code");
}
if (rc)
{
std::string error_string;
if (!ad.EvaluateAttrString(ATTR_ERROR_STRING, error_string))
{
err.push("CACHED", rc, "Unknown error from remote condor_cached");
}
else
{
err.push("CACHED", rc, error_string.c_str());
}
return rc;
}
compat_classad::ClassAd transfer_ad;
transfer_ad.InsertAttr("CondorVersion", version);
// Expand the files list and add to the classad
StringList inputFiles;
for (std::list<std::string>::iterator it = files.begin(); it != files.end(); it++) {
inputFiles.insert((*it).c_str());
}
char* filelist = inputFiles.print_to_string();
dprintf(D_FULLDEBUG, "Transfer list = %s\n", filelist);
transfer_ad.InsertAttr(ATTR_TRANSFER_INPUT_FILES, filelist);
char current_dir[PATH_MAX];
getcwd(current_dir, PATH_MAX);
transfer_ad.InsertAttr(ATTR_JOB_IWD, current_dir);
dprintf(D_FULLDEBUG, "IWD = %s\n", current_dir);
free(filelist);
// From here on out, this is the file transfer server socket.
FileTransfer ft;
rc = ft.SimpleInit(&transfer_ad, false, false, static_cast<ReliSock*>(rsock));
if (!rc) {
dprintf(D_ALWAYS, "Simple init failed\n");
return 1;
}
ft.setPeerVersion(version.c_str());
//UploadFilesHandler *handler = new UploadFilesHandler(*this, dirname);
//ft.RegisterCallback(static_cast<FileTransferHandlerCpp>(&UploadFilesHandler::handle), handler);
rc = ft.UploadFiles(true);
if (!rc) {
dprintf(D_ALWAYS, "Upload files failed.\n");
return 1;
}
return 0;
}
int
DCCached::downloadFiles(std::string &cacheName, std::string dest, CondorError &err)
{
if (!_addr && !locate())
{
err.push("CACHED", 2, error() && error()[0] ? error() : "Failed to locate remote cached");
return 2;
}
ReliSock *rsock = (ReliSock *)startCommand(
CACHED_DOWNLOAD_FILES, Stream::reli_sock, 20 );
if (!rsock)
{
err.push("CACHED", 1, "Failed to start command to remote cached");
return 1;
}
compat_classad::ClassAd ad;
std::string version = CondorVersion();
ad.InsertAttr("CondorVersion", version);
ad.InsertAttr("CacheName", cacheName);
if (!putClassAd(rsock, ad) || !rsock->end_of_message())
{
// Can't send another response! Must just hang-up.
return 1;
}
ad.Clear();
rsock->decode();
if (!getClassAd(rsock, ad) || !rsock->end_of_message())
{
delete rsock;
err.push("CACHED", 1, "Failed to get response from remote condor_cached");
return 1;
}
int rc;
if (!ad.EvaluateAttrInt(ATTR_ERROR_CODE, rc))
{
err.push("CACHED", 2, "Remote condor_cached did not return error code");
}
if (rc)
{
std::string error_string;
if (!ad.EvaluateAttrString(ATTR_ERROR_STRING, error_string))
{
err.push("CACHED", rc, "Unknown error from remote condor_cached");
}
else
{
err.push("CACHED", rc, error_string.c_str());
}
return rc;
}
compat_classad::ClassAd transfer_ad;
dprintf(D_FULLDEBUG, "Download Files Destination = %s\n", dest.c_str());
transfer_ad.InsertAttr(ATTR_OUTPUT_DESTINATION, dest.c_str());
char current_dir[PATH_MAX];
getcwd(current_dir, PATH_MAX);
transfer_ad.InsertAttr(ATTR_JOB_IWD, current_dir);
dprintf(D_FULLDEBUG, "IWD = %s\n", current_dir);
// From here on out, this is the file transfer server socket.
FileTransfer ft;
rc = ft.SimpleInit(&transfer_ad, false, true, static_cast<ReliSock*>(rsock));
if (!rc) {
dprintf(D_ALWAYS, "Simple init failed\n");
return 1;
}
ft.setPeerVersion(version.c_str());
rc = ft.DownloadFiles(true);
if (!rc) {
dprintf(D_ALWAYS, "Download files failed.\n");
return 1;
}
return 0;
}
<|endoftext|>
|
<commit_before>#pragma once
#include "gcd_utility.hpp"
#include "logger.hpp"
#include <CoreGraphics/CoreGraphics.h>
class event_tap_manager final {
public:
typedef std::function<void(bool)> caps_lock_state_changed_callback;
event_tap_manager(const event_tap_manager&) = delete;
event_tap_manager(const caps_lock_state_changed_callback& caps_lock_state_changed_callback) : caps_lock_state_changed_callback_(caps_lock_state_changed_callback),
event_tap_(nullptr),
run_loop_source_(nullptr),
last_flags_(0) {
// Observe flags changed in order to get the caps lock state.
auto mask = CGEventMaskBit(kCGEventFlagsChanged);
event_tap_ = CGEventTapCreate(kCGHIDEventTap,
kCGHeadInsertEventTap,
kCGEventTapOptionDefault,
mask,
event_tap_manager::static_callback,
this);
if (event_tap_) {
run_loop_source_ = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, event_tap_, 0);
if (run_loop_source_) {
CFRunLoopAddSource(CFRunLoopGetMain(), run_loop_source_, kCFRunLoopCommonModes);
CGEventTapEnable(event_tap_, true);
logger::get_logger().info("event_tap_manager initialized");
}
}
}
~event_tap_manager(void) {
// Release event_tap_ in main thread to avoid callback invocations after object has been destroyed.
gcd_utility::dispatch_sync_in_main_queue(^{
if (event_tap_) {
CGEventTapEnable(event_tap_, false);
if (run_loop_source_) {
CFRunLoopRemoveSource(CFRunLoopGetMain(), run_loop_source_, kCFRunLoopCommonModes);
CFRelease(run_loop_source_);
run_loop_source_ = nullptr;
}
CFRelease(event_tap_);
event_tap_ = nullptr;
}
logger::get_logger().info("event_tap_manager terminated");
});
}
bool get_caps_lock_state(void) const {
return (last_flags_ & NX_ALPHASHIFTMASK);
}
private:
static CGEventRef _Nullable static_callback(CGEventTapProxy _Nullable proxy, CGEventType type, CGEventRef _Nullable event, void* _Nonnull refcon) {
auto self = static_cast<event_tap_manager*>(refcon);
if (self) {
return self->callback(proxy, type, event);
}
return nullptr;
}
CGEventRef _Nullable callback(CGEventTapProxy _Nullable proxy, CGEventType type, CGEventRef _Nullable event) {
if (type == kCGEventTapDisabledByTimeout) {
logger::get_logger().info("Re-enable event_tap_ by kCGEventTapDisabledByTimeout");
CGEventTapEnable(event_tap_, true);
} else if (type == kCGEventFlagsChanged) {
// The caps lock key event from keyboard might be ignored by caps lock delay.
// Thus, we need to observe kCGEventFlagsChanged event in EventTap to detect the caps lock state change.
bool old_caps_lock_state = get_caps_lock_state();
last_flags_ = CGEventGetFlags(event);
bool new_caps_lock_state = get_caps_lock_state();
if (old_caps_lock_state != new_caps_lock_state) {
if (caps_lock_state_changed_callback_) {
caps_lock_state_changed_callback_(new_caps_lock_state);
}
}
}
return event;
}
caps_lock_state_changed_callback caps_lock_state_changed_callback_;
CFMachPortRef _Nullable event_tap_;
CFRunLoopSourceRef _Nullable run_loop_source_;
CGEventFlags last_flags_;
};
<commit_msg>use boost::optional to event_tap_manager::get_caps_lock_state<commit_after>#pragma once
#include "boost_defs.hpp"
#include "gcd_utility.hpp"
#include "logger.hpp"
#include <CoreGraphics/CoreGraphics.h>
#include <boost/optional.hpp>
class event_tap_manager final {
public:
typedef std::function<void(bool)> caps_lock_state_changed_callback;
event_tap_manager(const event_tap_manager&) = delete;
event_tap_manager(const caps_lock_state_changed_callback& caps_lock_state_changed_callback) : caps_lock_state_changed_callback_(caps_lock_state_changed_callback),
event_tap_(nullptr),
run_loop_source_(nullptr) {
// Observe flags changed in order to get the caps lock state.
auto mask = CGEventMaskBit(kCGEventFlagsChanged);
event_tap_ = CGEventTapCreate(kCGHIDEventTap,
kCGHeadInsertEventTap,
kCGEventTapOptionDefault,
mask,
event_tap_manager::static_callback,
this);
if (event_tap_) {
run_loop_source_ = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, event_tap_, 0);
if (run_loop_source_) {
CFRunLoopAddSource(CFRunLoopGetMain(), run_loop_source_, kCFRunLoopCommonModes);
CGEventTapEnable(event_tap_, true);
logger::get_logger().info("event_tap_manager initialized");
}
}
}
~event_tap_manager(void) {
// Release event_tap_ in main thread to avoid callback invocations after object has been destroyed.
gcd_utility::dispatch_sync_in_main_queue(^{
if (event_tap_) {
CGEventTapEnable(event_tap_, false);
if (run_loop_source_) {
CFRunLoopRemoveSource(CFRunLoopGetMain(), run_loop_source_, kCFRunLoopCommonModes);
CFRelease(run_loop_source_);
run_loop_source_ = nullptr;
}
CFRelease(event_tap_);
event_tap_ = nullptr;
}
logger::get_logger().info("event_tap_manager terminated");
});
}
boost::optional<bool> get_caps_lock_state(void) const {
if (last_flags_) {
return (*last_flags_ & NX_ALPHASHIFTMASK);
}
return boost::none;
}
private:
static CGEventRef _Nullable static_callback(CGEventTapProxy _Nullable proxy, CGEventType type, CGEventRef _Nullable event, void* _Nonnull refcon) {
auto self = static_cast<event_tap_manager*>(refcon);
if (self) {
return self->callback(proxy, type, event);
}
return nullptr;
}
CGEventRef _Nullable callback(CGEventTapProxy _Nullable proxy, CGEventType type, CGEventRef _Nullable event) {
if (type == kCGEventTapDisabledByTimeout) {
logger::get_logger().info("Re-enable event_tap_ by kCGEventTapDisabledByTimeout");
CGEventTapEnable(event_tap_, true);
} else if (type == kCGEventFlagsChanged) {
// The caps lock key event from keyboard might be ignored by caps lock delay.
// Thus, we need to observe kCGEventFlagsChanged event in EventTap to detect the caps lock state change.
auto old_caps_lock_state = get_caps_lock_state();
last_flags_ = CGEventGetFlags(event);
auto new_caps_lock_state = get_caps_lock_state();
if (old_caps_lock_state &&
new_caps_lock_state &&
*old_caps_lock_state == *new_caps_lock_state) {
// the caps lock state is not changed.
} else {
if (caps_lock_state_changed_callback_) {
caps_lock_state_changed_callback_(*new_caps_lock_state);
}
}
}
return event;
}
caps_lock_state_changed_callback caps_lock_state_changed_callback_;
CFMachPortRef _Nullable event_tap_;
CFRunLoopSourceRef _Nullable run_loop_source_;
boost::optional<CGEventFlags> last_flags_;
};
<|endoftext|>
|
<commit_before>/*************************************************************************
* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
///////////////////////////////////////////////////////////////////////////
// //
// Basic Analysis Task //
// //
///////////////////////////////////////////////////////////////////////////
#include <TChain.h>
#include <TH1D.h>
#include <AliCFContainer.h>
#include <AliInputEventHandler.h>
#include <AliESDInputHandler.h>
#include <AliAODInputHandler.h>
#include <AliAnalysisManager.h>
#include <AliVEvent.h>
#include <AliTriggerAnalysis.h>
#include <AliPIDResponse.h>
#include <AliTPCPIDResponse.h>
#include "AliDielectron.h"
#include "AliDielectronHistos.h"
#include "AliDielectronCF.h"
#include "AliDielectronMC.h"
#include "AliDielectronMixingHandler.h"
#include "AliAnalysisTaskMultiDielectron.h"
ClassImp(AliAnalysisTaskMultiDielectron)
//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron() :
AliAnalysisTaskSE(),
fListDielectron(),
fListHistos(),
fListCF(),
fSelectPhysics(kFALSE),
fTriggerMask(AliVEvent::kMB),
fExcludeTriggerMask(0),
fTriggerOnV0AND(kFALSE),
fRejectPileup(kFALSE),
fBeamEnergy(-1.),
fTriggerLogic(kAny),
fTriggerAnalysis(0x0),
fEventFilter(0x0),
fEventStat(0x0)
{
//
// Constructor
//
}
//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron(const char *name) :
AliAnalysisTaskSE(name),
fListDielectron(),
fListHistos(),
fListCF(),
fSelectPhysics(kFALSE),
fTriggerMask(AliVEvent::kMB),
fExcludeTriggerMask(0),
fTriggerOnV0AND(kFALSE),
fRejectPileup(kFALSE),
fBeamEnergy(-1.),
fTriggerLogic(kAny),
fTriggerAnalysis(0x0),
fEventFilter(0x0),
fEventStat(0x0)
{
//
// Constructor
//
DefineInput(0,TChain::Class());
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
DefineOutput(3, TH1D::Class());
fListHistos.SetName("Dielectron_Histos_Multi");
fListCF.SetName("Dielectron_CF_Multi");
fListDielectron.SetOwner();
fListHistos.SetOwner();
fListCF.SetOwner();
}
//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::~AliAnalysisTaskMultiDielectron()
{
//
// Destructor
//
//histograms and CF are owned by the dielectron framework.
//however they are streamed to file, so in the first place the
//lists need to be owner...
fListHistos.SetOwner(kFALSE);
fListCF.SetOwner(kFALSE);
}
//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::UserCreateOutputObjects()
{
//
// Add all histogram manager histogram lists to the output TList
//
if (!fListHistos.IsEmpty()||!fListCF.IsEmpty()) return; //already initialised
// AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
// Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
// Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
die->Init();
if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
if (die->GetHistogramArray()) fListHistos.Add(const_cast<TObjArray*>(die->GetHistogramArray()));
if (die->GetCFManagerPair()) fListCF.Add(const_cast<AliCFContainer*>(die->GetCFManagerPair()->GetContainer()));
}
Int_t cuts=fListDielectron.GetEntries();
Int_t nbins=kNbinsEvent+2*cuts;
if (!fEventStat){
fEventStat=new TH1D("hEventStat","Event statistics",nbins,0,nbins);
fEventStat->GetXaxis()->SetBinLabel(1,"Before Phys. Sel.");
fEventStat->GetXaxis()->SetBinLabel(2,"After Phys. Sel.");
//default names
fEventStat->GetXaxis()->SetBinLabel(3,"Bin3 not used");
fEventStat->GetXaxis()->SetBinLabel(4,"Bin4 not used");
fEventStat->GetXaxis()->SetBinLabel(5,"Bin5 not used");
if(fTriggerOnV0AND) fEventStat->GetXaxis()->SetBinLabel(3,"V0and triggers");
if (fEventFilter) fEventStat->GetXaxis()->SetBinLabel(4,"After Event Filter");
if (fRejectPileup) fEventStat->GetXaxis()->SetBinLabel(5,"After Pileup rejection");
for (Int_t i=0; i<cuts; ++i){
fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+1)+2*i,Form("#splitline{1 candidate}{%s}",fListDielectron.At(i)->GetName()));
fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+2)+2*i,Form("#splitline{With >1 candidate}{%s}",fListDielectron.At(i)->GetName()));
}
}
if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
fTriggerAnalysis->EnableHistograms();
fTriggerAnalysis->SetAnalyzeMC(AliDielectronMC::Instance()->HasMC());
PostData(1, &fListHistos);
PostData(2, &fListCF);
PostData(3, fEventStat);
}
//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::UserExec(Option_t *)
{
//
// Main loop. Called for every event
//
if (fListHistos.IsEmpty()&&fListCF.IsEmpty()) return;
AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
if (!inputHandler) return;
// AliPIDResponse *pidRes=inputHandler->GetPIDResponse();
if ( inputHandler->GetPIDResponse() ){
// for the 2.76 pass2 MC private train. Together with a sigma shift of -0.169
// pidRes->GetTPCResponse().SetSigma(4.637e-3,2.41332105409873257e+04);
AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
} else {
AliFatal("This task needs the PID response attached to the input event handler!");
}
// Was event selected ?
ULong64_t isSelected = AliVEvent::kAny;
Bool_t isRejected = kFALSE;
if( fSelectPhysics && inputHandler){
if((isESD && inputHandler->GetEventSelection()) || isAOD){
isSelected = inputHandler->IsEventSelected();
if (fExcludeTriggerMask && (isSelected&fExcludeTriggerMask)) isRejected=kTRUE;
if (fTriggerLogic==kAny) isSelected&=fTriggerMask;
else if (fTriggerLogic==kExact) isSelected=((isSelected&fTriggerMask)==fTriggerMask);
}
}
//Before physics selection
fEventStat->Fill(kAllEvents);
if (isSelected==0||isRejected) {
PostData(3,fEventStat);
return;
}
//after physics selection
fEventStat->Fill(kSelectedEvents);
//V0and
if(fTriggerOnV0AND){
if(isESD){if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND))
return;}
if(isAOD){if(!((static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0ADecision() == AliVVZERO::kV0BB &&
(static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0CDecision() == AliVVZERO::kV0BB) )
return;}
}
fEventStat->Fill(kV0andEvents);
//Fill Event histograms before the event filter
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
Double_t values[AliDielectronVarManager::kNMaxValues]={0};
Double_t valuesMC[AliDielectronVarManager::kNMaxValues]={0};
AliDielectronVarManager::SetEvent(InputEvent());
AliDielectronVarManager::Fill(InputEvent(),values);
AliDielectronVarManager::Fill(InputEvent(),valuesMC);
Bool_t hasMC=AliDielectronMC::Instance()->HasMC();
if (hasMC) {
if (AliDielectronMC::Instance()->ConnectMCEvent())
AliDielectronVarManager::Fill(AliDielectronMC::Instance()->GetMCEvent(),valuesMC);
}
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
AliDielectronHistos *h=die->GetHistoManager();
if (h){
if (h->GetHistogramList()->FindObject("Event_noCuts"))
h->FillClass("Event_noCuts",AliDielectronVarManager::kNMaxValues,values);
if (hasMC && h->GetHistogramList()->FindObject("MCEvent_noCuts"))
h->FillClass("Event_noCuts",AliDielectronVarManager::kNMaxValues,valuesMC);
}
}
nextDie.Reset();
//event filter
if (fEventFilter) {
if (!fEventFilter->IsSelected(InputEvent())) return;
}
fEventStat->Fill(kFilteredEvents);
//pileup
if (fRejectPileup){
if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
}
fEventStat->Fill(kPileupEvents);
//bz for AliKF
Double_t bz = InputEvent()->GetMagneticField();
AliKFParticle::SetField( bz );
AliDielectronPID::SetCorrVal((Double_t)InputEvent()->GetRunNumber());
// AliDielectronPair::SetBeamEnergy(InputEvent(), fBeamEnergy);
//Process event in all AliDielectron instances
// TIter nextDie(&fListDielectron);
// AliDielectron *die=0;
Int_t idie=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
die->Process(InputEvent());
if (die->HasCandidates()){
Int_t ncandidates=die->GetPairArray(1)->GetEntriesFast();
if (ncandidates==1) fEventStat->Fill((kNbinsEvent)+2*idie);
else if (ncandidates>1) fEventStat->Fill((kNbinsEvent+1)+2*idie);
}
++idie;
}
PostData(1, &fListHistos);
PostData(2, &fListCF);
PostData(3,fEventStat);
}
//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::FinishTaskOutput()
{
//
// Write debug tree
//
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
die->SaveDebugTree();
AliDielectronMixingHandler *mix=die->GetMixingHandler();
// printf("\n\n\n===============\ncall mix in Terminate: %p (%p)\n=================\n\n",mix,die);
if (mix) mix->MixRemaining(die);
}
PostData(1, &fListHistos);
PostData(2, &fListCF);
}
<commit_msg>-beam energy setter<commit_after>/*************************************************************************
* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
///////////////////////////////////////////////////////////////////////////
// //
// Basic Analysis Task //
// //
///////////////////////////////////////////////////////////////////////////
#include <TChain.h>
#include <TH1D.h>
#include <AliCFContainer.h>
#include <AliInputEventHandler.h>
#include <AliESDInputHandler.h>
#include <AliAODInputHandler.h>
#include <AliAnalysisManager.h>
#include <AliVEvent.h>
#include <AliTriggerAnalysis.h>
#include <AliPIDResponse.h>
#include <AliTPCPIDResponse.h>
#include "AliDielectron.h"
#include "AliDielectronHistos.h"
#include "AliDielectronCF.h"
#include "AliDielectronMC.h"
#include "AliDielectronMixingHandler.h"
#include "AliAnalysisTaskMultiDielectron.h"
ClassImp(AliAnalysisTaskMultiDielectron)
//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron() :
AliAnalysisTaskSE(),
fListDielectron(),
fListHistos(),
fListCF(),
fSelectPhysics(kFALSE),
fTriggerMask(AliVEvent::kMB),
fExcludeTriggerMask(0),
fTriggerOnV0AND(kFALSE),
fRejectPileup(kFALSE),
fBeamEnergy(-1.),
fTriggerLogic(kAny),
fTriggerAnalysis(0x0),
fEventFilter(0x0),
fEventStat(0x0)
{
//
// Constructor
//
}
//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron(const char *name) :
AliAnalysisTaskSE(name),
fListDielectron(),
fListHistos(),
fListCF(),
fSelectPhysics(kFALSE),
fTriggerMask(AliVEvent::kMB),
fExcludeTriggerMask(0),
fTriggerOnV0AND(kFALSE),
fRejectPileup(kFALSE),
fBeamEnergy(-1.),
fTriggerLogic(kAny),
fTriggerAnalysis(0x0),
fEventFilter(0x0),
fEventStat(0x0)
{
//
// Constructor
//
DefineInput(0,TChain::Class());
DefineOutput(1, TList::Class());
DefineOutput(2, TList::Class());
DefineOutput(3, TH1D::Class());
fListHistos.SetName("Dielectron_Histos_Multi");
fListCF.SetName("Dielectron_CF_Multi");
fListDielectron.SetOwner();
fListHistos.SetOwner();
fListCF.SetOwner();
}
//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::~AliAnalysisTaskMultiDielectron()
{
//
// Destructor
//
//histograms and CF are owned by the dielectron framework.
//however they are streamed to file, so in the first place the
//lists need to be owner...
fListHistos.SetOwner(kFALSE);
fListCF.SetOwner(kFALSE);
}
//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::UserCreateOutputObjects()
{
//
// Add all histogram manager histogram lists to the output TList
//
if (!fListHistos.IsEmpty()||!fListCF.IsEmpty()) return; //already initialised
// AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
// Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
// Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
die->Init();
if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
if (die->GetHistogramArray()) fListHistos.Add(const_cast<TObjArray*>(die->GetHistogramArray()));
if (die->GetCFManagerPair()) fListCF.Add(const_cast<AliCFContainer*>(die->GetCFManagerPair()->GetContainer()));
}
Int_t cuts=fListDielectron.GetEntries();
Int_t nbins=kNbinsEvent+2*cuts;
if (!fEventStat){
fEventStat=new TH1D("hEventStat","Event statistics",nbins,0,nbins);
fEventStat->GetXaxis()->SetBinLabel(1,"Before Phys. Sel.");
fEventStat->GetXaxis()->SetBinLabel(2,"After Phys. Sel.");
//default names
fEventStat->GetXaxis()->SetBinLabel(3,"Bin3 not used");
fEventStat->GetXaxis()->SetBinLabel(4,"Bin4 not used");
fEventStat->GetXaxis()->SetBinLabel(5,"Bin5 not used");
if(fTriggerOnV0AND) fEventStat->GetXaxis()->SetBinLabel(3,"V0and triggers");
if (fEventFilter) fEventStat->GetXaxis()->SetBinLabel(4,"After Event Filter");
if (fRejectPileup) fEventStat->GetXaxis()->SetBinLabel(5,"After Pileup rejection");
for (Int_t i=0; i<cuts; ++i){
fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+1)+2*i,Form("#splitline{1 candidate}{%s}",fListDielectron.At(i)->GetName()));
fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+2)+2*i,Form("#splitline{With >1 candidate}{%s}",fListDielectron.At(i)->GetName()));
}
}
if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
fTriggerAnalysis->EnableHistograms();
fTriggerAnalysis->SetAnalyzeMC(AliDielectronMC::Instance()->HasMC());
PostData(1, &fListHistos);
PostData(2, &fListCF);
PostData(3, fEventStat);
}
//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::UserExec(Option_t *)
{
//
// Main loop. Called for every event
//
if (fListHistos.IsEmpty()&&fListCF.IsEmpty()) return;
AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
if (!inputHandler) return;
// AliPIDResponse *pidRes=inputHandler->GetPIDResponse();
if ( inputHandler->GetPIDResponse() ){
// for the 2.76 pass2 MC private train. Together with a sigma shift of -0.169
// pidRes->GetTPCResponse().SetSigma(4.637e-3,2.41332105409873257e+04);
AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
} else {
AliFatal("This task needs the PID response attached to the input event handler!");
}
// Was event selected ?
ULong64_t isSelected = AliVEvent::kAny;
Bool_t isRejected = kFALSE;
if( fSelectPhysics && inputHandler){
if((isESD && inputHandler->GetEventSelection()) || isAOD){
isSelected = inputHandler->IsEventSelected();
if (fExcludeTriggerMask && (isSelected&fExcludeTriggerMask)) isRejected=kTRUE;
if (fTriggerLogic==kAny) isSelected&=fTriggerMask;
else if (fTriggerLogic==kExact) isSelected=((isSelected&fTriggerMask)==fTriggerMask);
}
}
//Before physics selection
fEventStat->Fill(kAllEvents);
if (isSelected==0||isRejected) {
PostData(3,fEventStat);
return;
}
//after physics selection
fEventStat->Fill(kSelectedEvents);
//V0and
if(fTriggerOnV0AND){
if(isESD){if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND))
return;}
if(isAOD){if(!((static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0ADecision() == AliVVZERO::kV0BB &&
(static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0CDecision() == AliVVZERO::kV0BB) )
return;}
}
fEventStat->Fill(kV0andEvents);
//Fill Event histograms before the event filter
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
Double_t values[AliDielectronVarManager::kNMaxValues]={0};
Double_t valuesMC[AliDielectronVarManager::kNMaxValues]={0};
AliDielectronVarManager::SetEvent(InputEvent());
AliDielectronVarManager::Fill(InputEvent(),values);
AliDielectronVarManager::Fill(InputEvent(),valuesMC);
Bool_t hasMC=AliDielectronMC::Instance()->HasMC();
if (hasMC) {
if (AliDielectronMC::Instance()->ConnectMCEvent())
AliDielectronVarManager::Fill(AliDielectronMC::Instance()->GetMCEvent(),valuesMC);
}
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
AliDielectronHistos *h=die->GetHistoManager();
if (h){
if (h->GetHistogramList()->FindObject("Event_noCuts"))
h->FillClass("Event_noCuts",AliDielectronVarManager::kNMaxValues,values);
if (hasMC && h->GetHistogramList()->FindObject("MCEvent_noCuts"))
h->FillClass("Event_noCuts",AliDielectronVarManager::kNMaxValues,valuesMC);
}
}
nextDie.Reset();
//event filter
if (fEventFilter) {
if (!fEventFilter->IsSelected(InputEvent())) return;
}
fEventStat->Fill(kFilteredEvents);
//pileup
if (fRejectPileup){
if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
}
fEventStat->Fill(kPileupEvents);
//bz for AliKF
Double_t bz = InputEvent()->GetMagneticField();
AliKFParticle::SetField( bz );
AliDielectronPID::SetCorrVal((Double_t)InputEvent()->GetRunNumber());
AliDielectronPair::SetBeamEnergy(InputEvent(), fBeamEnergy);
//Process event in all AliDielectron instances
// TIter nextDie(&fListDielectron);
// AliDielectron *die=0;
Int_t idie=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
die->Process(InputEvent());
if (die->HasCandidates()){
Int_t ncandidates=die->GetPairArray(1)->GetEntriesFast();
if (ncandidates==1) fEventStat->Fill((kNbinsEvent)+2*idie);
else if (ncandidates>1) fEventStat->Fill((kNbinsEvent+1)+2*idie);
}
++idie;
}
PostData(1, &fListHistos);
PostData(2, &fListCF);
PostData(3,fEventStat);
}
//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::FinishTaskOutput()
{
//
// Write debug tree
//
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
die->SaveDebugTree();
AliDielectronMixingHandler *mix=die->GetMixingHandler();
// printf("\n\n\n===============\ncall mix in Terminate: %p (%p)\n=================\n\n",mix,die);
if (mix) mix->MixRemaining(die);
}
PostData(1, &fListHistos);
PostData(2, &fListCF);
}
<|endoftext|>
|
<commit_before>/* wanderfreq -- start up 10 MYWAVETABLEs (modified WAVETABLE with a
frequency-access method) and randomly choose a target freq,
and wander towards it
demonstration of the RTcmix object -- BGG, 11/2002
Modified to show new Instrument functionality DS 03/2003
*/
#define MAIN
#include <iostream.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <globals.h>
#include "RTcmix.h"
#include "MYWAVETABLE/MYWAVETABLE.h"
// declare these here so they will be global for the wander() function
RTcmix *rrr;
#define NINSTS 10
MYWAVETABLE *theWaves[NINSTS];
double curfreq[NINSTS];
double targfreq[NINSTS];
double freqinc[NINSTS];
int
main(int argc, char *argv[])
{
int i;
void *wander();
double duration = 999.00; // default to loooong time
if (argc == 2)
duration = atof(argv[1]);
rrr = new RTcmix(44100.0, 2);
// rrr->printOn();
rrr->printOff();
sleep(1); // give the thread time to initialize
// load up MYWAVETABLE and set the makegens
rrr->cmd("load", 1, "./MYWAVETABLE/libMYWAVETABLE.so");
rrr->cmd("makegen", 9,
1.0, 24.0, 1000.0, 0.0, 0.0, 1.0, 1.0, 999.0, 1.0);
rrr->cmd("makegen", 6, 2.0, 10.0, 1000.0, 1.0, 0.3, 0.1);
for (i = 0; i < NINSTS; i++) {
// isn't this cute? we can use RTcmix score functions
curfreq[i] = rrr->cmd("random") * 1000.0 + 100.0;
targfreq[i] = rrr->cmd("random") * 1000.0 + 100.0;
freqinc[i] = rrr->cmd("random") * 9.0 + 1.0;
if (curfreq[i] > targfreq[i]) freqinc[i] = -freqinc[i];
// start the notes, looooong duration
theWaves[i] = (MYWAVETABLE*)rrr->cmd("MYWAVETABLE", 5,
0.0, duration, 30000.0/(double)NINSTS, curfreq[i],
(double)i*(1.0/(double)NINSTS));
theWaves[i]->Ref(); // Keep these from being destroyed
}
/* ok, I know scheduling a function to fire every 0.02 seconds is a little
crazed, but it's a *DEMO*, laddie! -- best place to do this would be
in the instrument itself and just set targets */
// set up the scheduling function, update every 0.02 seconds
RTtimeit(0.02, (sig_t)wander);
// and don't exit!
while(1) sleep(1);
}
void wander()
{
bool wavesLeft = false;
for (int i = 0; i < NINSTS; i++) {
if (theWaves[i] == NULL)
continue; // Already released this one
else if (theWaves[i]->IsDone())
{
theWaves[i]->Unref(); // Release our hold on this
theWaves[i] = NULL;
continue;
}
wavesLeft = true;
curfreq[i] += freqinc[i];
// this is where we change the frequency of each executing note
theWaves[i]->setfreq(curfreq[i]);
if (freqinc[i] < 0.0) {
if (curfreq[i] < targfreq[i]) {
targfreq[i] = rrr->cmd("random")*1000.0 + 100.0;
freqinc[i] = rrr->cmd("random")*9.0 + 1.0;
if (curfreq[i] > targfreq[i])
freqinc[i] = -freqinc[i];
}
} else {
if (curfreq[i] > targfreq[i]) {
targfreq[i] = rrr->cmd("random")*1000.0 + 100.0;
freqinc[i] = rrr->cmd("random")*9.0 + 1.0;
if (curfreq[i] > targfreq[i])
freqinc[i] = -freqinc[i];
}
}
}
if (!wavesLeft)
{
printf("All waves have finished. Exiting.\n");
exit(0);
}
}
<commit_msg>Tracked changes to Instrument<commit_after>/* wanderfreq -- start up 10 MYWAVETABLEs (modified WAVETABLE with a
frequency-access method) and randomly choose a target freq,
and wander towards it
demonstration of the RTcmix object -- BGG, 11/2002
Modified to show new Instrument functionality DS 03/2003
*/
#define MAIN
#include <iostream.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <globals.h>
#include "RTcmix.h"
#include "MYWAVETABLE/MYWAVETABLE.h"
// declare these here so they will be global for the wander() function
RTcmix *rrr;
#define NINSTS 10
MYWAVETABLE *theWaves[NINSTS];
double curfreq[NINSTS];
double targfreq[NINSTS];
double freqinc[NINSTS];
int
main(int argc, char *argv[])
{
int i;
void *wander();
double duration = 999.00; // default to loooong time
if (argc == 2)
duration = atof(argv[1]);
rrr = new RTcmix(44100.0, 2);
// rrr->printOn();
rrr->printOff();
sleep(1); // give the thread time to initialize
// load up MYWAVETABLE and set the makegens
rrr->cmd("load", 1, "./MYWAVETABLE/libMYWAVETABLE.so");
rrr->cmd("makegen", 9,
1.0, 24.0, 1000.0, 0.0, 0.0, 1.0, 1.0, 999.0, 1.0);
rrr->cmd("makegen", 6, 2.0, 10.0, 1000.0, 1.0, 0.3, 0.1);
for (i = 0; i < NINSTS; i++) {
// isn't this cute? we can use RTcmix score functions
curfreq[i] = rrr->cmd("random") * 1000.0 + 100.0;
targfreq[i] = rrr->cmd("random") * 1000.0 + 100.0;
freqinc[i] = rrr->cmd("random") * 9.0 + 1.0;
if (curfreq[i] > targfreq[i]) freqinc[i] = -freqinc[i];
// start the notes, looooong duration
theWaves[i] = (MYWAVETABLE*)rrr->cmd("MYWAVETABLE", 5,
0.0, duration, 30000.0/(double)NINSTS, curfreq[i],
(double)i*(1.0/(double)NINSTS));
theWaves[i]->ref(); // Keep these from being destroyed
}
/* ok, I know scheduling a function to fire every 0.02 seconds is a little
crazed, but it's a *DEMO*, laddie! -- best place to do this would be
in the instrument itself and just set targets */
// set up the scheduling function, update every 0.02 seconds
RTtimeit(0.02, (sig_t)wander);
// and don't exit!
while(1) sleep(1);
}
void wander()
{
bool wavesLeft = false;
for (int i = 0; i < NINSTS; i++) {
if (theWaves[i] == NULL)
continue; // Already released this one
else if (theWaves[i]->isDone())
{
theWaves[i]->unref(); // Release our hold on this
theWaves[i] = NULL;
continue;
}
wavesLeft = true;
curfreq[i] += freqinc[i];
// this is where we change the frequency of each executing note
theWaves[i]->setfreq(curfreq[i]);
if (freqinc[i] < 0.0) {
if (curfreq[i] < targfreq[i]) {
targfreq[i] = rrr->cmd("random")*1000.0 + 100.0;
freqinc[i] = rrr->cmd("random")*9.0 + 1.0;
if (curfreq[i] > targfreq[i])
freqinc[i] = -freqinc[i];
}
} else {
if (curfreq[i] > targfreq[i]) {
targfreq[i] = rrr->cmd("random")*1000.0 + 100.0;
freqinc[i] = rrr->cmd("random")*9.0 + 1.0;
if (curfreq[i] > targfreq[i])
freqinc[i] = -freqinc[i];
}
}
}
if (!wavesLeft)
{
printf("All waves have finished. Exiting.\n");
exit(0);
}
}
<|endoftext|>
|
<commit_before>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/renderer_webstoragearea_impl.h"
#include "content/common/dom_storage_messages.h"
#include "content/renderer/render_thread_impl.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageNamespace.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
using WebKit::WebStorageNamespace;
using WebKit::WebString;
using WebKit::WebURL;
RendererWebStorageAreaImpl::RendererWebStorageAreaImpl(
int64 namespace_id, const WebString& origin) {
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_StorageAreaId(namespace_id, origin,
&storage_area_id_));
}
RendererWebStorageAreaImpl::~RendererWebStorageAreaImpl() {
}
unsigned RendererWebStorageAreaImpl::length() {
unsigned length;
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_Length(storage_area_id_, &length));
return length;
}
WebString RendererWebStorageAreaImpl::key(unsigned index) {
NullableString16 key;
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_Key(storage_area_id_, index, &key));
return key;
}
WebString RendererWebStorageAreaImpl::getItem(const WebString& key) {
NullableString16 value;
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_GetItem(storage_area_id_, key, &value));
return value;
}
void RendererWebStorageAreaImpl::setItem(
const WebString& key, const WebString& value, const WebURL& url,
WebStorageArea::Result& result, WebString& old_value_webkit) {
const size_t kMaxKeyValueLength = WebStorageNamespace::m_localStorageQuota;
if (key.length() + value.length() > kMaxKeyValueLength) {
result = ResultBlockedByQuota;
return;
}
NullableString16 old_value;
RenderThreadImpl::current()->Send(new DOMStorageHostMsg_SetItem(
storage_area_id_, key, value, url, &result, &old_value));
old_value_webkit = old_value;
}
void RendererWebStorageAreaImpl::removeItem(
const WebString& key, const WebURL& url, WebString& old_value_webkit) {
NullableString16 old_value;
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_RemoveItem(storage_area_id_, key, url, &old_value));
old_value_webkit = old_value;
}
void RendererWebStorageAreaImpl::clear(
const WebURL& url, bool& cleared_something) {
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_Clear(storage_area_id_, url, &cleared_something));
}
<commit_msg>Histograms for DOMStorage access<commit_after>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/renderer_webstoragearea_impl.h"
#include "base/metrics/histogram.h"
#include "base/time.h"
#include "content/common/dom_storage_messages.h"
#include "content/renderer/render_thread_impl.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageNamespace.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
using WebKit::WebStorageNamespace;
using WebKit::WebString;
using WebKit::WebURL;
RendererWebStorageAreaImpl::RendererWebStorageAreaImpl(
int64 namespace_id, const WebString& origin) {
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_StorageAreaId(namespace_id, origin,
&storage_area_id_));
}
RendererWebStorageAreaImpl::~RendererWebStorageAreaImpl() {
}
unsigned RendererWebStorageAreaImpl::length() {
unsigned length;
base::Time start = base::Time::Now();
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_Length(storage_area_id_, &length));
UMA_HISTOGRAM_TIMES("DOMStorage.length", base::Time::Now() - start);
return length;
}
WebString RendererWebStorageAreaImpl::key(unsigned index) {
NullableString16 key;
base::Time start = base::Time::Now();
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_Key(storage_area_id_, index, &key));
UMA_HISTOGRAM_TIMES("DOMStorage.key", base::Time::Now() - start);
return key;
}
WebString RendererWebStorageAreaImpl::getItem(const WebString& key) {
NullableString16 value;
base::Time start = base::Time::Now();
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_GetItem(storage_area_id_, key, &value));
UMA_HISTOGRAM_TIMES("DOMStorage.getItem", base::Time::Now() - start);
return value;
}
void RendererWebStorageAreaImpl::setItem(
const WebString& key, const WebString& value, const WebURL& url,
WebStorageArea::Result& result, WebString& old_value_webkit) {
const size_t kMaxKeyValueLength = WebStorageNamespace::m_localStorageQuota;
if (key.length() + value.length() > kMaxKeyValueLength) {
result = ResultBlockedByQuota;
return;
}
NullableString16 old_value;
base::Time start = base::Time::Now();
RenderThreadImpl::current()->Send(new DOMStorageHostMsg_SetItem(
storage_area_id_, key, value, url, &result, &old_value));
UMA_HISTOGRAM_TIMES("DOMStorage.setItem", base::Time::Now() - start);
old_value_webkit = old_value;
}
void RendererWebStorageAreaImpl::removeItem(
const WebString& key, const WebURL& url, WebString& old_value_webkit) {
NullableString16 old_value;
base::Time start = base::Time::Now();
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_RemoveItem(storage_area_id_, key, url, &old_value));
UMA_HISTOGRAM_TIMES("DOMStorage.removeItem", base::Time::Now() - start);
old_value_webkit = old_value;
}
void RendererWebStorageAreaImpl::clear(
const WebURL& url, bool& cleared_something) {
base::Time start = base::Time::Now();
RenderThreadImpl::current()->Send(
new DOMStorageHostMsg_Clear(storage_area_id_, url, &cleared_something));
UMA_HISTOGRAM_TIMES("DOMStorage.clear", base::Time::Now() - start);
}
<|endoftext|>
|
<commit_before>/* Copyright 2018 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 "tensorflow/core/profiler/internal/traceme_recorder.h"
#include <stddef.h>
#include "tensorflow/core/platform/env.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/macros.h"
namespace tensorflow {
namespace profiler {
namespace internal {
std::atomic<int> g_trace_level =
ATOMIC_VAR_INIT(TraceMeRecorder::kTracingDisabled);
} // namespace internal
// Implementation of TraceMeRecorder::trace_level_ must be lock-free for faster
// execution of the TraceMe() public API. This can be commented (if compilation
// is failing) but execution might be slow (even when host tracing is disabled).
static_assert(ATOMIC_INT_LOCK_FREE == 2, "Assumed atomic<int> was lock free");
namespace {
// A single-producer single-consumer queue of Events.
//
// Implemented as a linked-list of blocks containing numbered slots, with start
// and end pointers:
//
// [ events........ | next-]--> [ events......... | next ]
// ^start_block_ ^start_ ^end_block_ ^end_
//
// start_ is the first occupied slot, end_ is the first unoccupied slot.
//
// Push writes at end_, and then advances it, allocating a block if needed.
// PopAll takes ownership of events in the range [start_, end_).
// The end_ pointer is atomic so Push and PopAll can be concurrent.
//
// Push and PopAll are lock free and each might be called from at most one
// thread. Push is only called by the owner thread. PopAll is called by the
// owner thread when it shuts down, or by the tracing control thread.
//
// Thus, PopAll might race with Push, so PopAll only removes events that were
// in the queue when it was invoked. If Push is called while PopAll is active,
// the new event remains in the queue. Thus, the tracing control thread should
// call PopAll when tracing stops to remove events created during tracing, but
// also when tracing starts again to clear any remaining events.
class EventQueue {
public:
EventQueue()
: start_block_(new Block{/*start=*/0, /*next=*/nullptr}),
start_(start_block_->start),
end_block_(start_block_),
end_(start_) {}
// REQUIRES: PopAll() was called since the last Push().
// Memory should be deallocated and trace events destroyed on destruction.
// This doesn't require global lock as this discards all the stored trace
// events and we assume of destruction of this instance only after the last
// Push() has been called.
~EventQueue() {
DCHECK(Empty()) << "EventQueue destroyed without PopAll()";
delete end_block_;
}
// Add a new event to the back of the queue. Fast and lock-free.
void Push(TraceMeRecorder::Event&& event) {
size_t end = end_.load(std::memory_order_relaxed);
new (&end_block_->events[end++ - end_block_->start].event)
TraceMeRecorder::Event(std::move(event));
if (TF_PREDICT_FALSE(end - end_block_->start == Block::kNumSlots)) {
auto* new_block = new Block{end, nullptr};
end_block_->next = new_block;
end_block_ = new_block;
}
end_.store(end, std::memory_order_release); // Write index after contents.
}
// Retrieve and remove all events in the queue at the time of invocation.
// If Push is called while PopAll is active, the new event will not be
// removed from the queue.
std::vector<TraceMeRecorder::Event> PopAll() {
// Read index before contents.
size_t end = end_.load(std::memory_order_acquire);
std::vector<TraceMeRecorder::Event> result;
result.reserve(end - start_);
while (start_ != end) {
result.emplace_back(Pop());
}
return result;
}
private:
// Returns true if the queue is empty at the time of invocation.
bool Empty() const {
return (start_ == end_.load(std::memory_order_acquire));
}
// Remove one event off the front of the queue and return it.
// REQUIRES: The queue must not be empty.
TraceMeRecorder::Event Pop() {
DCHECK(!Empty());
// Move the next event into the output.
auto& event = start_block_->events[start_++ - start_block_->start].event;
TraceMeRecorder::Event out = std::move(event);
event.~Event(); // Events must be individually destroyed.
// If we reach the end of a block, we own it and should delete it.
// The next block is present: end always points to something.
if (TF_PREDICT_FALSE(start_ - start_block_->start == Block::kNumSlots)) {
auto* next_block = start_block_->next;
delete start_block_;
start_block_ = next_block;
DCHECK_EQ(start_, start_block_->start);
}
return out;
}
struct Block {
// The number of slots in a block is chosen so the block fits in 64 KiB.
static constexpr size_t kSize = 1 << 16;
static constexpr size_t kNumSlots =
(kSize - (sizeof(size_t) + sizeof(Block*))) /
sizeof(TraceMeRecorder::Event);
size_t start; // The number of the first slot.
Block* next;
// Defer construction of Event until the data is available.
// Must also destroy manually, as the block may not fill entirely.
union MaybeEvent {
MaybeEvent() {}
~MaybeEvent() {}
TraceMeRecorder::Event event;
} events[kNumSlots];
};
static_assert(sizeof(Block) <= Block::kSize, "");
// Head of list for reading. Only accessed by consumer thread.
Block* start_block_;
size_t start_;
// Tail of list for writing. Accessed by producer thread.
Block* end_block_;
std::atomic<size_t> end_; // Atomic: also read by consumer thread.
};
} // namespace
// To avoid unnecessary synchronization between threads, each thread has a
// ThreadLocalRecorder that independently records its events.
class TraceMeRecorder::ThreadLocalRecorder {
public:
// The recorder is created the first time TraceMeRecorder::Record() is called
// on a thread.
ThreadLocalRecorder() {
auto* env = Env::Default();
info_.tid = env->GetCurrentThreadId();
env->GetCurrentThreadName(&info_.name);
TraceMeRecorder::Get()->RegisterThread(info_.tid, this);
}
// The destructor is called when the thread shuts down early.
~ThreadLocalRecorder() { TraceMeRecorder::Get()->UnregisterThread(Clear()); }
// Record is only called from the owner thread.
void Record(TraceMeRecorder::Event&& event) { queue_.Push(std::move(event)); }
// Clear is called from the control thread when tracing starts/stops, or from
// the owner thread when it shuts down (see destructor).
TraceMeRecorder::ThreadEvents Clear() { return {info_, queue_.PopAll()}; }
private:
TraceMeRecorder::ThreadInfo info_;
EventQueue queue_;
};
/*static*/ TraceMeRecorder* TraceMeRecorder::Get() {
static TraceMeRecorder* singleton = new TraceMeRecorder;
return singleton;
}
void TraceMeRecorder::RegisterThread(int32 tid, ThreadLocalRecorder* thread) {
mutex_lock lock(mutex_);
threads_.emplace(tid, thread);
}
void TraceMeRecorder::UnregisterThread(TraceMeRecorder::ThreadEvents&& events) {
mutex_lock lock(mutex_);
threads_.erase(events.thread.tid);
orphaned_events_.push_back(std::move(events));
}
// This method is performance critical and should be kept fast. It is called
// when tracing starts/stops. The mutex is held, so no threads can be
// registered/unregistered. This prevents calling ThreadLocalRecorder::Clear
// from two different threads.
TraceMeRecorder::Events TraceMeRecorder::Clear() {
TraceMeRecorder::Events result;
std::swap(orphaned_events_, result);
for (const auto& entry : threads_) {
auto* recorder = entry.second;
result.push_back(recorder->Clear());
}
return result;
}
bool TraceMeRecorder::StartRecording(int level) {
level = std::max(0, level);
mutex_lock lock(mutex_);
// Change trace_level_ while holding mutex_.
int expected = kTracingDisabled;
bool started = internal::g_trace_level.compare_exchange_strong(
expected, level, std::memory_order_acq_rel);
if (started) {
// We may have old events in buffers because Record() raced with Stop().
Clear();
}
return started;
}
void TraceMeRecorder::Record(Event event) {
static thread_local ThreadLocalRecorder thread_local_recorder;
thread_local_recorder.Record(std::move(event));
}
TraceMeRecorder::Events TraceMeRecorder::StopRecording() {
TraceMeRecorder::Events events;
mutex_lock lock(mutex_);
// Change trace_level_ while holding mutex_.
if (internal::g_trace_level.exchange(
kTracingDisabled, std::memory_order_acq_rel) != kTracingDisabled) {
events = Clear();
}
return events;
}
/*static*/ uint64 TraceMeRecorder::NewActivityId() {
// Activity IDs: To avoid contention over a counter, the top 32 bits identify
// the originating thread, the bottom 32 bits name the event within a thread.
// IDs may be reused after 4 billion events on one thread, or 4 billion
// threads.
static std::atomic<uint32> thread_counter(1); // avoid kUntracedActivity
const thread_local static uint32 thread_id =
thread_counter.fetch_add(1, std::memory_order_relaxed);
thread_local static uint32 per_thread_activity_id = 0;
return static_cast<uint64>(thread_id) << 32 | per_thread_activity_id++;
}
} // namespace profiler
} // namespace tensorflow
<commit_msg>Only save per-thread events when non-empty<commit_after>/* Copyright 2018 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 "tensorflow/core/profiler/internal/traceme_recorder.h"
#include <stddef.h>
#include "tensorflow/core/platform/env.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/platform/macros.h"
namespace tensorflow {
namespace profiler {
namespace internal {
std::atomic<int> g_trace_level =
ATOMIC_VAR_INIT(TraceMeRecorder::kTracingDisabled);
} // namespace internal
// Implementation of TraceMeRecorder::trace_level_ must be lock-free for faster
// execution of the TraceMe() public API. This can be commented (if compilation
// is failing) but execution might be slow (even when host tracing is disabled).
static_assert(ATOMIC_INT_LOCK_FREE == 2, "Assumed atomic<int> was lock free");
namespace {
// A single-producer single-consumer queue of Events.
//
// Implemented as a linked-list of blocks containing numbered slots, with start
// and end pointers:
//
// [ events........ | next-]--> [ events......... | next ]
// ^start_block_ ^start_ ^end_block_ ^end_
//
// start_ is the first occupied slot, end_ is the first unoccupied slot.
//
// Push writes at end_, and then advances it, allocating a block if needed.
// PopAll takes ownership of events in the range [start_, end_).
// The end_ pointer is atomic so Push and PopAll can be concurrent.
//
// Push and PopAll are lock free and each might be called from at most one
// thread. Push is only called by the owner thread. PopAll is called by the
// owner thread when it shuts down, or by the tracing control thread.
//
// Thus, PopAll might race with Push, so PopAll only removes events that were
// in the queue when it was invoked. If Push is called while PopAll is active,
// the new event remains in the queue. Thus, the tracing control thread should
// call PopAll when tracing stops to remove events created during tracing, but
// also when tracing starts again to clear any remaining events.
class EventQueue {
public:
EventQueue()
: start_block_(new Block{/*start=*/0, /*next=*/nullptr}),
start_(start_block_->start),
end_block_(start_block_),
end_(start_) {}
// REQUIRES: PopAll() was called since the last Push().
// Memory should be deallocated and trace events destroyed on destruction.
// This doesn't require global lock as this discards all the stored trace
// events and we assume of destruction of this instance only after the last
// Push() has been called.
~EventQueue() {
DCHECK(Empty()) << "EventQueue destroyed without PopAll()";
delete end_block_;
}
// Add a new event to the back of the queue. Fast and lock-free.
void Push(TraceMeRecorder::Event&& event) {
size_t end = end_.load(std::memory_order_relaxed);
new (&end_block_->events[end++ - end_block_->start].event)
TraceMeRecorder::Event(std::move(event));
if (TF_PREDICT_FALSE(end - end_block_->start == Block::kNumSlots)) {
auto* new_block = new Block{end, nullptr};
end_block_->next = new_block;
end_block_ = new_block;
}
end_.store(end, std::memory_order_release); // Write index after contents.
}
// Retrieve and remove all events in the queue at the time of invocation.
// If Push is called while PopAll is active, the new event will not be
// removed from the queue.
std::vector<TraceMeRecorder::Event> PopAll() {
// Read index before contents.
size_t end = end_.load(std::memory_order_acquire);
std::vector<TraceMeRecorder::Event> result;
result.reserve(end - start_);
while (start_ != end) {
result.emplace_back(Pop());
}
return result;
}
private:
// Returns true if the queue is empty at the time of invocation.
bool Empty() const {
return (start_ == end_.load(std::memory_order_acquire));
}
// Remove one event off the front of the queue and return it.
// REQUIRES: The queue must not be empty.
TraceMeRecorder::Event Pop() {
DCHECK(!Empty());
// Move the next event into the output.
auto& event = start_block_->events[start_++ - start_block_->start].event;
TraceMeRecorder::Event out = std::move(event);
event.~Event(); // Events must be individually destroyed.
// If we reach the end of a block, we own it and should delete it.
// The next block is present: end always points to something.
if (TF_PREDICT_FALSE(start_ - start_block_->start == Block::kNumSlots)) {
auto* next_block = start_block_->next;
delete start_block_;
start_block_ = next_block;
DCHECK_EQ(start_, start_block_->start);
}
return out;
}
struct Block {
// The number of slots in a block is chosen so the block fits in 64 KiB.
static constexpr size_t kSize = 1 << 16;
static constexpr size_t kNumSlots =
(kSize - (sizeof(size_t) + sizeof(Block*))) /
sizeof(TraceMeRecorder::Event);
size_t start; // The number of the first slot.
Block* next;
// Defer construction of Event until the data is available.
// Must also destroy manually, as the block may not fill entirely.
union MaybeEvent {
MaybeEvent() {}
~MaybeEvent() {}
TraceMeRecorder::Event event;
} events[kNumSlots];
};
static_assert(sizeof(Block) <= Block::kSize, "");
// Head of list for reading. Only accessed by consumer thread.
Block* start_block_;
size_t start_;
// Tail of list for writing. Accessed by producer thread.
Block* end_block_;
std::atomic<size_t> end_; // Atomic: also read by consumer thread.
};
} // namespace
// To avoid unnecessary synchronization between threads, each thread has a
// ThreadLocalRecorder that independently records its events.
class TraceMeRecorder::ThreadLocalRecorder {
public:
// The recorder is created the first time TraceMeRecorder::Record() is called
// on a thread.
ThreadLocalRecorder() {
auto* env = Env::Default();
info_.tid = env->GetCurrentThreadId();
env->GetCurrentThreadName(&info_.name);
TraceMeRecorder::Get()->RegisterThread(info_.tid, this);
}
// The destructor is called when the thread shuts down early.
~ThreadLocalRecorder() { TraceMeRecorder::Get()->UnregisterThread(Clear()); }
// Record is only called from the owner thread.
void Record(TraceMeRecorder::Event&& event) { queue_.Push(std::move(event)); }
// Clear is called from the control thread when tracing starts/stops, or from
// the owner thread when it shuts down (see destructor).
TraceMeRecorder::ThreadEvents Clear() { return {info_, queue_.PopAll()}; }
private:
TraceMeRecorder::ThreadInfo info_;
EventQueue queue_;
};
/*static*/ TraceMeRecorder* TraceMeRecorder::Get() {
static TraceMeRecorder* singleton = new TraceMeRecorder;
return singleton;
}
void TraceMeRecorder::RegisterThread(int32 tid, ThreadLocalRecorder* thread) {
mutex_lock lock(mutex_);
threads_.emplace(tid, thread);
}
void TraceMeRecorder::UnregisterThread(TraceMeRecorder::ThreadEvents&& events) {
mutex_lock lock(mutex_);
threads_.erase(events.thread.tid);
if (!events.events.empty()) {
orphaned_events_.push_back(std::move(events));
}
}
// This method is performance critical and should be kept fast. It is called
// when tracing starts/stops. The mutex is held, so no threads can be
// registered/unregistered. This prevents calling ThreadLocalRecorder::Clear
// from two different threads.
TraceMeRecorder::Events TraceMeRecorder::Clear() {
TraceMeRecorder::Events result;
std::swap(orphaned_events_, result);
for (const auto& entry : threads_) {
auto* recorder = entry.second;
TraceMeRecorder::ThreadEvents events = recorder->Clear();
if (!events.events.empty()) {
result.push_back(std::move(events));
}
}
return result;
}
bool TraceMeRecorder::StartRecording(int level) {
level = std::max(0, level);
mutex_lock lock(mutex_);
// Change trace_level_ while holding mutex_.
int expected = kTracingDisabled;
bool started = internal::g_trace_level.compare_exchange_strong(
expected, level, std::memory_order_acq_rel);
if (started) {
// We may have old events in buffers because Record() raced with Stop().
Clear();
}
return started;
}
void TraceMeRecorder::Record(Event event) {
static thread_local ThreadLocalRecorder thread_local_recorder;
thread_local_recorder.Record(std::move(event));
}
TraceMeRecorder::Events TraceMeRecorder::StopRecording() {
TraceMeRecorder::Events events;
mutex_lock lock(mutex_);
// Change trace_level_ while holding mutex_.
if (internal::g_trace_level.exchange(
kTracingDisabled, std::memory_order_acq_rel) != kTracingDisabled) {
events = Clear();
}
return events;
}
/*static*/ uint64 TraceMeRecorder::NewActivityId() {
// Activity IDs: To avoid contention over a counter, the top 32 bits identify
// the originating thread, the bottom 32 bits name the event within a thread.
// IDs may be reused after 4 billion events on one thread, or 4 billion
// threads.
static std::atomic<uint32> thread_counter(1); // avoid kUntracedActivity
const thread_local static uint32 thread_id =
thread_counter.fetch_add(1, std::memory_order_relaxed);
thread_local static uint32 per_thread_activity_id = 0;
return static_cast<uint64>(thread_id) << 32 | per_thread_activity_id++;
}
} // namespace profiler
} // namespace tensorflow
<|endoftext|>
|
<commit_before>#include <iostream>
#include <opencv2/opencv.hpp>
// using namespace cv;
using namespace std;
int main() {
cv::VideoCapture capture(0);
cv::Mat edges;
while (1) {
cv::Mat frame;
capture >> frame;
cout << (int)*(frame.data) << endl;
if (cv::waitKey(30) >= 0)
break;
}
return 0;
}<commit_msg>Draw with the pen.<commit_after>#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/opencv.hpp>
#include <unistd.h>
using namespace cv;
using namespace std;
void DrawLine(Mat img, Point start, Point end);
int main() {
VideoCapture capture(0);
Mat frame;
capture >> frame;
Mat canvas(frame.rows, frame.cols, CV_8UC3, Scalar(255, 255, 255));
int position_startx, position_starty = -1;
int position_endx, position_endy = 0;
while (1) {
capture >> frame;
int rowNum = frame.rows;
int colNum = frame.cols;
for (int i = 0; i < rowNum; i++) {
uchar *data = frame.ptr<uchar>(i);
for (int j = 0; j < colNum; j++) {
if (data[j] > 0 && data[j] < 30)
if (data[j + 1] > 100 && data[j + 1] < 200)
if (data[j + 2] > 250 && data[j + 2] < 256) {
position_startx = position_endx;
position_starty = position_endy;
position_endx = i;
position_endy = j;
}
if (position_starty != -1)
DrawLine(canvas, Point(position_startx, position_starty),
Point(position_endx, position_endy));
imshow("画布", canvas);
waitKey(30);
}
}
usleep(100000);
}
return 0;
}
void DrawLine(Mat img, Point start, Point end) {
int thickness = 2;
int lineType = 8;
line(img, start, end, Scalar(0, 0, 0), thickness, lineType);
}<|endoftext|>
|
<commit_before>/******************************************************
* This is CIR-KIT 3rd robot control driver.
* Author : Arita Yuta(Kyutech)
******************************************************/
#include <ros/ros.h>
#include <geometry_msgs/Twist.h> // cmd_vel
#include <tf/transform_broadcaster.h>
#include <string>
namespace cirkit
{
class ThirdRobotInterface; // forward declaration
class CirkitUnit03Driver
{
public:
CirkitUnit03Driver(ros::NodeHandle nh);
~CirkitUnit03Driver();
void run();
private:
// Callback function
void cmdVelReceived(const geometry_msgs::Twist::ConstPtr& cmd_vel);
ros::NodeHandle nh_;
ros::Rate rate_;
// ROS topic trader
ros::Publisher odom_pub_;
ros::Publisher steer_pub_;
ros::Subscriber cmd_vel_sub_;
// self member
tf::TransformBroadcaster odom_broadcaster_;
std::string imcs01_port_;
ros::Time current_time_, last_time_;
boost::mutex access_mutex_;
geometry_msgs::Twist steer_dir_;
// third robot interface object
cirkit::ThirdRobotInterface *cirkit_unit03_;
};
}
<commit_msg>Reformat writing<commit_after>/******************************************************
* This is CIR-KIT 3rd robot control driver.
* Author : Arita Yuta(Kyutech)
******************************************************/
#include <ros/ros.h>
#include <geometry_msgs/Twist.h> // cmd_vel
#include <tf/transform_broadcaster.h>
#include <string>
namespace cirkit {
class ThirdRobotInterface; // forward declaration
class CirkitUnit03Driver {
public:
CirkitUnit03Driver(ros::NodeHandle nh);
~CirkitUnit03Driver();
void run();
private:
// Callback function
void cmdVelReceived(const geometry_msgs::Twist::ConstPtr& cmd_vel);
ros::NodeHandle nh_;
ros::Rate rate_;
// ROS topic trader
ros::Publisher odom_pub_;
ros::Publisher steer_pub_;
ros::Subscriber cmd_vel_sub_;
// self member
tf::TransformBroadcaster odom_broadcaster_;
std::string imcs01_port_;
ros::Time current_time_, last_time_;
boost::mutex access_mutex_;
geometry_msgs::Twist steer_dir_;
// third robot interface object
cirkit::ThirdRobotInterface *cirkit_unit03_;
};
}
<|endoftext|>
|
<commit_before>#include "test_helper.h"
#include "compiler/prepare_grammar/flatten_grammar.h"
#include "compiler/prepare_grammar/initial_syntax_grammar.h"
#include "compiler/syntax_grammar.h"
#include "helpers/stream_methods.h"
START_TEST
using namespace rules;
using prepare_grammar::flatten_rule;
describe("flatten_grammar", []() {
it("associates each symbol with the precedence and associativity binding it to its successor", [&]() {
SyntaxVariable result = flatten_rule({
"test",
VariableTypeNamed,
Rule::seq({
Symbol::non_terminal(1),
Metadata::prec_left(101, Rule::seq({
Symbol::non_terminal(2),
Rule::choice({
Metadata::prec_right(102, Rule::seq({
Symbol::non_terminal(3),
Symbol::non_terminal(4)
})),
Symbol::non_terminal(5),
}),
Symbol::non_terminal(6),
})),
Symbol::non_terminal(7),
})
});
AssertThat(result.name, Equals("test"));
AssertThat(result.type, Equals(VariableTypeNamed));
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone},
{Symbol::non_terminal(2), 101, AssociativityLeft},
{Symbol::non_terminal(3), 102, AssociativityRight},
{Symbol::non_terminal(4), 101, AssociativityLeft},
{Symbol::non_terminal(6), 0, AssociativityNone},
{Symbol::non_terminal(7), 0, AssociativityNone},
}, 0},
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone},
{Symbol::non_terminal(2), 101, AssociativityLeft},
{Symbol::non_terminal(5), 101, AssociativityLeft},
{Symbol::non_terminal(6), 0, AssociativityNone},
{Symbol::non_terminal(7), 0, AssociativityNone},
}, 0}
})));
});
it("stores the maximum dynamic precedence specified in each production", [&]() {
SyntaxVariable result = flatten_rule({
"test",
VariableTypeNamed,
Rule::seq({
Symbol::non_terminal(1),
Metadata::prec_dynamic(101, Rule::seq({
Symbol::non_terminal(2),
Rule::choice({
Metadata::prec_dynamic(102, Rule::seq({
Symbol::non_terminal(3),
Symbol::non_terminal(4)
})),
Symbol::non_terminal(5),
}),
Symbol::non_terminal(6),
})),
Symbol::non_terminal(7),
})
});
AssertThat(result.name, Equals("test"));
AssertThat(result.type, Equals(VariableTypeNamed));
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone},
{Symbol::non_terminal(2), 0, AssociativityNone},
{Symbol::non_terminal(3), 0, AssociativityNone},
{Symbol::non_terminal(4), 0, AssociativityNone},
{Symbol::non_terminal(6), 0, AssociativityNone},
{Symbol::non_terminal(7), 0, AssociativityNone},
}, 102},
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone},
{Symbol::non_terminal(2), 0, AssociativityNone},
{Symbol::non_terminal(5), 0, AssociativityNone},
{Symbol::non_terminal(6), 0, AssociativityNone},
{Symbol::non_terminal(7), 0, AssociativityNone},
}, 101}
})));
});
it("uses the last assigned precedence", [&]() {
SyntaxVariable result = flatten_rule({
"test1",
VariableTypeNamed,
Metadata::prec_left(101, Rule::seq({
Symbol::non_terminal(1),
Symbol::non_terminal(2),
}))
});
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 101, AssociativityLeft},
{Symbol::non_terminal(2), 101, AssociativityLeft},
}, 0}
})));
result = flatten_rule({
"test2",
VariableTypeNamed,
Metadata::prec_left(101, Rule::seq({
Symbol::non_terminal(1),
}))
});
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 101, AssociativityLeft},
}, 0}
})));
});
});
END_TEST
<commit_msg>Fix compiler warnings in flatten_grammar_test<commit_after>#include "test_helper.h"
#include "compiler/prepare_grammar/flatten_grammar.h"
#include "compiler/prepare_grammar/initial_syntax_grammar.h"
#include "compiler/syntax_grammar.h"
#include "helpers/stream_methods.h"
START_TEST
using namespace rules;
using prepare_grammar::flatten_rule;
describe("flatten_grammar", []() {
it("associates each symbol with the precedence and associativity binding it to its successor", [&]() {
SyntaxVariable result = flatten_rule({
"test",
VariableTypeNamed,
Rule::seq({
Symbol::non_terminal(1),
Metadata::prec_left(101, Rule::seq({
Symbol::non_terminal(2),
Rule::choice({
Metadata::prec_right(102, Rule::seq({
Symbol::non_terminal(3),
Symbol::non_terminal(4)
})),
Symbol::non_terminal(5),
}),
Symbol::non_terminal(6),
})),
Symbol::non_terminal(7),
})
});
AssertThat(result.name, Equals("test"));
AssertThat(result.type, Equals(VariableTypeNamed));
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone, ""},
{Symbol::non_terminal(2), 101, AssociativityLeft, ""},
{Symbol::non_terminal(3), 102, AssociativityRight, ""},
{Symbol::non_terminal(4), 101, AssociativityLeft, ""},
{Symbol::non_terminal(6), 0, AssociativityNone, ""},
{Symbol::non_terminal(7), 0, AssociativityNone, ""},
}, 0},
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone, ""},
{Symbol::non_terminal(2), 101, AssociativityLeft, ""},
{Symbol::non_terminal(5), 101, AssociativityLeft, ""},
{Symbol::non_terminal(6), 0, AssociativityNone, ""},
{Symbol::non_terminal(7), 0, AssociativityNone, ""},
}, 0}
})));
});
it("stores the maximum dynamic precedence specified in each production", [&]() {
SyntaxVariable result = flatten_rule({
"test",
VariableTypeNamed,
Rule::seq({
Symbol::non_terminal(1),
Metadata::prec_dynamic(101, Rule::seq({
Symbol::non_terminal(2),
Rule::choice({
Metadata::prec_dynamic(102, Rule::seq({
Symbol::non_terminal(3),
Symbol::non_terminal(4)
})),
Symbol::non_terminal(5),
}),
Symbol::non_terminal(6),
})),
Symbol::non_terminal(7),
})
});
AssertThat(result.name, Equals("test"));
AssertThat(result.type, Equals(VariableTypeNamed));
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone, ""},
{Symbol::non_terminal(2), 0, AssociativityNone, ""},
{Symbol::non_terminal(3), 0, AssociativityNone, ""},
{Symbol::non_terminal(4), 0, AssociativityNone, ""},
{Symbol::non_terminal(6), 0, AssociativityNone, ""},
{Symbol::non_terminal(7), 0, AssociativityNone, ""},
}, 102},
Production{{
{Symbol::non_terminal(1), 0, AssociativityNone, ""},
{Symbol::non_terminal(2), 0, AssociativityNone, ""},
{Symbol::non_terminal(5), 0, AssociativityNone, ""},
{Symbol::non_terminal(6), 0, AssociativityNone, ""},
{Symbol::non_terminal(7), 0, AssociativityNone, ""},
}, 101}
})));
});
it("uses the last assigned precedence", [&]() {
SyntaxVariable result = flatten_rule({
"test1",
VariableTypeNamed,
Metadata::prec_left(101, Rule::seq({
Symbol::non_terminal(1),
Symbol::non_terminal(2),
}))
});
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 101, AssociativityLeft, ""},
{Symbol::non_terminal(2), 101, AssociativityLeft, ""},
}, 0}
})));
result = flatten_rule({
"test2",
VariableTypeNamed,
Metadata::prec_left(101, Rule::seq({
Symbol::non_terminal(1),
}))
});
AssertThat(result.productions, Equals(vector<Production>({
Production{{
{Symbol::non_terminal(1), 101, AssociativityLeft, ""},
}, 0}
})));
});
});
END_TEST
<|endoftext|>
|
<commit_before>#pragma once
#include <cstdint>
#include <string>
#include <type_traits>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/vector.hpp>
#include "blackhole/cpp17/string_view.hpp"
namespace blackhole {
/// Represents a trait for mapping an owned types to their associated lightweight view types.
///
/// By default all types are transparently mapped to itself, but Blackhole provides some
/// specializations.
///
/// \warning it is undefined behavior to add specializations for this trait.
template<typename T>
struct view_of {
typedef T type;
};
} // namespace blackhole
namespace blackhole {
namespace attribute {
class value_t;
class view_t;
/// Represents an attribute value holder.
///
/// Attribute value is an algebraic data type that can be initialized with one of six predefined
/// primitive types:
/// - none marker;
/// - boolean type (true or false);
/// - signed integer types up to 64-bit size;
/// - unsigned integer types up to 64-bit size;
/// - floating point type;
/// - and an owned string type.
///
/// The underlying value can be obtained through `blackhole::attribute::get` function with providing
/// the desired result type. For example:
/// blackhole::attribute::value_t value(42);
/// const auto actual = blackhole::attribute::get<std::int64_t>(value);
///
/// assert(42 == actual);
///
/// As an alternative a visitor pattern is provided for enabling underlying value visitation. To
/// enable this feature, implement the `value_t::visitor_t` interface and provide an instance of
/// this implementation to the `apply` method.
class value_t {
public:
/// Available types.
typedef std::nullptr_t null_type;
typedef bool bool_type;
typedef std::int64_t sint64_type;
typedef std::uint64_t uint64_type;
typedef double double_type;
typedef std::string string_type;
/// The type sequence of all available types.
typedef boost::mpl::vector<
null_type,
bool_type,
sint64_type,
uint64_type,
double_type,
string_type
> types;
/// Visitor interface.
class visitor_t {
public:
virtual ~visitor_t() = 0;
virtual auto operator()(const null_type&) -> void = 0;
virtual auto operator()(const bool_type&) -> void = 0;
virtual auto operator()(const sint64_type&) -> void = 0;
virtual auto operator()(const uint64_type&) -> void = 0;
virtual auto operator()(const double_type&) -> void = 0;
virtual auto operator()(const string_type&) -> void = 0;
};
struct inner_t;
private:
typedef std::aligned_storage<sizeof(std::string) + sizeof(int)>::type storage_type;
/// The underlying type.
storage_type storage;
public:
/// Constructs a null value containing tagged nullptr value.
value_t();
/// Constructs a value initialized with the given boolean value.
value_t(bool value);
/// Constructs a value initialized with the given signed integer.
value_t(char value);
value_t(short value);
value_t(int value);
value_t(long value);
value_t(long long value);
/// Constructs a value initialized with the given unsigned integer.
value_t(unsigned char value);
value_t(unsigned short value);
value_t(unsigned int value);
value_t(unsigned long value);
value_t(unsigned long long value);
value_t(double value);
/// Constructs a value from the given string literal not including the terminating null
/// character.
///
/// \note this overload is required to prevent implicit conversion literal values to bool.
template<std::size_t N>
value_t(const char(&value)[N]) { construct(string_type{value, N - 1}); }
value_t(std::string value);
~value_t();
value_t(const value_t& other);
value_t(value_t&& other);
auto operator=(const value_t& other) -> value_t&;
auto operator=(value_t&& other) -> value_t&;
/// Applies the given visitor to perform pattern matching.
auto apply(const visitor_t& visitor) const -> void;
/// Returns the internal underlying value.
auto inner() noexcept -> inner_t&;
auto inner() const noexcept -> const inner_t&;
private:
template<typename T>
auto construct(T&& value) -> void;
};
/// Represents an attribute value holder view, containing only lightweight references to the actual
/// values.
class view_t {
public:
/// Available types.
typedef std::nullptr_t null_type;
typedef bool bool_type;
typedef std::int64_t sint64_type;
typedef std::uint64_t uint64_type;
typedef double double_type;
typedef string_view string_type;
typedef boost::mpl::vector<
null_type,
bool_type,
sint64_type,
uint64_type,
double_type,
string_type
> types;
class visitor_t {
public:
virtual ~visitor_t() = 0;
virtual auto operator()(const null_type&) -> void = 0;
virtual auto operator()(const bool_type&) -> void = 0;
virtual auto operator()(const sint64_type&) -> void = 0;
virtual auto operator()(const uint64_type&) -> void = 0;
virtual auto operator()(const double_type&) -> void = 0;
virtual auto operator()(const string_type&) -> void = 0;
};
struct inner_t;
private:
typedef std::aligned_storage<2 * sizeof(void*) + sizeof(int)>::type storage_type;
/// The underlying type.
storage_type storage;
public:
/// Constructs a null value view containing tagged nullptr value.
view_t();
/// Constructs a value view initialized with the given boolean value.
view_t(bool value);
/// Constructs a value view initialized with the given signed integer.
view_t(char value);
view_t(short value);
view_t(int value);
view_t(long value);
view_t(long long value);
/// Constructs a value view initialized with the given unsigned integer.
view_t(unsigned char value);
view_t(unsigned short value);
view_t(unsigned int value);
view_t(unsigned long value);
view_t(unsigned long long value);
/// Constructs a value view from the given floating point value.
view_t(double value);
/// Constructs a value view from the given string literal not including the terminating null
/// character.
///
/// \note this overload is required to prevent implicit conversion literal values to bool.
template<std::size_t N>
view_t(const char(&value)[N]) { construct(string_type{value, N - 1}); }
/// Constructs a value view from the given string view.
view_t(const string_type& value);
/// Constructs a value view from the given string.
view_t(const std::string& value);
/// Constructs a value view from the given owned attribute value.
view_t(const value_t& value);
view_t(const view_t& other) = default;
view_t(view_t&& other) = default;
~view_t() = default;
auto operator=(const view_t& other) -> view_t& = default;
auto operator=(view_t&& other) -> view_t& = default;
/// Applies the given visitor to perform pattern matching.
auto apply(const visitor_t& visitor) const -> void;
auto operator==(const view_t& other) const -> bool;
auto operator!=(const view_t& other) const -> bool;
/// Returns the internal underlying value.
auto inner() noexcept -> inner_t&;
auto inner() const noexcept -> const inner_t&;
private:
template<typename T>
auto construct(T&& value) -> void;
};
/// Retrieves a value of a specified, but yet restricted type, from a given attribute value.
template<typename T>
auto get(const value_t& value) ->
typename std::enable_if<boost::mpl::contains<value_t::types, T>::value, const T&>::type;
/// Retrieves a value of a specified, but yet restricted type, from a given attribute value view.
template<typename T>
auto get(const view_t& value) ->
typename std::enable_if<boost::mpl::contains<view_t::types, T>::value, const T&>::type;
} // namespace attribute
} // namespace blackhole
<commit_msg>docs(attribute): add another documentation pack<commit_after>#pragma once
#include <cstdint>
#include <string>
#include <type_traits>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/vector.hpp>
#include "blackhole/cpp17/string_view.hpp"
namespace blackhole {
/// Represents a trait for mapping an owned types to their associated lightweight view types.
///
/// By default all types are transparently mapped to itself, but Blackhole provides some
/// specializations.
///
/// \warning it is undefined behavior to add specializations for this trait.
template<typename T>
struct view_of {
typedef T type;
};
} // namespace blackhole
namespace blackhole {
namespace attribute {
class value_t;
class view_t;
/// Represents an attribute value holder.
///
/// Attribute value is an algebraic data type that can be initialized with one of six predefined
/// primitive types:
/// - none marker;
/// - boolean type (true or false);
/// - signed integer types up to 64-bit size;
/// - unsigned integer types up to 64-bit size;
/// - floating point type;
/// - and an owned string type.
///
/// The underlying value can be obtained through `blackhole::attribute::get` function with providing
/// the desired result type. For example:
/// blackhole::attribute::value_t value(42);
/// const auto actual = blackhole::attribute::get<std::int64_t>(value);
///
/// assert(42 == actual);
///
/// As an alternative a visitor pattern is provided for enabling underlying value visitation. To
/// enable this feature, implement the `value_t::visitor_t` interface and provide an instance of
/// this implementation to the `apply` method.
class value_t {
public:
/// Available types.
typedef std::nullptr_t null_type;
typedef bool bool_type;
typedef std::int64_t sint64_type;
typedef std::uint64_t uint64_type;
typedef double double_type;
typedef std::string string_type;
/// The type sequence of all available types.
typedef boost::mpl::vector<
null_type,
bool_type,
sint64_type,
uint64_type,
double_type,
string_type
> types;
/// Visitor interface.
class visitor_t {
public:
virtual ~visitor_t() = 0;
virtual auto operator()(const null_type&) -> void = 0;
virtual auto operator()(const bool_type&) -> void = 0;
virtual auto operator()(const sint64_type&) -> void = 0;
virtual auto operator()(const uint64_type&) -> void = 0;
virtual auto operator()(const double_type&) -> void = 0;
virtual auto operator()(const string_type&) -> void = 0;
};
struct inner_t;
private:
typedef std::aligned_storage<sizeof(std::string) + sizeof(int)>::type storage_type;
/// The underlying type.
storage_type storage;
public:
/// Constructs a null value containing tagged nullptr value.
value_t();
/// Constructs a value initialized with the given boolean value.
value_t(bool value);
/// Constructs a value initialized with the given signed integer.
value_t(char value);
value_t(short value);
value_t(int value);
value_t(long value);
value_t(long long value);
/// Constructs a value initialized with the given unsigned integer.
value_t(unsigned char value);
value_t(unsigned short value);
value_t(unsigned int value);
value_t(unsigned long value);
value_t(unsigned long long value);
value_t(double value);
/// Constructs a value from the given string literal not including the terminating null
/// character.
///
/// \note this overload is required to prevent implicit conversion literal values to bool.
template<std::size_t N>
value_t(const char(&value)[N]) { construct(string_type{value, N - 1}); }
value_t(std::string value);
~value_t();
value_t(const value_t& other);
value_t(value_t&& other);
auto operator=(const value_t& other) -> value_t&;
auto operator=(value_t&& other) -> value_t&;
/// Applies the given visitor to perform pattern matching.
auto apply(const visitor_t& visitor) const -> void;
/// Returns the internal underlying value.
auto inner() noexcept -> inner_t&;
auto inner() const noexcept -> const inner_t&;
private:
template<typename T>
auto construct(T&& value) -> void;
};
/// Represents an attribute value holder view, containing only lightweight views of the actual
/// values.
///
/// If an owned value is small enough to keep its copy - this class does it, otherwise keeping only
/// view proxy values. For example for `std::string` values there is a lightweight mapping that
/// holds only two members: a pointer to constant char and a size.
///
/// The underlying value can also be obtained through `blackhole::attribute::get` function with
/// providing the desired result type. For example:
/// blackhole::attribute::view_t value("le vinegret");
/// const auto actual = blackhole::attribute::get<std::int64_t>(value);
///
/// assert("le vinegret" == actual);
///
class view_t {
public:
/// Available types.
typedef std::nullptr_t null_type;
typedef bool bool_type;
typedef std::int64_t sint64_type;
typedef std::uint64_t uint64_type;
typedef double double_type;
typedef string_view string_type;
/// The type sequence of all available types.
typedef boost::mpl::vector<
null_type,
bool_type,
sint64_type,
uint64_type,
double_type,
string_type
> types;
/// Visitor interface.
class visitor_t {
public:
virtual ~visitor_t() = 0;
virtual auto operator()(const null_type&) -> void = 0;
virtual auto operator()(const bool_type&) -> void = 0;
virtual auto operator()(const sint64_type&) -> void = 0;
virtual auto operator()(const uint64_type&) -> void = 0;
virtual auto operator()(const double_type&) -> void = 0;
virtual auto operator()(const string_type&) -> void = 0;
};
struct inner_t;
private:
typedef std::aligned_storage<2 * sizeof(void*) + sizeof(int)>::type storage_type;
/// The underlying type.
storage_type storage;
public:
/// Constructs a null value view containing tagged nullptr value.
view_t();
/// Constructs a value view initialized with the given boolean value.
view_t(bool value);
/// Constructs a value view initialized with the given signed integer.
view_t(char value);
view_t(short value);
view_t(int value);
view_t(long value);
view_t(long long value);
/// Constructs a value view initialized with the given unsigned integer.
view_t(unsigned char value);
view_t(unsigned short value);
view_t(unsigned int value);
view_t(unsigned long value);
view_t(unsigned long long value);
/// Constructs a value view from the given floating point value.
view_t(double value);
/// Constructs a value view from the given string literal not including the terminating null
/// character.
///
/// \note this overload is required to prevent implicit conversion literal values to bool.
template<std::size_t N>
view_t(const char(&value)[N]) { construct(string_type{value, N - 1}); }
/// Constructs a value view from the given string view.
view_t(const string_type& value);
/// Constructs a value view from the given string.
view_t(const std::string& value);
/// Constructs a value view from the given owned attribute value.
view_t(const value_t& value);
view_t(const view_t& other) = default;
view_t(view_t&& other) = default;
~view_t() = default;
auto operator=(const view_t& other) -> view_t& = default;
auto operator=(view_t&& other) -> view_t& = default;
/// Applies the given visitor to perform pattern matching.
auto apply(const visitor_t& visitor) const -> void;
auto operator==(const view_t& other) const -> bool;
auto operator!=(const view_t& other) const -> bool;
/// Returns the internal underlying value.
auto inner() noexcept -> inner_t&;
auto inner() const noexcept -> const inner_t&;
private:
template<typename T>
auto construct(T&& value) -> void;
};
/// Retrieves a value of a specified, but yet restricted type, from a given attribute value.
///
/// \throws std::bad_cast if the content is not of the specified type T.
template<typename T>
auto get(const value_t& value) ->
typename std::enable_if<boost::mpl::contains<value_t::types, T>::value, const T&>::type;
/// Retrieves a value of a specified, but yet restricted type, from a given attribute value view.
///
/// \throws std::bad_cast if the content is not of the specified type T.
template<typename T>
auto get(const view_t& value) ->
typename std::enable_if<boost::mpl::contains<view_t::types, T>::value, const T&>::type;
} // namespace attribute
} // namespace blackhole
<|endoftext|>
|
<commit_before>#pragma once
#include <memory>
#include <ratio>
#include "blackhole/factory.hpp"
namespace blackhole {
inline namespace v1 {
namespace sink {
/// Represents a sink that writes formatted log events to the file or files located at the specified
/// path.
///
/// The path can contain attribute placeholders, meaning that the real destination name will be
/// deduced at runtime using provided log record. No real file will be opened at construction
/// time.
/// All files are opened by default in append mode meaning seek to the end of stream immediately
/// after open.
///
/// \note associated files will be opened on demand during the first write operation.
class file_t;
} // namespace sink
namespace experimental {
/// Represents a binary unit.
template<class Rep, class Ratio = std::ratio<1>>
class binary_unit;
/// Disable all fractional units.
template<class Rep, std::uintmax_t Denom>
class binary_unit<Rep, std::ratio<1, Denom>>;
template<class Rep>
class binary_unit<Rep, std::ratio<1>> {
public:
typedef Rep rep;
private:
rep value;
public:
constexpr binary_unit(rep value) noexcept :
value(value)
{}
constexpr auto count() const noexcept -> rep {
return value;
}
};
template<class Rep, class Ratio>
class binary_unit {
public:
typedef Rep rep;
private:
rep value;
public:
constexpr binary_unit(rep value) noexcept :
value(value)
{}
constexpr auto count() const noexcept -> rep {
return value;
}
constexpr operator binary_unit<std::uintmax_t>() noexcept {
return binary_unit<std::uintmax_t>(count() * Ratio::num);
}
};
typedef binary_unit<std::uintmax_t> bytes_t;
typedef binary_unit<std::uintmax_t, std::kilo> kilobytes_t;
typedef binary_unit<std::uintmax_t, std::mega> megabytes_t;
typedef binary_unit<std::uintmax_t, std::giga> gigabytes_t;
typedef binary_unit<std::uintmax_t, std::ratio<1024>> kibibytes_t;
typedef binary_unit<std::uintmax_t, std::ratio<1024 * 1024>> mibibytes_t;
typedef binary_unit<std::uintmax_t, std::ratio<1024 * 1024 * 1024>> gibibytes_t;
/// Represents a file sink builder to ease its configuration.
template<>
class builder<sink::file_t> {
class inner_t;
std::unique_ptr<inner_t, deleter_t> p;
public:
/// Constructs a file sink builder with the given file path pattern.
///
/// By default this builder will produce file sinks with automatic flush policy, which can be
/// changed using threshold methods.
explicit builder(const std::string& path);
/// Specifies flush threshold in terms of bytes written.
///
/// Logging backend will flush its internal buffers after at least every count bytes written,
/// but the underlying implementation can decide to do it more often.
///
/// \note setting zero value resets the policy with automatic mode.
///
/// \param bytes flush threshold.
auto flush_every(bytes_t bytes) & -> builder&;
auto flush_every(bytes_t bytes) && -> builder&&;
/// Specifies flush threshold in terms of number of logging events processed.
///
/// Logging backend will flush its internal buffers after at least every count writes, but the
/// underlying implementation can decide to do it more often.
///
/// \note setting zero value resets the policy with automatic mode.
///
/// \param events flush threshold.
auto flush_every(std::size_t events) & -> builder&;
auto flush_every(std::size_t events) && -> builder&&;
/// Consumes this builder returning a file sink.
auto build() && -> std::unique_ptr<sink_t>;
};
template<>
class factory<sink::file_t> : public factory<sink_t> {
public:
auto type() const noexcept -> const char*;
auto from(const config::node_t& config) const -> std::unique_ptr<sink_t>;
};
} // namespace experimental
} // namespace v1
} // namespace blackhole
<commit_msg>docs: extend the comment<commit_after>#pragma once
#include <memory>
#include <ratio>
#include "blackhole/factory.hpp"
namespace blackhole {
inline namespace v1 {
namespace sink {
/// Represents a sink that writes formatted log events to the file or files located at the specified
/// path.
///
/// The path can contain attribute placeholders, meaning that the real destination name will be
/// deduced at runtime using provided log record. No real file will be opened at construction
/// time.
/// All files are opened by default in append mode meaning seek to the end of stream immediately
/// after open.
///
/// \note associated files will be opened on demand during the first write operation.
class file_t;
} // namespace sink
namespace experimental {
/// Represents a binary unit.
template<class Rep, class Ratio = std::ratio<1>>
class binary_unit;
/// Disable all fractional units.
template<class Rep, std::uintmax_t Denom>
class binary_unit<Rep, std::ratio<1, Denom>>;
template<class Rep>
class binary_unit<Rep, std::ratio<1>> {
public:
typedef Rep rep;
private:
rep value;
public:
constexpr binary_unit(rep value) noexcept :
value(value)
{}
constexpr auto count() const noexcept -> rep {
return value;
}
};
template<class Rep, class Ratio>
class binary_unit {
public:
typedef Rep rep;
private:
rep value;
public:
constexpr binary_unit(rep value) noexcept :
value(value)
{}
constexpr auto count() const noexcept -> rep {
return value;
}
constexpr operator binary_unit<std::uintmax_t>() noexcept {
return binary_unit<std::uintmax_t>(count() * Ratio::num);
}
};
typedef binary_unit<std::uintmax_t> bytes_t;
typedef binary_unit<std::uintmax_t, std::kilo> kilobytes_t;
typedef binary_unit<std::uintmax_t, std::mega> megabytes_t;
typedef binary_unit<std::uintmax_t, std::giga> gigabytes_t;
typedef binary_unit<std::uintmax_t, std::ratio<1024>> kibibytes_t;
typedef binary_unit<std::uintmax_t, std::ratio<1024 * 1024>> mibibytes_t;
typedef binary_unit<std::uintmax_t, std::ratio<1024 * 1024 * 1024>> gibibytes_t;
/// Represents a file sink builder to ease its configuration.
template<>
class builder<sink::file_t> {
class inner_t;
std::unique_ptr<inner_t, deleter_t> p;
public:
/// Constructs a file sink builder with the given file path pattern.
///
/// By default this builder will produce file sinks with automatic flush policy, which can be
/// changed using threshold methods.
explicit builder(const std::string& path);
/// Specifies flush threshold in terms of bytes written.
///
/// Logging backend will flush its internal buffers after at least every count bytes written,
/// but the underlying implementation can decide to do it more often.
///
/// \note setting zero value resets the policy with automatic mode.
///
/// \param bytes flush threshold.
auto flush_every(bytes_t bytes) & -> builder&;
auto flush_every(bytes_t bytes) && -> builder&&;
/// Specifies flush threshold in terms of number of logging events processed.
///
/// Logging backend will flush its internal buffers after at least every count writes, but the
/// underlying implementation can decide to do it more often.
///
/// \note setting zero value resets the policy with automatic mode.
///
/// \param events flush threshold.
auto flush_every(std::size_t events) & -> builder&;
auto flush_every(std::size_t events) && -> builder&&;
/// Consumes this builder, returning a newly created file sink with the options configured.
auto build() && -> std::unique_ptr<sink_t>;
};
template<>
class factory<sink::file_t> : public factory<sink_t> {
public:
auto type() const noexcept -> const char*;
auto from(const config::node_t& config) const -> std::unique_ptr<sink_t>;
};
} // namespace experimental
} // namespace v1
} // namespace blackhole
<|endoftext|>
|
<commit_before>/*! \file bitset.hpp
\brief Support for types found in \<bitset\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of cereal nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BITSET_HPP_
#define CEREAL_TYPES_BITSET_HPP_
#include <cereal/cereal.hpp>
#include <bitset>
namespace cereal
{
namespace bitset_detail
{
//! The type the bitset is encoded with
/*! @internal */
enum class type : uint8_t
{
ulong,
ullong,
string,
bits
};
}
//! Serializing (save) for std::bitset when BinaryData optimization supported
template <class Archive, size_t N,
traits::EnableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
= traits::sfinae> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
{
ar( CEREAL_NVP_("type", bitset_detail::type::bits) );
// Serialize 8 bit chunks
std::uint8_t chunk = 0;
std::uint8_t mask = 0x80;
// Set each chunk using a rotating mask for the current bit
for( std::size_t i = 0; i < N; ++i )
{
if( bits[i] )
chunk |= mask;
mask >>= 1;
// output current chunk when mask is empty (8 bits)
if( mask == 0 )
{
ar( chunk );
chunk = 0;
mask = 0x80;
}
}
// serialize remainder, if it exists
if( mask != 0x80 )
ar( chunk );
}
//! Serializing (save) for std::bitset when BinaryData is not supported
template <class Archive, size_t N,
traits::DisableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
= traits::sfinae> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
{
try
{
auto const b = bits.to_ulong();
ar( CEREAL_NVP_("type", bitset_detail::type::ulong) );
ar( CEREAL_NVP_("data", b) );
}
catch( std::overflow_error const & )
{
try
{
auto const b = bits.to_ullong();
ar( CEREAL_NVP_("type", bitset_detail::type::ullong) );
ar( CEREAL_NVP_("data", b) );
}
catch( std::overflow_error const & )
{
ar( CEREAL_NVP_("type", bitset_detail::type::string) );
ar( CEREAL_NVP_("data", bits.to_string()) );
}
}
}
//! Serializing (load) for std::bitset
template <class Archive, size_t N> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::bitset<N> & bits )
{
bitset_detail::type t;
ar( CEREAL_NVP_("type", t) );
switch( t )
{
case bitset_detail::type::ulong:
{
unsigned long b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::ullong:
{
unsigned long long b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::string:
{
std::string b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::bits:
{
// Normally we would use BinaryData to route this at compile time,
// but doing this at runtime doesn't break any old serialization
std::uint8_t chunk = 0;
std::uint8_t mask = 0;
// Load one chunk at a time, rotating through the chunk
// to set bits in the bitset
for( std::size_t i = 0; i < N; ++i )
{
if( mask == 0 )
{
ar( chunk );
mask = 0x80;
}
if( chunk & mask )
bits[i] = 1;
mask >>= 1;
}
break;
}
default:
throw Exception("Invalid bitset data representation");
}
}
} // namespace cereal
#endif // CEREAL_TYPES_BITSET_HPP_
<commit_msg>add string include to bitset see #302<commit_after>/*! \file bitset.hpp
\brief Support for types found in \<bitset\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of cereal nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BITSET_HPP_
#define CEREAL_TYPES_BITSET_HPP_
#include <cereal/cereal.hpp>
#include <cereal/types/string.hpp>
#include <bitset>
namespace cereal
{
namespace bitset_detail
{
//! The type the bitset is encoded with
/*! @internal */
enum class type : uint8_t
{
ulong,
ullong,
string,
bits
};
}
//! Serializing (save) for std::bitset when BinaryData optimization supported
template <class Archive, size_t N,
traits::EnableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
= traits::sfinae> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
{
ar( CEREAL_NVP_("type", bitset_detail::type::bits) );
// Serialize 8 bit chunks
std::uint8_t chunk = 0;
std::uint8_t mask = 0x80;
// Set each chunk using a rotating mask for the current bit
for( std::size_t i = 0; i < N; ++i )
{
if( bits[i] )
chunk |= mask;
mask >>= 1;
// output current chunk when mask is empty (8 bits)
if( mask == 0 )
{
ar( chunk );
chunk = 0;
mask = 0x80;
}
}
// serialize remainder, if it exists
if( mask != 0x80 )
ar( chunk );
}
//! Serializing (save) for std::bitset when BinaryData is not supported
template <class Archive, size_t N,
traits::DisableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
= traits::sfinae> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
{
try
{
auto const b = bits.to_ulong();
ar( CEREAL_NVP_("type", bitset_detail::type::ulong) );
ar( CEREAL_NVP_("data", b) );
}
catch( std::overflow_error const & )
{
try
{
auto const b = bits.to_ullong();
ar( CEREAL_NVP_("type", bitset_detail::type::ullong) );
ar( CEREAL_NVP_("data", b) );
}
catch( std::overflow_error const & )
{
ar( CEREAL_NVP_("type", bitset_detail::type::string) );
ar( CEREAL_NVP_("data", bits.to_string()) );
}
}
}
//! Serializing (load) for std::bitset
template <class Archive, size_t N> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::bitset<N> & bits )
{
bitset_detail::type t;
ar( CEREAL_NVP_("type", t) );
switch( t )
{
case bitset_detail::type::ulong:
{
unsigned long b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::ullong:
{
unsigned long long b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::string:
{
std::string b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::bits:
{
// Normally we would use BinaryData to route this at compile time,
// but doing this at runtime doesn't break any old serialization
std::uint8_t chunk = 0;
std::uint8_t mask = 0;
// Load one chunk at a time, rotating through the chunk
// to set bits in the bitset
for( std::size_t i = 0; i < N; ++i )
{
if( mask == 0 )
{
ar( chunk );
mask = 0x80;
}
if( chunk & mask )
bits[i] = 1;
mask >>= 1;
}
break;
}
default:
throw Exception("Invalid bitset data representation");
}
}
} // namespace cereal
#endif // CEREAL_TYPES_BITSET_HPP_
<|endoftext|>
|
<commit_before>//=======================================================================
// Copyright (c) 2014-2016 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
/*!
* \file
* \brief BLAS implementation of the outer product
*/
#pragma once
#ifdef ETL_BLAS_MODE
#include "cblas.h"
#endif
namespace etl {
namespace impl {
namespace blas {
#ifdef ETL_BLAS_MODE
/*!
* \brief Compute the outer product of a and b and store the result in c
* \param a The lhs expression
* \param b The rhs expression
* \param c The output expression
*/
template <typename A, typename B, typename C, cpp_enable_if(all_dma<A, B, C>::value&& all_single_precision<A, B, C>::value)>
void outer(const A& a, const B& b, C&& c) {
c = 0;
cblas_sger(
CblasRowMajor,
etl::dim<0>(a), etl::dim<0>(b),
1.0,
a.memory_start(), 1,
b.memory_start(), 1,
c.memory_start(), etl::dim<0>(b));
}
/*!
* \copydoc outer
*/
template <typename A, typename B, typename C, cpp_enable_if(all_dma<A, B, C>::value&& all_double_precision<A, B, C>::value)>
void outer(const A& a, const B& b, C&& c) {
c = 0;
cblas_dger(
CblasRowMajor,
etl::dim<0>(a), etl::dim<0>(b),
1.0,
a.memory_start(), 1,
b.memory_start(), 1,
c.memory_start(), etl::dim<0>(b));
}
/*!
* \copydoc outer
*/
template <typename A, typename B, typename C, cpp_enable_if(!all_dma<A, B>::value)>
void outer(const A& /*a*/, const B& /*b*/, C&& /*c*/) {
cpp_unreachable("BLAS not enabled/available");
}
#else
/*!
* \copydoc outer
*/
template <typename A, typename B, typename C>
void outer(const A& /*a*/, const B& /*b*/, C&& /*c*/) {
cpp_unreachable("BLAS not enabled/available");
}
#endif
} //end of namespace blas
} //end of namespace impl
} //end of namespace etl
<commit_msg>Cleanup legacy code<commit_after>//=======================================================================
// Copyright (c) 2014-2016 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
// http://opensource.org/licenses/MIT)
//=======================================================================
/*!
* \file
* \brief BLAS implementation of the outer product
*/
#pragma once
#ifdef ETL_BLAS_MODE
#include "cblas.h"
#endif
namespace etl {
namespace impl {
namespace blas {
#ifdef ETL_BLAS_MODE
/*!
* \brief Compute the outer product of a and b and store the result in c
* \param a The lhs expression
* \param b The rhs expression
* \param c The output expression
*/
template <typename A, typename B, typename C, cpp_enable_if(all_single_precision<A, B, C>::value)>
void outer(const A& a, const B& b, C&& c) {
c = 0;
cblas_sger(
CblasRowMajor,
etl::dim<0>(a), etl::dim<0>(b),
1.0,
a.memory_start(), 1,
b.memory_start(), 1,
c.memory_start(), etl::dim<0>(b));
}
/*!
* \copydoc outer
*/
template <typename A, typename B, typename C, cpp_enable_if(all_double_precision<A, B, C>::value)>
void outer(const A& a, const B& b, C&& c) {
c = 0;
cblas_dger(
CblasRowMajor,
etl::dim<0>(a), etl::dim<0>(b),
1.0,
a.memory_start(), 1,
b.memory_start(), 1,
c.memory_start(), etl::dim<0>(b));
}
#else
/*!
* \copydoc outer
*/
template <typename A, typename B, typename C>
void outer(const A& /*a*/, const B& /*b*/, C&& /*c*/) {
cpp_unreachable("BLAS not enabled/available");
}
#endif
} //end of namespace blas
} //end of namespace impl
} //end of namespace etl
<|endoftext|>
|
<commit_before>/* _______ __ __ __ ______ __ __ _______ __ __
* / _____/\ / /\ / /\ / /\ / ____/\ / /\ / /\ / ___ /\ / |\/ /\
* / /\____\// / // / // / // /\___\// /_// / // /\_/ / // , |/ / /
* / / /__ / / // / // / // / / / ___ / // ___ / // /| ' / /
* / /_// /\ / /_// / // / // /_/_ / / // / // /\_/ / // / | / /
* /______/ //______/ //_/ //_____/\ /_/ //_/ //_/ //_/ //_/ /|_/ /
* \______\/ \______\/ \_\/ \_____\/ \_\/ \_\/ \_\/ \_\/ \_\/ \_\/
*
* Copyright (c) 2004 darkbits Js_./
* Per Larsson a.k.a finalman _RqZ{a<^_aa
* Olof Naessn a.k.a jansem/yakslem _asww7!uY`> )\a//
* _Qhm`] _f "'c 1!5m
* Visit: http://guichan.darkbits.org )Qk<P ` _: :+' .' "{[
* .)j(] .d_/ '-( P . S
* License: (BSD) <Td/Z <fP"5(\"??"\a. .L
* Redistribution and use in source and _dV>ws?a-?' ._/L #'
* binary forms, with or without )4d[#7r, . ' )d`)[
* modification, are permitted provided _Q-5'5W..j/?' -?!\)cam'
* that the following conditions are met: j<<WP+k/);. _W=j f
* 1. Redistributions of source code must .$%w\/]Q . ."' . mj$
* retain the above copyright notice, ]E.pYY(Q]>. a J@\
* this list of conditions and the j(]1u<sE"L,. . ./^ ]{a
* following disclaimer. 4'_uomm\. )L);-4 (3=
* 2. Redistributions in binary form must )_]X{Z('a_"a7'<a"a, ]"[
* reproduce the above copyright notice, #}<]m7`Za??4,P-"'7. ).m
* this list of conditions and the ]d2e)Q(<Q( ?94 b- LQ/
* following disclaimer in the <B!</]C)d_, '(<' .f. =C+m
* documentation and/or other materials .Z!=J ]e []('-4f _ ) -.)m]'
* provided with the distribution. .w[5]' _[ /.)_-"+? _/ <W"
* 3. Neither the name of Guichan nor the :$we` _! + _/ . j?
* names of its contributors may be used =3)= _f (_yQmWW$#( "
* to endorse or promote products derived - W, sQQQQmZQ#Wwa]..
* from this software without specific (js, \[QQW$QWW#?!V"".
* prior written permission. ]y:.<\.. .
* -]n w/ ' [.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT )/ )/ !
* HOLDERS AND CONTRIBUTORS "AS IS" AND ANY < (; sac , '
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, ]^ .- %
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF c < r
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR aga< <La
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 5% )P'-3L
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR _bQf` y`..)a
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, ,J?4P'.P"_(\?d'.,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES _Pa,)!f/<[]/ ?"
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT _2-..:. .r+_,.. .
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ?a.<%"' " -'.a_ _,
* 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 GCN_DEFAULTFONT_HPP
#define GCN_DEFAULTFONT_HPP
#include "guichan/font.hpp"
#include "guichan/platform.hpp"
namespace gcn
{
/**
* This is the ugly default font used by widgets by default.
*
*/
class DECLSPEC DefaultFont : public Font
{
public:
/**
* Destructor.
*/
virtual ~DefaultFont(){}
// Inherited from Font
virtual int getWidth(unsigned char glyph) const;
virtual int getHeight() const;
virtual int drawGlyph(Graphics* graphics, unsigned char glyph, int x, int y);
}; // end DefaultFont
} // end gcn
#endif // end GCN_DEFAULTFONT_HPP
<commit_msg>Removed drawGlyph and getWidth for glyphs. Added getStringIndexAt.<commit_after>/* _______ __ __ __ ______ __ __ _______ __ __
* / _____/\ / /\ / /\ / /\ / ____/\ / /\ / /\ / ___ /\ / |\/ /\
* / /\____\// / // / // / // /\___\// /_// / // /\_/ / // , |/ / /
* / / /__ / / // / // / // / / / ___ / // ___ / // /| ' / /
* / /_// /\ / /_// / // / // /_/_ / / // / // /\_/ / // / | / /
* /______/ //______/ //_/ //_____/\ /_/ //_/ //_/ //_/ //_/ /|_/ /
* \______\/ \______\/ \_\/ \_____\/ \_\/ \_\/ \_\/ \_\/ \_\/ \_\/
*
* Copyright (c) 2004 darkbits Js_./
* Per Larsson a.k.a finalman _RqZ{a<^_aa
* Olof Naessn a.k.a jansem/yakslem _asww7!uY`> )\a//
* _Qhm`] _f "'c 1!5m
* Visit: http://guichan.darkbits.org )Qk<P ` _: :+' .' "{[
* .)j(] .d_/ '-( P . S
* License: (BSD) <Td/Z <fP"5(\"??"\a. .L
* Redistribution and use in source and _dV>ws?a-?' ._/L #'
* binary forms, with or without )4d[#7r, . ' )d`)[
* modification, are permitted provided _Q-5'5W..j/?' -?!\)cam'
* that the following conditions are met: j<<WP+k/);. _W=j f
* 1. Redistributions of source code must .$%w\/]Q . ."' . mj$
* retain the above copyright notice, ]E.pYY(Q]>. a J@\
* this list of conditions and the j(]1u<sE"L,. . ./^ ]{a
* following disclaimer. 4'_uomm\. )L);-4 (3=
* 2. Redistributions in binary form must )_]X{Z('a_"a7'<a"a, ]"[
* reproduce the above copyright notice, #}<]m7`Za??4,P-"'7. ).m
* this list of conditions and the ]d2e)Q(<Q( ?94 b- LQ/
* following disclaimer in the <B!</]C)d_, '(<' .f. =C+m
* documentation and/or other materials .Z!=J ]e []('-4f _ ) -.)m]'
* provided with the distribution. .w[5]' _[ /.)_-"+? _/ <W"
* 3. Neither the name of Guichan nor the :$we` _! + _/ . j?
* names of its contributors may be used =3)= _f (_yQmWW$#( "
* to endorse or promote products derived - W, sQQQQmZQ#Wwa]..
* from this software without specific (js, \[QQW$QWW#?!V"".
* prior written permission. ]y:.<\.. .
* -]n w/ ' [.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT )/ )/ !
* HOLDERS AND CONTRIBUTORS "AS IS" AND ANY < (; sac , '
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, ]^ .- %
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF c < r
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR aga< <La
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 5% )P'-3L
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR _bQf` y`..)a
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, ,J?4P'.P"_(\?d'.,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES _Pa,)!f/<[]/ ?"
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT _2-..:. .r+_,.. .
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ?a.<%"' " -'.a_ _,
* 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 GCN_DEFAULTFONT_HPP
#define GCN_DEFAULTFONT_HPP
#include "guichan/font.hpp"
#include "guichan/platform.hpp"
namespace gcn
{
/**
* This is the ugly default font used by widgets by default.
*
*/
class DECLSPEC DefaultFont : public Font
{
public:
/**
* Destructor.
*/
virtual ~DefaultFont(){}
/**
* Draws a glyph.
*
* NOTE: You normally won't use this function to draw text since
* the Graphics class contains better functions for drawing
* text.
*
* @param graphics a graphics object to be used for drawing.
* @param glyph a glyph to draw.
* @param x the x coordinate where to draw the glyph.
* @param y the y coordinate where to draw the glyph.
* @return the width of the glyph in pixels.
* @see Graphics
*/
virtual int drawGlyph(Graphics* graphics, unsigned char glyph, int x, int y);
// Inherited from Font
virtual void drawString(Graphics* graphics, const std::string& text, int x, int y);
virtual int getWidth(const std::string& text) const;
virtual int getHeight() const;
virtual int getStringIndexAt(const std::string& text, int x);
}; // end DefaultFont
} // end gcn
#endif // end GCN_DEFAULTFONT_HPP
<|endoftext|>
|
<commit_before><commit_msg>Added error message<commit_after><|endoftext|>
|
<commit_before><commit_msg>Arranged the #pragma implementation directives.<commit_after><|endoftext|>
|
<commit_before>/*
* Copyright (c) 2015-2017, Technische Universität Dresden, Germany
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted
* provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions
* and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef INCLUDE_NITRO_FORMAT_FORMAT_HPP
#define INCLUDE_NITRO_FORMAT_FORMAT_HPP
#include <nitro/except/raise.hpp>
#include <cstdio>
#include <regex>
#include <sstream>
#include <string>
namespace nitro
{
namespace detail
{
template <class Char, class Traits = std::char_traits<Char>>
class formatter
{
using self = formatter;
public:
using string_type = std::basic_string<Char, Traits>;
using stream_type = std::basic_stringstream<Char, Traits>;
formatter(const string_type& format) : format_(format)
{
}
template <typename T>
self& operator%(T&& arg)
{
stream_type str;
str << std::forward<T>(arg);
args_.emplace_back(str.str());
return *this;
}
template <typename Arg, typename... Args>
self& args(Arg&& arg, Args&&... args)
{
(*this) % std::forward<Arg>(arg);
this->args(std::forward<Args>(args)...);
return *this;
}
self& args()
{
return *this;
}
string_type str() const
{
string_type result;
std::regex r("\\{\\}");
auto input = format_.begin();
auto placeholders_begin = std::sregex_iterator(format_.begin(), format_.end(), r);
auto placeholders_end = std::sregex_iterator();
auto placeholder = placeholders_begin;
for (auto it = args_.begin(); it != args_.end(); ++it, ++placeholder)
{
if (placeholder == placeholders_end)
{
raise("Provided more arguments than placeholders available in format string");
}
result.append(input, format_.begin() + placeholder->position());
input = format_.begin() + placeholder->position() + placeholder->length();
result.append(it->begin(), it->end());
}
result.append(input, format_.end());
if (placeholder != placeholders_end)
{
raise("Provided less arguments than placeholders needed in format string");
}
return result;
}
operator string_type() const
{
return str();
}
private:
string_type format_;
std::vector<string_type> args_;
};
template <class Char, class Traits = std::char_traits<Char>>
std::ostream& operator<<(std::ostream& s, const formatter<Char, Traits>& f)
{
return s << f.str();
}
} // namespace detail
using format_string = detail::formatter<std::string::value_type>;
template <class Char, class Traits>
inline auto format(const std::basic_string<Char, Traits>& format_str)
-> detail::formatter<Char, Traits>
{
return detail::formatter<Char, Traits>(format_str);
}
template <class Char>
inline auto format(const Char* format_str) -> detail::formatter<Char>
{
return detail::formatter<Char>(format_str);
}
} // namespace nitro
inline nitro::detail::formatter<char> operator""_nf(const char* format_str, std::size_t)
{
return nitro::detail::formatter<char>(format_str);
}
inline nitro::detail::formatter<char16_t> operator""_nf(const char16_t* format_str, std::size_t)
{
return nitro::detail::formatter<char16_t>(format_str);
}
inline nitro::detail::formatter<char32_t> operator""_nf(const char32_t* format_str, std::size_t)
{
return nitro::detail::formatter<char32_t>(format_str);
}
inline nitro::detail::formatter<wchar_t> operator""_nf(const wchar_t* format_str, std::size_t)
{
return nitro::detail::formatter<wchar_t>(format_str);
}
#endif // INCLUDE_NITRO_FORMAT_FORMAT_HPP
<commit_msg>Actually, I don't want to export this<commit_after>/*
* Copyright (c) 2015-2017, Technische Universität Dresden, Germany
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted
* provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions
* and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef INCLUDE_NITRO_FORMAT_FORMAT_HPP
#define INCLUDE_NITRO_FORMAT_FORMAT_HPP
#include <nitro/except/raise.hpp>
#include <cstdio>
#include <regex>
#include <sstream>
#include <string>
namespace nitro
{
namespace detail
{
template <class Char, class Traits = std::char_traits<Char>>
class formatter
{
using self = formatter;
public:
using string_type = std::basic_string<Char, Traits>;
using stream_type = std::basic_stringstream<Char, Traits>;
formatter(const string_type& format) : format_(format)
{
}
template <typename T>
self& operator%(T&& arg)
{
stream_type str;
str << std::forward<T>(arg);
args_.emplace_back(str.str());
return *this;
}
template <typename Arg, typename... Args>
self& args(Arg&& arg, Args&&... args)
{
(*this) % std::forward<Arg>(arg);
this->args(std::forward<Args>(args)...);
return *this;
}
self& args()
{
return *this;
}
string_type str() const
{
string_type result;
std::regex r("\\{\\}");
auto input = format_.begin();
auto placeholders_begin = std::sregex_iterator(format_.begin(), format_.end(), r);
auto placeholders_end = std::sregex_iterator();
auto placeholder = placeholders_begin;
for (auto it = args_.begin(); it != args_.end(); ++it, ++placeholder)
{
if (placeholder == placeholders_end)
{
raise("Provided more arguments than placeholders available in format string");
}
result.append(input, format_.begin() + placeholder->position());
input = format_.begin() + placeholder->position() + placeholder->length();
result.append(it->begin(), it->end());
}
result.append(input, format_.end());
if (placeholder != placeholders_end)
{
raise("Provided less arguments than placeholders needed in format string");
}
return result;
}
operator string_type() const
{
return str();
}
private:
string_type format_;
std::vector<string_type> args_;
};
template <class Char, class Traits = std::char_traits<Char>>
std::ostream& operator<<(std::ostream& s, const formatter<Char, Traits>& f)
{
return s << f.str();
}
} // namespace detail
template <class Char, class Traits>
inline auto format(const std::basic_string<Char, Traits>& format_str)
-> detail::formatter<Char, Traits>
{
return detail::formatter<Char, Traits>(format_str);
}
template <class Char>
inline auto format(const Char* format_str) -> detail::formatter<Char>
{
return detail::formatter<Char>(format_str);
}
} // namespace nitro
inline nitro::detail::formatter<char> operator""_nf(const char* format_str, std::size_t)
{
return nitro::detail::formatter<char>(format_str);
}
inline nitro::detail::formatter<char16_t> operator""_nf(const char16_t* format_str, std::size_t)
{
return nitro::detail::formatter<char16_t>(format_str);
}
inline nitro::detail::formatter<char32_t> operator""_nf(const char32_t* format_str, std::size_t)
{
return nitro::detail::formatter<char32_t>(format_str);
}
inline nitro::detail::formatter<wchar_t> operator""_nf(const wchar_t* format_str, std::size_t)
{
return nitro::detail::formatter<wchar_t>(format_str);
}
#endif // INCLUDE_NITRO_FORMAT_FORMAT_HPP
<|endoftext|>
|
<commit_before>// Licensed GNU LGPL v3 or later: http://www.gnu.org/licenses/lgpl.html
#include "clientapi.hh"
namespace Rapicorn {
uint64 uithread_bootup (int *argcp, char **argv, const StringVector &args);
static struct __StaticCTorTest { int v; __StaticCTorTest() : v (0x120caca0) { v += 0x300000; } } __staticctortest;
/**
* Initialize Rapicorn core via init_core(), and then starts a seperately
* running UI thread. This UI thread initializes all UI related components
* and the global Application object. After initialization, it enters the
* main event loop for UI processing.
* @param app_ident Identifier for this application, this is used to distinguish
* persistent application resources and window configurations
* from other applications.
* @param argcp Pointer to @a argc as passed into main().
* @param argv The @a argv argument as passed into main().
* @param args Internal initialization arguments, see init_core() for details.
*/
Application_SmartHandle
init_app (const String &app_ident,
int *argcp,
char **argv,
const StringVector &args)
{
// assert global_ctors work
if (__staticctortest.v != 0x123caca0)
fatal ("librapicornui: link error: C++ constructors have not been executed");
// initialize core
if (program_ident().empty())
init_core (app_ident, argcp, argv, args);
else if (app_ident != program_ident())
fatal ("librapicornui: application identifier changed during ui initialization");
// boot up UI thread
uint64 appid = uithread_bootup (argcp, argv, args);
assert (appid != 0);
// construct smart handle
Plic::FieldBuffer8 fb (1);
fb.add_int64 (appid);
Plic::FieldReader fbr (fb);
return Application_SmartHandle (fbr);
}
uint64
server_init_app (const String &app_ident,
int *argcp,
char **argv,
const StringVector &args)
{
Application_SmartHandle app = init_app (app_ident, argcp, argv, args);
return app._rpc_id();
}
/**
* This function calls shutdown_app() first, to properly terminate Rapicorn's
* concurrently running ui-thread, and then terminates the program via
* exit(3posix). This function does not return.
* @param status The exit status returned to the parent process.
*/
void
exit (int status)
{
exit (shutdown_app (status));
}
} // Rapicorn
#include "clientapi.cc"
#include <rcore/testutils.hh>
namespace Rapicorn {
void
init_test_app (const String &app_ident,
int *argcp,
char **argv,
const StringVector &args)
{
init_core_test (app_ident, argcp, argv, args);
init_app (app_ident, argcp, argv, args);
}
} // Rapicorn
<commit_msg>UI: provide Plic connection for client glue<commit_after>// Licensed GNU LGPL v3 or later: http://www.gnu.org/licenses/lgpl.html
#include "clientapi.hh"
namespace Rapicorn {
uint64 uithread_bootup (int *argcp, char **argv, const StringVector &args);
static struct __StaticCTorTest { int v; __StaticCTorTest() : v (0x120caca0) { v += 0x300000; } } __staticctortest;
/**
* Initialize Rapicorn core via init_core(), and then starts a seperately
* running UI thread. This UI thread initializes all UI related components
* and the global Application object. After initialization, it enters the
* main event loop for UI processing.
* @param app_ident Identifier for this application, this is used to distinguish
* persistent application resources and window configurations
* from other applications.
* @param argcp Pointer to @a argc as passed into main().
* @param argv The @a argv argument as passed into main().
* @param args Internal initialization arguments, see init_core() for details.
*/
Application_SmartHandle
init_app (const String &app_ident,
int *argcp,
char **argv,
const StringVector &args)
{
// assert global_ctors work
if (__staticctortest.v != 0x123caca0)
fatal ("librapicornui: link error: C++ constructors have not been executed");
// initialize core
if (program_ident().empty())
init_core (app_ident, argcp, argv, args);
else if (app_ident != program_ident())
fatal ("librapicornui: application identifier changed during ui initialization");
// boot up UI thread
uint64 appid = uithread_bootup (argcp, argv, args);
assert (appid != 0);
// construct smart handle
Plic::FieldBuffer8 fb (1);
fb.add_int64 (appid);
Plic::FieldReader fbr (fb);
return Application_SmartHandle (fbr);
}
uint64
server_init_app (const String &app_ident,
int *argcp,
char **argv,
const StringVector &args)
{
Application_SmartHandle app = init_app (app_ident, argcp, argv, args);
return app._rpc_id();
}
/**
* This function calls shutdown_app() first, to properly terminate Rapicorn's
* concurrently running ui-thread, and then terminates the program via
* exit(3posix). This function does not return.
* @param status The exit status returned to the parent process.
*/
void
exit (int status)
{
exit (shutdown_app (status));
}
} // Rapicorn
namespace { // Anon
static Plic::Connection *_clientglue_connection = NULL;
};
#define PLIC_CONNECTION() (*_clientglue_connection)
#include "clientapi.cc"
#include <rcore/testutils.hh>
namespace Rapicorn {
void
init_test_app (const String &app_ident,
int *argcp,
char **argv,
const StringVector &args)
{
return_if_fail (_clientglue_connection == NULL);
init_core_test (app_ident, argcp, argv, args);
init_app (app_ident, argcp, argv, args);
_clientglue_connection = uithread_connection();
}
} // Rapicorn
<|endoftext|>
|
<commit_before>#pragma once
#include <type_traits>
#include <utility>
namespace gcl::mp::type_traits
{
template <class T>
struct is_template : std::false_type {};
template <class... T_args, template <class...> class T>
struct is_template<T<T_args...>> : std::true_type {};
template <auto... values, template <auto...> class T>
struct is_template<T<values...>> : std::true_type {};
template <class T>
inline constexpr auto is_template_v = is_template<T>::value;
template <class T, class U>
struct is_same_template_type : std::false_type {};
template <template <class...> class T, class... T_args, class... U_args>
struct is_same_template_type<T<T_args...>, T<U_args...>> : std::true_type {};
template <template <auto...> class T, auto... T_values, auto... U_values>
struct is_same_template_type<T<T_values...>, T<U_values...>> : std::true_type {};
template <class T, class U>
inline constexpr auto is_same_template_type_v = is_same_template_type<T, U>::value;
template <typename T, typename = void>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, std::void_t<decltype(sizeof(T))>>
: std::true_type {};
template <typename T>
constexpr inline auto is_complete_v = is_complete<T>::value;
template <class T_concrete, template <class...> class T>
struct is_instance_of : std::false_type {};
template <template <class...> class T, class... T_args>
struct is_instance_of<T<T_args...>, T> : std::true_type {};
template <class T_concrete, template <class...> class T>
inline constexpr auto is_instance_of_v = is_instance_of<T_concrete, T>::value;
template <class T, typename... Args>
class is_brace_constructible {
template <typename /*= void*/, typename U, typename... U_args>
struct impl : std::false_type {};
template <typename U, typename... U_args>
struct impl<std::void_t<decltype(U{std::declval<U_args>()...})>, U, U_args...> : std::true_type {};
public:
constexpr inline static auto value = impl<std::void_t<>, T, Args...>::value;
};
template <class T, typename... Args>
constexpr inline auto is_brace_constructible_v = is_brace_constructible<T, Args...>::value;
template <bool evaluation>
using if_t = std::conditional_t<evaluation, std::true_type, std::false_type>;
template <bool evaluation>
constexpr inline auto if_v = std::conditional_t<evaluation, std::true_type, std::false_type>::value;
template <typename...>
struct dependent_false {
constexpr static auto value = false;
};
template <typename... args>
constexpr auto dependent_false_v = dependent_false<args...>::value;
template <template <typename> typename first_trait, template <typename> typename... traits>
struct merge_traits_t {
template <typename T>
using type = typename merge_traits_t<traits...>::template type<first_trait<T>>;
};
template <template <typename> typename first_trait>
struct merge_traits_t<first_trait> {
template <typename T>
using type = first_trait<T>;
};
template <template <typename> typename first_trait, template <typename> typename... traits>
struct merge_traits {
template <typename T>
using type = typename first_trait<typename merge_traits<traits...>::template type<T>>::type;
};
template <template <typename> typename first_trait>
struct merge_traits<first_trait> {
template <typename T>
using type = typename first_trait<T>::type;
};
template <template <typename...> class base_type, typename... Ts>
class partial {
// differs type instanciation with partial template-type parameters
template <typename... Us>
struct impl {
// workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59498
using type = base_type<Ts..., Us...>;
};
template <typename U>
struct impl<U> {
using type = base_type<Ts..., U>;
};
public:
template <typename... Us>
requires(sizeof...(Us) >= 1) using type = typename impl<Us...>::type;
};
template <template <typename...> class base_type, typename... Ts>
struct partial_t {
template <typename... Us>
using type = typename partial<base_type, Ts...>::template type<Us...>::type;
};
}
#include <bitset>
#include <tuple>
#include <array>
namespace gcl::mp::type_traits
{
template <template <typename> class trait, typename... Ts>
struct trait_result {
constexpr static inline auto as_bitset_v = []() consteval
{
using bitset_type = std::bitset<sizeof...(Ts)>;
using bitset_initializer_t = unsigned long long;
bitset_initializer_t value{0};
return bitset_type{((value = (value << 1 | trait<Ts>::value)), ...)};
}
();
// see gcl::mp::pack_traits::pack_arguments_as for other expansion/conversions
template <template <typename...> class T>
using as_t = T<typename trait<Ts>::type...>;
template <template <typename...> class T>
constexpr static inline auto as_v = T{trait<Ts>::value...};
using as_tuple_t = as_t<std::tuple>;
constexpr static inline auto as_tuple_v = std::tuple{trait<Ts>::value...};
template <class Int = int>
using as_integer_sequence = std::integer_sequence<Int, trait<Ts>::value...>;
// constexpr static auto as_array_v = std::array{trait<Ts>::value...}; // OK with GCC 10.2
using as_array_t = std::array<std::tuple_element_t<0, decltype(std::tuple{trait<Ts>::value...})>, sizeof...(Ts)>;
constexpr static inline auto as_array_v = as_array_t{trait<Ts>::value...};
};
}
#if defined(GCL_ENABLE_COMPILE_TIME_TESTS)
#include <string>
namespace gcl::mp::type_traits::tests::is_template
{
static_assert(gcl::mp::type_traits::is_template_v<std::tuple<int, char>>);
static_assert(gcl::mp::type_traits::is_template_v<std::string>); // std::basic_string<charT, allocator>
static_assert(not gcl::mp::type_traits::is_template_v<int>);
}
namespace gcl::mp::type_traits::tests::is_same_template_type
{
static_assert(gcl::mp::type_traits::is_same_template_type_v<std::tuple<int>, std::tuple<char, float>>);
}
namespace gcl::mp::type_traits::tests::is_complete
{
struct complete_type {};
struct incomplete_type;
static_assert(gcl::mp::type_traits::is_complete_v<complete_type>);
static_assert(gcl::mp::type_traits::is_complete_v<int>);
static_assert(not gcl::mp::type_traits::is_complete_v<incomplete_type>);
}
namespace gcl::mp::type_traits::tests::is_instance_of
{
static_assert(gcl::mp::type_traits::is_instance_of_v<std::tuple<int, char>, std::tuple>);
static_assert(not gcl::mp::type_traits::is_instance_of_v<std::tuple<int, char>, std::pair>);
}
namespace gcl::mp::type_traits::tests::is_brace_constructible_v
{
struct toto {
int i;
};
struct titi {
explicit titi(int) {}
};
static_assert(type_traits::is_brace_constructible_v<toto>);
static_assert(type_traits::is_brace_constructible_v<toto, int>);
static_assert(type_traits::is_brace_constructible_v<toto, char>);
static_assert(not type_traits::is_brace_constructible_v<toto, char*>);
static_assert(not type_traits::is_brace_constructible_v<titi>);
static_assert(type_traits::is_brace_constructible_v<titi, int>);
static_assert(type_traits::is_brace_constructible_v<titi, char>);
static_assert(not type_traits::is_brace_constructible_v<titi, char*>);
}
namespace gcl::mp::type_traits::tests::if_t
{
static_assert(std::is_same_v<type_traits::if_t<true>, std::true_type>);
static_assert(std::is_same_v<type_traits::if_t<false>, std::false_type>);
static_assert(type_traits::if_v<true> == true);
static_assert(type_traits::if_v<false> == false);
}
#include <concepts>
namespace gcl::mp::type_traits::tests::if_t
{
// clang-format off
template <typename T>
concept is_red_colored = requires(T)
{
//{ T::color == decltype(T::color)::red } -> std::convertible_to<bool>;
{ type_traits::if_t<T::color == decltype(T::color)::red>{}} -> std::same_as<std::true_type>;
// equivalent to : `requires (T::color == decltype(T::color)::red);`
};
enum colors { red, blue, green };
struct smthg_blue { constexpr static auto color = colors::blue; };
struct smthg_red { constexpr static auto color = colors::red; };
// clang-format on
static_assert(not is_red_colored<smthg_blue>);
static_assert(is_red_colored<smthg_red>);
}
namespace gcl::mp::type_traits::tests::merge_traits_t
{
using remove_cv_and_ref = gcl::mp::type_traits::merge_traits_t<std::remove_reference_t, std::decay_t>;
static_assert(std::is_same_v<int, remove_cv_and_ref::type<const int&&>>);
}
namespace gcl::mp::type_traits::tests::merge_traits
{
template <typename T>
using add_cvref_t =
gcl::mp::type_traits::merge_traits<std::add_lvalue_reference, std::add_const, std::add_volatile>::type<T>;
static_assert(std::is_same_v<add_cvref_t<int>, const volatile int&>);
}
namespace gcl::mp::type_traits::tests::trait_results
{
template <typename T>
using is_int = std::is_same<int, T>;
using results = trait_result<is_int, char, int, bool>;
// static_assert(decltype(results::as_bitset_v){2UL} == results::as_bitset_v); // std::bitset::operator== is not cx
constexpr auto expected_result_as_bitset = decltype(results::as_bitset_v){2UL};
static_assert(expected_result_as_bitset[0] == results::as_bitset_v[0]);
static_assert(expected_result_as_bitset[1] == results::as_bitset_v[1]);
static_assert(expected_result_as_bitset[2] == results::as_bitset_v[2]);
using results_as_tuple = results::as_t<std::tuple>;
#if not defined(__clang__)
// See my Q on SO :
// https://stackoverflow.com/questions/66821952/clang-error-implicit-instantiation-of-undefined-template-stdtuple-sizeauto/66822584
using results_as_tuple_value_type = std::decay_t<decltype(results::as_v<std::tuple>)>;
static_assert(std::tuple_size_v<results_as_tuple> == std::tuple_size_v<results_as_tuple_value_type>); // clang and clang-cl complain here
using expected_result_type = std::tuple<
std::false_type,
std::true_type,
std::false_type>;
static_assert(std::is_same_v<results_as_tuple, expected_result_type>);
using expected_result_value_type = std::tuple<bool, bool, bool>;
static_assert(std::is_same_v<results_as_tuple_value_type, expected_result_value_type>);
#endif
using expected_result_as_tuple = std::tuple<std::false_type, std::true_type, std::false_type>;
static_assert(std::is_same_v<results::as_t<std::tuple>, expected_result_as_tuple>);
static_assert(std::is_same_v<results::as_integer_sequence<int>, std::integer_sequence<int, 0, 1, 0>>);
static_assert(results::as_array_v == std::array{false, true, false});
template <typename... Ts>
struct type_pack {};
using results_as_type_pack = results::as_t<type_pack>;
using expected_result_as_type_pack = type_pack<std::false_type, std::true_type, std::false_type>;
static_assert(std::is_same_v<results_as_type_pack, expected_result_as_type_pack>);
}
namespace gcl::mp::type_traits::tests::dependent_false
{
constexpr auto qwe = []<typename T>() -> bool {
if constexpr (true)
;
else
static_assert(gcl::mp::type_traits::dependent_false_v<T>);
return {};
}. template operator()<int>();
}
namespace gcl::mp::type_traits::tests::partial
{
static_assert(gcl::mp::type_traits::partial<std::is_same, int>::type<int>::value);
static_assert(gcl::mp::type_traits::partial<std::is_same>::type<int, int>::value);
template <typename T>
using add_const_t = partial_t<std::add_const>::type<T>;
static_assert(std::is_same_v<add_const_t<int>, std::add_const_t<int>>);
}
#endif<commit_msg>[mp/type_traits] : is_same_cvref_qualifiers<commit_after>#pragma once
#include <type_traits>
#include <utility>
namespace gcl::mp::type_traits
{
template <class T>
struct is_template : std::false_type {};
template <class... T_args, template <class...> class T>
struct is_template<T<T_args...>> : std::true_type {};
template <auto... values, template <auto...> class T>
struct is_template<T<values...>> : std::true_type {};
template <class T>
inline constexpr auto is_template_v = is_template<T>::value;
template <class T, class U>
struct is_same_template_type : std::false_type {};
template <template <class...> class T, class... T_args, class... U_args>
struct is_same_template_type<T<T_args...>, T<U_args...>> : std::true_type {};
template <template <auto...> class T, auto... T_values, auto... U_values>
struct is_same_template_type<T<T_values...>, T<U_values...>> : std::true_type {};
template <class T, class U>
inline constexpr auto is_same_template_type_v = is_same_template_type<T, U>::value;
template <typename T, typename = void>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, std::void_t<decltype(sizeof(T))>>
: std::true_type {};
template <typename T>
constexpr inline auto is_complete_v = is_complete<T>::value;
template <class T_concrete, template <class...> class T>
struct is_instance_of : std::false_type {};
template <template <class...> class T, class... T_args>
struct is_instance_of<T<T_args...>, T> : std::true_type {};
template <class T_concrete, template <class...> class T>
inline constexpr auto is_instance_of_v = is_instance_of<T_concrete, T>::value;
template <typename T, typename U>
struct is_same_cvref_qualifiers {
constexpr static bool value =
(std::is_lvalue_reference_v<T> == std::is_lvalue_reference_v<U> and
std::is_rvalue_reference_v<T> == std::is_rvalue_reference_v<U> and
std::is_const_v<std::remove_reference_t<T>> == std::is_const_v<std::remove_reference_t<U>> and
std::is_volatile_v<std::remove_reference_t<T>> == std::is_volatile_v<std::remove_reference_t<U>>);
};
template <typename T, typename U>
constexpr bool is_same_cvref_qualifiers_v = is_same_cvref_qualifiers<T, U>::value;
template <class T, typename... Args>
class is_brace_constructible {
template <typename /*= void*/, typename U, typename... U_args>
struct impl : std::false_type {};
template <typename U, typename... U_args>
struct impl<std::void_t<decltype(U{std::declval<U_args>()...})>, U, U_args...> : std::true_type {};
public:
constexpr inline static auto value = impl<std::void_t<>, T, Args...>::value;
};
template <class T, typename... Args>
constexpr inline auto is_brace_constructible_v = is_brace_constructible<T, Args...>::value;
template <bool evaluation>
using if_t = std::conditional_t<evaluation, std::true_type, std::false_type>;
template <bool evaluation>
constexpr inline auto if_v = std::conditional_t<evaluation, std::true_type, std::false_type>::value;
template <typename...>
struct dependent_false {
constexpr static auto value = false;
};
template <typename... args>
constexpr auto dependent_false_v = dependent_false<args...>::value;
template <template <typename> typename first_trait, template <typename> typename... traits>
struct merge_traits_t {
template <typename T>
using type = typename merge_traits_t<traits...>::template type<first_trait<T>>;
};
template <template <typename> typename first_trait>
struct merge_traits_t<first_trait> {
template <typename T>
using type = first_trait<T>;
};
template <template <typename> typename first_trait, template <typename> typename... traits>
struct merge_traits {
template <typename T>
using type = typename first_trait<typename merge_traits<traits...>::template type<T>>::type;
};
template <template <typename> typename first_trait>
struct merge_traits<first_trait> {
template <typename T>
using type = typename first_trait<T>::type;
};
template <template <typename...> class base_type, typename... Ts>
class partial {
// differs type instanciation with partial template-type parameters
template <typename... Us>
struct impl {
// workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59498
using type = base_type<Ts..., Us...>;
};
template <typename U>
struct impl<U> {
using type = base_type<Ts..., U>;
};
public:
template <typename... Us>
requires(sizeof...(Us) >= 1) using type = typename impl<Us...>::type;
};
template <template <typename...> class base_type, typename... Ts>
struct partial_t {
template <typename... Us>
using type = typename partial<base_type, Ts...>::template type<Us...>::type;
};
}
#include <bitset>
#include <tuple>
#include <array>
namespace gcl::mp::type_traits
{
template <template <typename> class trait, typename... Ts>
struct trait_result {
constexpr static inline auto as_bitset_v = []() consteval
{
using bitset_type = std::bitset<sizeof...(Ts)>;
using bitset_initializer_t = unsigned long long;
bitset_initializer_t value{0};
return bitset_type{((value = (value << 1 | trait<Ts>::value)), ...)};
}
();
// see gcl::mp::pack_traits::pack_arguments_as for other expansion/conversions
template <template <typename...> class T>
using as_t = T<typename trait<Ts>::type...>;
template <template <typename...> class T>
constexpr static inline auto as_v = T{trait<Ts>::value...};
using as_tuple_t = as_t<std::tuple>;
constexpr static inline auto as_tuple_v = std::tuple{trait<Ts>::value...};
template <class Int = int>
using as_integer_sequence = std::integer_sequence<Int, trait<Ts>::value...>;
// constexpr static auto as_array_v = std::array{trait<Ts>::value...}; // OK with GCC 10.2
using as_array_t = std::array<std::tuple_element_t<0, decltype(std::tuple{trait<Ts>::value...})>, sizeof...(Ts)>;
constexpr static inline auto as_array_v = as_array_t{trait<Ts>::value...};
};
}
#if defined(GCL_ENABLE_COMPILE_TIME_TESTS)
#include <string>
namespace gcl::mp::type_traits::tests::is_template
{
static_assert(gcl::mp::type_traits::is_template_v<std::tuple<int, char>>);
static_assert(gcl::mp::type_traits::is_template_v<std::string>); // std::basic_string<charT, allocator>
static_assert(not gcl::mp::type_traits::is_template_v<int>);
}
namespace gcl::mp::type_traits::tests::is_same_template_type
{
static_assert(gcl::mp::type_traits::is_same_template_type_v<std::tuple<int>, std::tuple<char, float>>);
}
namespace gcl::mp::type_traits::tests::is_complete
{
struct complete_type {};
struct incomplete_type;
static_assert(gcl::mp::type_traits::is_complete_v<complete_type>);
static_assert(gcl::mp::type_traits::is_complete_v<int>);
static_assert(not gcl::mp::type_traits::is_complete_v<incomplete_type>);
}
namespace gcl::mp::type_traits::tests::is_instance_of
{
static_assert(gcl::mp::type_traits::is_instance_of_v<std::tuple<int, char>, std::tuple>);
static_assert(not gcl::mp::type_traits::is_instance_of_v<std::tuple<int, char>, std::pair>);
}
namespace gcl::mp::type_traits::tests::is_brace_constructible_v
{
struct toto {
int i;
};
struct titi {
explicit titi(int) {}
};
static_assert(type_traits::is_brace_constructible_v<toto>);
static_assert(type_traits::is_brace_constructible_v<toto, int>);
static_assert(type_traits::is_brace_constructible_v<toto, char>);
static_assert(not type_traits::is_brace_constructible_v<toto, char*>);
static_assert(not type_traits::is_brace_constructible_v<titi>);
static_assert(type_traits::is_brace_constructible_v<titi, int>);
static_assert(type_traits::is_brace_constructible_v<titi, char>);
static_assert(not type_traits::is_brace_constructible_v<titi, char*>);
}
namespace gcl::mp::type_traits::tests::if_t
{
static_assert(std::is_same_v<type_traits::if_t<true>, std::true_type>);
static_assert(std::is_same_v<type_traits::if_t<false>, std::false_type>);
static_assert(type_traits::if_v<true> == true);
static_assert(type_traits::if_v<false> == false);
}
#include <concepts>
namespace gcl::mp::type_traits::tests::if_t
{
// clang-format off
template <typename T>
concept is_red_colored = requires(T)
{
//{ T::color == decltype(T::color)::red } -> std::convertible_to<bool>;
{ type_traits::if_t<T::color == decltype(T::color)::red>{}} -> std::same_as<std::true_type>;
// equivalent to : `requires (T::color == decltype(T::color)::red);`
};
enum colors { red, blue, green };
struct smthg_blue { constexpr static auto color = colors::blue; };
struct smthg_red { constexpr static auto color = colors::red; };
// clang-format on
static_assert(not is_red_colored<smthg_blue>);
static_assert(is_red_colored<smthg_red>);
}
namespace gcl::mp::type_traits::tests::merge_traits_t
{
using remove_cv_and_ref = gcl::mp::type_traits::merge_traits_t<std::remove_reference_t, std::decay_t>;
static_assert(std::is_same_v<int, remove_cv_and_ref::type<const int&&>>);
}
namespace gcl::mp::type_traits::tests::merge_traits
{
template <typename T>
using add_cvref_t =
gcl::mp::type_traits::merge_traits<std::add_lvalue_reference, std::add_const, std::add_volatile>::type<T>;
static_assert(std::is_same_v<add_cvref_t<int>, const volatile int&>);
}
namespace gcl::mp::type_traits::tests::trait_results
{
template <typename T>
using is_int = std::is_same<int, T>;
using results = trait_result<is_int, char, int, bool>;
// static_assert(decltype(results::as_bitset_v){2UL} == results::as_bitset_v); // std::bitset::operator== is not cx
constexpr auto expected_result_as_bitset = decltype(results::as_bitset_v){2UL};
static_assert(expected_result_as_bitset[0] == results::as_bitset_v[0]);
static_assert(expected_result_as_bitset[1] == results::as_bitset_v[1]);
static_assert(expected_result_as_bitset[2] == results::as_bitset_v[2]);
using results_as_tuple = results::as_t<std::tuple>;
#if not defined(__clang__)
// See my Q on SO :
// https://stackoverflow.com/questions/66821952/clang-error-implicit-instantiation-of-undefined-template-stdtuple-sizeauto/66822584
using results_as_tuple_value_type = std::decay_t<decltype(results::as_v<std::tuple>)>;
static_assert(std::tuple_size_v<results_as_tuple> == std::tuple_size_v<results_as_tuple_value_type>); // clang and clang-cl complain here
using expected_result_type = std::tuple<
std::false_type,
std::true_type,
std::false_type>;
static_assert(std::is_same_v<results_as_tuple, expected_result_type>);
using expected_result_value_type = std::tuple<bool, bool, bool>;
static_assert(std::is_same_v<results_as_tuple_value_type, expected_result_value_type>);
#endif
using expected_result_as_tuple = std::tuple<std::false_type, std::true_type, std::false_type>;
static_assert(std::is_same_v<results::as_t<std::tuple>, expected_result_as_tuple>);
static_assert(std::is_same_v<results::as_integer_sequence<int>, std::integer_sequence<int, 0, 1, 0>>);
static_assert(results::as_array_v == std::array{false, true, false});
template <typename... Ts>
struct type_pack {};
using results_as_type_pack = results::as_t<type_pack>;
using expected_result_as_type_pack = type_pack<std::false_type, std::true_type, std::false_type>;
static_assert(std::is_same_v<results_as_type_pack, expected_result_as_type_pack>);
}
namespace gcl::mp::type_traits::tests::dependent_false
{
constexpr auto qwe = []<typename T>() -> bool {
if constexpr (true)
;
else
static_assert(gcl::mp::type_traits::dependent_false_v<T>);
return {};
}. template operator()<int>();
}
namespace gcl::mp::type_traits::tests::partial
{
static_assert(gcl::mp::type_traits::partial<std::is_same, int>::type<int>::value);
static_assert(gcl::mp::type_traits::partial<std::is_same>::type<int, int>::value);
template <typename T>
using add_const_t = partial_t<std::add_const>::type<T>;
static_assert(std::is_same_v<add_const_t<int>, std::add_const_t<int>>);
}
#endif<|endoftext|>
|
<commit_before><commit_msg>Unref queue2 on destroyPipeline<commit_after><|endoftext|>
|
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: embeddedobjectcontainer.hxx,v $
*
* $Revision: 1.9 $
*
* last change: $Author: rt $ $Date: 2005-10-19 12:47:36 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _COMPHELPER_OBJECTCONTAINER_HXX_
#define _COMPHELPER_OBJECTCONTAINER_HXX_
#ifndef _COM_SUN_STAR_UNO_REFERENCE_H_
#include <com/sun/star/uno/Reference.h>
#endif
#ifndef _COM_SUN_STAR_UNO_SEQUENCE_HXX_
#include <com/sun/star/uno/Sequence.hxx>
#endif
#ifndef _COM_SUN_STAR_EMBED_XEMBEDDEDOBJECT_HPP_
#include <com/sun/star/embed/XEmbeddedObject.hpp>
#endif
#ifndef _COM_SUN_STAR_EMBED_XSTORAGE_HPP_
#include <com/sun/star/embed/XStorage.hpp>
#endif
#ifndef _COM_SUN_STAR_IO_XINPUTSTREAM_HPP_
#include <com/sun/star/io/XInputStrem.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
#include <com/sun/star/beans/PropertyValue.hpp>
#endif
#ifndef INCLUDED_COMPHELPERDLLAPI_H
#include "comphelper/comphelperdllapi.h"
#endif
#include <rtl/ustring.hxx>
namespace comphelper
{
struct EmbedImpl;
class COMPHELPER_DLLPUBLIC EmbeddedObjectContainer
{
EmbedImpl* pImpl;
public:
// add an embedded object to the container storage
sal_Bool StoreEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString&, sal_Bool );
// add an embedded object that has been imported from the container storage - should only be called by filters!
void AddEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, const ::rtl::OUString& );
EmbeddedObjectContainer();
EmbeddedObjectContainer( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& );
~EmbeddedObjectContainer();
void SwitchPersistence( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& );
sal_Bool CommitImageSubStorage();
void ReleaseImageSubStorage();
::rtl::OUString CreateUniqueObjectName();
// get a list of object names that have been added so far
com::sun::star::uno::Sequence < ::rtl::OUString > GetObjectNames();
// check for existence of objects at all
sal_Bool HasEmbeddedObjects();
// check existence of an object - either by identity or by name
sal_Bool HasEmbeddedObject( const ::rtl::OUString& );
sal_Bool HasEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& );
// get the object name of an object - this is the persist name if the object has persistence
::rtl::OUString GetEmbeddedObjectName( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& );
// retrieve an embedded object by name that either has been added already or is available in the container storage
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject > GetEmbeddedObject( const ::rtl::OUString& );
// create an object from a ClassId
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
CreateEmbeddedObject( const com::sun::star::uno::Sequence < sal_Int8 >&, ::rtl::OUString& );
// insert an embedded object into the container - objects persistant representation will be added to the storage
sal_Bool InsertEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString& );
// load an embedded object from a MediaDescriptor and insert it into the container
// a new object will be created from the new content and returned
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
InsertEmbeddedObject( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, ::rtl::OUString& );
// create an embedded link based on a MediaDescriptor and insert it into the container
// a new object will be created from the new content and returned
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
InsertEmbeddedLink( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, ::rtl::OUString& );
// create an object from a stream that contains its persistent representation and insert it as usual (usually called from clipboard)
// a new object will be created from the new content and returned
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
InsertEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::io::XInputStream >&, ::rtl::OUString& );
// copy an embedded object into the storage
sal_Bool CopyEmbeddedObject( EmbeddedObjectContainer& rSrc, const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString& );
// copy an embedded object into the storage, open the new copy and return it
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject > CopyAndGetEmbeddedObject( EmbeddedObjectContainer& rSrc, const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& xObj, /* TODO const ::rtl::OUString& aOrigName,*/ ::rtl::OUString& rName );
// move an embedded object from one container to another one
sal_Bool MoveEmbeddedObject( EmbeddedObjectContainer& rSrc, const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString& );
// remove an embedded object from the container and from the storage; if object can't be closed
sal_Bool RemoveEmbeddedObject( const ::rtl::OUString& rName, sal_Bool bClose=sal_True );
sal_Bool RemoveEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, sal_Bool bClose=sal_True );
// close and remove an embedded object from the container without removing it from the storage
sal_Bool CloseEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& );
// move an embedded object to another container (keep the persistent name)
sal_Bool MoveEmbeddedObject( const ::rtl::OUString& rName, EmbeddedObjectContainer& );
// get the stored graphical representation for the object
com::sun::star::uno::Reference < com::sun::star::io::XInputStream > GetGraphicStream( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString* pMediaType=0 );
// get the stored graphical representation by the object name
com::sun::star::uno::Reference < com::sun::star::io::XInputStream > GetGraphicStream( const ::rtl::OUString& aName, ::rtl::OUString* pMediaType=0 );
// add a graphical representation for an object
sal_Bool InsertGraphicStream( const com::sun::star::uno::Reference < com::sun::star::io::XInputStream >& rStream, const ::rtl::OUString& rObjectName, const ::rtl::OUString& rMediaType );
// try to add a graphical representation for an object in optimized way ( might fail )
sal_Bool InsertGraphicStreamDirectly( const com::sun::star::uno::Reference < com::sun::star::io::XInputStream >& rStream, const ::rtl::OUString& rObjectName, const rtl::OUString& rMediaType );
// remove a graphical representation for an object
sal_Bool RemoveGraphicStream( const ::rtl::OUString& rObjectName );
// copy the graphical representation from different container
sal_Bool TryToCopyGraphReplacement( EmbeddedObjectContainer& rSrc,
const ::rtl::OUString& aOrigName,
const ::rtl::OUString& aTargetName );
void CloseEmbeddedObjects();
};
};
#endif
<commit_msg>INTEGRATION: CWS warnings01 (1.7.16); FILE MERGED 2005/11/07 18:37:13 pl 1.7.16.3: RESYNC: (1.8-1.9); FILE MERGED 2005/09/23 03:02:28 sb 1.7.16.2: RESYNC: (1.7-1.8); FILE MERGED 2005/09/08 13:16:47 sb 1.7.16.1: #i53898# Made code warning-free.<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: embeddedobjectcontainer.hxx,v $
*
* $Revision: 1.10 $
*
* last change: $Author: hr $ $Date: 2006-06-19 22:42:55 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _COMPHELPER_OBJECTCONTAINER_HXX_
#define _COMPHELPER_OBJECTCONTAINER_HXX_
#ifndef _COM_SUN_STAR_UNO_REFERENCE_H_
#include <com/sun/star/uno/Reference.h>
#endif
#ifndef _COM_SUN_STAR_UNO_SEQUENCE_HXX_
#include <com/sun/star/uno/Sequence.hxx>
#endif
#ifndef _COM_SUN_STAR_EMBED_XEMBEDDEDOBJECT_HPP_
#include <com/sun/star/embed/XEmbeddedObject.hpp>
#endif
#ifndef _COM_SUN_STAR_EMBED_XSTORAGE_HPP_
#include <com/sun/star/embed/XStorage.hpp>
#endif
#ifndef _COM_SUN_STAR_IO_XINPUTSTREAM_HPP_
#include <com/sun/star/io/XInputStrem.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
#include <com/sun/star/beans/PropertyValue.hpp>
#endif
#ifndef INCLUDED_COMPHELPERDLLAPI_H
#include "comphelper/comphelperdllapi.h"
#endif
#include <rtl/ustring.hxx>
namespace comphelper
{
struct EmbedImpl;
class COMPHELPER_DLLPUBLIC EmbeddedObjectContainer
{
EmbedImpl* pImpl;
public:
// add an embedded object to the container storage
sal_Bool StoreEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString&, sal_Bool );
// add an embedded object that has been imported from the container storage - should only be called by filters!
void AddEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, const ::rtl::OUString& );
EmbeddedObjectContainer();
EmbeddedObjectContainer( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& );
~EmbeddedObjectContainer();
void SwitchPersistence( const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& );
sal_Bool CommitImageSubStorage();
void ReleaseImageSubStorage();
::rtl::OUString CreateUniqueObjectName();
// get a list of object names that have been added so far
com::sun::star::uno::Sequence < ::rtl::OUString > GetObjectNames();
// check for existence of objects at all
sal_Bool HasEmbeddedObjects();
// check existence of an object - either by identity or by name
sal_Bool HasEmbeddedObject( const ::rtl::OUString& );
sal_Bool HasEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& );
// get the object name of an object - this is the persist name if the object has persistence
::rtl::OUString GetEmbeddedObjectName( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& );
// retrieve an embedded object by name that either has been added already or is available in the container storage
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject > GetEmbeddedObject( const ::rtl::OUString& );
// create an object from a ClassId
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
CreateEmbeddedObject( const com::sun::star::uno::Sequence < sal_Int8 >&, ::rtl::OUString& );
// insert an embedded object into the container - objects persistant representation will be added to the storage
sal_Bool InsertEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString& );
// load an embedded object from a MediaDescriptor and insert it into the container
// a new object will be created from the new content and returned
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
InsertEmbeddedObject( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, ::rtl::OUString& );
// create an embedded link based on a MediaDescriptor and insert it into the container
// a new object will be created from the new content and returned
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
InsertEmbeddedLink( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, ::rtl::OUString& );
// create an object from a stream that contains its persistent representation and insert it as usual (usually called from clipboard)
// a new object will be created from the new content and returned
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >
InsertEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::io::XInputStream >&, ::rtl::OUString& );
// copy an embedded object into the storage
sal_Bool CopyEmbeddedObject( EmbeddedObjectContainer& rSrc, const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString& );
// copy an embedded object into the storage, open the new copy and return it
::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject > CopyAndGetEmbeddedObject( EmbeddedObjectContainer& rSrc, const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& xObj, /* TODO const ::rtl::OUString& aOrigName,*/ ::rtl::OUString& rName );
// move an embedded object from one container to another one
sal_Bool MoveEmbeddedObject( EmbeddedObjectContainer& rSrc, const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString& );
// remove an embedded object from the container and from the storage; if object can't be closed
sal_Bool RemoveEmbeddedObject( const ::rtl::OUString& rName, sal_Bool bClose=sal_True );
sal_Bool RemoveEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, sal_Bool bClose=sal_True );
// close and remove an embedded object from the container without removing it from the storage
sal_Bool CloseEmbeddedObject( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >& );
// move an embedded object to another container (keep the persistent name)
sal_Bool MoveEmbeddedObject( const ::rtl::OUString& rName, EmbeddedObjectContainer& );
// get the stored graphical representation for the object
com::sun::star::uno::Reference < com::sun::star::io::XInputStream > GetGraphicStream( const ::com::sun::star::uno::Reference < ::com::sun::star::embed::XEmbeddedObject >&, ::rtl::OUString* pMediaType=0 );
// get the stored graphical representation by the object name
com::sun::star::uno::Reference < com::sun::star::io::XInputStream > GetGraphicStream( const ::rtl::OUString& aName, ::rtl::OUString* pMediaType=0 );
// add a graphical representation for an object
sal_Bool InsertGraphicStream( const com::sun::star::uno::Reference < com::sun::star::io::XInputStream >& rStream, const ::rtl::OUString& rObjectName, const ::rtl::OUString& rMediaType );
// try to add a graphical representation for an object in optimized way ( might fail )
sal_Bool InsertGraphicStreamDirectly( const com::sun::star::uno::Reference < com::sun::star::io::XInputStream >& rStream, const ::rtl::OUString& rObjectName, const rtl::OUString& rMediaType );
// remove a graphical representation for an object
sal_Bool RemoveGraphicStream( const ::rtl::OUString& rObjectName );
// copy the graphical representation from different container
sal_Bool TryToCopyGraphReplacement( EmbeddedObjectContainer& rSrc,
const ::rtl::OUString& aOrigName,
const ::rtl::OUString& aTargetName );
void CloseEmbeddedObjects();
};
}
#endif
<|endoftext|>
|
<commit_before>/*************************************************************************
*
* $RCSfile: options.hxx,v $
*
* $Revision: 1.4 $
*
* last change: $Author: rt $ $Date: 2004-09-08 16:26:49 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef _CODEMAKER_OPTIONS_HXX_
#define _CODEMAKER_OPTIONS_HXX_
#include <hash_map>
#ifndef _CODEMAKER_GLOBAL_HXX_
#include <codemaker/global.hxx>
#endif
#if defined( _MSC_VER ) && ( _MSC_VER < 1200 )
typedef ::std::__hash_map__
<
::rtl::OString,
::rtl::OString,
HashString,
EqualString,
NewAlloc
> OptionMap;
#else
typedef ::std::hash_map
<
::rtl::OString,
::rtl::OString,
HashString,
EqualString
> OptionMap;
#endif
class CannotDumpException
{
public:
CannotDumpException(const ::rtl::OString& msg)
: m_message(msg) {}
::rtl::OString m_message;
};
class IllegalArgument
{
public:
IllegalArgument(const ::rtl::OString& msg)
: m_message(msg) {}
::rtl::OString m_message;
};
class Options
{
public:
Options();
~Options();
virtual sal_Bool initOptions(int ac, char* av[], sal_Bool bCmdFile=sal_False)
throw( IllegalArgument ) = 0;
virtual ::rtl::OString prepareHelp() = 0;
const ::rtl::OString& getProgramName() const;
sal_uInt16 getNumberOfOptions() const;
sal_Bool isValid(const ::rtl::OString& option);
const ::rtl::OString getOption(const ::rtl::OString& option)
throw( IllegalArgument );
const OptionMap& getOptions();
sal_uInt16 getNumberOfInputFiles() const;
const ::rtl::OString getInputFile(sal_uInt16 index)
throw( IllegalArgument );
const StringVector& getInputFiles();
::rtl::OString getExtraInputFile(sal_uInt16 index) const throw( IllegalArgument );
inline sal_uInt16 getNumberOfExtraInputFiles() const
{ return (sal_uInt16)m_extra_input_files.size(); }
inline const StringVector& getExtraInputFiles() const
{ return m_extra_input_files; }
protected:
::rtl::OString m_program;
StringVector m_inputFiles;
StringVector m_extra_input_files;
OptionMap m_options;
};
#endif // _CODEMAKER_OPTIONS_HXX_
<commit_msg>INTEGRATION: CWS sdksample (1.3.102); FILE MERGED 2004/10/04 13:42:24 jsc 1.3.102.2: RESYNC: (1.3-1.4); FILE MERGED 2004/07/07 09:52:49 jsc 1.3.102.1: #i30954# adjusted to genrate dependent types fro cppu<commit_after>/*************************************************************************
*
* $RCSfile: options.hxx,v $
*
* $Revision: 1.5 $
*
* last change: $Author: rt $ $Date: 2005-01-31 15:27:04 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef _CODEMAKER_OPTIONS_HXX_
#define _CODEMAKER_OPTIONS_HXX_
#include <hash_map>
#ifndef _CODEMAKER_GLOBAL_HXX_
#include <codemaker/global.hxx>
#endif
#if defined( _MSC_VER ) && ( _MSC_VER < 1200 )
typedef ::std::__hash_map__
<
::rtl::OString,
::rtl::OString,
HashString,
EqualString,
NewAlloc
> OptionMap;
#else
typedef ::std::hash_map
<
::rtl::OString,
::rtl::OString,
HashString,
EqualString
> OptionMap;
#endif
class IllegalArgument
{
public:
IllegalArgument(const ::rtl::OString& msg)
: m_message(msg) {}
::rtl::OString m_message;
};
class Options
{
public:
Options();
~Options();
virtual sal_Bool initOptions(int ac, char* av[], sal_Bool bCmdFile=sal_False)
throw( IllegalArgument ) = 0;
virtual ::rtl::OString prepareHelp() = 0;
const ::rtl::OString& getProgramName() const;
sal_uInt16 getNumberOfOptions() const;
sal_Bool isValid(const ::rtl::OString& option);
const ::rtl::OString getOption(const ::rtl::OString& option)
throw( IllegalArgument );
const OptionMap& getOptions();
sal_uInt16 getNumberOfInputFiles() const;
const ::rtl::OString getInputFile(sal_uInt16 index)
throw( IllegalArgument );
const StringVector& getInputFiles();
::rtl::OString getExtraInputFile(sal_uInt16 index) const throw( IllegalArgument );
inline sal_uInt16 getNumberOfExtraInputFiles() const
{ return (sal_uInt16)m_extra_input_files.size(); }
inline const StringVector& getExtraInputFiles() const
{ return m_extra_input_files; }
protected:
::rtl::OString m_program;
StringVector m_inputFiles;
StringVector m_extra_input_files;
OptionMap m_options;
};
#endif // _CODEMAKER_OPTIONS_HXX_
<|endoftext|>
|
<commit_before>/** \file create_literary_remains_records.cc
* \author Dr. Johannes Ruscheinski
*
* A tool for creating literary remains MARC records from Beacon files.
*/
/*
Copyright (C) 2019, Library of the University of Tübingen
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unordered_map>
#include <unordered_set>
#include "FileUtil.h"
#include "MARC.h"
#include "StringUtil.h"
#include "TimeUtil.h"
#include "util.h"
namespace {
// Counts the number of religious studies title records for authors.
void CopyMarcAndCollectRelgiousStudiesFrequencies(MARC::Reader * const reader, MARC::Writer * const writer,
std::unordered_map<std::string, unsigned> * const author_ppn_to_relstudies_titles_count)
{
while (auto record = reader->read()) {
if (record.findTag("REL") != record.end()) {
for (const auto &author_name_and_author_ppn : record.getAllAuthorsAndPPNs()) {
auto author_ppn_and_count(author_ppn_to_relstudies_titles_count->find(author_name_and_author_ppn.second));
if (author_ppn_and_count == author_ppn_to_relstudies_titles_count->end())
(*author_ppn_to_relstudies_titles_count)[author_name_and_author_ppn.second] = 1;
else
++(author_ppn_and_count->second);
}
}
writer->write(record);
}
}
struct LiteraryRemainsInfo {
std::string author_name_;
std::string url_;
std::string source_name_;
std::string dates_;
public:
LiteraryRemainsInfo() = default;
LiteraryRemainsInfo(const LiteraryRemainsInfo &other) = default;
LiteraryRemainsInfo(const std::string &author_name, const std::string &url, const std::string &source_name, const std::string &dates)
: author_name_(author_name), url_(url), source_name_(source_name), dates_(dates) { }
LiteraryRemainsInfo &operator=(const LiteraryRemainsInfo &rhs) = default;
};
void LoadAuthorGNDNumbers(
const std::string &filename,
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> * const gnd_numbers_to_literary_remains_infos_map,
std::unordered_map<std::string, std::string> * const gnd_numbers_to_ppns_map)
{
auto reader(MARC::Reader::Factory(filename));
unsigned total_count(0), references_count(0);
while (auto record = reader->read()) {
++total_count;
auto beacon_field(record.findTag("BEA"));
if (beacon_field == record.end())
continue;
const auto _100_field(record.findTag("100"));
if (_100_field == record.end() or not _100_field->hasSubfield('a'))
continue;
std::string gnd_number;
if (not MARC::GetGNDCode(record, &gnd_number))
continue;
(*gnd_numbers_to_ppns_map)[gnd_number] = record.getControlNumber();
const auto numeration(_100_field->getFirstSubfieldWithCode('b'));
const auto titles_and_other_words_associated_with_a_name(_100_field->getFirstSubfieldWithCode('c'));
const auto name_and_numeration(_100_field->getFirstSubfieldWithCode('a') + (numeration.empty() ? "" : " " + numeration));
const auto author_name(not titles_and_other_words_associated_with_a_name.empty()
? name_and_numeration + " (" + titles_and_other_words_associated_with_a_name + ")"
: name_and_numeration);
const auto dates(_100_field->getFirstSubfieldWithCode('d'));
std::vector<LiteraryRemainsInfo> literary_remains_infos;
while (beacon_field != record.end() and beacon_field->getTag() == "BEA") {
literary_remains_infos.emplace_back(author_name, beacon_field->getFirstSubfieldWithCode('u'),
beacon_field->getFirstSubfieldWithCode('a'), dates);
++beacon_field;
}
(*gnd_numbers_to_literary_remains_infos_map)[gnd_number] = literary_remains_infos;
references_count += literary_remains_infos.size();
}
LOG_INFO("Loaded " + std::to_string(references_count) + " literary remains references from \"" + filename
+ "\" which contained a total of " + std::to_string(total_count) + " records.");
}
std::string NormaliseAuthorName(std::string author_name) {
const auto comma_pos(author_name.find(','));
if (comma_pos == std::string::npos)
return author_name;
std::string auxillary_info;
const auto open_paren_pos(author_name.find('('));
if (open_paren_pos != std::string::npos) {
if (comma_pos > open_paren_pos)
return author_name;
auxillary_info = " " + author_name.substr(open_paren_pos);
author_name.resize(open_paren_pos);
}
return StringUtil::TrimWhite(author_name.substr(comma_pos + 1)) + " " + StringUtil::TrimWhite(author_name.substr(0, comma_pos))
+ auxillary_info;
}
const unsigned RELIGIOUS_STUDIES_THRESHOLD(3); // We assume that authors that have at least this many religious studies
// titles are religious studies authors.
void AppendLiteraryRemainsRecords(
MARC::Writer * const writer,
const std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> &gnd_numbers_to_literary_remains_infos_map,
const std::unordered_map<std::string, std::string> &gnd_numbers_to_ppns_map,
const std::unordered_map<std::string, unsigned> &author_ppn_to_relstudies_titles_count)
{
unsigned creation_count(0);
for (const auto &gnd_numbers_and_literary_remains_infos : gnd_numbers_to_literary_remains_infos_map) {
MARC::Record new_record(MARC::Record::TypeOfRecord::MIXED_MATERIALS, MARC::Record::BibliographicLevel::COLLECTION,
"LR" + gnd_numbers_and_literary_remains_infos.first);
const std::string &author_name(gnd_numbers_and_literary_remains_infos.second.front().author_name_);
std::string dates(gnd_numbers_and_literary_remains_infos.second.front().dates_.empty()
? "" : " " + gnd_numbers_and_literary_remains_infos.second.front().dates_);
new_record.insertField("003", "PipeLineGenerated");
new_record.insertField("005", TimeUtil::GetCurrentDateAndTime("%Y%m%d%H%M%S") + ".0");
new_record.insertField("008", "190606s2019 xx ||||| 00| ||ger c");
if (gnd_numbers_and_literary_remains_infos.second.front().dates_.empty())
new_record.insertField("100", { { 'a', author_name }, { '0', "(DE-588)" + gnd_numbers_and_literary_remains_infos.first } });
else
new_record.insertField("100",
{ { 'a', author_name }, { '0', "(DE-588)" + gnd_numbers_and_literary_remains_infos.first },
{ 'd', gnd_numbers_and_literary_remains_infos.second.front().dates_ } });
new_record.insertField("245", { { 'a', "Nachlass von " + NormaliseAuthorName(author_name) + dates } });
for (const auto &literary_remains_info : gnd_numbers_and_literary_remains_infos.second)
new_record.insertField("856",
{ { 'u', literary_remains_info.url_ },
{ '3', "Nachlassdatenbank (" + literary_remains_info.source_name_ + ")" } });
// Do we have a religious studies author?
const auto gnd_number_and_author_ppn(gnd_numbers_to_ppns_map.find(gnd_numbers_and_literary_remains_infos.first));
if (unlikely(gnd_number_and_author_ppn == gnd_numbers_to_ppns_map.cend()))
LOG_ERROR("we should *always* find the GND number in gnd_numbers_to_ppns_map!");
const auto author_ppn_and_relstudies_titles_count(author_ppn_to_relstudies_titles_count.find(gnd_number_and_author_ppn->second));
if (author_ppn_and_relstudies_titles_count != author_ppn_to_relstudies_titles_count.cend()
and author_ppn_and_relstudies_titles_count->second >= RELIGIOUS_STUDIES_THRESHOLD)
new_record.insertField("REL", { { 'a', "1" } });
writer->write(new_record);
}
LOG_INFO("Appended a total of " + std::to_string(creation_count) + " record(s).");
}
} // unnamed namespace
int Main(int argc, char **argv) {
if (argc != 4)
::Usage("marc_input marc_output authority_records");
auto reader(MARC::Reader::Factory(argv[1]));
auto writer(MARC::Writer::Factory(argv[2]));
std::unordered_map<std::string, unsigned> author_ppn_to_relstudies_titles_count;
CopyMarcAndCollectRelgiousStudiesFrequencies(reader.get(), writer.get(), &author_ppn_to_relstudies_titles_count);
if (author_ppn_to_relstudies_titles_count.empty())
LOG_ERROR("You must run this program on an input that contains REL records!");
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> gnd_numbers_to_literary_remains_infos_map;
std::unordered_map<std::string, std::string> gnd_numbers_to_ppns_map;
LoadAuthorGNDNumbers(argv[3], &gnd_numbers_to_literary_remains_infos_map, &gnd_numbers_to_ppns_map);
AppendLiteraryRemainsRecords(writer.get(), gnd_numbers_to_literary_remains_infos_map, gnd_numbers_to_ppns_map,
author_ppn_to_relstudies_titles_count);
return EXIT_SUCCESS;
}
<commit_msg>Try a better strategy than having an absolute threshold.<commit_after>/** \file create_literary_remains_records.cc
* \author Dr. Johannes Ruscheinski
*
* A tool for creating literary remains MARC records from Beacon files.
*/
/*
Copyright (C) 2019, Library of the University of Tübingen
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unordered_map>
#include <unordered_set>
#include "FileUtil.h"
#include "MARC.h"
#include "StringUtil.h"
#include "TimeUtil.h"
#include "util.h"
namespace {
struct TitleRecordCounter {
unsigned total_count_;
unsigned religious_studies_count_;
public:
TitleRecordCounter(): total_count_(0), religious_studies_count_(0) { }
TitleRecordCounter(const TitleRecordCounter &other) = default;
TitleRecordCounter(const bool is_relevant_to_reigious_studies)
: total_count_(1), religious_studies_count_(is_relevant_to_reigious_studies ? 1 : 0) { }
inline bool exceedsReligiousStudiesThreshold() const
{ return 100.0 * static_cast<double>(religious_studies_count_) / static_cast<double>(total_count_) >= 10.0 /* percent */; }
};
// Counts the number of religious studies title records for authors.
void CopyMarcAndCollectRelgiousStudiesFrequencies(
MARC::Reader * const reader, MARC::Writer * const writer,
std::unordered_map<std::string, TitleRecordCounter> * const author_ppn_to_relstudies_title_counters)
{
while (auto record = reader->read()) {
const bool rel_tag_found(record.findTag("REL") != record.end());
for (const auto &author_name_and_author_ppn : record.getAllAuthorsAndPPNs()) {
auto author_ppn_and_counter(author_ppn_to_relstudies_title_counters->find(author_name_and_author_ppn.second));
if (author_ppn_and_counter == author_ppn_to_relstudies_title_counters->end())
(*author_ppn_to_relstudies_title_counters)[author_name_and_author_ppn.second] = TitleRecordCounter(rel_tag_found);
else {
++(author_ppn_and_counter->second.total_count_);
if (rel_tag_found)
++(author_ppn_and_counter->second.religious_studies_count_);
}
}
writer->write(record);
}
}
struct LiteraryRemainsInfo {
std::string author_name_;
std::string url_;
std::string source_name_;
std::string dates_;
public:
LiteraryRemainsInfo() = default;
LiteraryRemainsInfo(const LiteraryRemainsInfo &other) = default;
LiteraryRemainsInfo(const std::string &author_name, const std::string &url, const std::string &source_name, const std::string &dates)
: author_name_(author_name), url_(url), source_name_(source_name), dates_(dates) { }
LiteraryRemainsInfo &operator=(const LiteraryRemainsInfo &rhs) = default;
};
void LoadAuthorGNDNumbers(
MARC::Reader * const reader,
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> * const gnd_numbers_to_literary_remains_infos_map,
std::unordered_map<std::string, std::string> * const gnd_numbers_to_ppns_map)
{
unsigned total_count(0), references_count(0);
while (auto record = reader->read()) {
++total_count;
auto beacon_field(record.findTag("BEA"));
if (beacon_field == record.end())
continue;
const auto _100_field(record.findTag("100"));
if (_100_field == record.end() or not _100_field->hasSubfield('a'))
continue;
std::string gnd_number;
if (not MARC::GetGNDCode(record, &gnd_number))
continue;
(*gnd_numbers_to_ppns_map)[gnd_number] = record.getControlNumber();
const auto numeration(_100_field->getFirstSubfieldWithCode('b'));
const auto titles_and_other_words_associated_with_a_name(_100_field->getFirstSubfieldWithCode('c'));
const auto name_and_numeration(_100_field->getFirstSubfieldWithCode('a') + (numeration.empty() ? "" : " " + numeration));
const auto author_name(not titles_and_other_words_associated_with_a_name.empty()
? name_and_numeration + " (" + titles_and_other_words_associated_with_a_name + ")"
: name_and_numeration);
const auto dates(_100_field->getFirstSubfieldWithCode('d'));
std::vector<LiteraryRemainsInfo> literary_remains_infos;
while (beacon_field != record.end() and beacon_field->getTag() == "BEA") {
literary_remains_infos.emplace_back(author_name, beacon_field->getFirstSubfieldWithCode('u'),
beacon_field->getFirstSubfieldWithCode('a'), dates);
++beacon_field;
}
(*gnd_numbers_to_literary_remains_infos_map)[gnd_number] = literary_remains_infos;
references_count += literary_remains_infos.size();
}
LOG_INFO("Loaded " + std::to_string(references_count) + " literary remains references from \"" + reader->getPath()
+ "\" which contained a total of " + std::to_string(total_count) + " records.");
}
std::string NormaliseAuthorName(std::string author_name) {
const auto comma_pos(author_name.find(','));
if (comma_pos == std::string::npos)
return author_name;
std::string auxillary_info;
const auto open_paren_pos(author_name.find('('));
if (open_paren_pos != std::string::npos) {
if (comma_pos > open_paren_pos)
return author_name;
auxillary_info = " " + author_name.substr(open_paren_pos);
author_name.resize(open_paren_pos);
}
return StringUtil::TrimWhite(author_name.substr(comma_pos + 1)) + " " + StringUtil::TrimWhite(author_name.substr(0, comma_pos))
+ auxillary_info;
}
void AppendLiteraryRemainsRecords(
MARC::Writer * const writer,
const std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> &gnd_numbers_to_literary_remains_infos_map,
const std::unordered_map<std::string, std::string> &gnd_numbers_to_ppns_map,
const std::unordered_map<std::string, TitleRecordCounter> &author_ppn_to_relstudies_titles_counters)
{
unsigned creation_count(0);
for (const auto &gnd_numbers_and_literary_remains_infos : gnd_numbers_to_literary_remains_infos_map) {
MARC::Record new_record(MARC::Record::TypeOfRecord::MIXED_MATERIALS, MARC::Record::BibliographicLevel::COLLECTION,
"LR" + gnd_numbers_and_literary_remains_infos.first);
const std::string &author_name(gnd_numbers_and_literary_remains_infos.second.front().author_name_);
std::string dates(gnd_numbers_and_literary_remains_infos.second.front().dates_.empty()
? "" : " " + gnd_numbers_and_literary_remains_infos.second.front().dates_);
new_record.insertField("003", "PipeLineGenerated");
new_record.insertField("005", TimeUtil::GetCurrentDateAndTime("%Y%m%d%H%M%S") + ".0");
new_record.insertField("008", "190606s2019 xx ||||| 00| ||ger c");
if (gnd_numbers_and_literary_remains_infos.second.front().dates_.empty())
new_record.insertField("100", { { 'a', author_name }, { '0', "(DE-588)" + gnd_numbers_and_literary_remains_infos.first } });
else
new_record.insertField("100",
{ { 'a', author_name }, { '0', "(DE-588)" + gnd_numbers_and_literary_remains_infos.first },
{ 'd', gnd_numbers_and_literary_remains_infos.second.front().dates_ } });
new_record.insertField("245", { { 'a', "Nachlass von " + NormaliseAuthorName(author_name) + dates } });
for (const auto &literary_remains_info : gnd_numbers_and_literary_remains_infos.second)
new_record.insertField("856",
{ { 'u', literary_remains_info.url_ },
{ '3', "Nachlassdatenbank (" + literary_remains_info.source_name_ + ")" } });
// Do we have a religious studies author?
const auto gnd_number_and_author_ppn(gnd_numbers_to_ppns_map.find(gnd_numbers_and_literary_remains_infos.first));
if (unlikely(gnd_number_and_author_ppn == gnd_numbers_to_ppns_map.cend()))
LOG_ERROR("we should *always* find the GND number in gnd_numbers_to_ppns_map!");
const auto author_ppn_and_relstudies_titles_counter(
author_ppn_to_relstudies_titles_counters.find(gnd_number_and_author_ppn->second));
if (author_ppn_and_relstudies_titles_counter != author_ppn_to_relstudies_titles_counters.cend()
and author_ppn_and_relstudies_titles_counter->second.exceedsReligiousStudiesThreshold())
new_record.insertField("REL", { { 'a', "1" } });
writer->write(new_record);
}
LOG_INFO("Appended a total of " + std::to_string(creation_count) + " record(s).");
}
} // unnamed namespace
int Main(int argc, char **argv) {
if (argc != 5)
::Usage("marc_input marc_output authority_records_input authority_records_ouput");
auto title_reader(MARC::Reader::Factory(argv[1]));
auto title_writer(MARC::Writer::Factory(argv[2]));
std::unordered_map<std::string, TitleRecordCounter> author_ppn_to_relstudies_titles_counters;
CopyMarcAndCollectRelgiousStudiesFrequencies(title_reader.get(), title_writer.get(), &author_ppn_to_relstudies_titles_counters);
if (author_ppn_to_relstudies_titles_counters.empty())
LOG_ERROR("You must run this program on an input that contains REL records!");
auto authority_reader(MARC::Reader::Factory(argv[3]));
auto authority_writer(MARC::Writer::Factory(argv[4]));
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> gnd_numbers_to_literary_remains_infos_map;
std::unordered_map<std::string, std::string> gnd_numbers_to_ppns_map;
LoadAuthorGNDNumbers(authority_reader.get(), &gnd_numbers_to_literary_remains_infos_map, &gnd_numbers_to_ppns_map);
AppendLiteraryRemainsRecords(authority_writer.get(), gnd_numbers_to_literary_remains_infos_map, gnd_numbers_to_ppns_map,
author_ppn_to_relstudies_titles_counters);
return EXIT_SUCCESS;
}
<|endoftext|>
|
<commit_before>/** \file create_literary_remains_records.cc
* \author Dr. Johannes Ruscheinski
*
* A tool for creating literary remains MARC records from Beacon files.
*/
/*
Copyright (C) 2019, Library of the University of Tübingen
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unordered_map>
#include <unordered_set>
#include "MARC.h"
#include "StringUtil.h"
#include "util.h"
namespace {
void CopyMarc(MARC::Reader * const reader, MARC::Writer * const writer) {
while (auto record = reader->read())
writer->write(record);
}
struct LiteraryRemainsInfo {
std::string author_name_;
std::string url_;
public:
LiteraryRemainsInfo() = default;
LiteraryRemainsInfo(const LiteraryRemainsInfo &other) = default;
LiteraryRemainsInfo(const std::string &author_name, const std::string &url): author_name_(author_name), url_(url) { }
LiteraryRemainsInfo &operator=(const LiteraryRemainsInfo &rhs) = default;
};
void LoadAuthorGNDNumbers(
const std::string &filename,
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> * const gnd_numbers_to_literary_remains_infos_map)
{
auto reader(MARC::Reader::Factory(filename));
unsigned total_count(0), references_count(0);
while (auto record = reader->read()) {
++total_count;
auto beacon_field(record.findTag("BEA"));
if (beacon_field == record.end())
continue;
const auto _100_field(record.findTag("100"));
if (_100_field == record.end() or not _100_field->hasSubfield('a'))
continue;
std::string gnd_number;
if (not MARC::GetGNDCode(record, &gnd_number))
continue;
const std::string author_name(_100_field->getFirstSubfieldWithCode('a'));
std::vector<LiteraryRemainsInfo> literary_remains_infos;
while (beacon_field != record.end() and beacon_field->getTag() == "BEA") {
literary_remains_infos.emplace_back(author_name, beacon_field->getFirstSubfieldWithCode('u'));;
++beacon_field;
}
(*gnd_numbers_to_literary_remains_infos_map)[gnd_number] = literary_remains_infos;
references_count += literary_remains_infos.size();
}
LOG_INFO("Loaded " + std::to_string(references_count) + " literary remains references from \"" + filename
+ "\" which contained a total of " + std::to_string(total_count) + " records.");
}
void AppendLiteraryRemainsRecords(
MARC::Writer * const writer,
const std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> &gnd_numbers_to_literary_remains_infos_map)
{
unsigned creation_count(0);
for (const auto &gnd_numbers_and_literary_remains_infos : gnd_numbers_to_literary_remains_infos_map) {
MARC::Record new_record(MARC::Record::TypeOfRecord::MIXED_MATERIALS, MARC::Record::BibliographicLevel::COLLECTION,
"LR" + StringUtil::ToString(++creation_count, 10, 6));
const std::string &author_name(gnd_numbers_and_literary_remains_infos.second.front().author_name_);
new_record.insertField("100", { { 'a', author_name }, { '0', "(DE-588)" + gnd_numbers_and_literary_remains_infos.first } });
new_record.insertField("245", { { 'a', "Nachlass von " + author_name } });
for (const auto &literary_remains_info : gnd_numbers_and_literary_remains_infos.second)
new_record.insertField("856", { { 'u', literary_remains_info.url_ }, { '3', "Nachlassdatenbank" } });
writer->write(new_record);
}
LOG_INFO("Appended a total of " + std::to_string(creation_count) + " record(s).");
}
} // unnamed namespace
int Main(int argc, char **argv) {
if (argc != 4)
::Usage("marc_input marc_output authority_records");
auto reader(MARC::Reader::Factory(argv[1]));
auto writer(MARC::Writer::Factory(argv[2]));
CopyMarc(reader.get(), writer.get());
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> gnd_numbers_to_literary_remains_infos_map;
LoadAuthorGNDNumbers(argv[3], &gnd_numbers_to_literary_remains_infos_map);
AppendLiteraryRemainsRecords(writer.get(), gnd_numbers_to_literary_remains_infos_map);
return EXIT_SUCCESS;
}
<commit_msg>Fix space in control number problem.<commit_after>/** \file create_literary_remains_records.cc
* \author Dr. Johannes Ruscheinski
*
* A tool for creating literary remains MARC records from Beacon files.
*/
/*
Copyright (C) 2019, Library of the University of Tübingen
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unordered_map>
#include <unordered_set>
#include "MARC.h"
#include "StringUtil.h"
#include "util.h"
namespace {
void CopyMarc(MARC::Reader * const reader, MARC::Writer * const writer) {
while (auto record = reader->read())
writer->write(record);
}
struct LiteraryRemainsInfo {
std::string author_name_;
std::string url_;
public:
LiteraryRemainsInfo() = default;
LiteraryRemainsInfo(const LiteraryRemainsInfo &other) = default;
LiteraryRemainsInfo(const std::string &author_name, const std::string &url): author_name_(author_name), url_(url) { }
LiteraryRemainsInfo &operator=(const LiteraryRemainsInfo &rhs) = default;
};
void LoadAuthorGNDNumbers(
const std::string &filename,
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> * const gnd_numbers_to_literary_remains_infos_map)
{
auto reader(MARC::Reader::Factory(filename));
unsigned total_count(0), references_count(0);
while (auto record = reader->read()) {
++total_count;
auto beacon_field(record.findTag("BEA"));
if (beacon_field == record.end())
continue;
const auto _100_field(record.findTag("100"));
if (_100_field == record.end() or not _100_field->hasSubfield('a'))
continue;
std::string gnd_number;
if (not MARC::GetGNDCode(record, &gnd_number))
continue;
const std::string author_name(_100_field->getFirstSubfieldWithCode('a'));
std::vector<LiteraryRemainsInfo> literary_remains_infos;
while (beacon_field != record.end() and beacon_field->getTag() == "BEA") {
literary_remains_infos.emplace_back(author_name, beacon_field->getFirstSubfieldWithCode('u'));;
++beacon_field;
}
(*gnd_numbers_to_literary_remains_infos_map)[gnd_number] = literary_remains_infos;
references_count += literary_remains_infos.size();
}
LOG_INFO("Loaded " + std::to_string(references_count) + " literary remains references from \"" + filename
+ "\" which contained a total of " + std::to_string(total_count) + " records.");
}
void AppendLiteraryRemainsRecords(
MARC::Writer * const writer,
const std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> &gnd_numbers_to_literary_remains_infos_map)
{
unsigned creation_count(0);
for (const auto &gnd_numbers_and_literary_remains_infos : gnd_numbers_to_literary_remains_infos_map) {
MARC::Record new_record(MARC::Record::TypeOfRecord::MIXED_MATERIALS, MARC::Record::BibliographicLevel::COLLECTION,
"LR" + StringUtil::ToString(++creation_count, /* base = */10, /* width= */6, /* padding_char = */'0'));
const std::string &author_name(gnd_numbers_and_literary_remains_infos.second.front().author_name_);
new_record.insertField("100", { { 'a', author_name }, { '0', "(DE-588)" + gnd_numbers_and_literary_remains_infos.first } });
new_record.insertField("245", { { 'a', "Nachlass von " + author_name } });
for (const auto &literary_remains_info : gnd_numbers_and_literary_remains_infos.second)
new_record.insertField("856", { { 'u', literary_remains_info.url_ }, { '3', "Nachlassdatenbank" } });
writer->write(new_record);
}
LOG_INFO("Appended a total of " + std::to_string(creation_count) + " record(s).");
}
} // unnamed namespace
int Main(int argc, char **argv) {
if (argc != 4)
::Usage("marc_input marc_output authority_records");
auto reader(MARC::Reader::Factory(argv[1]));
auto writer(MARC::Writer::Factory(argv[2]));
CopyMarc(reader.get(), writer.get());
std::unordered_map<std::string, std::vector<LiteraryRemainsInfo>> gnd_numbers_to_literary_remains_infos_map;
LoadAuthorGNDNumbers(argv[3], &gnd_numbers_to_literary_remains_infos_map);
AppendLiteraryRemainsRecords(writer.get(), gnd_numbers_to_literary_remains_infos_map);
return EXIT_SUCCESS;
}
<|endoftext|>
|
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: dropdownboxtoolbarcontroller.cxx,v $
*
* $Revision: 1.3 $
*
* last change: $Author: obo $ $Date: 2006-09-16 14:19:05 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_framework.hxx"
#ifndef __FRAMEWORK_UIELEMENT_DROPDOWNBOXTOOLBARCONTROLLER_HXX
#include "uielement/dropdownboxtoolbarcontroller.hxx"
#endif
//_________________________________________________________________________________________________________________
// my own includes
//_________________________________________________________________________________________________________________
#ifndef __FRAMEWORK_TOOLBAR_HXX_
#include "uielement/toolbar.hxx"
#endif
//_________________________________________________________________________________________________________________
// interface includes
//_________________________________________________________________________________________________________________
#ifndef _COM_SUN_STAR_UTIL_XURLTRANSFORMER_HPP_
#include <com/sun/star/util/XURLTransformer.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XDISPATCHPROVIDER_HPP_
#include <com/sun/star/frame/XDispatchProvider.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
#include <com/sun/star/beans/PropertyValue.hpp>
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_STATUS_ITEMSTATUS_HPP_
#include <com/sun/star/frame/status/ItemStatus.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_STATUS_ITEMSTATE_HPP_
#include <com/sun/star/frame/status/ItemState.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_STATUS_VISIBILITY_HPP_
#include <com/sun/star/frame/status/Visibility.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XCONTROLNOTIFICATIONLISTENER_HPP_
#include <com/sun/star/frame/XControlNotificationListener.hpp>
#endif
//_________________________________________________________________________________________________________________
// other includes
//_________________________________________________________________________________________________________________
#ifndef _SVTOOLS_TOOLBOXCONTROLLER_HXX
#include <svtools/toolboxcontroller.hxx>
#endif
#ifndef _VOS_MUTEX_HXX_
#include <vos/mutex.hxx>
#endif
#ifndef _SV_SVAPP_HXX
#include <vcl/svapp.hxx>
#endif
#ifndef _VCL_MNEMONIC_HXX_
#include <vcl/mnemonic.hxx>
#endif
#include <tools/urlobj.hxx>
using namespace ::rtl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::awt;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::frame::status;
using namespace ::com::sun::star::util;
namespace framework
{
// ------------------------------------------------------------------
// Wrapper class to notify controller about events from ListBox.
// Unfortunaltly the events are notifed through virtual methods instead
// of Listeners.
class ListBoxControl : public ListBox
{
public:
ListBoxControl( Window* pParent, WinBits nStyle, IListBoxListener* pListBoxListener );
virtual ~ListBoxControl();
virtual void Select();
virtual void DoubleClick();
virtual void GetFocus();
virtual void LoseFocus();
virtual long PreNotify( NotifyEvent& rNEvt );
private:
IListBoxListener* m_pListBoxListener;
};
ListBoxControl::ListBoxControl( Window* pParent, WinBits nStyle, IListBoxListener* pListBoxListener ) :
ListBox( pParent, nStyle )
, m_pListBoxListener( pListBoxListener )
{
}
ListBoxControl::~ListBoxControl()
{
m_pListBoxListener = 0;
}
void ListBoxControl::Select()
{
ListBox::Select();
if ( m_pListBoxListener )
m_pListBoxListener->Select();
}
void ListBoxControl::DoubleClick()
{
ListBox::DoubleClick();
if ( m_pListBoxListener )
m_pListBoxListener->DoubleClick();
}
void ListBoxControl::GetFocus()
{
ListBox::GetFocus();
if ( m_pListBoxListener )
m_pListBoxListener->GetFocus();
}
void ListBoxControl::LoseFocus()
{
ListBox::LoseFocus();
if ( m_pListBoxListener )
m_pListBoxListener->LoseFocus();
}
long ListBoxControl::PreNotify( NotifyEvent& rNEvt )
{
long nRet( 0 );
if ( m_pListBoxListener )
nRet = m_pListBoxListener->PreNotify( rNEvt );
if ( nRet == 0 )
nRet = ListBox::PreNotify( rNEvt );
return nRet;
}
// ------------------------------------------------------------------
DropdownToolbarController::DropdownToolbarController(
const Reference< XMultiServiceFactory >& rServiceManager,
const Reference< XFrame >& rFrame,
ToolBar* pToolbar,
USHORT nID,
sal_Int32 nWidth,
const OUString& aCommand ) :
ComplexToolbarController( rServiceManager, rFrame, pToolbar, nID, aCommand )
, m_pListBoxControl( 0 )
{
m_pListBoxControl = new ListBoxControl( m_pToolbar, WB_DROPDOWN|WB_AUTOHSCROLL|WB_BORDER, this );
if ( nWidth == 0 )
nWidth = 100;
// default dropdown size
::Size aLogicalSize( 0, 160 );
::Size aPixelSize = m_pListBoxControl->LogicToPixel( aLogicalSize, MAP_APPFONT );
m_pListBoxControl->SetSizePixel( ::Size( nWidth, aPixelSize.Height() ));
m_pToolbar->SetItemWindow( m_nID, m_pListBoxControl );
m_pListBoxControl->SetDropDownLineCount( 5 );
}
// ------------------------------------------------------------------
DropdownToolbarController::~DropdownToolbarController()
{
}
// ------------------------------------------------------------------
void SAL_CALL DropdownToolbarController::dispose()
throw ( RuntimeException )
{
vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
m_pToolbar->SetItemWindow( m_nID, 0 );
delete m_pListBoxControl;
ComplexToolbarController::dispose();
m_pListBoxControl = 0;
}
// ------------------------------------------------------------------
void SAL_CALL DropdownToolbarController::execute( sal_Int16 KeyModifier )
throw ( RuntimeException )
{
Reference< XDispatch > xDispatch;
Reference< XURLTransformer > xURLTransformer;
OUString aCommandURL;
OUString aSelectedText;
::com::sun::star::util::URL aTargetURL;
{
vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
if ( m_bDisposed )
throw DisposedException();
if ( m_bInitialized &&
m_xFrame.is() &&
m_xServiceManager.is() &&
m_aCommandURL.getLength() )
{
xURLTransformer = m_xURLTransformer;
xDispatch = getDispatchFromCommand( m_aCommandURL );
aCommandURL = m_aCommandURL;
aTargetURL = getInitializedURL();
aSelectedText = m_pListBoxControl->GetText();
}
}
if ( xDispatch.is() && aTargetURL.Complete.getLength() > 0 )
{
Sequence<PropertyValue> aArgs( 2 );
// Add key modifier to argument list
aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "KeyModifier" ));
aArgs[0].Value <<= KeyModifier;
aArgs[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Text" ));
aArgs[1].Value <<= aSelectedText;
// Execute dispatch asynchronously
ExecuteInfo* pExecuteInfo = new ExecuteInfo;
pExecuteInfo->xDispatch = xDispatch;
pExecuteInfo->aTargetURL = aTargetURL;
pExecuteInfo->aArgs = aArgs;
Application::PostUserEvent( STATIC_LINK(0, ComplexToolbarController , ExecuteHdl_Impl), pExecuteInfo );
}
}
// ------------------------------------------------------------------
void DropdownToolbarController::Select()
{
if ( m_pListBoxControl->GetEntryCount() > 0 )
{
Window::PointerState aState = m_pListBoxControl->GetPointerState();
sal_uInt16 nKeyModifier = sal_uInt16( aState.mnState & KEY_MODTYPE );
execute( nKeyModifier );
}
}
void DropdownToolbarController::DoubleClick()
{
}
void DropdownToolbarController::GetFocus()
{
notifyFocusGet();
}
void DropdownToolbarController::LoseFocus()
{
notifyFocusLost();
}
long DropdownToolbarController::PreNotify( NotifyEvent& /*rNEvt*/ )
{
return 0;
}
// --------------------------------------------------------
void DropdownToolbarController::executeControlCommand( const ::com::sun::star::frame::ControlCommand& rControlCommand )
{
if ( rControlCommand.Command.equalsAsciiL( "SetList", 7 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "List", 4 ))
{
Sequence< OUString > aList;
m_pListBoxControl->Clear();
rControlCommand.Arguments[i].Value >>= aList;
for ( sal_Int32 j = 0; j < aList.getLength(); j++ )
m_pListBoxControl->InsertEntry( aList[j] );
m_pListBoxControl->SelectEntryPos( 0 );
// send notification
uno::Sequence< beans::NamedValue > aInfo( 1 );
aInfo[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "List" ));
aInfo[0].Value <<= aList;
addNotifyInfo( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ListChanged" )),
getDispatchFromCommand( m_aCommandURL ),
aInfo );
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "AddEntry", 8 ))
{
sal_uInt16 nPos( LISTBOX_APPEND );
rtl::OUString aText;
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Text", 4 ))
{
if ( rControlCommand.Arguments[i].Value >>= aText )
m_pListBoxControl->InsertEntry( aText, nPos );
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "InsertEntry", 11 ))
{
sal_uInt16 nPos( LISTBOX_APPEND );
rtl::OUString aText;
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Pos", 3 ))
{
sal_Int32 nTmpPos;
if ( rControlCommand.Arguments[i].Value >>= nTmpPos )
{
if (( nTmpPos >= 0 ) &&
( nTmpPos < sal_Int32( m_pListBoxControl->GetEntryCount() )))
nPos = sal_uInt16( nTmpPos );
}
}
else if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Text", 4 ))
rControlCommand.Arguments[i].Value >>= aText;
}
m_pListBoxControl->InsertEntry( aText, nPos );
}
else if ( rControlCommand.Command.equalsAsciiL( "RemoveEntryPos", 14 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Pos", 3 ))
{
sal_Int32 nPos( -1 );
if ( rControlCommand.Arguments[i].Value >>= nPos )
{
if ( nPos < sal_Int32( m_pListBoxControl->GetEntryCount() ))
m_pListBoxControl->RemoveEntry( sal_uInt16( nPos ));
}
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "RemoveEntryText", 15 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Text", 4 ))
{
rtl::OUString aText;
if ( rControlCommand.Arguments[i].Value >>= aText )
m_pListBoxControl->RemoveEntry( aText );
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "SetDropDownLines", 16 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Lines", 5 ))
{
sal_Int32 nValue( 5 );
rControlCommand.Arguments[i].Value >>= nValue;
m_pListBoxControl->SetDropDownLineCount( sal_uInt16( nValue ));
break;
}
}
}
}
} // namespace
<commit_msg>INTEGRATION: CWS pj65 (1.3.32); FILE MERGED 2006/10/31 14:05:55 pjanik 1.3.32.1: #i71027#: prevent warnings on Mac OS X with gcc 4.0.1.<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: dropdownboxtoolbarcontroller.cxx,v $
*
* $Revision: 1.4 $
*
* last change: $Author: vg $ $Date: 2006-11-21 17:21:39 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_framework.hxx"
#ifndef __FRAMEWORK_UIELEMENT_DROPDOWNBOXTOOLBARCONTROLLER_HXX
#include "uielement/dropdownboxtoolbarcontroller.hxx"
#endif
//_________________________________________________________________________________________________________________
// my own includes
//_________________________________________________________________________________________________________________
#ifndef __FRAMEWORK_TOOLBAR_HXX_
#include "uielement/toolbar.hxx"
#endif
//_________________________________________________________________________________________________________________
// interface includes
//_________________________________________________________________________________________________________________
#ifndef _COM_SUN_STAR_UTIL_XURLTRANSFORMER_HPP_
#include <com/sun/star/util/XURLTransformer.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XDISPATCHPROVIDER_HPP_
#include <com/sun/star/frame/XDispatchProvider.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
#include <com/sun/star/beans/PropertyValue.hpp>
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_STATUS_ITEMSTATUS_HPP_
#include <com/sun/star/frame/status/ItemStatus.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_STATUS_ITEMSTATE_HPP_
#include <com/sun/star/frame/status/ItemState.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_STATUS_VISIBILITY_HPP_
#include <com/sun/star/frame/status/Visibility.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XCONTROLNOTIFICATIONLISTENER_HPP_
#include <com/sun/star/frame/XControlNotificationListener.hpp>
#endif
//_________________________________________________________________________________________________________________
// other includes
//_________________________________________________________________________________________________________________
#ifndef _SVTOOLS_TOOLBOXCONTROLLER_HXX
#include <svtools/toolboxcontroller.hxx>
#endif
#ifndef _VOS_MUTEX_HXX_
#include <vos/mutex.hxx>
#endif
#ifndef _SV_SVAPP_HXX
#include <vcl/svapp.hxx>
#endif
#ifndef _VCL_MNEMONIC_HXX_
#include <vcl/mnemonic.hxx>
#endif
#include <tools/urlobj.hxx>
using namespace ::rtl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::awt;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::frame::status;
using namespace ::com::sun::star::util;
namespace framework
{
// ------------------------------------------------------------------
// Wrapper class to notify controller about events from ListBox.
// Unfortunaltly the events are notifed through virtual methods instead
// of Listeners.
class ListBoxControl : public ListBox
{
public:
ListBoxControl( Window* pParent, WinBits nStyle, IListBoxListener* pListBoxListener );
virtual ~ListBoxControl();
virtual void Select();
virtual void DoubleClick();
virtual void GetFocus();
virtual void LoseFocus();
virtual long PreNotify( NotifyEvent& rNEvt );
private:
IListBoxListener* m_pListBoxListener;
};
ListBoxControl::ListBoxControl( Window* pParent, WinBits nStyle, IListBoxListener* pListBoxListener ) :
ListBox( pParent, nStyle )
, m_pListBoxListener( pListBoxListener )
{
}
ListBoxControl::~ListBoxControl()
{
m_pListBoxListener = 0;
}
void ListBoxControl::Select()
{
ListBox::Select();
if ( m_pListBoxListener )
m_pListBoxListener->Select();
}
void ListBoxControl::DoubleClick()
{
ListBox::DoubleClick();
if ( m_pListBoxListener )
m_pListBoxListener->DoubleClick();
}
void ListBoxControl::GetFocus()
{
ListBox::GetFocus();
if ( m_pListBoxListener )
m_pListBoxListener->GetFocus();
}
void ListBoxControl::LoseFocus()
{
ListBox::LoseFocus();
if ( m_pListBoxListener )
m_pListBoxListener->LoseFocus();
}
long ListBoxControl::PreNotify( NotifyEvent& rNEvt )
{
long nRet( 0 );
if ( m_pListBoxListener )
nRet = m_pListBoxListener->PreNotify( rNEvt );
if ( nRet == 0 )
nRet = ListBox::PreNotify( rNEvt );
return nRet;
}
// ------------------------------------------------------------------
DropdownToolbarController::DropdownToolbarController(
const Reference< XMultiServiceFactory >& rServiceManager,
const Reference< XFrame >& rFrame,
ToolBar* pToolbar,
USHORT nID,
sal_Int32 nWidth,
const OUString& aCommand ) :
ComplexToolbarController( rServiceManager, rFrame, pToolbar, nID, aCommand )
, m_pListBoxControl( 0 )
{
m_pListBoxControl = new ListBoxControl( m_pToolbar, WB_DROPDOWN|WB_AUTOHSCROLL|WB_BORDER, this );
if ( nWidth == 0 )
nWidth = 100;
// default dropdown size
::Size aLogicalSize( 0, 160 );
::Size aPixelSize = m_pListBoxControl->LogicToPixel( aLogicalSize, MAP_APPFONT );
m_pListBoxControl->SetSizePixel( ::Size( nWidth, aPixelSize.Height() ));
m_pToolbar->SetItemWindow( m_nID, m_pListBoxControl );
m_pListBoxControl->SetDropDownLineCount( 5 );
}
// ------------------------------------------------------------------
DropdownToolbarController::~DropdownToolbarController()
{
}
// ------------------------------------------------------------------
void SAL_CALL DropdownToolbarController::dispose()
throw ( RuntimeException )
{
vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
m_pToolbar->SetItemWindow( m_nID, 0 );
delete m_pListBoxControl;
ComplexToolbarController::dispose();
m_pListBoxControl = 0;
}
// ------------------------------------------------------------------
void SAL_CALL DropdownToolbarController::execute( sal_Int16 KeyModifier )
throw ( RuntimeException )
{
Reference< XDispatch > xDispatch;
Reference< XURLTransformer > xURLTransformer;
OUString aCommandURL;
OUString aSelectedText;
::com::sun::star::util::URL aTargetURL;
{
vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
if ( m_bDisposed )
throw DisposedException();
if ( m_bInitialized &&
m_xFrame.is() &&
m_xServiceManager.is() &&
m_aCommandURL.getLength() )
{
xURLTransformer = m_xURLTransformer;
xDispatch = getDispatchFromCommand( m_aCommandURL );
aCommandURL = m_aCommandURL;
aTargetURL = getInitializedURL();
aSelectedText = m_pListBoxControl->GetText();
}
}
if ( xDispatch.is() && aTargetURL.Complete.getLength() > 0 )
{
Sequence<PropertyValue> aArgs( 2 );
// Add key modifier to argument list
aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "KeyModifier" ));
aArgs[0].Value <<= KeyModifier;
aArgs[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Text" ));
aArgs[1].Value <<= aSelectedText;
// Execute dispatch asynchronously
ExecuteInfo* pExecuteInfo = new ExecuteInfo;
pExecuteInfo->xDispatch = xDispatch;
pExecuteInfo->aTargetURL = aTargetURL;
pExecuteInfo->aArgs = aArgs;
Application::PostUserEvent( STATIC_LINK(0, ComplexToolbarController , ExecuteHdl_Impl), pExecuteInfo );
}
}
// ------------------------------------------------------------------
void DropdownToolbarController::Select()
{
if ( m_pListBoxControl->GetEntryCount() > 0 )
{
Window::PointerState aState = m_pListBoxControl->GetPointerState();
sal_uInt16 nKeyModifier = sal_uInt16( aState.mnState & KEY_MODTYPE );
execute( nKeyModifier );
}
}
void DropdownToolbarController::DoubleClick()
{
}
void DropdownToolbarController::GetFocus()
{
notifyFocusGet();
}
void DropdownToolbarController::LoseFocus()
{
notifyFocusLost();
}
long DropdownToolbarController::PreNotify( NotifyEvent& /*rNEvt*/ )
{
return 0;
}
// --------------------------------------------------------
void DropdownToolbarController::executeControlCommand( const ::com::sun::star::frame::ControlCommand& rControlCommand )
{
if ( rControlCommand.Command.equalsAsciiL( "SetList", 7 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "List", 4 ))
{
Sequence< OUString > aList;
m_pListBoxControl->Clear();
rControlCommand.Arguments[i].Value >>= aList;
for ( sal_Int32 j = 0; j < aList.getLength(); j++ )
m_pListBoxControl->InsertEntry( aList[j] );
m_pListBoxControl->SelectEntryPos( 0 );
// send notification
uno::Sequence< beans::NamedValue > aInfo( 1 );
aInfo[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "List" ));
aInfo[0].Value <<= aList;
addNotifyInfo( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ListChanged" )),
getDispatchFromCommand( m_aCommandURL ),
aInfo );
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "AddEntry", 8 ))
{
sal_uInt16 nPos( LISTBOX_APPEND );
rtl::OUString aText;
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Text", 4 ))
{
if ( rControlCommand.Arguments[i].Value >>= aText )
m_pListBoxControl->InsertEntry( aText, nPos );
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "InsertEntry", 11 ))
{
sal_uInt16 nPos( LISTBOX_APPEND );
rtl::OUString aText;
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Pos", 3 ))
{
sal_Int32 nTmpPos = 0;
if ( rControlCommand.Arguments[i].Value >>= nTmpPos )
{
if (( nTmpPos >= 0 ) &&
( nTmpPos < sal_Int32( m_pListBoxControl->GetEntryCount() )))
nPos = sal_uInt16( nTmpPos );
}
}
else if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Text", 4 ))
rControlCommand.Arguments[i].Value >>= aText;
}
m_pListBoxControl->InsertEntry( aText, nPos );
}
else if ( rControlCommand.Command.equalsAsciiL( "RemoveEntryPos", 14 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Pos", 3 ))
{
sal_Int32 nPos( -1 );
if ( rControlCommand.Arguments[i].Value >>= nPos )
{
if ( nPos < sal_Int32( m_pListBoxControl->GetEntryCount() ))
m_pListBoxControl->RemoveEntry( sal_uInt16( nPos ));
}
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "RemoveEntryText", 15 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Text", 4 ))
{
rtl::OUString aText;
if ( rControlCommand.Arguments[i].Value >>= aText )
m_pListBoxControl->RemoveEntry( aText );
break;
}
}
}
else if ( rControlCommand.Command.equalsAsciiL( "SetDropDownLines", 16 ))
{
for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
{
if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Lines", 5 ))
{
sal_Int32 nValue( 5 );
rControlCommand.Arguments[i].Value >>= nValue;
m_pListBoxControl->SetDropDownLineCount( sal_uInt16( nValue ));
break;
}
}
}
}
} // namespace
<|endoftext|>
|
<commit_before>/*
* Copyright (c) 2017-2018 ARM Limited.
*
* SPDX-License-Identifier: MIT
*
* 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 "armcl_graph_common.h"
#include <GraphUtils.h>
#include <utils/Utils.h>
using namespace arm_compute;
using namespace arm_compute::graph;
using namespace arm_compute::graph_utils;
#if defined(ARMCL_18_05_PLUS)
using namespace arm_compute::graph::frontend;
#endif
class CKInputAccessor : public ITensorAccessor {
public:
CKInputAccessor(const float *buffer, CKDataLayout data_layout): _buffer(buffer), _data_layout(data_layout) {}
CKInputAccessor(CKInputAccessor &&) = default;
bool access_tensor(ITensor &tensor) override {
const size_t W = tensor.info()->dimension(_data_layout == LAYOUT_NCHW ? 0 : 1);
const size_t C = tensor.info()->dimension(_data_layout == LAYOUT_NCHW ? 2 : 0);
Window window;
const TensorShape tensor_shape = tensor.info()->tensor_shape();
window.use_tensor_dimensions(tensor_shape);
// Source data layout is always NHWC
if (_data_layout == LAYOUT_NCHW) {
execute_window_loop(window, [&](const Coordinates & id) {
const size_t source_offset = (id[1] * W + id[0]) * C + id[2];
auto target_ptr = reinterpret_cast<float*>(tensor.ptr_to_element(id));
*target_ptr = _buffer[source_offset];
});
}
else { // LAYOUT_NHWC
execute_window_loop(window, [&](const Coordinates & id) {
const size_t source_offset = (id[2] * W + id[1]) * C + id[0];
auto target_ptr = reinterpret_cast<float*>(tensor.ptr_to_element(id));
*target_ptr = _buffer[source_offset];
});
}
return false;
}
private:
const float *_buffer;
CKDataLayout _data_layout;
};
class CKOutputAccessor : public ITensorAccessor {
public:
CKOutputAccessor(float* buffer): _buffer(buffer) {}
CKOutputAccessor(CKOutputAccessor &&) = default;
bool access_tensor(ITensor &tensor) override {
const size_t num_classes = tensor.info()->dimension(0);
float* probes = reinterpret_cast<float*>(tensor.buffer() + tensor.info()->offset_first_element_in_bytes());
std::copy(probes, probes + num_classes, _buffer);
return true;
}
private:
float* _buffer;
};
inline std::unique_ptr<ITensorAccessor> empty_accessor() {
return std::unique_ptr<ITensorAccessor>(nullptr);
}
void setup_mobilenet(GraphObject& graph,
unsigned int image_size,
float multiplier,
const std::string& weights_dir,
const float *input_data_buffer,
float *output_data_buffer,
CKDataLayout data_layout)
{
TensorShape input_shape = (data_layout == LAYOUT_NCHW) ?
TensorShape(image_size, image_size, 3U, 1U) :
TensorShape(3U, image_size, image_size, 1U);
auto weights_accessor = [&](const std::string &file) -> std::unique_ptr<ITensorAccessor> {
return arm_compute::support::cpp14::make_unique<NumPyBinLoader>(weights_dir + '/' + file);
};
auto get_dwsc_node = [&](std::string &¶m_path,
unsigned int conv_filt,
PadStrideInfo dwc_pad_stride_info,
PadStrideInfo conv_pad_stride_info) {
#if defined(ARMCL_18_05_PLUS)
SubStream sg(graph);
#else
SubGraph sg;
#endif
sg << DepthwiseConvolutionLayer(
3U, 3U,
weights_accessor(param_path + "_depthwise_depthwise_weights.npy"),
empty_accessor(),
dwc_pad_stride_info)
<< BatchNormalizationLayer(
weights_accessor(param_path + "_depthwise_BatchNorm_moving_mean.npy"),
weights_accessor(param_path + "_depthwise_BatchNorm_moving_variance.npy"),
weights_accessor(param_path + "_depthwise_BatchNorm_gamma.npy"),
weights_accessor(param_path + "_depthwise_BatchNorm_beta.npy"),
0.001f)
<< ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f))
<< ConvolutionLayer(
1U, 1U, static_cast<unsigned int>(conv_filt * multiplier),
weights_accessor(param_path + "_pointwise_weights.npy"),
empty_accessor(),
conv_pad_stride_info)
<< BatchNormalizationLayer(
weights_accessor(param_path + "_pointwise_BatchNorm_moving_mean.npy"),
weights_accessor(param_path + "_pointwise_BatchNorm_moving_variance.npy"),
weights_accessor(param_path + "_pointwise_BatchNorm_gamma.npy"),
weights_accessor(param_path + "_pointwise_BatchNorm_beta.npy"),
0.001f)
<< ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f));
return BranchLayer(std::move(sg));
};
auto target_hint = get_target_hint();
#if defined(ARMCL_18_08_PLUS)
TensorDescriptor tensor_descr(input_shape, DATATYPE, arm_compute::QuantizationInfo(),
(data_layout == LAYOUT_NCHW) ? arm_compute::DataLayout::NCHW : arm_compute::DataLayout::NHWC);
#elif defined(ARMCL_18_05_PLUS)
TensorDescriptor tensor_descr(input_shape, DATATYPE);
#endif
graph << target_hint
<< get_convolution_method()
#if defined(ARMCL_18_05_PLUS)
<< DepthwiseConvolutionMethod_OPTIMIZED_3x3
<< InputLayer(tensor_descr,
arm_compute::support::cpp14::make_unique<CKInputAccessor>(input_data_buffer, data_layout))
#else
<< arm_compute::graph::Tensor(TensorInfo(input_shape, 1, DATATYPE),
arm_compute::support::cpp14::make_unique<CKInputAccessor>(input_data_buffer, data_layout))
#endif
<< ConvolutionLayer(
3U, 3U, static_cast<unsigned int>(32 * multiplier),
weights_accessor("Conv2d_0_weights.npy"),
empty_accessor(),
PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR))
<< BatchNormalizationLayer(
weights_accessor("Conv2d_0_BatchNorm_moving_mean.npy"),
weights_accessor("Conv2d_0_BatchNorm_moving_variance.npy"),
weights_accessor("Conv2d_0_BatchNorm_gamma.npy"),
weights_accessor("Conv2d_0_BatchNorm_beta.npy"),
0.001f)
<< ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f))
<< get_dwsc_node("Conv2d_1", 64, PadStrideInfo(1, 1, 1, 1), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_2", 128, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_3", 128, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_4", 256, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_5", 256, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_6", 512, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_7", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_8", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_9", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_10", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_11", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_12", 1024, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_13", 1024, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< PoolingLayer(PoolingLayerInfo(PoolingType::AVG))
<< ConvolutionLayer(
1U, 1U, 1001U,
weights_accessor("Logits_Conv2d_1c_1x1_weights.npy"),
weights_accessor("Logits_Conv2d_1c_1x1_biases.npy"),
PadStrideInfo(1, 1, 0, 0))
<< ReshapeLayer(TensorShape(1001U))
<< SoftmaxLayer()
#if defined(ARMCL_18_05_PLUS)
<< OutputLayer(arm_compute::support::cpp14::make_unique<CKOutputAccessor>(output_data_buffer));
#else
<< arm_compute::graph::Tensor(arm_compute::support::cpp14::make_unique<CKOutputAccessor>(output_data_buffer));
#endif
#if defined(ARMCL_18_05_PLUS)
// Finalize graph
GraphConfig config {};
graph.finalize(target_hint, config);
#endif
}
<commit_msg>Remove whitespace from program:armcl-classification-mobilenet.<commit_after>/*
* Copyright (c) 2017-2018 ARM Limited.
*
* SPDX-License-Identifier: MIT
*
* 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 "armcl_graph_common.h"
#include <GraphUtils.h>
#include <utils/Utils.h>
using namespace arm_compute;
using namespace arm_compute::graph;
using namespace arm_compute::graph_utils;
#if defined(ARMCL_18_05_PLUS)
using namespace arm_compute::graph::frontend;
#endif
class CKInputAccessor : public ITensorAccessor {
public:
CKInputAccessor(const float *buffer, CKDataLayout data_layout): _buffer(buffer), _data_layout(data_layout) {}
CKInputAccessor(CKInputAccessor &&) = default;
bool access_tensor(ITensor &tensor) override {
const size_t W = tensor.info()->dimension(_data_layout == LAYOUT_NCHW ? 0 : 1);
const size_t C = tensor.info()->dimension(_data_layout == LAYOUT_NCHW ? 2 : 0);
Window window;
const TensorShape tensor_shape = tensor.info()->tensor_shape();
window.use_tensor_dimensions(tensor_shape);
// Source data layout is always NHWC
if (_data_layout == LAYOUT_NCHW) {
execute_window_loop(window, [&](const Coordinates & id) {
const size_t source_offset = (id[1] * W + id[0]) * C + id[2];
auto target_ptr = reinterpret_cast<float*>(tensor.ptr_to_element(id));
*target_ptr = _buffer[source_offset];
});
}
else { // LAYOUT_NHWC
execute_window_loop(window, [&](const Coordinates & id) {
const size_t source_offset = (id[2] * W + id[1]) * C + id[0];
auto target_ptr = reinterpret_cast<float*>(tensor.ptr_to_element(id));
*target_ptr = _buffer[source_offset];
});
}
return false;
}
private:
const float *_buffer;
CKDataLayout _data_layout;
};
class CKOutputAccessor : public ITensorAccessor {
public:
CKOutputAccessor(float* buffer): _buffer(buffer) {}
CKOutputAccessor(CKOutputAccessor &&) = default;
bool access_tensor(ITensor &tensor) override {
const size_t num_classes = tensor.info()->dimension(0);
float* probes = reinterpret_cast<float*>(tensor.buffer() + tensor.info()->offset_first_element_in_bytes());
std::copy(probes, probes + num_classes, _buffer);
return true;
}
private:
float* _buffer;
};
inline std::unique_ptr<ITensorAccessor> empty_accessor() {
return std::unique_ptr<ITensorAccessor>(nullptr);
}
void setup_mobilenet(GraphObject& graph,
unsigned int image_size,
float multiplier,
const std::string& weights_dir,
const float *input_data_buffer,
float *output_data_buffer,
CKDataLayout data_layout)
{
TensorShape input_shape = (data_layout == LAYOUT_NCHW) ?
TensorShape(image_size, image_size, 3U, 1U) :
TensorShape(3U, image_size, image_size, 1U);
auto weights_accessor = [&](const std::string &file) -> std::unique_ptr<ITensorAccessor> {
return arm_compute::support::cpp14::make_unique<NumPyBinLoader>(weights_dir + '/' + file);
};
auto get_dwsc_node = [&](std::string &¶m_path,
unsigned int conv_filt,
PadStrideInfo dwc_pad_stride_info,
PadStrideInfo conv_pad_stride_info) {
#if defined(ARMCL_18_05_PLUS)
SubStream sg(graph);
#else
SubGraph sg;
#endif
sg << DepthwiseConvolutionLayer(
3U, 3U,
weights_accessor(param_path + "_depthwise_depthwise_weights.npy"),
empty_accessor(),
dwc_pad_stride_info)
<< BatchNormalizationLayer(
weights_accessor(param_path + "_depthwise_BatchNorm_moving_mean.npy"),
weights_accessor(param_path + "_depthwise_BatchNorm_moving_variance.npy"),
weights_accessor(param_path + "_depthwise_BatchNorm_gamma.npy"),
weights_accessor(param_path + "_depthwise_BatchNorm_beta.npy"),
0.001f)
<< ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f))
<< ConvolutionLayer(
1U, 1U, static_cast<unsigned int>(conv_filt * multiplier),
weights_accessor(param_path + "_pointwise_weights.npy"),
empty_accessor(),
conv_pad_stride_info)
<< BatchNormalizationLayer(
weights_accessor(param_path + "_pointwise_BatchNorm_moving_mean.npy"),
weights_accessor(param_path + "_pointwise_BatchNorm_moving_variance.npy"),
weights_accessor(param_path + "_pointwise_BatchNorm_gamma.npy"),
weights_accessor(param_path + "_pointwise_BatchNorm_beta.npy"),
0.001f)
<< ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f));
return BranchLayer(std::move(sg));
};
auto target_hint = get_target_hint();
#if defined(ARMCL_18_08_PLUS)
TensorDescriptor tensor_descr(input_shape, DATATYPE, arm_compute::QuantizationInfo(),
(data_layout == LAYOUT_NCHW) ? arm_compute::DataLayout::NCHW : arm_compute::DataLayout::NHWC);
#elif defined(ARMCL_18_05_PLUS)
TensorDescriptor tensor_descr(input_shape, DATATYPE);
#endif
graph << target_hint
<< get_convolution_method()
#if defined(ARMCL_18_05_PLUS)
<< DepthwiseConvolutionMethod_OPTIMIZED_3x3
<< InputLayer(tensor_descr,
arm_compute::support::cpp14::make_unique<CKInputAccessor>(input_data_buffer, data_layout))
#else
<< arm_compute::graph::Tensor(TensorInfo(input_shape, 1, DATATYPE),
arm_compute::support::cpp14::make_unique<CKInputAccessor>(input_data_buffer, data_layout))
#endif
<< ConvolutionLayer(
3U, 3U, static_cast<unsigned int>(32 * multiplier),
weights_accessor("Conv2d_0_weights.npy"),
empty_accessor(),
PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR))
<< BatchNormalizationLayer(
weights_accessor("Conv2d_0_BatchNorm_moving_mean.npy"),
weights_accessor("Conv2d_0_BatchNorm_moving_variance.npy"),
weights_accessor("Conv2d_0_BatchNorm_gamma.npy"),
weights_accessor("Conv2d_0_BatchNorm_beta.npy"),
0.001f)
<< ActivationLayer(ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::BOUNDED_RELU, 6.f))
<< get_dwsc_node("Conv2d_1", 64, PadStrideInfo(1, 1, 1, 1), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_2", 128, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_3", 128, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_4", 256, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_5", 256, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_6", 512, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_7", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_8", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_9", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_10", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_11", 512, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_12", 1024, PadStrideInfo(2, 2, 0, 1, 0, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< get_dwsc_node("Conv2d_13", 1024, PadStrideInfo(1, 1, 1, 1, 1, 1, DimensionRoundingType::FLOOR), PadStrideInfo(1, 1, 0, 0))
<< PoolingLayer(PoolingLayerInfo(PoolingType::AVG))
<< ConvolutionLayer(
1U, 1U, 1001U,
weights_accessor("Logits_Conv2d_1c_1x1_weights.npy"),
weights_accessor("Logits_Conv2d_1c_1x1_biases.npy"),
PadStrideInfo(1, 1, 0, 0))
<< ReshapeLayer(TensorShape(1001U))
<< SoftmaxLayer()
#if defined(ARMCL_18_05_PLUS)
<< OutputLayer(arm_compute::support::cpp14::make_unique<CKOutputAccessor>(output_data_buffer));
#else
<< arm_compute::graph::Tensor(arm_compute::support::cpp14::make_unique<CKOutputAccessor>(output_data_buffer));
#endif
#if defined(ARMCL_18_05_PLUS)
// Finalize graph
GraphConfig config {};
graph.finalize(target_hint, config);
#endif
}
<|endoftext|>
|
<commit_before>// Copyright 2017 Nest Labs, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "nltest.h"
#include "test_statictypedallocator.h"
#include "statictypedallocator-lite.hpp"
#include <typeinfo>
#define SUITE_DECLARATION(name, test_ptr) { #name, test_ptr, setup_##name, teardown_##name }
using namespace DetectorGraph;
static int setup_statictypedallocator(void *inContext)
{
return 0;
}
static int teardown_statictypedallocator(void *inContext)
{
return 0;
}
// Helper Types used in this tests.
struct SomeBase { virtual ~SomeBase() { } };
template<class T> struct SomeChild : public SomeBase
{
static int instanceCount;
SomeChild(const T& d) : data(d) { instanceCount++; }
SomeChild(const SomeChild& other) : data(other.data) { instanceCount++; }
~SomeChild() { instanceCount--; }
T data;
};
struct TopicStateA { TopicStateA(int arg) : a(arg) {} int a; };
struct TopicStateB { TopicStateB(int arg) : b(arg) {} int b; };
struct TopicStateC { TopicStateC(int arg) : c(arg) {} int c; };
template<>
int SomeChild<TopicStateA>::instanceCount = 0;
template<>
int SomeChild<TopicStateB>::instanceCount = 0;
template<>
int SomeChild<TopicStateC>::instanceCount = 0;
static void Test_StoreOneType(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
SomeBase* basePtr = allocator.New(SomeChild<TopicStateA>(TopicStateA(42)));
allocator.Delete(basePtr);
SomeChild<TopicStateA>* childPtr = static_cast< SomeChild<TopicStateA>* >(basePtr);
NL_TEST_ASSERT(inSuite, childPtr->data.a == 42);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
}
static void Test_StoreMultiple(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
SomeBase* basePtrA = allocator.New(SomeChild<TopicStateA>(73));
SomeBase* basePtrB = allocator.New(SomeChild<TopicStateB>(83));
NL_TEST_ASSERT(inSuite, basePtrA != basePtrB);
SomeChild<TopicStateA>* childPtrA = static_cast< SomeChild<TopicStateA>* >(basePtrA);
SomeChild<TopicStateB>* childPtrB = static_cast< SomeChild<TopicStateB>* >(basePtrB);
NL_TEST_ASSERT(inSuite, childPtrA->data.a == 73);
NL_TEST_ASSERT(inSuite, childPtrB->data.b == 83);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
}
static void Test_Reuse(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
SomeBase* basePtr;
basePtr = allocator.New(SomeChild<TopicStateA>(TopicStateA(666)));
allocator.Delete(basePtr);
basePtr = allocator.New(SomeChild<TopicStateA>(TopicStateA(999)));
SomeChild<TopicStateA>* childPtr = static_cast< SomeChild<TopicStateA>* >(basePtr);
NL_TEST_ASSERT(inSuite, childPtr->data.a == 999);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
}
static void Test_DeleteMiddle(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
allocator.New(SomeChild<TopicStateA>(0));
SomeBase* basePtrB = allocator.New(SomeChild<TopicStateB>(1000));
allocator.New(SomeChild<TopicStateC>(0));
allocator.Delete(basePtrB);
basePtrB = allocator.New(SomeChild<TopicStateB>(1001));
SomeChild<TopicStateB>* childPtr = static_cast< SomeChild<TopicStateB>* >(basePtrB);
NL_TEST_ASSERT(inSuite, childPtr->data.b == 1001);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateC>::instanceCount == 0);
}
static void Test_DeleteLast(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
allocator.New(SomeChild<TopicStateA>(0));
allocator.New(SomeChild<TopicStateB>(0));
SomeBase* basePtrC = allocator.New(SomeChild<TopicStateC>(1000));
allocator.Delete(basePtrC);
basePtrC = allocator.New(SomeChild<TopicStateC>(1001));
SomeChild<TopicStateC>* childPtr = static_cast< SomeChild<TopicStateC>* >(basePtrC);
NL_TEST_ASSERT(inSuite, childPtr->data.c == 1001);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateC>::instanceCount == 0);
}
static void Test_MultipleInstances(nlTestSuite *inSuite, void *inContext)
{
{
struct One {};
StaticTypedAllocator<SomeBase, One > allocatorOne;
struct Two {};
StaticTypedAllocator<SomeBase, Two > allocatorTwo;
SomeBase* basePtrOne = allocatorOne.New(SomeChild<TopicStateA>(1));
SomeBase* basePtrTwo = allocatorTwo.New(SomeChild<TopicStateA>(2));
SomeChild<TopicStateA>* childPtrOne = static_cast< SomeChild<TopicStateA>* >(basePtrOne);
SomeChild<TopicStateA>* childPtrTwo = static_cast< SomeChild<TopicStateA>* >(basePtrTwo);
NL_TEST_ASSERT(inSuite, childPtrOne != childPtrTwo);
NL_TEST_ASSERT(inSuite, childPtrOne->data.a == 1);
NL_TEST_ASSERT(inSuite, childPtrTwo->data.a == 2);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
}
static const nlTest sTests[] = {
NL_TEST_DEF("Test_StoreOneType", Test_StoreOneType),
NL_TEST_DEF("Test_StoreMultiple", Test_StoreMultiple),
NL_TEST_DEF("Test_Reuse", Test_Reuse),
NL_TEST_DEF("Test_DeleteMiddle", Test_DeleteMiddle),
NL_TEST_DEF("Test_DeleteLast", Test_DeleteLast),
NL_TEST_DEF("Test_MultipleInstances", Test_MultipleInstances),
NL_TEST_SENTINEL()
};
//This function creates the Suite (i.e: the name of your test and points to the array of test functions)
extern "C"
int statictypedallocator_testsuite(void)
{
nlTestSuite theSuite = SUITE_DECLARATION(statictypedallocator, &sTests[0]);
nlTestRunner(&theSuite, NULL);
return nlTestRunnerStats(&theSuite);
}
<commit_msg>Added clearing test for StaticTypedAllocator<commit_after>// Copyright 2017 Nest Labs, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "nltest.h"
#include "test_statictypedallocator.h"
#include "statictypedallocator-lite.hpp"
#include <typeinfo>
#define SUITE_DECLARATION(name, test_ptr) { #name, test_ptr, setup_##name, teardown_##name }
using namespace DetectorGraph;
static int setup_statictypedallocator(void *inContext)
{
return 0;
}
static int teardown_statictypedallocator(void *inContext)
{
return 0;
}
// Helper Types used in this tests.
struct SomeBase { virtual ~SomeBase() { } };
template<class T> struct SomeChild : public SomeBase
{
static int instanceCount;
SomeChild(const T& d) : data(d) { instanceCount++; }
SomeChild(const SomeChild& other) : data(other.data) { instanceCount++; }
~SomeChild() { instanceCount--; }
T data;
};
struct TopicStateA { TopicStateA(int arg) : a(arg) {} int a; };
struct TopicStateB { TopicStateB(int arg) : b(arg) {} int b; };
struct TopicStateC { TopicStateC(int arg) : c(arg) {} int c; };
template<>
int SomeChild<TopicStateA>::instanceCount = 0;
template<>
int SomeChild<TopicStateB>::instanceCount = 0;
template<>
int SomeChild<TopicStateC>::instanceCount = 0;
static void Test_StoreOneType(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
SomeBase* basePtr = allocator.New(SomeChild<TopicStateA>(TopicStateA(42)));
allocator.Delete(basePtr);
SomeChild<TopicStateA>* childPtr = static_cast< SomeChild<TopicStateA>* >(basePtr);
NL_TEST_ASSERT(inSuite, childPtr->data.a == 42);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
}
static void Test_StoreMultiple(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
SomeBase* basePtrA = allocator.New(SomeChild<TopicStateA>(73));
SomeBase* basePtrB = allocator.New(SomeChild<TopicStateB>(83));
NL_TEST_ASSERT(inSuite, basePtrA != basePtrB);
SomeChild<TopicStateA>* childPtrA = static_cast< SomeChild<TopicStateA>* >(basePtrA);
SomeChild<TopicStateB>* childPtrB = static_cast< SomeChild<TopicStateB>* >(basePtrB);
NL_TEST_ASSERT(inSuite, childPtrA->data.a == 73);
NL_TEST_ASSERT(inSuite, childPtrB->data.b == 83);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
}
static void Test_Reuse(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
SomeBase* basePtr;
basePtr = allocator.New(SomeChild<TopicStateA>(TopicStateA(666)));
allocator.Delete(basePtr);
basePtr = allocator.New(SomeChild<TopicStateA>(TopicStateA(999)));
SomeChild<TopicStateA>* childPtr = static_cast< SomeChild<TopicStateA>* >(basePtr);
NL_TEST_ASSERT(inSuite, childPtr->data.a == 999);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
}
static void Test_DeleteMiddle(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
allocator.New(SomeChild<TopicStateA>(0));
SomeBase* basePtrB = allocator.New(SomeChild<TopicStateB>(1000));
allocator.New(SomeChild<TopicStateC>(0));
allocator.Delete(basePtrB);
basePtrB = allocator.New(SomeChild<TopicStateB>(1001));
SomeChild<TopicStateB>* childPtr = static_cast< SomeChild<TopicStateB>* >(basePtrB);
NL_TEST_ASSERT(inSuite, childPtr->data.b == 1001);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateC>::instanceCount == 0);
}
static void Test_DeleteLast(nlTestSuite *inSuite, void *inContext)
{
{
StaticTypedAllocator<SomeBase> allocator;
allocator.New(SomeChild<TopicStateA>(0));
allocator.New(SomeChild<TopicStateB>(0));
SomeBase* basePtrC = allocator.New(SomeChild<TopicStateC>(1000));
allocator.Delete(basePtrC);
basePtrC = allocator.New(SomeChild<TopicStateC>(1001));
SomeChild<TopicStateC>* childPtr = static_cast< SomeChild<TopicStateC>* >(basePtrC);
NL_TEST_ASSERT(inSuite, childPtr->data.c == 1001);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateC>::instanceCount == 0);
}
static void Test_MultipleInstances(nlTestSuite *inSuite, void *inContext)
{
{
struct One {};
StaticTypedAllocator<SomeBase, One > allocatorOne;
struct Two {};
StaticTypedAllocator<SomeBase, Two > allocatorTwo;
SomeBase* basePtrOne = allocatorOne.New(SomeChild<TopicStateA>(1));
SomeBase* basePtrTwo = allocatorTwo.New(SomeChild<TopicStateA>(2));
SomeChild<TopicStateA>* childPtrOne = static_cast< SomeChild<TopicStateA>* >(basePtrOne);
SomeChild<TopicStateA>* childPtrTwo = static_cast< SomeChild<TopicStateA>* >(basePtrTwo);
NL_TEST_ASSERT(inSuite, childPtrOne != childPtrTwo);
NL_TEST_ASSERT(inSuite, childPtrOne->data.a == 1);
NL_TEST_ASSERT(inSuite, childPtrTwo->data.a == 2);
}
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
}
static void Test_Clear(nlTestSuite *inSuite, void *inContext)
{
StaticTypedAllocator<SomeBase> allocator;
allocator.New(SomeChild<TopicStateA>(0));
allocator.New(SomeChild<TopicStateB>(0));
allocator.clear();
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
allocator.New(SomeChild<TopicStateA>(1));
allocator.New(SomeChild<TopicStateB>(1));
allocator.clear();
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateA>::instanceCount == 0);
NL_TEST_ASSERT(inSuite, SomeChild<TopicStateB>::instanceCount == 0);
}
static const nlTest sTests[] = {
NL_TEST_DEF("Test_StoreOneType", Test_StoreOneType),
NL_TEST_DEF("Test_StoreMultiple", Test_StoreMultiple),
NL_TEST_DEF("Test_Reuse", Test_Reuse),
NL_TEST_DEF("Test_DeleteMiddle", Test_DeleteMiddle),
NL_TEST_DEF("Test_DeleteLast", Test_DeleteLast),
NL_TEST_DEF("Test_MultipleInstances", Test_MultipleInstances),
NL_TEST_DEF("Test_Clear", Test_Clear),
NL_TEST_SENTINEL()
};
//This function creates the Suite (i.e: the name of your test and points to the array of test functions)
extern "C"
int statictypedallocator_testsuite(void)
{
nlTestSuite theSuite = SUITE_DECLARATION(statictypedallocator, &sTests[0]);
nlTestRunner(&theSuite, NULL);
return nlTestRunnerStats(&theSuite);
}
<|endoftext|>
|
<commit_before>#include "AndroidMessageProcessor.h"
#include "AndroidEventHandler.h"
#include "log.h"
using namespace ammo::gateway;
const char DEFAULT_PRIORITY = 50;
AndroidMessageProcessor::AndroidMessageProcessor(AndroidEventHandler *serviceHandler) :
closed(false),
closeMutex(),
newMessageMutex(),
newMessageAvailable(newMessageMutex),
commsHandler(serviceHandler),
gatewayConnector(NULL),
deviceId("(unidentified)"),
userId("(unidentified)"),
deviceIdAuthenticated(false)
{
//need to initialize GatewayConnector in the main thread; the constructor always
//happens in the main thread
gatewayConnector = new GatewayConnector(this);
}
AndroidMessageProcessor::~AndroidMessageProcessor() {
LOG_TRACE((long) commsHandler << " In ~AndroidMessageProcessor()");
if(gatewayConnector) {
delete gatewayConnector;
}
}
int AndroidMessageProcessor::open(void *args) {
closed = false;
return 0;
}
int AndroidMessageProcessor::close(unsigned long flags) {
LOG_TRACE((long) commsHandler << " Closing MessageProcessor (in AndroidMessageProcessor.close())");
LOG_DEBUG((long) commsHandler << " user " << this->userId << " disconnected");
closeMutex.acquire();
closed = true;
closeMutex.release();
signalNewMessageAvailable();
return 0;
}
bool AndroidMessageProcessor::isClosed() {
volatile bool ret; //does this need to be volatile to keep the compiler from optimizing it out?
closeMutex.acquire();
ret = closed;
closeMutex.release();
return ret;
}
int AndroidMessageProcessor::svc() {
while(!isClosed()) {
ammo::protocol::MessageWrapper *msg = NULL;
do {
msg = commsHandler->getNextReceivedMessage();
if(msg) {
processMessage(*msg);
delete msg;
}
} while (msg != NULL);
if(!isClosed()) {
newMessageMutex.acquire();
newMessageAvailable.wait();
newMessageMutex.release();
}
}
return 0;
}
void AndroidMessageProcessor::signalNewMessageAvailable() {
newMessageMutex.acquire();
newMessageAvailable.signal();
newMessageMutex.release();
}
void AndroidMessageProcessor::processMessage(ammo::protocol::MessageWrapper &msg) {
LOG_TRACE((long) commsHandler << " Message Received: " << msg.DebugString());
if(msg.type() == ammo::protocol::MessageWrapper_MessageType_AUTHENTICATION_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Authentication Message...");
if(gatewayConnector != NULL) {
ammo::protocol::AuthenticationMessage authMessage = msg.authentication_message();
gatewayConnector->associateDevice(authMessage.device_id(), authMessage.user_id(), authMessage.user_key());
this->deviceId = authMessage.device_id();
this->userId = authMessage.user_id();
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_DATA_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Data Message...");
if(gatewayConnector != NULL) {
ammo::protocol::DataMessage dataMessage = msg.data_message();
MessageScope scope;
if(dataMessage.scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
PushData pushData;
pushData.uri = dataMessage.uri();
pushData.mimeType = dataMessage.mime_type();
pushData.data = dataMessage.data();
pushData.scope = scope;
pushData.encoding = dataMessage.encoding();
pushData.originUsername = dataMessage.user_id();
pushData.originDevice = dataMessage.origin_device();
pushData.priority = msg.message_priority();
pushData.ackThresholds.deviceDelivered = dataMessage.thresholds().device_delivered();
pushData.ackThresholds.pluginDelivered = dataMessage.thresholds().plugin_delivered();
gatewayConnector->pushData(pushData);
//Send acknowledgement back to device if that field of the acknowledgement
//thresholds object is set
if(msg.data_message().thresholds().android_plugin_received()) {
ammo::protocol::MessageWrapper *ackMsg = new ammo::protocol::MessageWrapper();
ammo::protocol::PushAcknowledgement *ack = ackMsg->mutable_push_acknowledgement();
ack->set_uri(dataMessage.uri());
ack->set_destination_device(dataMessage.origin_device());
ack->set_destination_user(dataMessage.user_id());
ammo::protocol::AcknowledgementThresholds *thresholds = ack->mutable_threshold();
thresholds->set_device_delivered(false);
thresholds->set_plugin_delivered(false);
thresholds->set_android_plugin_received(true);
ack->set_status(ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED);
ackMsg->set_type(ammo::protocol::MessageWrapper_MessageType_PUSH_ACKNOWLEDGEMENT);
LOG_DEBUG(commsHandler << " Sending push acknowledgment to connected device...");
ackMsg->set_message_priority(pushData.priority);
commsHandler->send(ackMsg);
}
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_PUSH_ACKNOWLEDGEMENT) {
LOG_DEBUG((long) commsHandler << " Received Push Acknowledgement...");
ammo::gateway::PushAcknowledgement pushAck;
ammo::protocol::PushAcknowledgement ackMsg = msg.push_acknowledgement();
pushAck.uid = ackMsg.uri();
pushAck.destinationDevice = ackMsg.destination_device();
pushAck.acknowledgingDevice = ackMsg.acknowledging_device();
pushAck.acknowledgingUser = ackMsg.acknowledging_user();
pushAck.destinationUser = ackMsg.destination_user();
pushAck.deviceDelivered = ackMsg.threshold().device_delivered();
pushAck.pluginDelivered = ackMsg.threshold().plugin_delivered();
switch(ackMsg.status()) {
case ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED:
pushAck.status = ammo::gateway::PUSH_RECEIVED;
break;
case ammo::protocol::PushAcknowledgement_PushStatus_SUCCESS:
pushAck.status = ammo::gateway::PUSH_SUCCESS;
break;
case ammo::protocol::PushAcknowledgement_PushStatus_FAIL:
pushAck.status = ammo::gateway::PUSH_FAIL;
break;
case ammo::protocol::PushAcknowledgement_PushStatus_REJECTED:
pushAck.status = ammo::gateway::PUSH_REJECTED;
break;
}
if(gatewayConnector != NULL) {
gatewayConnector->pushAcknowledgement(pushAck);
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_SUBSCRIBE_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Subscribe Message...");
MessageScope scope;
if(msg.subscribe_message().scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
if(gatewayConnector != NULL) {
ammo::protocol::SubscribeMessage subscribeMessage = msg.subscribe_message();
gatewayConnector->registerDataInterest(subscribeMessage.mime_type(), this, scope);
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_UNSUBSCRIBE_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Unubscribe Message...");
MessageScope scope;
if(msg.unsubscribe_message().scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
if(gatewayConnector != NULL) {
ammo::protocol::UnsubscribeMessage unsubscribeMessage = msg.unsubscribe_message();
gatewayConnector->unregisterDataInterest(unsubscribeMessage.mime_type(), scope);
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_PULL_REQUEST) {
LOG_DEBUG((long) commsHandler << " Received Pull Request Message...");
if(gatewayConnector != NULL && deviceIdAuthenticated) {
ammo::protocol::PullRequest pullRequest = msg.pull_request();
// register for pull response -
gatewayConnector->registerPullResponseInterest(pullRequest.mime_type(), this);
MessageScope scope;
if(pullRequest.scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
// now send request
PullRequest req;
req.requestUid = pullRequest.request_uid();
req.pluginId = this->deviceId;
req.mimeType = pullRequest.mime_type();
req.query = pullRequest.query();
req.projection = pullRequest.projection();
req.maxResults = pullRequest.max_results();
req.startFromCount = pullRequest.start_from_count();
req.liveQuery = pullRequest.live_query();
req.scope = scope;
req.priority = msg.message_priority();
gatewayConnector->pullRequest(req);
} else {
if(!deviceIdAuthenticated) {
LOG_ERROR((long) commsHandler << " Attempted to send a pull request before authentication.");
}
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_HEARTBEAT) {
LOG_DEBUG((long) commsHandler << " Received Heartbeat from device...");
ammo::protocol::Heartbeat heartbeat = msg.heartbeat();
ammo::protocol::MessageWrapper *heartbeatAck = new ammo::protocol::MessageWrapper();
ammo::protocol::Heartbeat *ack = heartbeatAck->mutable_heartbeat();
ack->set_sequence_number(heartbeat.sequence_number());
heartbeatAck->set_type(ammo::protocol::MessageWrapper_MessageType_HEARTBEAT);
heartbeatAck->set_message_priority(ammo::gateway::PRIORITY_CTRL);
LOG_DEBUG((long) commsHandler << " Sending heartbeat acknowledgement to connected device...");
commsHandler->send(heartbeatAck);
PushData pushData;
pushData.mimeType = "ammo/edu.vu.isis.ammo.heartbeat";
pushData.scope = SCOPE_GLOBAL;
pushData.originUsername = this->userId;
pushData.originDevice = this->deviceId;
LOG_DEBUG((long) commsHandler << " Sending heartbeat push to gateway...");
gatewayConnector->pushData(pushData);
}
}
void AndroidMessageProcessor::onConnect(GatewayConnector *sender) {
}
void AndroidMessageProcessor::onDisconnect(GatewayConnector *sender) {
LOG_WARN("GatewayConnector disconnected");
}
void AndroidMessageProcessor::onPushAcknowledgementReceived(GatewayConnector *sender, const ammo::gateway::PushAcknowledgement &ack) {
LOG_DEBUG((long) commsHandler << " Sending push acknowledgement to device...");
LOG_DEBUG((long) commsHandler << " uid: " << ack.uid);
ammo::protocol::MessageWrapper *msg = new ammo::protocol::MessageWrapper;
ammo::protocol::PushAcknowledgement *ackMsg = msg->mutable_push_acknowledgement();
ackMsg->set_uri(ack.uid);
ackMsg->set_destination_device(ack.destinationDevice);
ackMsg->set_acknowledging_device(ack.acknowledgingDevice);
ackMsg->set_destination_user(ack.destinationUser);
ackMsg->set_acknowledging_user(ack.acknowledgingUser);
ackMsg->mutable_threshold()->set_device_delivered(ack.deviceDelivered);
ackMsg->mutable_threshold()->set_plugin_delivered(ack.pluginDelivered);
ackMsg->mutable_threshold()->set_android_plugin_received(false);
ammo::protocol::PushAcknowledgement_PushStatus status = ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED;
switch(ack.status) {
case PUSH_RECEIVED:
status = ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED;
break;
case PUSH_SUCCESS:
status = ammo::protocol::PushAcknowledgement_PushStatus_SUCCESS;
break;
case PUSH_FAIL:
status = ammo::protocol::PushAcknowledgement_PushStatus_FAIL;
break;
case PUSH_REJECTED:
status = ammo::protocol::PushAcknowledgement_PushStatus_REJECTED;
break;
}
ackMsg->set_status(status);
msg->set_type(ammo::protocol::MessageWrapper_MessageType_PUSH_ACKNOWLEDGEMENT);
msg->set_message_priority(ammo::gateway::PRIORITY_CTRL);
LOG_DEBUG((long) commsHandler << " Sending push acknowledgement message to connected device");
commsHandler->send(msg);
}
void AndroidMessageProcessor::onPushDataReceived(GatewayConnector *sender, ammo::gateway::PushData &pushData) {
LOG_DEBUG((long) commsHandler << " Sending subscribed data to device...");
LOG_DEBUG((long) commsHandler << " " << pushData);
std::string dataString(pushData.data.begin(), pushData.data.end());
ammo::protocol::MessageWrapper *msg = new ammo::protocol::MessageWrapper;
ammo::protocol::DataMessage *dataMsg = msg->mutable_data_message();
dataMsg->set_uri(pushData.uri);
dataMsg->set_mime_type(pushData.mimeType);
dataMsg->set_encoding(pushData.encoding);
dataMsg->set_data(dataString);
dataMsg->set_origin_device(pushData.originDevice);
dataMsg->set_user_id(pushData.originUsername);
dataMsg->mutable_thresholds()->set_device_delivered(pushData.ackThresholds.deviceDelivered);
dataMsg->mutable_thresholds()->set_plugin_delivered(pushData.ackThresholds.pluginDelivered);
dataMsg->mutable_thresholds()->set_android_plugin_received(false);
msg->set_type(ammo::protocol::MessageWrapper_MessageType_DATA_MESSAGE);
msg->set_message_priority(pushData.priority);
LOG_DEBUG((long) commsHandler << " Sending Data Push message to connected device");
commsHandler->send(msg);
}
void AndroidMessageProcessor::onPullResponseReceived(GatewayConnector *sender, ammo::gateway::PullResponse &response) {
LOG_DEBUG((long) commsHandler << " Sending pull response to device...");
LOG_DEBUG((long) commsHandler << " URI: " << response.uri << ", Type: " << response.mimeType);
std::string dataString(response.data.begin(), response.data.end());
ammo::protocol::MessageWrapper *msg = new ammo::protocol::MessageWrapper();
ammo::protocol::PullResponse *pullMsg = msg->mutable_pull_response();
pullMsg->set_request_uid(response.requestUid);
pullMsg->set_plugin_id(response.pluginId);
pullMsg->set_mime_type(response.mimeType);
pullMsg->set_uri(response.uri);
pullMsg->set_encoding(response.encoding);
pullMsg->set_data(dataString);
msg->set_type(ammo::protocol::MessageWrapper_MessageType_PULL_RESPONSE);
msg->set_message_priority(response.priority);
LOG_DEBUG((long) commsHandler << " Sending Pull Response message to connected device");
commsHandler->send(msg);
}
void AndroidMessageProcessor::onAuthenticationResponse(GatewayConnector *sender, bool result) {
LOG_DEBUG((long) commsHandler << " Delegate: onAuthenticationResponse");
if(result == true) {
deviceIdAuthenticated = true;
}
ammo::protocol::MessageWrapper *newMsg = new ammo::protocol::MessageWrapper();
newMsg->set_type(ammo::protocol::MessageWrapper_MessageType_AUTHENTICATION_RESULT);
newMsg->set_message_priority(ammo::gateway::PRIORITY_AUTH);
newMsg->mutable_authentication_result()->set_result(result ? ammo::protocol::AuthenticationResult_Status_SUCCESS : ammo::protocol::AuthenticationResult_Status_SUCCESS);
commsHandler->send(newMsg);
}
<commit_msg>Fix indentation<commit_after>#include "AndroidMessageProcessor.h"
#include "AndroidEventHandler.h"
#include "log.h"
using namespace ammo::gateway;
const char DEFAULT_PRIORITY = 50;
AndroidMessageProcessor::AndroidMessageProcessor(AndroidEventHandler *serviceHandler) :
closed(false),
closeMutex(),
newMessageMutex(),
newMessageAvailable(newMessageMutex),
commsHandler(serviceHandler),
gatewayConnector(NULL),
deviceId("(unidentified)"),
userId("(unidentified)"),
deviceIdAuthenticated(false)
{
//need to initialize GatewayConnector in the main thread; the constructor always
//happens in the main thread
gatewayConnector = new GatewayConnector(this);
}
AndroidMessageProcessor::~AndroidMessageProcessor() {
LOG_TRACE((long) commsHandler << " In ~AndroidMessageProcessor()");
if(gatewayConnector) {
delete gatewayConnector;
}
}
int AndroidMessageProcessor::open(void *args) {
closed = false;
return 0;
}
int AndroidMessageProcessor::close(unsigned long flags) {
LOG_TRACE((long) commsHandler << " Closing MessageProcessor (in AndroidMessageProcessor.close())");
LOG_DEBUG((long) commsHandler << " user " << this->userId << " disconnected");
closeMutex.acquire();
closed = true;
closeMutex.release();
signalNewMessageAvailable();
return 0;
}
bool AndroidMessageProcessor::isClosed() {
volatile bool ret; //does this need to be volatile to keep the compiler from optimizing it out?
closeMutex.acquire();
ret = closed;
closeMutex.release();
return ret;
}
int AndroidMessageProcessor::svc() {
while(!isClosed()) {
ammo::protocol::MessageWrapper *msg = NULL;
do {
msg = commsHandler->getNextReceivedMessage();
if(msg) {
processMessage(*msg);
delete msg;
}
} while (msg != NULL);
if(!isClosed()) {
newMessageMutex.acquire();
newMessageAvailable.wait();
newMessageMutex.release();
}
}
return 0;
}
void AndroidMessageProcessor::signalNewMessageAvailable() {
newMessageMutex.acquire();
newMessageAvailable.signal();
newMessageMutex.release();
}
void AndroidMessageProcessor::processMessage(ammo::protocol::MessageWrapper &msg) {
LOG_TRACE((long) commsHandler << " Message Received: " << msg.DebugString());
if(msg.type() == ammo::protocol::MessageWrapper_MessageType_AUTHENTICATION_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Authentication Message...");
if(gatewayConnector != NULL) {
ammo::protocol::AuthenticationMessage authMessage = msg.authentication_message();
gatewayConnector->associateDevice(authMessage.device_id(), authMessage.user_id(), authMessage.user_key());
this->deviceId = authMessage.device_id();
this->userId = authMessage.user_id();
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_DATA_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Data Message...");
if(gatewayConnector != NULL) {
ammo::protocol::DataMessage dataMessage = msg.data_message();
MessageScope scope;
if(dataMessage.scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
PushData pushData;
pushData.uri = dataMessage.uri();
pushData.mimeType = dataMessage.mime_type();
pushData.data = dataMessage.data();
pushData.scope = scope;
pushData.encoding = dataMessage.encoding();
pushData.originUsername = dataMessage.user_id();
pushData.originDevice = dataMessage.origin_device();
pushData.priority = msg.message_priority();
pushData.ackThresholds.deviceDelivered = dataMessage.thresholds().device_delivered();
pushData.ackThresholds.pluginDelivered = dataMessage.thresholds().plugin_delivered();
gatewayConnector->pushData(pushData);
//Send acknowledgement back to device if that field of the acknowledgement
//thresholds object is set
if(msg.data_message().thresholds().android_plugin_received()) {
ammo::protocol::MessageWrapper *ackMsg = new ammo::protocol::MessageWrapper();
ammo::protocol::PushAcknowledgement *ack = ackMsg->mutable_push_acknowledgement();
ack->set_uri(dataMessage.uri());
ack->set_destination_device(dataMessage.origin_device());
ack->set_destination_user(dataMessage.user_id());
ammo::protocol::AcknowledgementThresholds *thresholds = ack->mutable_threshold();
thresholds->set_device_delivered(false);
thresholds->set_plugin_delivered(false);
thresholds->set_android_plugin_received(true);
ack->set_status(ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED);
ackMsg->set_type(ammo::protocol::MessageWrapper_MessageType_PUSH_ACKNOWLEDGEMENT);
LOG_DEBUG(commsHandler << " Sending push acknowledgment to connected device...");
ackMsg->set_message_priority(pushData.priority);
commsHandler->send(ackMsg);
}
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_PUSH_ACKNOWLEDGEMENT) {
LOG_DEBUG((long) commsHandler << " Received Push Acknowledgement...");
ammo::gateway::PushAcknowledgement pushAck;
ammo::protocol::PushAcknowledgement ackMsg = msg.push_acknowledgement();
pushAck.uid = ackMsg.uri();
pushAck.destinationDevice = ackMsg.destination_device();
pushAck.acknowledgingDevice = ackMsg.acknowledging_device();
pushAck.acknowledgingUser = ackMsg.acknowledging_user();
pushAck.destinationUser = ackMsg.destination_user();
pushAck.deviceDelivered = ackMsg.threshold().device_delivered();
pushAck.pluginDelivered = ackMsg.threshold().plugin_delivered();
switch(ackMsg.status()) {
case ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED:
pushAck.status = ammo::gateway::PUSH_RECEIVED;
break;
case ammo::protocol::PushAcknowledgement_PushStatus_SUCCESS:
pushAck.status = ammo::gateway::PUSH_SUCCESS;
break;
case ammo::protocol::PushAcknowledgement_PushStatus_FAIL:
pushAck.status = ammo::gateway::PUSH_FAIL;
break;
case ammo::protocol::PushAcknowledgement_PushStatus_REJECTED:
pushAck.status = ammo::gateway::PUSH_REJECTED;
break;
}
if(gatewayConnector != NULL) {
gatewayConnector->pushAcknowledgement(pushAck);
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_SUBSCRIBE_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Subscribe Message...");
MessageScope scope;
if(msg.subscribe_message().scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
if(gatewayConnector != NULL) {
ammo::protocol::SubscribeMessage subscribeMessage = msg.subscribe_message();
gatewayConnector->registerDataInterest(subscribeMessage.mime_type(), this, scope);
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_UNSUBSCRIBE_MESSAGE) {
LOG_DEBUG((long) commsHandler << " Received Unubscribe Message...");
MessageScope scope;
if(msg.unsubscribe_message().scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
if(gatewayConnector != NULL) {
ammo::protocol::UnsubscribeMessage unsubscribeMessage = msg.unsubscribe_message();
gatewayConnector->unregisterDataInterest(unsubscribeMessage.mime_type(), scope);
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_PULL_REQUEST) {
LOG_DEBUG((long) commsHandler << " Received Pull Request Message...");
if(gatewayConnector != NULL && deviceIdAuthenticated) {
ammo::protocol::PullRequest pullRequest = msg.pull_request();
// register for pull response -
gatewayConnector->registerPullResponseInterest(pullRequest.mime_type(), this);
MessageScope scope;
if(pullRequest.scope() == ammo::protocol::LOCAL) {
scope = SCOPE_LOCAL;
} else {
scope = SCOPE_GLOBAL;
}
// now send request
PullRequest req;
req.requestUid = pullRequest.request_uid();
req.pluginId = this->deviceId;
req.mimeType = pullRequest.mime_type();
req.query = pullRequest.query();
req.projection = pullRequest.projection();
req.maxResults = pullRequest.max_results();
req.startFromCount = pullRequest.start_from_count();
req.liveQuery = pullRequest.live_query();
req.scope = scope;
req.priority = msg.message_priority();
gatewayConnector->pullRequest(req);
} else {
if(!deviceIdAuthenticated) {
LOG_ERROR((long) commsHandler << " Attempted to send a pull request before authentication.");
}
}
} else if(msg.type() == ammo::protocol::MessageWrapper_MessageType_HEARTBEAT) {
LOG_DEBUG((long) commsHandler << " Received Heartbeat from device...");
ammo::protocol::Heartbeat heartbeat = msg.heartbeat();
ammo::protocol::MessageWrapper *heartbeatAck = new ammo::protocol::MessageWrapper();
ammo::protocol::Heartbeat *ack = heartbeatAck->mutable_heartbeat();
ack->set_sequence_number(heartbeat.sequence_number());
heartbeatAck->set_type(ammo::protocol::MessageWrapper_MessageType_HEARTBEAT);
heartbeatAck->set_message_priority(ammo::gateway::PRIORITY_CTRL);
LOG_DEBUG((long) commsHandler << " Sending heartbeat acknowledgement to connected device...");
commsHandler->send(heartbeatAck);
PushData pushData;
pushData.mimeType = "ammo/edu.vu.isis.ammo.heartbeat";
pushData.scope = SCOPE_GLOBAL;
pushData.originUsername = this->userId;
pushData.originDevice = this->deviceId;
LOG_DEBUG((long) commsHandler << " Sending heartbeat push to gateway...");
gatewayConnector->pushData(pushData);
}
}
void AndroidMessageProcessor::onConnect(GatewayConnector *sender) {
}
void AndroidMessageProcessor::onDisconnect(GatewayConnector *sender) {
LOG_WARN("GatewayConnector disconnected");
}
void AndroidMessageProcessor::onPushAcknowledgementReceived(GatewayConnector *sender, const ammo::gateway::PushAcknowledgement &ack) {
LOG_DEBUG((long) commsHandler << " Sending push acknowledgement to device...");
LOG_DEBUG((long) commsHandler << " uid: " << ack.uid);
ammo::protocol::MessageWrapper *msg = new ammo::protocol::MessageWrapper;
ammo::protocol::PushAcknowledgement *ackMsg = msg->mutable_push_acknowledgement();
ackMsg->set_uri(ack.uid);
ackMsg->set_destination_device(ack.destinationDevice);
ackMsg->set_acknowledging_device(ack.acknowledgingDevice);
ackMsg->set_destination_user(ack.destinationUser);
ackMsg->set_acknowledging_user(ack.acknowledgingUser);
ackMsg->mutable_threshold()->set_device_delivered(ack.deviceDelivered);
ackMsg->mutable_threshold()->set_plugin_delivered(ack.pluginDelivered);
ackMsg->mutable_threshold()->set_android_plugin_received(false);
ammo::protocol::PushAcknowledgement_PushStatus status = ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED;
switch(ack.status) {
case PUSH_RECEIVED:
status = ammo::protocol::PushAcknowledgement_PushStatus_RECEIVED;
break;
case PUSH_SUCCESS:
status = ammo::protocol::PushAcknowledgement_PushStatus_SUCCESS;
break;
case PUSH_FAIL:
status = ammo::protocol::PushAcknowledgement_PushStatus_FAIL;
break;
case PUSH_REJECTED:
status = ammo::protocol::PushAcknowledgement_PushStatus_REJECTED;
break;
}
ackMsg->set_status(status);
msg->set_type(ammo::protocol::MessageWrapper_MessageType_PUSH_ACKNOWLEDGEMENT);
msg->set_message_priority(ammo::gateway::PRIORITY_CTRL);
LOG_DEBUG((long) commsHandler << " Sending push acknowledgement message to connected device");
commsHandler->send(msg);
}
void AndroidMessageProcessor::onPushDataReceived(GatewayConnector *sender, ammo::gateway::PushData &pushData) {
LOG_DEBUG((long) commsHandler << " Sending subscribed data to device...");
LOG_DEBUG((long) commsHandler << " " << pushData);
std::string dataString(pushData.data.begin(), pushData.data.end());
ammo::protocol::MessageWrapper *msg = new ammo::protocol::MessageWrapper;
ammo::protocol::DataMessage *dataMsg = msg->mutable_data_message();
dataMsg->set_uri(pushData.uri);
dataMsg->set_mime_type(pushData.mimeType);
dataMsg->set_encoding(pushData.encoding);
dataMsg->set_data(dataString);
dataMsg->set_origin_device(pushData.originDevice);
dataMsg->set_user_id(pushData.originUsername);
dataMsg->mutable_thresholds()->set_device_delivered(pushData.ackThresholds.deviceDelivered);
dataMsg->mutable_thresholds()->set_plugin_delivered(pushData.ackThresholds.pluginDelivered);
dataMsg->mutable_thresholds()->set_android_plugin_received(false);
msg->set_type(ammo::protocol::MessageWrapper_MessageType_DATA_MESSAGE);
msg->set_message_priority(pushData.priority);
LOG_DEBUG((long) commsHandler << " Sending Data Push message to connected device");
commsHandler->send(msg);
}
void AndroidMessageProcessor::onPullResponseReceived(GatewayConnector *sender, ammo::gateway::PullResponse &response) {
LOG_DEBUG((long) commsHandler << " Sending pull response to device...");
LOG_DEBUG((long) commsHandler << " URI: " << response.uri << ", Type: " << response.mimeType);
std::string dataString(response.data.begin(), response.data.end());
ammo::protocol::MessageWrapper *msg = new ammo::protocol::MessageWrapper();
ammo::protocol::PullResponse *pullMsg = msg->mutable_pull_response();
pullMsg->set_request_uid(response.requestUid);
pullMsg->set_plugin_id(response.pluginId);
pullMsg->set_mime_type(response.mimeType);
pullMsg->set_uri(response.uri);
pullMsg->set_encoding(response.encoding);
pullMsg->set_data(dataString);
msg->set_type(ammo::protocol::MessageWrapper_MessageType_PULL_RESPONSE);
msg->set_message_priority(response.priority);
LOG_DEBUG((long) commsHandler << " Sending Pull Response message to connected device");
commsHandler->send(msg);
}
void AndroidMessageProcessor::onAuthenticationResponse(GatewayConnector *sender, bool result) {
LOG_DEBUG((long) commsHandler << " Delegate: onAuthenticationResponse");
if(result == true) {
deviceIdAuthenticated = true;
}
ammo::protocol::MessageWrapper *newMsg = new ammo::protocol::MessageWrapper();
newMsg->set_type(ammo::protocol::MessageWrapper_MessageType_AUTHENTICATION_RESULT);
newMsg->set_message_priority(ammo::gateway::PRIORITY_AUTH);
newMsg->mutable_authentication_result()->set_result(result ? ammo::protocol::AuthenticationResult_Status_SUCCESS : ammo::protocol::AuthenticationResult_Status_SUCCESS);
commsHandler->send(newMsg);
}
<|endoftext|>
|
<commit_before>#ifndef __bootstrap_hpp
#define __bootstrap_hpp__
#include "boxedcpp.hpp"
#include "register_function.hpp"
template<typename Ret, typename P1, typename P2>
Ret add(P1 p1, P2 p2)
{
return p1 + p2;
}
template<typename Ret, typename P1, typename P2>
Ret subtract(P1 p1, P2 p2)
{
return p1 - p2;
}
template<typename Ret, typename P1, typename P2>
Ret divide(P1 p1, P2 p2)
{
return p1 / p2;
}
template<typename Ret, typename P1, typename P2>
Ret multiply(P1 p1, P2 p2)
{
return p1 * p2;
}
template<typename P1, typename P2>
bool bool_and(P1 p1, P2 p2)
{
return p1 && p2;
}
template<typename P1, typename P2>
bool bool_or(P1 p1, P2 p2)
{
return p1 || p2;
}
template<typename P1, typename P2>
P1 &assign(P1 &p1, const P2 &p2)
{
return (p1 = p2);
}
template<typename P1, typename P2>
bool equals(P1 p1, P2 p2)
{
return p1 == p2;
}
template<typename P1, typename P2>
bool not_equals(P1 p1, P2 p2)
{
return p1 != p2;
}
template<typename P1, typename P2>
bool less_than(P1 p1, P2 p2)
{
return p1 < p2;
}
template<typename P1, typename P2>
bool greater_than(P1 p1, P2 p2)
{
return p1 > p2;
}
template<typename P1, typename P2>
bool less_than_equals(P1 p1, P2 p2)
{
return p1 <= p2;
}
template<typename P1, typename P2>
bool greater_than_equals(P1 p1, P2 p2)
{
return p1 >= p2;
}
template<typename P1, typename P2>
P1 ×equal(P1 &p1, const P2 &p2)
{
return (p1 *= p2);
}
template<typename P1, typename P2>
P1 ÷sequal(P1 &p1, const P2 &p2)
{
return (p1 /= p2);
}
template<typename P1, typename P2>
P1 &addsequal(P1 &p1, const P2 &p2)
{
return (p1 += p2);
}
template<typename P1, typename P2>
P1 &subtractsequal(P1 &p1, const P2 &p2)
{
return (p1 -= p2);
}
//Add canonical forms of operators
template<typename T>
void add_oper_equals(BoxedCPP_System &s)
{
register_function(s, &equals<const T&, const T&>, "=");
}
template<typename T>
void add_oper_add(BoxedCPP_System &s)
{
register_function(s, &add<T, const T&, const T&>, "+");
}
template<typename T>
void add_oper_subtract(BoxedCPP_System &s)
{
register_function(s, &subtract<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_divide(BoxedCPP_System &s)
{
register_function(s, ÷<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_multiply(BoxedCPP_System &s)
{
register_function(s, &multiply<T, const T&, const T&>, "*");
}
template<typename T>
void add_oper_not_equals(BoxedCPP_System &s)
{
register_function(s, ¬_equals<const T&, const T&>, "!=");
}
template<typename T>
void add_oper_assign(BoxedCPP_System &s)
{
register_function(s, &assign<T,T>, "=");
}
template<typename T>
void add_oper_less_than(BoxedCPP_System &s)
{
register_function(s, &less_than<const T&, const T&>, "<");
}
template<typename T>
void add_oper_greater_than(BoxedCPP_System &s)
{
register_function(s, &greater_than<const T&, const T&>, ">");
}
template<typename T>
void add_oper_less_than_equals(BoxedCPP_System &s)
{
register_function(s, &less_than_equals<const T&, const T&>, "<=");
}
template<typename T>
void add_oper_greater_than_equals(BoxedCPP_System &s)
{
register_function(s, &greater_than_equals<const T&, const T&>, ">=");
}
template<typename T, typename R>
void add_opers_comparison_overload(BoxedCPP_System &s)
{
register_function(s, &equals<const T&, const R&>, "==");
register_function(s, ¬_equals<const T&, const R&>, "!=");
register_function(s, &less_than<const T&, const R&>, "<");
register_function(s, &greater_than<const T&, const R&>, ">");
register_function(s, &less_than_equals<const T&, const R&>, "<=");
register_function(s, &greater_than_equals<const T&, const R&>, ">=");
}
template<typename T>
void add_opers_comparison(BoxedCPP_System &s)
{
add_opers_comparison_overload<T, T>(s);
}
template<typename Ret, typename T, typename R>
void add_opers_arithmetic_overload(BoxedCPP_System &s)
{
register_function(s, &add<Ret, T, R>, "+");
register_function(s, &subtract<Ret, T, R>, "-");
register_function(s, ÷<Ret, T, R>, "/");
register_function(s, &multiply<Ret, T, R>, "*");
register_function(s, ×equal<T, R>, "*=");
register_function(s, ÷sequal<T, R>, "/=");
register_function(s, &subtractsequal<T, R>, "-=");
register_function(s, &addsequal<T, R>, "+=");
}
template<typename T>
void add_opers_arithmetic(BoxedCPP_System &s)
{
add_opers_arithmetic_overload<T, T, T>(s);
}
//Built in to_string operator
template<typename Input>
std::string to_string(Input i)
{
return boost::lexical_cast<std::string>(i);
}
void bootstrap(BoxedCPP_System &s)
{
s.register_type<void>("void");
s.register_type<double>("double");
s.register_type<int>("int");
s.register_type<char>("char");
s.register_type<bool>("bool");
s.register_type<std::string>("string");
add_opers_comparison<int>(s);
add_opers_comparison<double>(s);
add_opers_comparison<char>(s);
add_opers_comparison<std::string>(s);
add_oper_assign<int>(s);
add_oper_assign<double>(s);
add_oper_assign<char>(s);
add_oper_assign<std::string>(s);
add_opers_comparison_overload<int, double>(s);
add_opers_comparison_overload<double, int>(s);
add_opers_arithmetic<int>(s);
add_opers_arithmetic<double>(s);
add_opers_arithmetic_overload<double, int, double>(s);
add_opers_arithmetic_overload<double, double, int>(s);
add_oper_add<std::string>(s);
register_function(s, &bool_and<bool, bool>, "&&");
register_function(s, &bool_or<bool, bool>, "||");
register_function(s, &to_string<int>, "to_string");
register_function(s, &to_string<const std::string &>, "to_string");
register_function(s, &to_string<char>, "to_string");
register_function(s, &to_string<double>, "to_string");
}
#endif
<commit_msg>Add default and copy constructors for bootstrapped types<commit_after>#ifndef __bootstrap_hpp
#define __bootstrap_hpp__
#include "boxedcpp.hpp"
#include "register_function.hpp"
template<typename Ret, typename P1, typename P2>
Ret add(P1 p1, P2 p2)
{
return p1 + p2;
}
template<typename Ret, typename P1, typename P2>
Ret subtract(P1 p1, P2 p2)
{
return p1 - p2;
}
template<typename Ret, typename P1, typename P2>
Ret divide(P1 p1, P2 p2)
{
return p1 / p2;
}
template<typename Ret, typename P1, typename P2>
Ret multiply(P1 p1, P2 p2)
{
return p1 * p2;
}
template<typename P1, typename P2>
bool bool_and(P1 p1, P2 p2)
{
return p1 && p2;
}
template<typename P1, typename P2>
bool bool_or(P1 p1, P2 p2)
{
return p1 || p2;
}
template<typename P1, typename P2>
P1 &assign(P1 &p1, const P2 &p2)
{
return (p1 = p2);
}
template<typename P1, typename P2>
bool equals(P1 p1, P2 p2)
{
return p1 == p2;
}
template<typename P1, typename P2>
bool not_equals(P1 p1, P2 p2)
{
return p1 != p2;
}
template<typename P1, typename P2>
bool less_than(P1 p1, P2 p2)
{
return p1 < p2;
}
template<typename P1, typename P2>
bool greater_than(P1 p1, P2 p2)
{
return p1 > p2;
}
template<typename P1, typename P2>
bool less_than_equals(P1 p1, P2 p2)
{
return p1 <= p2;
}
template<typename P1, typename P2>
bool greater_than_equals(P1 p1, P2 p2)
{
return p1 >= p2;
}
template<typename P1, typename P2>
P1 ×equal(P1 &p1, const P2 &p2)
{
return (p1 *= p2);
}
template<typename P1, typename P2>
P1 ÷sequal(P1 &p1, const P2 &p2)
{
return (p1 /= p2);
}
template<typename P1, typename P2>
P1 &addsequal(P1 &p1, const P2 &p2)
{
return (p1 += p2);
}
template<typename P1, typename P2>
P1 &subtractsequal(P1 &p1, const P2 &p2)
{
return (p1 -= p2);
}
//Add canonical forms of operators
template<typename T>
void add_oper_equals(BoxedCPP_System &s)
{
register_function(s, &equals<const T&, const T&>, "=");
}
template<typename T>
void add_oper_add(BoxedCPP_System &s)
{
register_function(s, &add<T, const T&, const T&>, "+");
}
template<typename T>
void add_oper_subtract(BoxedCPP_System &s)
{
register_function(s, &subtract<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_divide(BoxedCPP_System &s)
{
register_function(s, ÷<T, const T&, const T&>, "-");
}
template<typename T>
void add_oper_multiply(BoxedCPP_System &s)
{
register_function(s, &multiply<T, const T&, const T&>, "*");
}
template<typename T>
void add_oper_not_equals(BoxedCPP_System &s)
{
register_function(s, ¬_equals<const T&, const T&>, "!=");
}
template<typename T>
void add_oper_assign(BoxedCPP_System &s)
{
register_function(s, &assign<T,T>, "=");
}
template<typename T>
void add_oper_less_than(BoxedCPP_System &s)
{
register_function(s, &less_than<const T&, const T&>, "<");
}
template<typename T>
void add_oper_greater_than(BoxedCPP_System &s)
{
register_function(s, &greater_than<const T&, const T&>, ">");
}
template<typename T>
void add_oper_less_than_equals(BoxedCPP_System &s)
{
register_function(s, &less_than_equals<const T&, const T&>, "<=");
}
template<typename T>
void add_oper_greater_than_equals(BoxedCPP_System &s)
{
register_function(s, &greater_than_equals<const T&, const T&>, ">=");
}
template<typename T, typename R>
void add_opers_comparison_overload(BoxedCPP_System &s)
{
register_function(s, &equals<const T&, const R&>, "==");
register_function(s, ¬_equals<const T&, const R&>, "!=");
register_function(s, &less_than<const T&, const R&>, "<");
register_function(s, &greater_than<const T&, const R&>, ">");
register_function(s, &less_than_equals<const T&, const R&>, "<=");
register_function(s, &greater_than_equals<const T&, const R&>, ">=");
}
template<typename T>
void add_opers_comparison(BoxedCPP_System &s)
{
add_opers_comparison_overload<T, T>(s);
}
template<typename Ret, typename T, typename R>
void add_opers_arithmetic_overload(BoxedCPP_System &s)
{
register_function(s, &add<Ret, T, R>, "+");
register_function(s, &subtract<Ret, T, R>, "-");
register_function(s, ÷<Ret, T, R>, "/");
register_function(s, &multiply<Ret, T, R>, "*");
register_function(s, ×equal<T, R>, "*=");
register_function(s, ÷sequal<T, R>, "/=");
register_function(s, &subtractsequal<T, R>, "-=");
register_function(s, &addsequal<T, R>, "+=");
}
template<typename T>
void add_basic_constructors(BoxedCPP_System &s, const std::string &type)
{
s.register_function(build_constructor<T>(), type);
s.register_function(build_constructor<T, const T &>(), type);
}
template<typename T>
void add_opers_arithmetic(BoxedCPP_System &s)
{
add_opers_arithmetic_overload<T, T, T>(s);
}
//Built in to_string operator
template<typename Input>
std::string to_string(Input i)
{
return boost::lexical_cast<std::string>(i);
}
void bootstrap(BoxedCPP_System &s)
{
s.register_type<void>("void");
s.register_type<double>("double");
s.register_type<int>("int");
s.register_type<char>("char");
s.register_type<bool>("bool");
s.register_type<std::string>("string");
add_basic_constructors<double>(s, "double");
add_basic_constructors<int>(s, "int");
add_basic_constructors<char>(s, "char");
add_basic_constructors<bool>(s, "bool");
add_basic_constructors<std::string>(s, "string");
add_opers_comparison<int>(s);
add_opers_comparison<double>(s);
add_opers_comparison<char>(s);
add_opers_comparison<std::string>(s);
add_oper_assign<int>(s);
add_oper_assign<double>(s);
add_oper_assign<char>(s);
add_oper_assign<std::string>(s);
add_opers_comparison_overload<int, double>(s);
add_opers_comparison_overload<double, int>(s);
add_opers_arithmetic<int>(s);
add_opers_arithmetic<double>(s);
add_opers_arithmetic_overload<double, int, double>(s);
add_opers_arithmetic_overload<double, double, int>(s);
add_oper_add<std::string>(s);
register_function(s, &bool_and<bool, bool>, "&&");
register_function(s, &bool_or<bool, bool>, "||");
register_function(s, &to_string<int>, "to_string");
register_function(s, &to_string<const std::string &>, "to_string");
register_function(s, &to_string<char>, "to_string");
register_function(s, &to_string<double>, "to_string");
}
#endif
<|endoftext|>
|
<commit_before><commit_msg>Minor updates to BaseObject. Most notably: checking for the existence of a component before deleting will take double the time if the component actually exists.<commit_after><|endoftext|>
|
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: dbtreemodel.hxx,v $
*
* $Revision: 1.16 $
*
* last change: $Author: hr $ $Date: 2005-09-23 12:20:17 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef DBAUI_DBTREEMODEL_HXX
#define DBAUI_DBTREEMODEL_HXX
#ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_
#include <com/sun/star/container/XNameAccess.hpp>
#endif
#ifndef _SVLBOX_HXX
#include <svtools/svlbox.hxx>
#endif
#ifndef _SVLBOXITM_HXX
#include <svtools/svlbitm.hxx>
#endif
#ifndef _DBAUI_MODULE_DBU_HXX_
#include "moduledbu.hxx"
#endif
#ifndef _SBA_UNODATBR_HXX_
#include "unodatbr.hxx"
#endif
#ifndef DBACCESS_SOURCE_UI_INC_DOCUMENTCONTROLLER_HXX
#include "documentcontroller.hxx"
#endif
#ifndef _DBAUI_COMMON_TYPES_HXX_
#include "commontypes.hxx"
#endif
// syntax of the tree userdata
// datasource holds the connection
// queries holds the nameaccess for the queries
// query holds the query
// tables holds the nameaccess for the tables
// table holds the table
// bookmarks holds the nameaccess for the document links
// table holds the document links
namespace com { namespace sun { namespace star { namespace lang { class XMultiServiceFactory; } } } }
namespace dbaui
{
//========================================================================
//= DBTreeListModel
//========================================================================
class DBTreeListModel : public SvLBoxTreeList
{
public:
struct DBTreeListUserData
{
/// if the entry denotes a table or query, this is the respective UNO object
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xObjectProperties;
/// if the entry denotes a object container, this is the UNO interface for this container
::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >
xContainer;
/// if the entry denotes a data source, this is the connection for this data source (if already connection)
SharedConnection xConnection;
/** if the entry denotes a data source, this is the connector between the model and the controller,
keeping the model alive as long as necessary
*/
ModelControllerConnector aController;
SbaTableQueryBrowser::EntryType eType;
String sAccessor;
DBTreeListUserData();
~DBTreeListUserData();
};
static sal_uInt16 getImageResId(SbaTableQueryBrowser::EntryType _eType,sal_Bool _bHiContrast);
};
}
#endif // DBAUI_DBTREEMODEL_HXX
<commit_msg>INTEGRATION: CWS hsqlcsvstage1 (1.16.194); FILE MERGED 2006/09/20 11:43:56 fs 1.16.194.1: #i69696#, being stage 1 of issue #i69526#: merging changes from CWS hsqlcsv herein<commit_after>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: dbtreemodel.hxx,v $
*
* $Revision: 1.17 $
*
* last change: $Author: kz $ $Date: 2006-10-05 13:01:46 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef DBAUI_DBTREEMODEL_HXX
#define DBAUI_DBTREEMODEL_HXX
#ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_
#include <com/sun/star/container/XNameAccess.hpp>
#endif
#ifndef _SVLBOX_HXX
#include <svtools/svlbox.hxx>
#endif
#ifndef _SVLBOXITM_HXX
#include <svtools/svlbitm.hxx>
#endif
#ifndef _DBAUI_MODULE_DBU_HXX_
#include "moduledbu.hxx"
#endif
#ifndef _SBA_UNODATBR_HXX_
#include "unodatbr.hxx"
#endif
#ifndef DBACCESS_SOURCE_UI_INC_DOCUMENTCONTROLLER_HXX
#include "documentcontroller.hxx"
#endif
#ifndef _DBAUI_COMMON_TYPES_HXX_
#include "commontypes.hxx"
#endif
// syntax of the tree userdata
// datasource holds the connection
// queries holds the nameaccess for the queries
// query holds the query
// tables holds the nameaccess for the tables
// table holds the table
// bookmarks holds the nameaccess for the document links
// table holds the document links
namespace com { namespace sun { namespace star { namespace lang { class XMultiServiceFactory; } } } }
namespace dbaui
{
//========================================================================
//= DBTreeListModel
//========================================================================
class DBTreeListModel : public SvLBoxTreeList
{
public:
struct DBTreeListUserData
{
/// if the entry denotes a table or query, this is the respective UNO object
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xObjectProperties;
/// if the entry denotes a object container, this is the UNO interface for this container
::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >
xContainer;
/// if the entry denotes a data source, this is the connection for this data source (if already connection)
SharedConnection xConnection;
/** if the entry denotes a data source, this is the connector between the model and the controller,
keeping the model alive as long as necessary
*/
ModelControllerConnector aController;
SbaTableQueryBrowser::EntryType eType;
String sAccessor;
DBTreeListUserData();
~DBTreeListUserData();
};
};
}
#endif // DBAUI_DBTREEMODEL_HXX
<|endoftext|>
|
<commit_before>#include "core/sampler.h"
#include <opencv2/imgproc.hpp>
#include "core/area.h"
#include "ts/ts.h"
using namespace cv;
namespace {
TEST(DistrSampler1D, Uniform) {
const int SIZE = 10, N = 1e4;
const float MEAN = 1.f/static_cast<float>(SIZE);
Mat1f pdf_uniform = Mat1f::ones(1, SIZE)*MEAN;
Sampler1D to; // test object
to.pdf(pdf_uniform);
Mat1f hist = Mat1f::zeros(1, SIZE);
for(int i=0; i<N; i++) {
int sampled_index = to.Sample();
EXPECT_IN_CLOSED(sampled_index, 0, SIZE-1);
hist(sampled_index)++;
}
EXPECT_EQ(sum(hist)(0), N);
Mat1f hist_normalized = hist/static_cast<float>(N);
EXPECT_MAT_NEAR(hist_normalized, pdf_uniform, 0.2f);
Mat m, s;
meanStdDev(hist_normalized, m, s);
EXPECT_NEAR(m.at<double>(0, 0), MEAN, 0.1);
EXPECT_NEAR(s.at<double>(0, 0), 0., 0.1);
}
TEST(DistrSampler1D, Gaussian) {
const int SIZE = 10, N=2000;
const float MEAN = 5.f, STD_DEV = 2.f;
// generate gaussian pdf
Mat data(1, N, CV_32FC1);
randn(data, MEAN, STD_DEV);
float pdf_values[SIZE] = {};
for (int i=0; i<N; i++) {
float v = data.at<float>(i);
if ( v >= 0.f && v<10.0) {
++pdf_values[static_cast<int>(v)];
}
}
Sampler1D to; // test object
Mat pdf = Mat(1,10, CV_32FC1, pdf_values)/static_cast<float>(N)*SIZE;
to.pdf(pdf);
Mat1f hist = Mat1f::zeros(1, SIZE);
for(int i=0; i<N; i++) {
int sampled_index = to.Sample();
EXPECT_IN_CLOSED(sampled_index, 0, SIZE-1);
hist(sampled_index)++;
}
EXPECT_EQ(sum(hist)(0), N);
Mat1f hist_normalized = hist/static_cast<float>(N)*SIZE;
EXPECT_MAT_NEAR(hist_normalized, pdf, 0.2f);
}
TEST(DistrSampler2D, Uniform) {
const int ROWS = 7, COLS = 10, N = 2e4;
const float MEAN = 1.f/static_cast<float>(ROWS*COLS);
Mat1f pdf_uniform = Mat1f::ones(ROWS, COLS)*MEAN;
Sampler2D to; // test object
to.pdf(pdf_uniform);
Mat1f hist = Mat1f::zeros(ROWS, COLS);
for(int i=0; i<N; i++) {
Point2i sampled_point = to.Sample();
EXPECT_TRUE( sampled_point.inside(Rect(0, 0, COLS, ROWS)) );
hist(sampled_point.y, sampled_point.x)++;
}
EXPECT_EQ(sum(hist)(0), N);
Mat1f hist_normalized = hist/static_cast<float>(N);
EXPECT_MAT_NEAR(hist_normalized, pdf_uniform, 0.2f);
Mat m, s;
meanStdDev(hist_normalized, m, s);
EXPECT_NEAR(m.at<double>(0, 0), MEAN, 0.1);
EXPECT_NEAR(s.at<double>(0, 0), 0., 0.1);
}
class PoissonProcessTest : public testing::Test
{
protected:
PoissonProcessTest()
: frequency_(1.f),
delta_t_msec_(1000.f),
to_(0.f, 0.f) // dummy initialization
{
}
virtual void SetUp()
{
to_ = PoissonProcess(frequency_, delta_t_msec_); // -ve frequency => inf firing rate, 1 msec time resolution
}
float frequency_;
float delta_t_msec_;
PoissonProcess to_; ///< test object
};
TEST_F(PoissonProcessTest, PDF)
{
Mat1f pdf = to_.pdf();
EXPECT_MAT_DIMS_EQ(pdf, Mat1f(1, 1));
float lambda = pdf(0, 0);
EXPECT_LE(lambda, 0);
EXPECT_FLOAT_EQ(lambda, 1.f-frequency_*delta_t_msec_/1000.f);
}
TEST_F(PoissonProcessTest, Sample)
{
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(1, to_.Sample());
}
}
TEST_F(PoissonProcessTest, SampleZeroFreq)
{
PoissonProcess to(0.f, 1.f);
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(0, to.Sample());
}
}
TEST_F(PoissonProcessTest, SampleZeroDeltaT)
{
PoissonProcess to(40.f, 0.f);
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(0, to.Sample());
}
}
TEST_F(PoissonProcessTest, SampleZeroFreqAndDeltaT)
{
PoissonProcess to(0.f, 0.f);
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(0, to.Sample());
}
}
TEST_F(PoissonProcessTest, SampleCoinToss)
{
PoissonProcess to(50.f, 10.f);
const int N = 1e4;
int net = 0;
for(int i=0; i<N; i++) {
net += to.Sample();
}
float rate = net/static_cast<float>(N);
EXPECT_NEAR(rate, 0.5f, 0.02f);
}
/**
* @brief Compare theoretical pdf for exponential distr.
* to pdf generate from 1) pdf sampler 2) randexp()
*/
TEST(ExponentialPDFTest, Sample)
{
const double PDF_END=10.; // last x element in pdf function
const int SIZE=30, N=2000; // no. of bins, no. of samples to draw
const float LAMBDA = 1.f;
// generate exponential pdf
Mat1f pdf(1, SIZE);
double x = 0.;
for (int i=0; i<SIZE; i++,
x += PDF_END/static_cast<double>(SIZE)) {
double f = exp(-static_cast<double>(LAMBDA)*x);
pdf(i) = LAMBDA*static_cast<float>(f);
}
// add generated pdf to a sampler and draw samples from it
Sampler1D to; // test object
to.pdf(pdf);
// generate a histogram from sampled values
// also sample values from randexp() function
Mat1f hist1 = Mat1f::zeros(1, SIZE);
Mat1f hist2 = Mat1f::zeros(1, SIZE);
for(int i=0; i<N; i++) {
// collect samples drawn from pdf into a histogram
int sampled_index = to.Sample();
EXPECT_IN_CLOSED(sampled_index, 0, SIZE-1) << "Sample out of bounds.";
hist1(sampled_index)++;
// collect samples drawn from exp. sampling function into a second histogram
float v = sem::randexp(LAMBDA);
int bin = static_cast<int>(v*SIZE/PDF_END); // find the right bin for it
if(bin < SIZE) {
hist2(bin)++;
}
}
EXPECT_EQ(sum(hist1)(0), N);
// compare each histogram of drawn samples to original exponential pdf
Mat1f hist1_normalized = hist1/hist1(0);
EXPECT_MAT_NEAR(hist1_normalized, pdf, 0.2f);
Mat1f hist2_normalized = hist2/hist2(0);
EXPECT_MAT_NEAR(hist2_normalized, pdf, 0.2f);
}
/**
* @brief Compare samples from randexp() with different lambda values
*/
TEST(ExponentialPDFTest, Lambda)
{
const float PDF_END=5.; // last x element in pdf function
const int SIZE=10, N=2000; // no. of bins, no. of samples to draw
const float PDF_SCALE_FACTOR=static_cast<float>(SIZE)/PDF_END;
// generate a histogram from sampled values
// also sample values from randexp() function
std::vector<Mat1f> hists;
// collect samples drawn from exp. sampling function into a second histogram
int hist_index=0;
for(float lambda=0.5f; lambda<=1.5f; lambda+=0.5f, hist_index++) {
hists.push_back(Mat1f::zeros(1, SIZE)); // initialize histogram counts
for(int i=0; i<N; i++) {
float v = sem::randexp(lambda);
int bin = static_cast<int>(v*PDF_SCALE_FACTOR); // find the right bin for it
if(bin < SIZE) {
hists[hist_index](bin)++;
}
}
}
// compare pdf amplitudes
for(int i=1; i<static_cast<int>(hists.size()); i++) {
// left part of pdf
Mat gt = hists[i] > hists[i-1];
EXPECT_EQ(countNonZero(gt.colRange(0, 2)), 2)
<< "hist[" << i <<"] <= hist[" << i-1 << "]";
// pdf tail
Mat lt = hists[i] < hists[i-1];
EXPECT_EQ(countNonZero(lt.colRange(lt.cols-4, lt.cols-2)), 2)
<< "hist[" << i <<"] >= hist[" << i-1 << "]";
}
}
TEST(ExponentialPDFTest, PDFArea)
{
const float PDF_END=10.; // last x element in pdf function
const int SIZE=50, N=2000; // no. of bins, no. of samples to draw
const float PDF_SCALE_FACTOR=static_cast<float>(SIZE)/PDF_END;
Mat1f x(1, SIZE);
float x_val = 0.f;
for(int i=0; i<SIZE; i++) {
x(i) = x_val;
x_val += 1.f/PDF_SCALE_FACTOR;
}
// generate a histogram from sampled values
// also sample values from randexp() function
std::vector<Mat1f> hists;
// collect samples drawn from exp. sampling function into a second histogram
int hist_index=0;
for(float lambda=0.5f; lambda<=1.5f; lambda+=0.5f, hist_index++) {
hists.push_back(Mat1f::zeros(1, SIZE)); // initialize histogram counts
for(int i=0; i<N; i++) {
float v = sem::randexp(lambda);
int bin = static_cast<int>(v*PDF_SCALE_FACTOR); // find the right bin for it
if(bin < SIZE) {
hists[hist_index](bin)++;
}
}
}
// check moments
double lambda = 0.5;
for(int i=0; i<static_cast<int>(hists.size()); i++) {
Mat1f pdf;
divide(hists[i], sum(hists[i]/PDF_SCALE_FACTOR)(0), pdf);
EXPECT_NEAR(Trapz()(x, pdf), 1.f, 0.2f);
lambda += 0.5;
}
}
} // namespace
<commit_msg>update test name<commit_after>#include "core/sampler.h"
#include <opencv2/imgproc.hpp>
#include "core/area.h"
#include "ts/ts.h"
using namespace cv;
namespace {
TEST(Sampler1DTest, Uniform) {
const int SIZE = 10, N = 1e4;
const float MEAN = 1.f/static_cast<float>(SIZE);
Mat1f pdf_uniform = Mat1f::ones(1, SIZE)*MEAN;
Sampler1D to; // test object
to.pdf(pdf_uniform);
Mat1f hist = Mat1f::zeros(1, SIZE);
for(int i=0; i<N; i++) {
int sampled_index = to.Sample();
EXPECT_IN_CLOSED(sampled_index, 0, SIZE-1);
hist(sampled_index)++;
}
EXPECT_EQ(sum(hist)(0), N);
Mat1f hist_normalized = hist/static_cast<float>(N);
EXPECT_MAT_NEAR(hist_normalized, pdf_uniform, 0.2f);
Mat m, s;
meanStdDev(hist_normalized, m, s);
EXPECT_NEAR(m.at<double>(0, 0), MEAN, 0.1);
EXPECT_NEAR(s.at<double>(0, 0), 0., 0.1);
}
TEST(Sampler1DTest, Gaussian) {
const int SIZE = 10, N=2000;
const float MEAN = 5.f, STD_DEV = 2.f;
// generate gaussian pdf
Mat data(1, N, CV_32FC1);
randn(data, MEAN, STD_DEV);
float pdf_values[SIZE] = {};
for (int i=0; i<N; i++) {
float v = data.at<float>(i);
if ( v >= 0.f && v<10.0) {
++pdf_values[static_cast<int>(v)];
}
}
Sampler1D to; // test object
Mat pdf = Mat(1,10, CV_32FC1, pdf_values)/static_cast<float>(N)*SIZE;
to.pdf(pdf);
Mat1f hist = Mat1f::zeros(1, SIZE);
for(int i=0; i<N; i++) {
int sampled_index = to.Sample();
EXPECT_IN_CLOSED(sampled_index, 0, SIZE-1);
hist(sampled_index)++;
}
EXPECT_EQ(sum(hist)(0), N);
Mat1f hist_normalized = hist/static_cast<float>(N)*SIZE;
EXPECT_MAT_NEAR(hist_normalized, pdf, 0.2f);
}
TEST(Sampler2DTest, Uniform) {
const int ROWS = 7, COLS = 10, N = 2e4;
const float MEAN = 1.f/static_cast<float>(ROWS*COLS);
Mat1f pdf_uniform = Mat1f::ones(ROWS, COLS)*MEAN;
Sampler2D to; // test object
to.pdf(pdf_uniform);
Mat1f hist = Mat1f::zeros(ROWS, COLS);
for(int i=0; i<N; i++) {
Point2i sampled_point = to.Sample();
EXPECT_TRUE( sampled_point.inside(Rect(0, 0, COLS, ROWS)) );
hist(sampled_point.y, sampled_point.x)++;
}
EXPECT_EQ(sum(hist)(0), N);
Mat1f hist_normalized = hist/static_cast<float>(N);
EXPECT_MAT_NEAR(hist_normalized, pdf_uniform, 0.2f);
Mat m, s;
meanStdDev(hist_normalized, m, s);
EXPECT_NEAR(m.at<double>(0, 0), MEAN, 0.1);
EXPECT_NEAR(s.at<double>(0, 0), 0., 0.1);
}
class PoissonProcessTest : public testing::Test
{
protected:
PoissonProcessTest()
: frequency_(1.f),
delta_t_msec_(1000.f),
to_(0.f, 0.f) // dummy initialization
{
}
virtual void SetUp()
{
to_ = PoissonProcess(frequency_, delta_t_msec_); // -ve frequency => inf firing rate, 1 msec time resolution
}
float frequency_;
float delta_t_msec_;
PoissonProcess to_; ///< test object
};
TEST_F(PoissonProcessTest, PDF)
{
Mat1f pdf = to_.pdf();
EXPECT_MAT_DIMS_EQ(pdf, Mat1f(1, 1));
float lambda = pdf(0, 0);
EXPECT_LE(lambda, 0);
EXPECT_FLOAT_EQ(lambda, 1.f-frequency_*delta_t_msec_/1000.f);
}
TEST_F(PoissonProcessTest, Sample)
{
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(1, to_.Sample());
}
}
TEST_F(PoissonProcessTest, SampleZeroFreq)
{
PoissonProcess to(0.f, 1.f);
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(0, to.Sample());
}
}
TEST_F(PoissonProcessTest, SampleZeroDeltaT)
{
PoissonProcess to(40.f, 0.f);
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(0, to.Sample());
}
}
TEST_F(PoissonProcessTest, SampleZeroFreqAndDeltaT)
{
PoissonProcess to(0.f, 0.f);
const int N = 100;
for(int i=0; i<N; i++) {
EXPECT_EQ(0, to.Sample());
}
}
TEST_F(PoissonProcessTest, SampleCoinToss)
{
PoissonProcess to(50.f, 10.f);
const int N = 1e4;
int net = 0;
for(int i=0; i<N; i++) {
net += to.Sample();
}
float rate = net/static_cast<float>(N);
EXPECT_NEAR(rate, 0.5f, 0.02f);
}
/**
* @brief Compare theoretical pdf for exponential distr.
* to pdf generate from 1) pdf sampler 2) randexp()
*/
TEST(ExponentialPDFTest, Sample)
{
const double PDF_END=10.; // last x element in pdf function
const int SIZE=30, N=2000; // no. of bins, no. of samples to draw
const float LAMBDA = 1.f;
// generate exponential pdf
Mat1f pdf(1, SIZE);
double x = 0.;
for (int i=0; i<SIZE; i++,
x += PDF_END/static_cast<double>(SIZE)) {
double f = exp(-static_cast<double>(LAMBDA)*x);
pdf(i) = LAMBDA*static_cast<float>(f);
}
// add generated pdf to a sampler and draw samples from it
Sampler1D to; // test object
to.pdf(pdf);
// generate a histogram from sampled values
// also sample values from randexp() function
Mat1f hist1 = Mat1f::zeros(1, SIZE);
Mat1f hist2 = Mat1f::zeros(1, SIZE);
for(int i=0; i<N; i++) {
// collect samples drawn from pdf into a histogram
int sampled_index = to.Sample();
EXPECT_IN_CLOSED(sampled_index, 0, SIZE-1) << "Sample out of bounds.";
hist1(sampled_index)++;
// collect samples drawn from exp. sampling function into a second histogram
float v = sem::randexp(LAMBDA);
int bin = static_cast<int>(v*SIZE/PDF_END); // find the right bin for it
if(bin < SIZE) {
hist2(bin)++;
}
}
EXPECT_EQ(sum(hist1)(0), N);
// compare each histogram of drawn samples to original exponential pdf
Mat1f hist1_normalized = hist1/hist1(0);
EXPECT_MAT_NEAR(hist1_normalized, pdf, 0.2f);
Mat1f hist2_normalized = hist2/hist2(0);
EXPECT_MAT_NEAR(hist2_normalized, pdf, 0.2f);
}
/**
* @brief Compare samples from randexp() with different lambda values
*/
TEST(ExponentialPDFTest, Lambda)
{
const float PDF_END=5.; // last x element in pdf function
const int SIZE=10, N=2000; // no. of bins, no. of samples to draw
const float PDF_SCALE_FACTOR=static_cast<float>(SIZE)/PDF_END;
// generate a histogram from sampled values
// also sample values from randexp() function
std::vector<Mat1f> hists;
// collect samples drawn from exp. sampling function into a second histogram
int hist_index=0;
for(float lambda=0.5f; lambda<=1.5f; lambda+=0.5f, hist_index++) {
hists.push_back(Mat1f::zeros(1, SIZE)); // initialize histogram counts
for(int i=0; i<N; i++) {
float v = sem::randexp(lambda);
int bin = static_cast<int>(v*PDF_SCALE_FACTOR); // find the right bin for it
if(bin < SIZE) {
hists[hist_index](bin)++;
}
}
}
// compare pdf amplitudes
for(int i=1; i<static_cast<int>(hists.size()); i++) {
// left part of pdf
Mat gt = hists[i] > hists[i-1];
EXPECT_EQ(countNonZero(gt.colRange(0, 2)), 2)
<< "hist[" << i <<"] <= hist[" << i-1 << "]";
// pdf tail
Mat lt = hists[i] < hists[i-1];
EXPECT_EQ(countNonZero(lt.colRange(lt.cols-4, lt.cols-2)), 2)
<< "hist[" << i <<"] >= hist[" << i-1 << "]";
}
}
TEST(ExponentialPDFTest, PDFArea)
{
const float PDF_END=10.; // last x element in pdf function
const int SIZE=50, N=2000; // no. of bins, no. of samples to draw
const float PDF_SCALE_FACTOR=static_cast<float>(SIZE)/PDF_END;
Mat1f x(1, SIZE);
float x_val = 0.f;
for(int i=0; i<SIZE; i++) {
x(i) = x_val;
x_val += 1.f/PDF_SCALE_FACTOR;
}
// generate a histogram from sampled values
// also sample values from randexp() function
std::vector<Mat1f> hists;
// collect samples drawn from exp. sampling function into a second histogram
int hist_index=0;
for(float lambda=0.5f; lambda<=1.5f; lambda+=0.5f, hist_index++) {
hists.push_back(Mat1f::zeros(1, SIZE)); // initialize histogram counts
for(int i=0; i<N; i++) {
float v = sem::randexp(lambda);
int bin = static_cast<int>(v*PDF_SCALE_FACTOR); // find the right bin for it
if(bin < SIZE) {
hists[hist_index](bin)++;
}
}
}
// check moments
double lambda = 0.5;
for(int i=0; i<static_cast<int>(hists.size()); i++) {
Mat1f pdf;
divide(hists[i], sum(hists[i]/PDF_SCALE_FACTOR)(0), pdf);
EXPECT_NEAR(Trapz()(x, pdf), 1.f, 0.2f);
lambda += 0.5;
}
}
} // namespace
<|endoftext|>
|
<commit_before>#ifndef _GUARD_CAST_HPP_
#define _GUARD_CAST_HPP_
#include <limits>
#include "bpmodule/pragma.h"
#include "bpmodule/exception/MathException.hpp"
#include "bpmodule/mangle/Mangle.hpp"
namespace bpmodule {
namespace math {
/*! Perform a safe cast between integer types or between floating point types
*
* Checks for overflows and underflows, as well as loss of precision with floating
* point conversions.
*
* Cannot be used to convert integer <-> floating point. Use round_cast instead.
*
* \throw bpmodule::exception::MathException if there is a problem (overflow, underflow, etc)
*/
template<typename Target, typename Source>
Target numeric_cast(Source s)
{
static_assert( ( std::is_integral<Source>::value && std::is_integral<Target>::value) ||
( std::is_floating_point<Source>::value && std::is_floating_point<Target>::value),
"Attempting to perform integer <-> floating point conversion using numeric_cast. Consider round_cast");
// no casting
if(std::is_same<Target, Source>::value)
return static_cast<Target>(s); // cast to make compiler warnings go away
////////////////////////////////////////////////////////////////////////////////
// this is written with branching so that the limits checking isn't always done
// (ie, going from short->int should be pretty much optimized out)
//
// Actually, most branching shown here should be optimized out at compile
////////////////////////////////////////////////////////////////////////////////
///////////////////
// for integers
///////////////////
if(std::is_integral<Source>::value && std::is_integral<Target>::value)
{
// both are signed or unsigned
if(std::is_signed<Source>::value == std::is_signed<Target>::value)
{
// going from smaller to larger type - ok
if(std::numeric_limits<Target>::digits >= std::numeric_limits<Source>::digits)
return static_cast<Target>(s);
else
{
// source is larger type than target. check limits
Source tmax = static_cast<Source>(std::numeric_limits<Target>::max());
Source tmin = static_cast<Source>(std::numeric_limits<Target>::lowest());
if(s > tmax)
throw exception::MathException("Error in numeric_cast",
"desc", "source value overflows target type",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
else if(s < tmin)
throw exception::MathException("Error in numeric_cast",
"desc", "source value underflows target type",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
else // safe!
return static_cast<Target>(s);
}
}
else if(std::is_signed<Source>::value) // Source is signed, Target is unsigned
{
if(s < 0)
throw exception::MathException("Error in numeric_cast",
"desc", "source value underflows target type",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
// going from smaller to larger type - ok (since s >= 0)
if(std::numeric_limits<Target>::digits >= std::numeric_limits<Source>::digits)
return static_cast<Target>(s);
else
{
// source is larger type than target. check other limit
// casting to Source type should be ok since sizeof(Source) > sizeof(Target)
Source tmax = static_cast<Source>(std::numeric_limits<Target>::max());
if(s > tmax)
throw exception::MathException("Error in numeric_cast",
"desc", "source value overflows target type",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
else // safe!
return static_cast<Target>(s);
}
}
else // Source is unsigned, target is signed
{
// going from smaller to larger type - ok
// (since numeric_limits::digits reports bits without sign bit)
if(std::numeric_limits<Target>::digits >= std::numeric_limits<Source>::digits)
return static_cast<Target>(s);
else
{
// source is larger type than target. check max limit
// casting to Source type should be ok since sizeof(Source) > sizeof(Target)
Source tmax = static_cast<Source>(std::numeric_limits<Target>::max());
if(s > tmax)
throw exception::MathException("Error in numeric_cast",
"desc", "source value overflows target type",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
else // safe!
return static_cast<Target>(s);
}
}
}
// if both are floating point
// we have to check that the conversion is valid
else if(std::is_floating_point<Source>::value && std::is_floating_point<Target>::value)
{
// Hackish way, but convert to target and back, then compare
// check for overflow and underflow
Target t = static_cast<Target>(s);
Source s2 = static_cast<Source>(t);
// ignore this warning -- we are doing it on purpose
PRAGMA_WARNING_PUSH
PRAGMA_WARNING_IGNORE_FP_EQUALITY
if(s == s2)
return t;
else
throw exception::MathException("Error in numeric_cast",
"desc", "Floating point conversion results in loss of precision",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
PRAGMA_WARNING_POP
}
else
throw std::logic_error("numeric_cast unhandled types");
}
/*! \brief Convert between integer and floating point types, with rounding
*
* \todo NYI
*/
template<typename Target, typename Source>
Target round_cast(Source s)
{
static_assert(std::is_same<Source, Target>::value, "TODO: round_cast between different types");
return s;
}
} // close namespace math
} // close namespace bpmodule
#endif
<commit_msg>Fix exception info<commit_after>#ifndef _GUARD_CAST_HPP_
#define _GUARD_CAST_HPP_
#include <limits>
#include "bpmodule/pragma.h"
#include "bpmodule/exception/MathException.hpp"
#include "bpmodule/mangle/Mangle.hpp"
namespace bpmodule {
namespace math {
/*! Perform a safe cast between integer types or between floating point types
*
* Checks for overflows and underflows, as well as loss of precision with floating
* point conversions.
*
* Cannot be used to convert integer <-> floating point. Use round_cast instead.
*
* \throw bpmodule::exception::MathException if there is a problem (overflow, underflow, etc)
*/
template<typename Target, typename Source>
Target numeric_cast(Source s)
{
static_assert( ( std::is_integral<Source>::value && std::is_integral<Target>::value) ||
( std::is_floating_point<Source>::value && std::is_floating_point<Target>::value),
"Attempting to perform integer <-> floating point conversion using numeric_cast. Consider round_cast");
// no casting
if(std::is_same<Target, Source>::value)
return static_cast<Target>(s); // cast to make compiler warnings go away
////////////////////////////////////////////////////////////////////////////////
// this is written with branching so that the limits checking isn't always done
// (ie, going from short->int should be pretty much optimized out)
//
// Actually, most branching shown here should be optimized out at compile
////////////////////////////////////////////////////////////////////////////////
///////////////////
// for integers
///////////////////
if(std::is_integral<Source>::value && std::is_integral<Target>::value)
{
// both are signed or unsigned
if(std::is_signed<Source>::value == std::is_signed<Target>::value)
{
// going from smaller to larger type - ok
if(std::numeric_limits<Target>::digits >= std::numeric_limits<Source>::digits)
return static_cast<Target>(s);
else
{
// source is larger type than target. check limits
Source tmax = static_cast<Source>(std::numeric_limits<Target>::max());
Source tmin = static_cast<Source>(std::numeric_limits<Target>::lowest());
if(s > tmax)
throw exception::MathException("Error in numeric_cast",
"desc", "source value overflows target type",
"ifrom", mangle::DemangleCppType<Source>(),
"ito", mangle::DemangleCppType<Target>());
else if(s < tmin)
throw exception::MathException("Error in numeric_cast",
"desc", "source value underflows target type",
"ifrom", mangle::DemangleCppType<Source>(),
"ito", mangle::DemangleCppType<Target>());
else // safe!
return static_cast<Target>(s);
}
}
else if(std::is_signed<Source>::value) // Source is signed, Target is unsigned
{
if(s < 0)
throw exception::MathException("Error in numeric_cast",
"desc", "source value underflows target type",
"ifrom", mangle::DemangleCppType<Source>(),
"ito", mangle::DemangleCppType<Target>());
// going from smaller to larger type - ok (since s >= 0)
if(std::numeric_limits<Target>::digits >= std::numeric_limits<Source>::digits)
return static_cast<Target>(s);
else
{
// source is larger type than target. check other limit
// casting to Source type should be ok since sizeof(Source) > sizeof(Target)
Source tmax = static_cast<Source>(std::numeric_limits<Target>::max());
if(s > tmax)
throw exception::MathException("Error in numeric_cast",
"desc", "source value overflows target type",
"ifrom", mangle::DemangleCppType<Source>(),
"ito", mangle::DemangleCppType<Target>());
else // safe!
return static_cast<Target>(s);
}
}
else // Source is unsigned, target is signed
{
// going from smaller to larger type - ok
// (since numeric_limits::digits reports bits without sign bit)
if(std::numeric_limits<Target>::digits >= std::numeric_limits<Source>::digits)
return static_cast<Target>(s);
else
{
// source is larger type than target. check max limit
// casting to Source type should be ok since sizeof(Source) > sizeof(Target)
Source tmax = static_cast<Source>(std::numeric_limits<Target>::max());
if(s > tmax)
throw exception::MathException("Error in numeric_cast",
"desc", "source value overflows target type",
"ifrom", mangle::DemangleCppType<Source>(),
"ito", mangle::DemangleCppType<Target>());
else // safe!
return static_cast<Target>(s);
}
}
}
// if both are floating point
// we have to check that the conversion is valid
else if(std::is_floating_point<Source>::value && std::is_floating_point<Target>::value)
{
// Hackish way, but convert to target and back, then compare
// check for overflow and underflow
Target t = static_cast<Target>(s);
Source s2 = static_cast<Source>(t);
// ignore this warning -- we are doing it on purpose
PRAGMA_WARNING_PUSH
PRAGMA_WARNING_IGNORE_FP_EQUALITY
if(s == s2)
return t;
else
throw exception::MathException("Error in numeric_cast",
"desc", "Floating point conversion results in loss of precision",
"fpfrom", mangle::DemangleCppType<Source>(),
"fpto", mangle::DemangleCppType<Target>());
PRAGMA_WARNING_POP
}
else
throw std::logic_error("numeric_cast unhandled types");
}
/*! \brief Convert between integer and floating point types, with rounding
*
* \todo NYI
*/
template<typename Target, typename Source>
Target round_cast(Source s)
{
static_assert(std::is_same<Source, Target>::value, "TODO: round_cast between different types");
return s;
}
} // close namespace math
} // close namespace bpmodule
#endif
<|endoftext|>
|
<commit_before>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include <vector>
#include "base/memory/scoped_ptr.h"
#include "base/rand_util.h"
#include "base/utf_string_conversions.h"
#include "chrome/browser/sessions/session_types.h"
#include "chrome/browser/sync/glue/synced_session_tracker.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace browser_sync {
typedef testing::Test SyncedSessionTrackerTest;
TEST_F(SyncedSessionTrackerTest, GetSession) {
SyncedSessionTracker tracker;
SyncedSession* session1 = tracker.GetSession("tag");
SyncedSession* session2 = tracker.GetSession("tag2");
ASSERT_EQ(session1, tracker.GetSession("tag"));
ASSERT_NE(session1, session2);
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) {
SyncedSessionTracker tracker;
SessionTab* tab = tracker.GetTab("tag", 0);
ASSERT_EQ(tab, tracker.GetTab("tag", 0));
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, PutWindowInSession) {
SyncedSessionTracker tracker;
tracker.PutWindowInSession("tag", 0);
SyncedSession* session = tracker.GetSession("tag");
ASSERT_EQ(1U, session->windows.size());
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, PutTabInWindow) {
SyncedSessionTracker tracker;
tracker.PutWindowInSession("tag", 10);
tracker.PutTabInWindow("tag", 10, 15, 0); // win id 10, tab id 15, tab ind 0.
SyncedSession* session = tracker.GetSession("tag");
ASSERT_EQ(1U, session->windows.size());
ASSERT_EQ(1U, session->windows[10]->tabs.size());
ASSERT_EQ(tracker.GetTab("tag", 15), session->windows[10]->tabs[0]);
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) {
SyncedSessionTracker tracker;
std::vector<const SyncedSession*> sessions;
ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions));
tracker.GetSession("tag1");
tracker.GetSession("tag2");
tracker.PutWindowInSession("tag1", 0);
tracker.PutTabInWindow("tag1", 0, 15, 0);
SessionTab* tab = tracker.GetTab("tag1", 15);
ASSERT_TRUE(tab);
tab->navigations.push_back(TabNavigation(
0, GURL("valid_url"), GURL("referrer"),
string16(ASCIIToUTF16("title")),
std::string("state"), content::PageTransitionFromInt(0)));
ASSERT_TRUE(tracker.LookupAllForeignSessions(&sessions));
// Only the session with a valid window and tab gets returned.
ASSERT_EQ(1U, sessions.size());
ASSERT_EQ("tag1", sessions[0]->session_tag);
}
TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) {
SyncedSessionTracker tracker;
std::vector<const SessionWindow*> windows;
ASSERT_FALSE(tracker.LookupSessionWindows("tag1", &windows));
tracker.GetSession("tag1");
tracker.PutWindowInSession("tag1", 0);
tracker.PutWindowInSession("tag1", 2);
tracker.GetSession("tag2");
tracker.PutWindowInSession("tag2", 0);
tracker.PutWindowInSession("tag2", 2);
ASSERT_TRUE(tracker.LookupSessionWindows("tag1", &windows));
ASSERT_EQ(2U, windows.size()); // Only windows from tag1 session.
ASSERT_NE((SessionWindow*)NULL, windows[0]);
ASSERT_NE((SessionWindow*)NULL, windows[1]);
ASSERT_NE(windows[1], windows[0]);
}
TEST_F(SyncedSessionTrackerTest, LookupSessionTab) {
SyncedSessionTracker tracker;
const SessionTab* tab;
ASSERT_FALSE(tracker.LookupSessionTab("tag1", 5, &tab));
tracker.GetSession("tag1");
tracker.PutWindowInSession("tag1", 0);
tracker.PutTabInWindow("tag1", 0, 5, 0);
ASSERT_TRUE(tracker.LookupSessionTab("tag1", 5, &tab));
ASSERT_NE((SessionTab*)NULL, tab);
}
TEST_F(SyncedSessionTrackerTest, Complex) {
const std::string tag1 = "tag";
const std::string tag2 = "tag2";
const std::string tag3 = "tag3";
SyncedSessionTracker tracker;
std::vector<SessionTab*> tabs1, tabs2;
SessionTab* temp_tab;
ASSERT_TRUE(tracker.Empty());
ASSERT_EQ(0U, tracker.num_synced_sessions());
ASSERT_EQ(0U, tracker.num_synced_tabs(tag1));
tabs1.push_back(tracker.GetTab(tag1, 0));
tabs1.push_back(tracker.GetTab(tag1, 1));
tabs1.push_back(tracker.GetTab(tag1, 2));
ASSERT_EQ(3U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(0U, tracker.num_synced_sessions());
temp_tab = tracker.GetTab(tag1, 0); // Already created.
ASSERT_EQ(3U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(0U, tracker.num_synced_sessions());
ASSERT_EQ(tabs1[0], temp_tab);
tabs2.push_back(tracker.GetTab(tag2, 0));
ASSERT_EQ(1U, tracker.num_synced_tabs(tag2));
ASSERT_EQ(0U, tracker.num_synced_sessions());
ASSERT_FALSE(tracker.DeleteSession(tag3));
SyncedSession* session = tracker.GetSession(tag1);
SyncedSession* session2 = tracker.GetSession(tag2);
SyncedSession* session3 = tracker.GetSession(tag3);
ASSERT_EQ(3U, tracker.num_synced_sessions());
ASSERT_TRUE(session);
ASSERT_TRUE(session2);
ASSERT_TRUE(session3);
ASSERT_NE(session, session2);
ASSERT_NE(session2, session3);
ASSERT_TRUE(tracker.DeleteSession(tag3));
ASSERT_EQ(2U, tracker.num_synced_sessions());
tracker.PutWindowInSession(tag1, 0); // Create a window.
tracker.PutTabInWindow(tag1, 0, 2, 0); // No longer unmapped.
ASSERT_EQ(3U, tracker.num_synced_tabs(tag1)); // Has not changed.
const SessionTab *tab_ptr;
ASSERT_TRUE(tracker.LookupSessionTab(tag1, 0, &tab_ptr));
ASSERT_EQ(tab_ptr, tabs1[0]);
ASSERT_TRUE(tracker.LookupSessionTab(tag1, 2, &tab_ptr));
ASSERT_EQ(tab_ptr, tabs1[2]);
ASSERT_FALSE(tracker.LookupSessionTab(tag1, 3, &tab_ptr));
ASSERT_EQ(static_cast<const SessionTab*>(NULL), tab_ptr);
std::vector<const SessionWindow*> windows;
ASSERT_TRUE(tracker.LookupSessionWindows(tag1, &windows));
ASSERT_EQ(1U, windows.size());
ASSERT_TRUE(tracker.LookupSessionWindows(tag2, &windows));
ASSERT_EQ(0U, windows.size());
// The sessions don't have valid tabs, lookup should not succeed.
std::vector<const SyncedSession*> sessions;
ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions));
tracker.Clear();
ASSERT_EQ(0U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(0U, tracker.num_synced_tabs(tag2));
ASSERT_EQ(0U, tracker.num_synced_sessions());
}
TEST_F(SyncedSessionTrackerTest, ManyGetTabs) {
SyncedSessionTracker tracker;
ASSERT_TRUE(tracker.Empty());
const int kMaxSessions = 10;
const int kMaxTabs = 1000;
const int kMaxAttempts = 10000;
for (int j=0; j<kMaxSessions; ++j) {
std::string tag = "tag" + j;
for (int i=0; i<kMaxAttempts; ++i) {
// More attempts than tabs means we'll sometimes get the same tabs,
// sometimes have to allocate new tabs.
int rand_tab_num = base::RandInt(0, kMaxTabs);
SessionTab* tab = tracker.GetTab(tag, rand_tab_num);
ASSERT_TRUE(tab);
}
}
}
TEST_F(SyncedSessionTrackerTest, SessionTracking) {
SyncedSessionTracker tracker;
ASSERT_TRUE(tracker.Empty());
std::string tag1 = "tag1";
std::string tag2 = "tag2";
// Create some session information that is stale.
SyncedSession* session1= tracker.GetSession(tag1);
tracker.PutWindowInSession(tag1, 0);
tracker.PutTabInWindow(tag1, 0, 0, 0);
tracker.PutTabInWindow(tag1, 0, 1, 1);
tracker.GetTab(tag1, 2)->window_id.set_id(0); // Will be an unmapped tab.
tracker.GetTab(tag1, 3)->window_id.set_id(0); // Will be an unmapped tab.
tracker.PutWindowInSession(tag1, 1);
tracker.PutTabInWindow(tag1, 1, 4, 0);
tracker.PutTabInWindow(tag1, 1, 5, 1);
ASSERT_EQ(2U, session1->windows.size());
ASSERT_EQ(2U, session1->windows[0]->tabs.size());
ASSERT_EQ(2U, session1->windows[1]->tabs.size());
ASSERT_EQ(6U, tracker.num_synced_tabs(tag1));
// Create a session that should not be affected.
SyncedSession* session2 = tracker.GetSession(tag2);
tracker.PutWindowInSession(tag2, 2);
tracker.PutTabInWindow(tag2, 2, 1, 0);
ASSERT_EQ(1U, session2->windows.size());
ASSERT_EQ(1U, session2->windows[2]->tabs.size());
ASSERT_EQ(1U, tracker.num_synced_tabs(tag2));
// Reset tracking and get the current windows/tabs.
// We simulate moving a tab from one window to another, then closing the first
// window (including it's one remaining tab), and opening a new tab on the
// remaining window.
tracker.GetTab(tag1, 6); // New tab, arrived before meta node so unmapped.
tracker.ResetSessionTracking(tag1);
tracker.PutWindowInSession(tag1, 0);
tracker.PutTabInWindow(tag1, 0, 0, 0);
// Tab 1 is closed.
tracker.PutTabInWindow(tag1, 0, 2, 1); // No longer unmapped.
// Tab 3 was unmapped and does not get used.
tracker.PutTabInWindow(tag1, 0, 4, 2); // Moved from window 1.
// Window 1 was closed, along with tab 5.
tracker.PutTabInWindow(tag1, 0, 6, 3); // No longer unmapped.
// Session 2 should not be affected.
tracker.CleanupSession(tag1);
// Verify that only those parts of the session not owned have been removed.
ASSERT_EQ(1U, session1->windows.size());
ASSERT_EQ(4U, session1->windows[0]->tabs.size());
ASSERT_EQ(1U, session2->windows.size());
ASSERT_EQ(1U, session2->windows[2]->tabs.size());
ASSERT_EQ(2U, tracker.num_synced_sessions());
ASSERT_EQ(4U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(1U, tracker.num_synced_tabs(tag2));
// All memory should be properly deallocated by destructor for the
// SyncedSessionTracker.
}
} // namespace browser_sync
<commit_msg>Hotfix SyncedSessionTrackerTest.ManyGetTabs to pass under AddressSanitizer.<commit_after>// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include <vector>
#include "base/memory/scoped_ptr.h"
#include "base/rand_util.h"
#include "base/utf_string_conversions.h"
#include "chrome/browser/sessions/session_types.h"
#include "chrome/browser/sync/glue/synced_session_tracker.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace browser_sync {
typedef testing::Test SyncedSessionTrackerTest;
TEST_F(SyncedSessionTrackerTest, GetSession) {
SyncedSessionTracker tracker;
SyncedSession* session1 = tracker.GetSession("tag");
SyncedSession* session2 = tracker.GetSession("tag2");
ASSERT_EQ(session1, tracker.GetSession("tag"));
ASSERT_NE(session1, session2);
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) {
SyncedSessionTracker tracker;
SessionTab* tab = tracker.GetTab("tag", 0);
ASSERT_EQ(tab, tracker.GetTab("tag", 0));
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, PutWindowInSession) {
SyncedSessionTracker tracker;
tracker.PutWindowInSession("tag", 0);
SyncedSession* session = tracker.GetSession("tag");
ASSERT_EQ(1U, session->windows.size());
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, PutTabInWindow) {
SyncedSessionTracker tracker;
tracker.PutWindowInSession("tag", 10);
tracker.PutTabInWindow("tag", 10, 15, 0); // win id 10, tab id 15, tab ind 0.
SyncedSession* session = tracker.GetSession("tag");
ASSERT_EQ(1U, session->windows.size());
ASSERT_EQ(1U, session->windows[10]->tabs.size());
ASSERT_EQ(tracker.GetTab("tag", 15), session->windows[10]->tabs[0]);
// Should clean up memory on it's own.
}
TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) {
SyncedSessionTracker tracker;
std::vector<const SyncedSession*> sessions;
ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions));
tracker.GetSession("tag1");
tracker.GetSession("tag2");
tracker.PutWindowInSession("tag1", 0);
tracker.PutTabInWindow("tag1", 0, 15, 0);
SessionTab* tab = tracker.GetTab("tag1", 15);
ASSERT_TRUE(tab);
tab->navigations.push_back(TabNavigation(
0, GURL("valid_url"), GURL("referrer"),
string16(ASCIIToUTF16("title")),
std::string("state"), content::PageTransitionFromInt(0)));
ASSERT_TRUE(tracker.LookupAllForeignSessions(&sessions));
// Only the session with a valid window and tab gets returned.
ASSERT_EQ(1U, sessions.size());
ASSERT_EQ("tag1", sessions[0]->session_tag);
}
TEST_F(SyncedSessionTrackerTest, LookupSessionWindows) {
SyncedSessionTracker tracker;
std::vector<const SessionWindow*> windows;
ASSERT_FALSE(tracker.LookupSessionWindows("tag1", &windows));
tracker.GetSession("tag1");
tracker.PutWindowInSession("tag1", 0);
tracker.PutWindowInSession("tag1", 2);
tracker.GetSession("tag2");
tracker.PutWindowInSession("tag2", 0);
tracker.PutWindowInSession("tag2", 2);
ASSERT_TRUE(tracker.LookupSessionWindows("tag1", &windows));
ASSERT_EQ(2U, windows.size()); // Only windows from tag1 session.
ASSERT_NE((SessionWindow*)NULL, windows[0]);
ASSERT_NE((SessionWindow*)NULL, windows[1]);
ASSERT_NE(windows[1], windows[0]);
}
TEST_F(SyncedSessionTrackerTest, LookupSessionTab) {
SyncedSessionTracker tracker;
const SessionTab* tab;
ASSERT_FALSE(tracker.LookupSessionTab("tag1", 5, &tab));
tracker.GetSession("tag1");
tracker.PutWindowInSession("tag1", 0);
tracker.PutTabInWindow("tag1", 0, 5, 0);
ASSERT_TRUE(tracker.LookupSessionTab("tag1", 5, &tab));
ASSERT_NE((SessionTab*)NULL, tab);
}
TEST_F(SyncedSessionTrackerTest, Complex) {
const std::string tag1 = "tag";
const std::string tag2 = "tag2";
const std::string tag3 = "tag3";
SyncedSessionTracker tracker;
std::vector<SessionTab*> tabs1, tabs2;
SessionTab* temp_tab;
ASSERT_TRUE(tracker.Empty());
ASSERT_EQ(0U, tracker.num_synced_sessions());
ASSERT_EQ(0U, tracker.num_synced_tabs(tag1));
tabs1.push_back(tracker.GetTab(tag1, 0));
tabs1.push_back(tracker.GetTab(tag1, 1));
tabs1.push_back(tracker.GetTab(tag1, 2));
ASSERT_EQ(3U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(0U, tracker.num_synced_sessions());
temp_tab = tracker.GetTab(tag1, 0); // Already created.
ASSERT_EQ(3U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(0U, tracker.num_synced_sessions());
ASSERT_EQ(tabs1[0], temp_tab);
tabs2.push_back(tracker.GetTab(tag2, 0));
ASSERT_EQ(1U, tracker.num_synced_tabs(tag2));
ASSERT_EQ(0U, tracker.num_synced_sessions());
ASSERT_FALSE(tracker.DeleteSession(tag3));
SyncedSession* session = tracker.GetSession(tag1);
SyncedSession* session2 = tracker.GetSession(tag2);
SyncedSession* session3 = tracker.GetSession(tag3);
ASSERT_EQ(3U, tracker.num_synced_sessions());
ASSERT_TRUE(session);
ASSERT_TRUE(session2);
ASSERT_TRUE(session3);
ASSERT_NE(session, session2);
ASSERT_NE(session2, session3);
ASSERT_TRUE(tracker.DeleteSession(tag3));
ASSERT_EQ(2U, tracker.num_synced_sessions());
tracker.PutWindowInSession(tag1, 0); // Create a window.
tracker.PutTabInWindow(tag1, 0, 2, 0); // No longer unmapped.
ASSERT_EQ(3U, tracker.num_synced_tabs(tag1)); // Has not changed.
const SessionTab *tab_ptr;
ASSERT_TRUE(tracker.LookupSessionTab(tag1, 0, &tab_ptr));
ASSERT_EQ(tab_ptr, tabs1[0]);
ASSERT_TRUE(tracker.LookupSessionTab(tag1, 2, &tab_ptr));
ASSERT_EQ(tab_ptr, tabs1[2]);
ASSERT_FALSE(tracker.LookupSessionTab(tag1, 3, &tab_ptr));
ASSERT_EQ(static_cast<const SessionTab*>(NULL), tab_ptr);
std::vector<const SessionWindow*> windows;
ASSERT_TRUE(tracker.LookupSessionWindows(tag1, &windows));
ASSERT_EQ(1U, windows.size());
ASSERT_TRUE(tracker.LookupSessionWindows(tag2, &windows));
ASSERT_EQ(0U, windows.size());
// The sessions don't have valid tabs, lookup should not succeed.
std::vector<const SyncedSession*> sessions;
ASSERT_FALSE(tracker.LookupAllForeignSessions(&sessions));
tracker.Clear();
ASSERT_EQ(0U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(0U, tracker.num_synced_tabs(tag2));
ASSERT_EQ(0U, tracker.num_synced_sessions());
}
TEST_F(SyncedSessionTrackerTest, ManyGetTabs) {
SyncedSessionTracker tracker;
ASSERT_TRUE(tracker.Empty());
const int kMaxSessions = 10;
const int kMaxTabs = 1000;
const int kMaxAttempts = 10000;
char tag_buf[20];
for (int j=0; j<kMaxSessions; ++j) {
snprintf(tag_buf, sizeof(tag_buf), "tag%d", j);
std::string tag(tag_buf);
for (int i=0; i<kMaxAttempts; ++i) {
// More attempts than tabs means we'll sometimes get the same tabs,
// sometimes have to allocate new tabs.
int rand_tab_num = base::RandInt(0, kMaxTabs);
SessionTab* tab = tracker.GetTab(tag, rand_tab_num);
ASSERT_TRUE(tab);
}
}
}
TEST_F(SyncedSessionTrackerTest, SessionTracking) {
SyncedSessionTracker tracker;
ASSERT_TRUE(tracker.Empty());
std::string tag1 = "tag1";
std::string tag2 = "tag2";
// Create some session information that is stale.
SyncedSession* session1= tracker.GetSession(tag1);
tracker.PutWindowInSession(tag1, 0);
tracker.PutTabInWindow(tag1, 0, 0, 0);
tracker.PutTabInWindow(tag1, 0, 1, 1);
tracker.GetTab(tag1, 2)->window_id.set_id(0); // Will be an unmapped tab.
tracker.GetTab(tag1, 3)->window_id.set_id(0); // Will be an unmapped tab.
tracker.PutWindowInSession(tag1, 1);
tracker.PutTabInWindow(tag1, 1, 4, 0);
tracker.PutTabInWindow(tag1, 1, 5, 1);
ASSERT_EQ(2U, session1->windows.size());
ASSERT_EQ(2U, session1->windows[0]->tabs.size());
ASSERT_EQ(2U, session1->windows[1]->tabs.size());
ASSERT_EQ(6U, tracker.num_synced_tabs(tag1));
// Create a session that should not be affected.
SyncedSession* session2 = tracker.GetSession(tag2);
tracker.PutWindowInSession(tag2, 2);
tracker.PutTabInWindow(tag2, 2, 1, 0);
ASSERT_EQ(1U, session2->windows.size());
ASSERT_EQ(1U, session2->windows[2]->tabs.size());
ASSERT_EQ(1U, tracker.num_synced_tabs(tag2));
// Reset tracking and get the current windows/tabs.
// We simulate moving a tab from one window to another, then closing the first
// window (including it's one remaining tab), and opening a new tab on the
// remaining window.
tracker.GetTab(tag1, 6); // New tab, arrived before meta node so unmapped.
tracker.ResetSessionTracking(tag1);
tracker.PutWindowInSession(tag1, 0);
tracker.PutTabInWindow(tag1, 0, 0, 0);
// Tab 1 is closed.
tracker.PutTabInWindow(tag1, 0, 2, 1); // No longer unmapped.
// Tab 3 was unmapped and does not get used.
tracker.PutTabInWindow(tag1, 0, 4, 2); // Moved from window 1.
// Window 1 was closed, along with tab 5.
tracker.PutTabInWindow(tag1, 0, 6, 3); // No longer unmapped.
// Session 2 should not be affected.
tracker.CleanupSession(tag1);
// Verify that only those parts of the session not owned have been removed.
ASSERT_EQ(1U, session1->windows.size());
ASSERT_EQ(4U, session1->windows[0]->tabs.size());
ASSERT_EQ(1U, session2->windows.size());
ASSERT_EQ(1U, session2->windows[2]->tabs.size());
ASSERT_EQ(2U, tracker.num_synced_sessions());
ASSERT_EQ(4U, tracker.num_synced_tabs(tag1));
ASSERT_EQ(1U, tracker.num_synced_tabs(tag2));
// All memory should be properly deallocated by destructor for the
// SyncedSessionTracker.
}
} // namespace browser_sync
<|endoftext|>
|
<commit_before>/*
Copyright (c) 2009-2015, Jack Poulson, Lexing Ying,
The University of Texas at Austin, Stanford University, and the
Georgia Insitute of Technology.
All rights reserved.
This file is part of Elemental and is under the BSD 2-Clause License,
which can be found in the LICENSE file in the root directory, or at
http://opensource.org/licenses/BSD-2-Clause
*/
#pragma once
#ifndef EL_SYMBOLIC_NESTEDDISSECTION_HPP
#define EL_SYMBOLIC_NESTEDDISSECTION_HPP
#ifdef EL_HAVE_PARMETIS
#include "parmetis.h"
extern "C" {
void ElBisect
( idx_t* nvtxs, idx_t* xAdj, idx_t* adjacency, idx_t* nseps, real_t* imbalance,
idx_t* perm, idx_t* sizes );
void ElParallelBisect
( idx_t* vtxDist, idx_t* xAdj, idx_t* adjacency,
idx_t* nparseps, idx_t* nseqseps, real_t* imbalance, idx_t* options,
idx_t* perm, idx_t* sizes, MPI_Comm* comm );
} // extern "C"
#elif defined(EL_HAVE_METIS)
#include "metis.h"
extern "C" {
void ElBisect
( idx_t* nvtxs, idx_t* xAdj, idx_t* adjacency, idx_t* nseps, real_t* imbalance,
idx_t* perm, idx_t* sizes );
} // extern "C"
#endif
namespace El {
struct BisectCtrl
{
bool sequential;
Int numDistSeps;
Int numSeqSeps;
Int cutoff;
bool storeFactRecvInds;
BisectCtrl()
: sequential(true), numDistSeps(1), numSeqSeps(1), cutoff(128),
storeFactRecvInds(false)
{ }
};
void NestedDissection
( const DistGraph& graph,
DistMap& map,
DistSeparatorTree& sepTree,
DistSymmInfo& info,
const BisectCtrl& ctrl=BisectCtrl() );
Int Bisect
( const Graph& graph,
Graph& leftChild,
Graph& rightChild,
std::vector<Int>& perm,
const BisectCtrl& ctrl=BisectCtrl() );
// NOTE: for two or more processes
Int Bisect
( const DistGraph& graph,
DistGraph& child,
DistMap& perm,
bool& onLeft,
const BisectCtrl& ctrl=BisectCtrl() );
int DistributedDepth( mpi::Comm comm );
void EnsurePermutation( const std::vector<Int>& map );
void EnsurePermutation( const DistMap& map );
void ReverseOrder( DistSeparatorTree& sepTree, DistSymmElimTree& eTree );
void BuildChildrenFromPerm
( const Graph& graph, const std::vector<Int>& perm,
Int leftChildSize, Graph& leftChild,
Int rightChildSize, Graph& rightChild );
void BuildChildFromPerm
( const DistGraph& graph, const DistMap& perm,
Int leftChildSize, Int rightChildSize,
bool& onLeft, DistGraph& child );
void BuildMap
( const DistGraph& graph,
const DistSeparatorTree& sepTree,
DistMap& map );
} // namespace El
#endif // ifndef EL_SYMBOLIC_NESTEDDISSECTION_HPP
<commit_msg>Removing references to ElBisect<commit_after>/*
Copyright (c) 2009-2015, Jack Poulson, Lexing Ying,
The University of Texas at Austin, Stanford University, and the
Georgia Insitute of Technology.
All rights reserved.
This file is part of Elemental and is under the BSD 2-Clause License,
which can be found in the LICENSE file in the root directory, or at
http://opensource.org/licenses/BSD-2-Clause
*/
#pragma once
#ifndef EL_SYMBOLIC_NESTEDDISSECTION_HPP
#define EL_SYMBOLIC_NESTEDDISSECTION_HPP
#ifdef EL_HAVE_PARMETIS
#include "parmetis.h"
extern "C" {
void ElParallelBisect
( idx_t* vtxDist, idx_t* xAdj, idx_t* adjacency,
idx_t* nparseps, idx_t* nseqseps, real_t* imbalance, idx_t* options,
idx_t* perm, idx_t* sizes, MPI_Comm* comm );
} // extern "C"
#endif
namespace El {
struct BisectCtrl
{
bool sequential;
Int numDistSeps;
Int numSeqSeps;
Int cutoff;
bool storeFactRecvInds;
BisectCtrl()
: sequential(true), numDistSeps(1), numSeqSeps(1), cutoff(128),
storeFactRecvInds(false)
{ }
};
void NestedDissection
( const DistGraph& graph,
DistMap& map,
DistSeparatorTree& sepTree,
DistSymmInfo& info,
const BisectCtrl& ctrl=BisectCtrl() );
Int Bisect
( const Graph& graph,
Graph& leftChild,
Graph& rightChild,
std::vector<Int>& perm,
const BisectCtrl& ctrl=BisectCtrl() );
// NOTE: for two or more processes
Int Bisect
( const DistGraph& graph,
DistGraph& child,
DistMap& perm,
bool& onLeft,
const BisectCtrl& ctrl=BisectCtrl() );
int DistributedDepth( mpi::Comm comm );
void EnsurePermutation( const std::vector<Int>& map );
void EnsurePermutation( const DistMap& map );
void ReverseOrder( DistSeparatorTree& sepTree, DistSymmElimTree& eTree );
void BuildChildrenFromPerm
( const Graph& graph, const std::vector<Int>& perm,
Int leftChildSize, Graph& leftChild,
Int rightChildSize, Graph& rightChild );
void BuildChildFromPerm
( const DistGraph& graph, const DistMap& perm,
Int leftChildSize, Int rightChildSize,
bool& onLeft, DistGraph& child );
void BuildMap
( const DistGraph& graph,
const DistSeparatorTree& sepTree,
DistMap& map );
} // namespace El
#endif // ifndef EL_SYMBOLIC_NESTEDDISSECTION_HPP
<|endoftext|>
|
<commit_before>/*****************************************************************************
* preferences.cpp : Preferences
*****************************************************************************
* Copyright (C) 2006-2007 the VideoLAN team
* $Id$
*
* Authors: Clément Stenac <zorglub@videolan.org>
* Jean-Baptiste Kempf <jb@videolan.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "dialogs/preferences.hpp"
#include "util/qvlcframe.hpp"
#include "dialogs/errors.hpp"
#include "components/complete_preferences.hpp"
#include "components/simple_preferences.hpp"
#include "util/searchlineedit.hpp"
#include "main_interface.hpp"
#include <QHBoxLayout>
#include <QGroupBox>
#include <QRadioButton>
#include <QPushButton>
#include <QMessageBox>
#include <QDialogButtonBox>
#include <QStackedWidget>
#include <QSplitter>
PrefsDialog::PrefsDialog( QWidget *parent, intf_thread_t *_p_intf )
: QVLCDialog( parent, _p_intf )
{
QGridLayout *main_layout = new QGridLayout( this );
setWindowTitle( qtr( "Preferences" ) );
setWindowRole( "vlc-preferences" );
setWindowModality( Qt::WindowModal );
/* Whether we want it or not, we need to destroy on close to get
consistency when reset */
setAttribute( Qt::WA_DeleteOnClose );
/* Create Panels */
simple_tree_panel = new QWidget;
simple_tree_panel->setLayout( new QVBoxLayout );
advanced_tree_panel = new QWidget;
advanced_tree_panel->setLayout( new QVBoxLayout );
/* Choice for types */
types = new QGroupBox( qtr("Show settings") );
types->setAlignment( Qt::AlignHCenter );
QHBoxLayout *types_l = new QHBoxLayout;
types_l->setSpacing( 3 ); types_l->setMargin( 3 );
small = new QRadioButton( qtr( "Simple" ), types );
small->setToolTip( qtr( "Switch to simple preferences view" ) );
types_l->addWidget( small );
all = new QRadioButton( qtr("All"), types ); types_l->addWidget( all );
all->setToolTip( qtr( "Switch to full preferences view" ) );
types->setLayout( types_l );
small->setChecked( true );
/* Tree and panel initialisations */
advanced_tree = NULL;
tree_filter = NULL;
current_filter = NULL;
simple_tree = NULL;
simple_panels_stack = new QStackedWidget;
advanced_panels_stack = new QStackedWidget;
/* Buttons */
QDialogButtonBox *buttonsBox = new QDialogButtonBox();
QPushButton *save = new QPushButton( qtr( "&Save" ) );
save->setToolTip( qtr( "Save and close the dialog" ) );
QPushButton *cancel = new QPushButton( qtr( "&Cancel" ) );
QPushButton *reset = new QPushButton( qtr( "&Reset Preferences" ) );
buttonsBox->addButton( save, QDialogButtonBox::AcceptRole );
buttonsBox->addButton( cancel, QDialogButtonBox::RejectRole );
buttonsBox->addButton( reset, QDialogButtonBox::ResetRole );
simple_split_widget = new QWidget();
simple_split_widget->setLayout( new QHBoxLayout );
advanced_split_widget = new QSplitter();
advanced_split_widget->setLayout( new QHBoxLayout );
stack = new QStackedWidget();
stack->insertWidget( SIMPLE, simple_split_widget );
stack->insertWidget( ADVANCED, advanced_split_widget );
simple_split_widget->layout()->addWidget( simple_tree_panel );
simple_split_widget->layout()->addWidget( simple_panels_stack );
simple_split_widget->layout()->setMargin( 0 );
advanced_split_widget->layout()->addWidget( advanced_tree_panel );
advanced_split_widget->layout()->addWidget( advanced_panels_stack );
advanced_split_widget->layout()->setMargin( 0 );
/* Layout */
main_layout->addWidget( stack, 0, 0, 3, 3 );
main_layout->addWidget( types, 3, 0, 2, 1 );
main_layout->addWidget( buttonsBox, 4, 2, 1 ,1 );
main_layout->setRowStretch( 2, 4 );
main_layout->setMargin( 9 );
setLayout( main_layout );
/* Margins */
simple_tree_panel->layout()->setMargin( 1 );
simple_panels_stack->layout()->setContentsMargins( 6, 0, 0, 3 );
b_small = (p_intf->p_sys->i_screenHeight < 750);
if( b_small ) msg_Dbg( p_intf, "Small Resolution");
setMaximumHeight( p_intf->p_sys->i_screenHeight );
for( int i = 0; i < SPrefsMax ; i++ ) simple_panels[i] = NULL;
if( var_InheritBool( p_intf, "qt-advanced-pref" )
|| var_InheritBool( p_intf, "advanced" ) )
setAdvanced();
else
setSmall();
BUTTONACT( save, save() );
BUTTONACT( cancel, cancel() );
BUTTONACT( reset, reset() );
BUTTONACT( small, setSmall() );
BUTTONACT( all, setAdvanced() );
resize( 780, sizeHint().height() );
}
void PrefsDialog::setAdvanced()
{
if ( !tree_filter )
{
tree_filter = new SearchLineEdit( simple_tree_panel );
tree_filter->setMinimumHeight( 26 );
CONNECT( tree_filter, textChanged( const QString & ),
this, advancedTreeFilterChanged( const QString & ) );
advanced_tree_panel->layout()->addWidget( tree_filter );
current_filter = new QCheckBox( qtr("Only show current") );
current_filter->setToolTip(
qtr("Only show modules related to current playback") );
CONNECT( current_filter, stateChanged(int),
this, onlyLoadedToggled() );
advanced_tree_panel->layout()->addWidget( current_filter );
}
/* If don't have already and advanced TREE, then create it */
if( !advanced_tree )
{
/* Creation */
advanced_tree = new PrefsTree( p_intf, simple_tree_panel );
/* and connections */
CONNECT( advanced_tree,
currentItemChanged( QTreeWidgetItem *, QTreeWidgetItem * ),
this, changeAdvPanel( QTreeWidgetItem * ) );
advanced_tree_panel->layout()->addWidget( advanced_tree );
advanced_tree_panel->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Preferred );
}
/* If no advanced Panel exist, create one, attach it and show it*/
if( advanced_panels_stack->count() < 1 )
{
AdvPrefsPanel *insert = new AdvPrefsPanel( advanced_panels_stack );
advanced_panels_stack->insertWidget( 0, insert );
}
/* Select the first Item of the preferences. Maybe you want to select a specified
category... */
advanced_tree->setCurrentIndex(
advanced_tree->model()->index( 0, 0, QModelIndex() ) );
all->setChecked( true );
stack->setCurrentIndex( ADVANCED );
}
void PrefsDialog::setSmall()
{
/* If no simple_tree, create one, connect it */
if( !simple_tree )
{
simple_tree = new SPrefsCatList( p_intf, simple_tree_panel, b_small );
CONNECT( simple_tree,
currentItemChanged( int ),
this, changeSimplePanel( int ) );
simple_tree_panel->layout()->addWidget( simple_tree );
simple_tree_panel->setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Preferred );
}
if( ! simple_panels[SPrefsDefaultCat] )
changeSimplePanel( SPrefsDefaultCat );
small->setChecked( true );
stack->setCurrentIndex( SIMPLE );
}
/* Switching from on simple panel to another */
void PrefsDialog::changeSimplePanel( int number )
{
if( ! simple_panels[number] )
{
SPrefsPanel *insert = new SPrefsPanel( p_intf, simple_panels_stack, number, b_small ) ;
simple_panels_stack->insertWidget( number, insert );
simple_panels[number] = insert;
}
simple_panels_stack->setCurrentWidget( simple_panels[number] );
}
/* Changing from one Advanced Panel to another */
void PrefsDialog::changeAdvPanel( QTreeWidgetItem *item )
{
if( item == NULL ) return;
PrefsItemData *data = item->data( 0, Qt::UserRole ).value<PrefsItemData*>();
if( !data->panel )
{
data->panel = new AdvPrefsPanel( p_intf, advanced_panels_stack, data );
advanced_panels_stack->insertWidget( advanced_panels_stack->count(),
data->panel );
}
advanced_panels_stack->setCurrentWidget( data->panel );
}
#if 0
/*Called from extended settings, is not used anymore, but could be useful one day*/
void PrefsDialog::showModulePrefs( char *psz_module )
{
setAdvanced();
all->setChecked( true );
for( int i_cat_index = 0 ; i_cat_index < advanced_tree->topLevelItemCount();
i_cat_index++ )
{
QTreeWidgetItem *cat_item = advanced_tree->topLevelItem( i_cat_index );
PrefsItemData *data = cat_item->data( 0, Qt::UserRole ).
value<PrefsItemData *>();
for( int i_sc_index = 0; i_sc_index < cat_item->childCount();
i_sc_index++ )
{
QTreeWidgetItem *subcat_item = cat_item->child( i_sc_index );
PrefsItemData *sc_data = subcat_item->data(0, Qt::UserRole).
value<PrefsItemData *>();
for( int i_module = 0; i_module < subcat_item->childCount();
i_module++ )
{
QTreeWidgetItem *module_item = subcat_item->child( i_module );
PrefsItemData *mod_data = module_item->data( 0, Qt::UserRole ).
value<PrefsItemData *>();
if( !strcmp( mod_data->psz_name, psz_module ) ) {
advanced_tree->setCurrentItem( module_item );
}
}
}
}
show();
}
#endif
/* Actual apply and save for the preferences */
void PrefsDialog::save()
{
if( small->isChecked() && simple_tree->isVisible() )
{
msg_Dbg( p_intf, "Saving the simple preferences" );
for( int i = 0 ; i< SPrefsMax; i++ ){
if( simple_panels_stack->widget(i) )
qobject_cast<SPrefsPanel *>(simple_panels_stack->widget(i))->apply();
}
}
else if( all->isChecked() && advanced_tree->isVisible() )
{
msg_Dbg( p_intf, "Saving the advanced preferences" );
advanced_tree->applyAll();
}
/* Save to file */
if( config_SaveConfigFile( p_intf ) != 0 )
{
ErrorsDialog::getInstance (p_intf)->addError( qtr( "Cannot save Configuration" ),
qtr("Preferences file could not be saved") );
}
if( p_intf->p_sys->p_mi )
p_intf->p_sys->p_mi->reloadPrefs();
accept();
}
/* Clean the preferences, dunno if it does something really */
void PrefsDialog::cancel()
{
reject();
}
/* Reset all the preferences, when you click the button */
void PrefsDialog::reset()
{
int ret = QMessageBox::question(
this,
qtr( "Reset Preferences" ),
qtr( "Are you sure you want to reset your VLC media player preferences?" ),
QMessageBox::Ok | QMessageBox::Cancel,
QMessageBox::Ok);
if( ret == QMessageBox::Ok )
{
config_ResetAll( p_intf );
config_SaveConfigFile( p_intf );
getSettings()->clear();
accept();
}
}
void PrefsDialog::advancedTreeFilterChanged( const QString & text )
{
advanced_tree->filter( text );
}
void PrefsDialog::onlyLoadedToggled()
{
advanced_tree->setLoadedOnly( current_filter->isChecked() );
}
<commit_msg>Qt: Preferences: match window title to current prefs<commit_after>/*****************************************************************************
* preferences.cpp : Preferences
*****************************************************************************
* Copyright (C) 2006-2007 the VideoLAN team
* $Id$
*
* Authors: Clément Stenac <zorglub@videolan.org>
* Jean-Baptiste Kempf <jb@videolan.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "dialogs/preferences.hpp"
#include "util/qvlcframe.hpp"
#include "dialogs/errors.hpp"
#include "components/complete_preferences.hpp"
#include "components/simple_preferences.hpp"
#include "util/searchlineedit.hpp"
#include "main_interface.hpp"
#include <QHBoxLayout>
#include <QGroupBox>
#include <QRadioButton>
#include <QPushButton>
#include <QMessageBox>
#include <QDialogButtonBox>
#include <QStackedWidget>
#include <QSplitter>
PrefsDialog::PrefsDialog( QWidget *parent, intf_thread_t *_p_intf )
: QVLCDialog( parent, _p_intf )
{
QGridLayout *main_layout = new QGridLayout( this );
setWindowTitle( qtr( "Preferences" ) );
setWindowRole( "vlc-preferences" );
setWindowModality( Qt::WindowModal );
/* Whether we want it or not, we need to destroy on close to get
consistency when reset */
setAttribute( Qt::WA_DeleteOnClose );
/* Create Panels */
simple_tree_panel = new QWidget;
simple_tree_panel->setLayout( new QVBoxLayout );
advanced_tree_panel = new QWidget;
advanced_tree_panel->setLayout( new QVBoxLayout );
/* Choice for types */
types = new QGroupBox( qtr("Show settings") );
types->setAlignment( Qt::AlignHCenter );
QHBoxLayout *types_l = new QHBoxLayout;
types_l->setSpacing( 3 ); types_l->setMargin( 3 );
small = new QRadioButton( qtr( "Simple" ), types );
small->setToolTip( qtr( "Switch to simple preferences view" ) );
types_l->addWidget( small );
all = new QRadioButton( qtr("All"), types ); types_l->addWidget( all );
all->setToolTip( qtr( "Switch to full preferences view" ) );
types->setLayout( types_l );
small->setChecked( true );
/* Tree and panel initialisations */
advanced_tree = NULL;
tree_filter = NULL;
current_filter = NULL;
simple_tree = NULL;
simple_panels_stack = new QStackedWidget;
advanced_panels_stack = new QStackedWidget;
/* Buttons */
QDialogButtonBox *buttonsBox = new QDialogButtonBox();
QPushButton *save = new QPushButton( qtr( "&Save" ) );
save->setToolTip( qtr( "Save and close the dialog" ) );
QPushButton *cancel = new QPushButton( qtr( "&Cancel" ) );
QPushButton *reset = new QPushButton( qtr( "&Reset Preferences" ) );
buttonsBox->addButton( save, QDialogButtonBox::AcceptRole );
buttonsBox->addButton( cancel, QDialogButtonBox::RejectRole );
buttonsBox->addButton( reset, QDialogButtonBox::ResetRole );
simple_split_widget = new QWidget();
simple_split_widget->setLayout( new QHBoxLayout );
advanced_split_widget = new QSplitter();
advanced_split_widget->setLayout( new QHBoxLayout );
stack = new QStackedWidget();
stack->insertWidget( SIMPLE, simple_split_widget );
stack->insertWidget( ADVANCED, advanced_split_widget );
simple_split_widget->layout()->addWidget( simple_tree_panel );
simple_split_widget->layout()->addWidget( simple_panels_stack );
simple_split_widget->layout()->setMargin( 0 );
advanced_split_widget->layout()->addWidget( advanced_tree_panel );
advanced_split_widget->layout()->addWidget( advanced_panels_stack );
advanced_split_widget->layout()->setMargin( 0 );
/* Layout */
main_layout->addWidget( stack, 0, 0, 3, 3 );
main_layout->addWidget( types, 3, 0, 2, 1 );
main_layout->addWidget( buttonsBox, 4, 2, 1 ,1 );
main_layout->setRowStretch( 2, 4 );
main_layout->setMargin( 9 );
setLayout( main_layout );
/* Margins */
simple_tree_panel->layout()->setMargin( 1 );
simple_panels_stack->layout()->setContentsMargins( 6, 0, 0, 3 );
b_small = (p_intf->p_sys->i_screenHeight < 750);
if( b_small ) msg_Dbg( p_intf, "Small Resolution");
setMaximumHeight( p_intf->p_sys->i_screenHeight );
for( int i = 0; i < SPrefsMax ; i++ ) simple_panels[i] = NULL;
if( var_InheritBool( p_intf, "qt-advanced-pref" )
|| var_InheritBool( p_intf, "advanced" ) )
setAdvanced();
else
setSmall();
BUTTONACT( save, save() );
BUTTONACT( cancel, cancel() );
BUTTONACT( reset, reset() );
BUTTONACT( small, setSmall() );
BUTTONACT( all, setAdvanced() );
resize( 780, sizeHint().height() );
}
void PrefsDialog::setAdvanced()
{
if ( !tree_filter )
{
tree_filter = new SearchLineEdit( simple_tree_panel );
tree_filter->setMinimumHeight( 26 );
CONNECT( tree_filter, textChanged( const QString & ),
this, advancedTreeFilterChanged( const QString & ) );
advanced_tree_panel->layout()->addWidget( tree_filter );
current_filter = new QCheckBox( qtr("Only show current") );
current_filter->setToolTip(
qtr("Only show modules related to current playback") );
CONNECT( current_filter, stateChanged(int),
this, onlyLoadedToggled() );
advanced_tree_panel->layout()->addWidget( current_filter );
}
/* If don't have already and advanced TREE, then create it */
if( !advanced_tree )
{
/* Creation */
advanced_tree = new PrefsTree( p_intf, simple_tree_panel );
/* and connections */
CONNECT( advanced_tree,
currentItemChanged( QTreeWidgetItem *, QTreeWidgetItem * ),
this, changeAdvPanel( QTreeWidgetItem * ) );
advanced_tree_panel->layout()->addWidget( advanced_tree );
advanced_tree_panel->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Preferred );
}
/* If no advanced Panel exist, create one, attach it and show it*/
if( advanced_panels_stack->count() < 1 )
{
AdvPrefsPanel *insert = new AdvPrefsPanel( advanced_panels_stack );
advanced_panels_stack->insertWidget( 0, insert );
}
/* Select the first Item of the preferences. Maybe you want to select a specified
category... */
advanced_tree->setCurrentIndex(
advanced_tree->model()->index( 0, 0, QModelIndex() ) );
all->setChecked( true );
stack->setCurrentIndex( ADVANCED );
setWindowTitle( qtr( "Advanced Preferences" ) );
}
void PrefsDialog::setSmall()
{
/* If no simple_tree, create one, connect it */
if( !simple_tree )
{
simple_tree = new SPrefsCatList( p_intf, simple_tree_panel, b_small );
CONNECT( simple_tree,
currentItemChanged( int ),
this, changeSimplePanel( int ) );
simple_tree_panel->layout()->addWidget( simple_tree );
simple_tree_panel->setSizePolicy( QSizePolicy::Fixed, QSizePolicy::Preferred );
}
if( ! simple_panels[SPrefsDefaultCat] )
changeSimplePanel( SPrefsDefaultCat );
small->setChecked( true );
stack->setCurrentIndex( SIMPLE );
setWindowTitle( qtr( "Simple Preferences" ) );
}
/* Switching from on simple panel to another */
void PrefsDialog::changeSimplePanel( int number )
{
if( ! simple_panels[number] )
{
SPrefsPanel *insert = new SPrefsPanel( p_intf, simple_panels_stack, number, b_small ) ;
simple_panels_stack->insertWidget( number, insert );
simple_panels[number] = insert;
}
simple_panels_stack->setCurrentWidget( simple_panels[number] );
}
/* Changing from one Advanced Panel to another */
void PrefsDialog::changeAdvPanel( QTreeWidgetItem *item )
{
if( item == NULL ) return;
PrefsItemData *data = item->data( 0, Qt::UserRole ).value<PrefsItemData*>();
if( !data->panel )
{
data->panel = new AdvPrefsPanel( p_intf, advanced_panels_stack, data );
advanced_panels_stack->insertWidget( advanced_panels_stack->count(),
data->panel );
}
advanced_panels_stack->setCurrentWidget( data->panel );
}
#if 0
/*Called from extended settings, is not used anymore, but could be useful one day*/
void PrefsDialog::showModulePrefs( char *psz_module )
{
setAdvanced();
all->setChecked( true );
for( int i_cat_index = 0 ; i_cat_index < advanced_tree->topLevelItemCount();
i_cat_index++ )
{
QTreeWidgetItem *cat_item = advanced_tree->topLevelItem( i_cat_index );
PrefsItemData *data = cat_item->data( 0, Qt::UserRole ).
value<PrefsItemData *>();
for( int i_sc_index = 0; i_sc_index < cat_item->childCount();
i_sc_index++ )
{
QTreeWidgetItem *subcat_item = cat_item->child( i_sc_index );
PrefsItemData *sc_data = subcat_item->data(0, Qt::UserRole).
value<PrefsItemData *>();
for( int i_module = 0; i_module < subcat_item->childCount();
i_module++ )
{
QTreeWidgetItem *module_item = subcat_item->child( i_module );
PrefsItemData *mod_data = module_item->data( 0, Qt::UserRole ).
value<PrefsItemData *>();
if( !strcmp( mod_data->psz_name, psz_module ) ) {
advanced_tree->setCurrentItem( module_item );
}
}
}
}
show();
}
#endif
/* Actual apply and save for the preferences */
void PrefsDialog::save()
{
if( small->isChecked() && simple_tree->isVisible() )
{
msg_Dbg( p_intf, "Saving the simple preferences" );
for( int i = 0 ; i< SPrefsMax; i++ ){
if( simple_panels_stack->widget(i) )
qobject_cast<SPrefsPanel *>(simple_panels_stack->widget(i))->apply();
}
}
else if( all->isChecked() && advanced_tree->isVisible() )
{
msg_Dbg( p_intf, "Saving the advanced preferences" );
advanced_tree->applyAll();
}
/* Save to file */
if( config_SaveConfigFile( p_intf ) != 0 )
{
ErrorsDialog::getInstance (p_intf)->addError( qtr( "Cannot save Configuration" ),
qtr("Preferences file could not be saved") );
}
if( p_intf->p_sys->p_mi )
p_intf->p_sys->p_mi->reloadPrefs();
accept();
}
/* Clean the preferences, dunno if it does something really */
void PrefsDialog::cancel()
{
reject();
}
/* Reset all the preferences, when you click the button */
void PrefsDialog::reset()
{
int ret = QMessageBox::question(
this,
qtr( "Reset Preferences" ),
qtr( "Are you sure you want to reset your VLC media player preferences?" ),
QMessageBox::Ok | QMessageBox::Cancel,
QMessageBox::Ok);
if( ret == QMessageBox::Ok )
{
config_ResetAll( p_intf );
config_SaveConfigFile( p_intf );
getSettings()->clear();
accept();
}
}
void PrefsDialog::advancedTreeFilterChanged( const QString & text )
{
advanced_tree->filter( text );
}
void PrefsDialog::onlyLoadedToggled()
{
advanced_tree->setLoadedOnly( current_filter->isChecked() );
}
<|endoftext|>
|
<commit_before>/*****************************************************************************
* vout_manager.cpp
*****************************************************************************
* Copyright (C) 2009 the VideoLAN team
* $Id$
*
* Authors: Erwan Tulou <brezhoneg1 at yahoo.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "vout_manager.hpp"
#include "vlcproc.hpp"
#include "os_factory.hpp"
VoutManager *VoutManager::instance( intf_thread_t *pIntf )
{
if( pIntf->p_sys->p_voutManager == NULL )
{
pIntf->p_sys->p_voutManager = new VoutManager( pIntf );
}
return pIntf->p_sys->p_voutManager;
}
void VoutManager::destroy( intf_thread_t *pIntf )
{
delete pIntf->p_sys->p_voutManager;
pIntf->p_sys->p_voutManager = NULL;
}
VoutManager::VoutManager( intf_thread_t *pIntf ): SkinObject( pIntf ),
m_pCtrlVideoVec(), m_pCtrlVideoVecBackup(), m_SavedWndVec(),
m_pVoutMainWindow( NULL ), m_pFscWindow( NULL )
{
m_pVoutMainWindow = new VoutMainWindow( getIntf() );
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
int width = pOsFactory->getScreenWidth();
int height = pOsFactory->getScreenHeight();
m_pVoutMainWindow->move( 0, 0 );
m_pVoutMainWindow->resize( width, height );
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
rFullscreen.addObserver( this );
}
VoutManager::~VoutManager( )
{
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
rFullscreen.delObserver( this );
delete m_pVoutMainWindow;
}
void VoutManager::registerCtrlVideo( CtrlVideo* p_CtrlVideo )
{
m_pCtrlVideoVec.push_back( p_CtrlVideo );
}
void VoutManager::registerFSC( FscWindow* p_Win )
{
m_pFscWindow = p_Win;
}
void VoutManager::saveVoutConfig( )
{
// Save width/height to be consistent across themes
// and detach Video Controls
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pCtrlVideo )
{
// detach vout thread from VideoControl
it->pCtrlVideo->detachVoutWindow( );
// memorize width/height before VideoControl is destroyed
it->width = it->pCtrlVideo->getPosition()->getWidth();
it->height = it->pCtrlVideo->getPosition()->getHeight();
it->pCtrlVideo = NULL;
}
}
// Create a backup copy and reset original for new theme
m_pCtrlVideoVecBackup = m_pCtrlVideoVec;
m_pCtrlVideoVec.clear();
}
void VoutManager::restoreVoutConfig( bool b_success )
{
if( !b_success )
{
// loading new theme failed, restoring previous theme
m_pCtrlVideoVec = m_pCtrlVideoVecBackup;
}
// reattach vout(s) to Video Controls
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
CtrlVideo* pCtrlVideo = getBestCtrlVideo();
if( pCtrlVideo )
{
pCtrlVideo->attachVoutWindow( it->pVoutWindow );
it->pCtrlVideo = pCtrlVideo;
}
}
}
void VoutManager::discardVout( CtrlVideo* pCtrlVideo )
{
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pCtrlVideo == pCtrlVideo )
{
// detach vout thread from VideoControl
it->pCtrlVideo->detachVoutWindow( );
it->width = it->pCtrlVideo->getPosition()->getWidth();
it->height = it->pCtrlVideo->getPosition()->getHeight();
it->pCtrlVideo = NULL;
break;
}
}
}
void VoutManager::requestVout( CtrlVideo* pCtrlVideo )
{
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pCtrlVideo == NULL )
{
pCtrlVideo->attachVoutWindow( it->pVoutWindow,
it->width, it->height );
it->pCtrlVideo = pCtrlVideo;
break;
}
}
}
CtrlVideo* VoutManager::getBestCtrlVideo( )
{
vector<CtrlVideo*>::const_iterator it;
// first, look up a video control that is visible and unused
for( it = m_pCtrlVideoVec.begin(); it != m_pCtrlVideoVec.end(); ++it )
{
if( (*it)->isUseable() && !(*it)->isUsed() )
{
return (*it);
}
}
// as a fallback, look up any video control that is unused
for( it = m_pCtrlVideoVec.begin(); it != m_pCtrlVideoVec.end(); ++it )
{
if( !(*it)->isUsed() )
{
return (*it);
}
}
return NULL;
}
// Functions called by window provider
// ///////////////////////////////////
void VoutManager::acceptWnd( vout_window_t* pWnd, int width, int height )
{
// Creation of a dedicated Window per vout thread
VoutWindow* pVoutWindow = new VoutWindow( getIntf(), pWnd, width, height,
(GenericWindow*) m_pVoutMainWindow );
// try to find a video Control within the theme
CtrlVideo* pCtrlVideo = getBestCtrlVideo();
if( pCtrlVideo )
{
// A Video Control is available
// directly attach vout thread to it
pCtrlVideo->attachVoutWindow( pVoutWindow );
}
else
{
pVoutWindow->setCtrlVideo( NULL );
}
// save vout characteristics
m_SavedWndVec.push_back( SavedWnd( pWnd, pVoutWindow, pCtrlVideo ) );
msg_Dbg( pWnd, "New vout : Ctrl = %p, w x h = %ix%i",
pCtrlVideo, width, height );
}
void VoutManager::releaseWnd( vout_window_t* pWnd )
{
// remove vout thread from savedVec
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pWnd == pWnd )
{
msg_Dbg( getIntf(), "vout released vout=%p, VideoCtrl=%p",
pWnd, it->pCtrlVideo );
// if a video control was being used, detach from it
if( it->pCtrlVideo )
{
it->pCtrlVideo->detachVoutWindow( );
}
// remove resources
delete it->pVoutWindow;
m_SavedWndVec.erase( it );
break;
}
}
// force fullscreen to false so that user regains control
VlcProc::instance( getIntf() )->setFullscreenVar( false );
}
void VoutManager::setSizeWnd( vout_window_t *pWnd, int width, int height )
{
msg_Dbg( pWnd, "setSize (%ix%i) received from vout thread",
width, height );
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pWnd == pWnd )
{
VoutWindow* pVoutWindow = it->pVoutWindow;
pVoutWindow->setOriginalWidth( width );
pVoutWindow->setOriginalHeight( height );
CtrlVideo* pCtrlVideo = pVoutWindow->getCtrlVideo();
if( pCtrlVideo )
{
pCtrlVideo->resizeControl( width, height );
}
break;
}
}
}
void VoutManager::setFullscreenWnd( vout_window_t *pWnd, bool b_fullscreen )
{
msg_Dbg( pWnd, "setFullscreen (%i) received from vout thread",
b_fullscreen );
// reconfigure the fullscreen window (multiple screens)
if( b_fullscreen )
{
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pWnd == pWnd )
{
VoutWindow* pVoutWindow = it->pVoutWindow;
configureFullscreen( *pVoutWindow );
break;
}
}
}
// set fullscreen
VlcProc::instance( getIntf() )->setFullscreenVar( b_fullscreen );
}
void VoutManager::onUpdate( Subject<VarBool> &rVariable, void *arg )
{
(void)arg;
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
if( &rVariable == &rFullscreen )
{
if( rFullscreen.get() )
m_pVoutMainWindow->show();
else
m_pVoutMainWindow->hide();
}
}
void VoutManager::configureFullscreen( VoutWindow& rWindow )
{
int numScr = var_InheritInteger( getIntf(), "qt-fullscreen-screennumber" );
int x0 = m_pVoutMainWindow->getTop();
int y0 = m_pVoutMainWindow->getLeft();
int x, y, w, h;
if( numScr >= 0 )
{
// select screen requested by user
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
pOsFactory->getMonitorInfo( numScr, &x, &y, &w, &h );
}
else
{
// select screen where display is already occurring
rWindow.getMonitorInfo( &x, &y, &w, &h );
}
if( x != x0 || y != y0 )
{
// move and resize fullscreen
m_pVoutMainWindow->move( x, y );
m_pVoutMainWindow->resize( w, h );
// ensure the fs controller is also moved
if( m_pFscWindow )
{
m_pFscWindow->moveTo( x, y, w, h );
}
}
}
<commit_msg>skins2: remove a fallback when choosing a video control<commit_after>/*****************************************************************************
* vout_manager.cpp
*****************************************************************************
* Copyright (C) 2009 the VideoLAN team
* $Id$
*
* Authors: Erwan Tulou <brezhoneg1 at yahoo.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "vout_manager.hpp"
#include "vlcproc.hpp"
#include "os_factory.hpp"
VoutManager *VoutManager::instance( intf_thread_t *pIntf )
{
if( pIntf->p_sys->p_voutManager == NULL )
{
pIntf->p_sys->p_voutManager = new VoutManager( pIntf );
}
return pIntf->p_sys->p_voutManager;
}
void VoutManager::destroy( intf_thread_t *pIntf )
{
delete pIntf->p_sys->p_voutManager;
pIntf->p_sys->p_voutManager = NULL;
}
VoutManager::VoutManager( intf_thread_t *pIntf ): SkinObject( pIntf ),
m_pCtrlVideoVec(), m_pCtrlVideoVecBackup(), m_SavedWndVec(),
m_pVoutMainWindow( NULL ), m_pFscWindow( NULL )
{
m_pVoutMainWindow = new VoutMainWindow( getIntf() );
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
int width = pOsFactory->getScreenWidth();
int height = pOsFactory->getScreenHeight();
m_pVoutMainWindow->move( 0, 0 );
m_pVoutMainWindow->resize( width, height );
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
rFullscreen.addObserver( this );
}
VoutManager::~VoutManager( )
{
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
rFullscreen.delObserver( this );
delete m_pVoutMainWindow;
}
void VoutManager::registerCtrlVideo( CtrlVideo* p_CtrlVideo )
{
m_pCtrlVideoVec.push_back( p_CtrlVideo );
}
void VoutManager::registerFSC( FscWindow* p_Win )
{
m_pFscWindow = p_Win;
}
void VoutManager::saveVoutConfig( )
{
// Save width/height to be consistent across themes
// and detach Video Controls
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pCtrlVideo )
{
// detach vout thread from VideoControl
it->pCtrlVideo->detachVoutWindow( );
// memorize width/height before VideoControl is destroyed
it->width = it->pCtrlVideo->getPosition()->getWidth();
it->height = it->pCtrlVideo->getPosition()->getHeight();
it->pCtrlVideo = NULL;
}
}
// Create a backup copy and reset original for new theme
m_pCtrlVideoVecBackup = m_pCtrlVideoVec;
m_pCtrlVideoVec.clear();
}
void VoutManager::restoreVoutConfig( bool b_success )
{
if( !b_success )
{
// loading new theme failed, restoring previous theme
m_pCtrlVideoVec = m_pCtrlVideoVecBackup;
}
// reattach vout(s) to Video Controls
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
CtrlVideo* pCtrlVideo = getBestCtrlVideo();
if( pCtrlVideo )
{
pCtrlVideo->attachVoutWindow( it->pVoutWindow );
it->pCtrlVideo = pCtrlVideo;
}
}
}
void VoutManager::discardVout( CtrlVideo* pCtrlVideo )
{
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pCtrlVideo == pCtrlVideo )
{
// detach vout thread from VideoControl
it->pCtrlVideo->detachVoutWindow( );
it->width = it->pCtrlVideo->getPosition()->getWidth();
it->height = it->pCtrlVideo->getPosition()->getHeight();
it->pCtrlVideo = NULL;
break;
}
}
}
void VoutManager::requestVout( CtrlVideo* pCtrlVideo )
{
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pCtrlVideo == NULL )
{
pCtrlVideo->attachVoutWindow( it->pVoutWindow,
it->width, it->height );
it->pCtrlVideo = pCtrlVideo;
break;
}
}
}
CtrlVideo* VoutManager::getBestCtrlVideo( )
{
vector<CtrlVideo*>::const_iterator it;
// first, look up a video control that is visible and unused
for( it = m_pCtrlVideoVec.begin(); it != m_pCtrlVideoVec.end(); ++it )
{
if( (*it)->isUseable() && !(*it)->isUsed() )
{
return (*it);
}
}
return NULL;
}
// Functions called by window provider
// ///////////////////////////////////
void VoutManager::acceptWnd( vout_window_t* pWnd, int width, int height )
{
// Creation of a dedicated Window per vout thread
VoutWindow* pVoutWindow = new VoutWindow( getIntf(), pWnd, width, height,
(GenericWindow*) m_pVoutMainWindow );
// try to find a video Control within the theme
CtrlVideo* pCtrlVideo = getBestCtrlVideo();
if( pCtrlVideo )
{
// A Video Control is available
// directly attach vout thread to it
pCtrlVideo->attachVoutWindow( pVoutWindow );
}
else
{
pVoutWindow->setCtrlVideo( NULL );
}
// save vout characteristics
m_SavedWndVec.push_back( SavedWnd( pWnd, pVoutWindow, pCtrlVideo ) );
msg_Dbg( pWnd, "New vout : Ctrl = %p, w x h = %ix%i",
pCtrlVideo, width, height );
}
void VoutManager::releaseWnd( vout_window_t* pWnd )
{
// remove vout thread from savedVec
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pWnd == pWnd )
{
msg_Dbg( getIntf(), "vout released vout=%p, VideoCtrl=%p",
pWnd, it->pCtrlVideo );
// if a video control was being used, detach from it
if( it->pCtrlVideo )
{
it->pCtrlVideo->detachVoutWindow( );
}
// remove resources
delete it->pVoutWindow;
m_SavedWndVec.erase( it );
break;
}
}
// force fullscreen to false so that user regains control
VlcProc::instance( getIntf() )->setFullscreenVar( false );
}
void VoutManager::setSizeWnd( vout_window_t *pWnd, int width, int height )
{
msg_Dbg( pWnd, "setSize (%ix%i) received from vout thread",
width, height );
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pWnd == pWnd )
{
VoutWindow* pVoutWindow = it->pVoutWindow;
pVoutWindow->setOriginalWidth( width );
pVoutWindow->setOriginalHeight( height );
CtrlVideo* pCtrlVideo = pVoutWindow->getCtrlVideo();
if( pCtrlVideo )
{
pCtrlVideo->resizeControl( width, height );
}
break;
}
}
}
void VoutManager::setFullscreenWnd( vout_window_t *pWnd, bool b_fullscreen )
{
msg_Dbg( pWnd, "setFullscreen (%i) received from vout thread",
b_fullscreen );
// reconfigure the fullscreen window (multiple screens)
if( b_fullscreen )
{
vector<SavedWnd>::iterator it;
for( it = m_SavedWndVec.begin(); it != m_SavedWndVec.end(); ++it )
{
if( it->pWnd == pWnd )
{
VoutWindow* pVoutWindow = it->pVoutWindow;
configureFullscreen( *pVoutWindow );
break;
}
}
}
// set fullscreen
VlcProc::instance( getIntf() )->setFullscreenVar( b_fullscreen );
}
void VoutManager::onUpdate( Subject<VarBool> &rVariable, void *arg )
{
(void)arg;
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
if( &rVariable == &rFullscreen )
{
if( rFullscreen.get() )
m_pVoutMainWindow->show();
else
m_pVoutMainWindow->hide();
}
}
void VoutManager::configureFullscreen( VoutWindow& rWindow )
{
int numScr = var_InheritInteger( getIntf(), "qt-fullscreen-screennumber" );
int x0 = m_pVoutMainWindow->getTop();
int y0 = m_pVoutMainWindow->getLeft();
int x, y, w, h;
if( numScr >= 0 )
{
// select screen requested by user
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
pOsFactory->getMonitorInfo( numScr, &x, &y, &w, &h );
}
else
{
// select screen where display is already occurring
rWindow.getMonitorInfo( &x, &y, &w, &h );
}
if( x != x0 || y != y0 )
{
// move and resize fullscreen
m_pVoutMainWindow->move( x, y );
m_pVoutMainWindow->resize( w, h );
// ensure the fs controller is also moved
if( m_pFscWindow )
{
m_pFscWindow->moveTo( x, y, w, h );
}
}
}
<|endoftext|>
|
<commit_before>/**
* @file
* @author 2012 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
* @copyright Simplified BSD
*
* @cond
* This program is free software: you can redistribute it and/or modify
* it under the terms of the FreeBSD license as published by the FreeBSD
* project.
*
* 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.
*
* You should have received a copy of the FreeBSD license along with this
* program. If not, see <http://www.opensource.org/licenses/bsd-license>.
* @endcond
*/
#ifdef WIN32
#include <time.h>
#include <WinSock2.h>
#include <ws2tcpip.h>
#include <Windows.h>
#endif
#include "umundo/connection/zeromq/ZeroMQPublisher.h"
#include "umundo/connection/zeromq/ZeroMQNode.h"
#include "umundo/common/Message.h"
#include "umundo/common/UUID.h"
#include "umundo/common/Host.h"
#include "umundo/config.h"
#if defined UNIX || defined IOS || defined IOSSIM
#include <string.h> // strlen, memcpy
#include <stdio.h> // snprintf
#endif
namespace umundo {
shared_ptr<Implementation> ZeroMQPublisher::create(void* facade) {
shared_ptr<Implementation> instance(new ZeroMQPublisher());
boost::static_pointer_cast<ZeroMQPublisher>(instance)->_facade = facade;
return instance;
}
void ZeroMQPublisher::destroy() {
delete(this);
}
void ZeroMQPublisher::init(shared_ptr<Configuration> config) {
ScopeLock lock(_mutex);
_uuid = (_uuid.length() > 0 ? _uuid : UUID::getUUID());
_config = boost::static_pointer_cast<PublisherConfig>(config);
_transport = "tcp";
(_socket = zmq_socket(ZeroMQNode::getZeroMQContext(), ZMQ_XPUB)) || LOG_WARN("zmq_socket: %s",zmq_strerror(errno));
int hwm = NET_ZEROMQ_SND_HWM;
zmq_setsockopt(_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm)) && LOG_WARN("zmq_setsockopt: %s",zmq_strerror(errno));
std::stringstream ssInProc;
ssInProc << "inproc://" << _uuid;
zmq_bind(_socket, ssInProc.str().c_str()) && LOG_WARN("zmq_bind: %s",zmq_strerror(errno));
LOG_INFO("creating publisher for %s on uuid %s", _channelName.c_str(), ssInProc.str().c_str());
#ifndef PUBPORT_SHARING
_port = ZeroMQNode::bindToFreePort(_socket, _transport, "*");
LOG_INFO("creating publisher for %s on port %d", _channelName.c_str(), _port);
start();
#else
_port = ZeroMQNode::_sharedPubPort;
#endif
LOG_DEBUG("creating publisher on %s", ssInProc.str().c_str());
}
ZeroMQPublisher::ZeroMQPublisher() {
}
ZeroMQPublisher::~ZeroMQPublisher() {
LOG_INFO("deleting publisher for %s", _channelName.c_str());
stop();
join();
zmq_close(_socket) && LOG_WARN("zmq_close: %s",zmq_strerror(errno));
// clean up pending messages
map<string, std::list<std::pair<uint64_t, Message*> > >::iterator queuedMsgHostIter = _queuedMessages.begin();
while(queuedMsgHostIter != _queuedMessages.end()) {
std::list<std::pair<uint64_t, Message*> >::iterator queuedMsgIter = queuedMsgHostIter->second.begin();
while(queuedMsgIter != queuedMsgHostIter->second.end()) {
delete (queuedMsgIter->second);
queuedMsgIter++;
}
queuedMsgHostIter++;
}
}
void ZeroMQPublisher::join() {
Thread::join();
}
void ZeroMQPublisher::suspend() {
if (_isSuspended)
return;
ScopeLock lock(_mutex);
_isSuspended = true;
stop();
join();
zmq_close(_socket) && LOG_WARN("zmq_close: %s",zmq_strerror(errno));
}
void ZeroMQPublisher::resume() {
if (!_isSuspended)
return;
_isSuspended = false;
init(_config);
}
void ZeroMQPublisher::run() {
// read subscription requests from the pub socket
while(isStarted()) {
zmq_msg_t message;
zmq_msg_init(&message) && LOG_WARN("zmq_msg_init: %s", zmq_strerror(errno));
int rv;
{
ScopeLock lock(_mutex);
while ((rv = zmq_recvmsg(_socket, &message, ZMQ_DONTWAIT)) < 0) {
if (errno == EAGAIN) // no messages available at the moment
break;
if (errno != EINTR)
LOG_WARN("zmq_recvmsg: %s",zmq_strerror(errno));
}
}
if (rv > 0) {
size_t msgSize = zmq_msg_size(&message);
// every subscriber will sent its uuid as a subscription as well
if (msgSize == 37) {
//ScopeLock lock(&_mutex);
char* data = (char*)zmq_msg_data(&message);
bool subscription = (data[0] == 0x1);
char* subId = data+1;
subId[msgSize - 1] = 0;
if (subscription) {
LOG_INFO("%s received ZMQ subscription from %s", _channelName.c_str(), subId);
_pendingZMQSubscriptions.insert(subId);
addedSubscriber("", subId);
} else {
LOG_INFO("%s received ZMQ unsubscription from %s", _channelName.c_str(), subId);
}
}
zmq_msg_close(&message) && LOG_WARN("zmq_msg_close: %s", zmq_strerror(errno));
} else {
Thread::sleepMs(50);
}
// try to send pending messages
ScopeLock lock(_mutex);
if (_queuedMessages.size() > 0) {
uint64_t now = Thread::getTimeStampMs();
map<string, std::list<std::pair<uint64_t, Message*> > >::iterator queuedMsgHostIter = _queuedMessages.begin();
while(queuedMsgHostIter != _queuedMessages.end()) {
std::list<std::pair<uint64_t, Message*> >::iterator queuedMsgIter = queuedMsgHostIter->second.begin();
if (_subUUIDs.find(queuedMsgHostIter->first) != _subUUIDs.end()) {
// node became available, send pending messages
LOG_INFO("Subscriber %s became available on %s - sending %d pending message", queuedMsgHostIter->first.c_str(), _channelName.c_str(), queuedMsgHostIter->second.size());
while(queuedMsgIter != queuedMsgHostIter->second.end()) {
send(queuedMsgIter->second);
delete queuedMsgIter->second;
queuedMsgHostIter->second.erase(queuedMsgIter++);
}
} else {
while(queuedMsgIter != queuedMsgHostIter->second.end()) {
if (now - queuedMsgIter->first > 5000) {
LOG_ERR("Pending message for %s on %s is too old - removing", queuedMsgHostIter->first.c_str(), _channelName.c_str());
delete queuedMsgIter->second;
queuedMsgIter = queuedMsgHostIter->second.erase(queuedMsgIter);
} else {
queuedMsgIter++;
}
}
}
if (queuedMsgHostIter->second.empty()) {
_queuedMessages.erase(queuedMsgHostIter++);
} else {
queuedMsgHostIter++;
}
}
}
}
}
/**
* Block until we have a given number of subscribers.
*/
int ZeroMQPublisher::waitForSubscribers(int count, int timeoutMs) {
ScopeLock lock(_mutex);
uint64_t now = Thread::getTimeStampMs();
while (_subscriptions.size() < (unsigned int)count) {
_pubLock.wait(_mutex, timeoutMs);
if (timeoutMs > 0 && Thread::getTimeStampMs() - timeoutMs > now)
break;
}
return _subscriptions.size();
}
void ZeroMQPublisher::addedSubscriber(const string remoteId, const string subId) {
ScopeLock lock(_mutex);
// ZeroMQPublisher::run calls us without a remoteId
if (remoteId.length() != 0) {
// we already know about this subscription
if (_pendingSubscriptions.find(subId) != _pendingSubscriptions.end())
return;
_pendingSubscriptions[subId] = remoteId;
}
// if we received a subscription from xpub and the node socket
if (_pendingSubscriptions.find(subId) == _pendingSubscriptions.end() ||
_pendingZMQSubscriptions.find(subId) == _pendingZMQSubscriptions.end()) {
return;
}
_subscriptions[subId] = _pendingSubscriptions[subId];
_pendingSubscriptions.erase(subId);
_pendingZMQSubscriptions.erase(subId);
_subUUIDs.insert(subId);
if (_greeter != NULL)
_greeter->welcome((Publisher*)_facade, _pendingSubscriptions[subId], subId);
UMUNDO_SIGNAL(_pubLock);
}
void ZeroMQPublisher::removedSubscriber(const string remoteId, const string subId) {
ScopeLock lock(_mutex);
if (_subscriptions.find(subId) == _subscriptions.end())
return;
_subscriptions.erase(subId);
_subUUIDs.erase(subId);
if (_greeter != NULL)
_greeter->farewell((Publisher*)_facade, _pendingSubscriptions[subId], subId);
UMUNDO_SIGNAL(_pubLock);
}
void ZeroMQPublisher::send(Message* msg) {
ScopeLock lock(_mutex);
//LOG_DEBUG("ZeroMQPublisher sending msg on %s", _channelName.c_str());
if (_isSuspended) {
LOG_WARN("Not sending message on suspended publisher");
return;
}
// topic name or explicit subscriber id is first message in envelope
zmq_msg_t channelEnvlp;
if (msg->getMeta().find("um.sub") != msg->getMeta().end()) {
// explicit destination
if (_subUUIDs.find(msg->getMeta("um.sub")) == _subUUIDs.end() && !msg->isQueued()) {
LOG_INFO("Subscriber %s is not (yet) connected on %s - queuing message", msg->getMeta("um.sub").c_str(), _channelName.c_str());
Message* queuedMsg = new Message(*msg); // copy message
queuedMsg->setQueued(true);
_queuedMessages[msg->getMeta("um.sub")].push_back(std::make_pair(Thread::getTimeStampMs(), queuedMsg));
return;
}
ZMQ_PREPARE_STRING(channelEnvlp, msg->getMeta("um.sub").c_str(), msg->getMeta("um.sub").size());
} else {
// everyone on channel
ZMQ_PREPARE_STRING(channelEnvlp, _channelName.c_str(), _channelName.size());
}
// mandatory meta fields
msg->putMeta("um.pub", _uuid);
msg->putMeta("um.proc", procUUID);
msg->putMeta("um.host", Host::getHostId());
map<string, string>::const_iterator metaIter = _mandatoryMeta.begin();
while(metaIter != _mandatoryMeta.end()) {
if (metaIter->second.length() > 0)
msg->putMeta(metaIter->first, metaIter->second);
metaIter++;
}
zmq_sendmsg(_socket, &channelEnvlp, ZMQ_SNDMORE) >= 0 || LOG_WARN("zmq_sendmsg: %s",zmq_strerror(errno));
zmq_msg_close(&channelEnvlp) && LOG_WARN("zmq_msg_close: %s",zmq_strerror(errno));
// all our meta information
for (metaIter = msg->getMeta().begin(); metaIter != msg->getMeta().end(); metaIter++) {
// string key(metaIter->first);
// string value(metaIter->second);
// std::cout << key << ": " << value << std::endl;
// string length of key + value + two null bytes as string delimiters
size_t metaSize = (metaIter->first).length() + (metaIter->second).length() + 2;
zmq_msg_t metaMsg;
ZMQ_PREPARE(metaMsg, metaSize);
char* writePtr = (char*)zmq_msg_data(&metaMsg);
memcpy(writePtr, (metaIter->first).data(), (metaIter->first).length());
// indexes start at zero, so length is the byte after the string
((char*)zmq_msg_data(&metaMsg))[(metaIter->first).length()] = '\0';
assert(strlen((char*)zmq_msg_data(&metaMsg)) == (metaIter->first).length());
assert(strlen(writePtr) == (metaIter->first).length()); // just to be sure
// increment write pointer
writePtr += (metaIter->first).length() + 1;
memcpy(writePtr,
(metaIter->second).data(),
(metaIter->second).length());
// first string + null byte + second string
((char*)zmq_msg_data(&metaMsg))[(metaIter->first).length() + 1 + (metaIter->second).length()] = '\0';
assert(strlen(writePtr) == (metaIter->second).length());
zmq_sendmsg(_socket, &metaMsg, ZMQ_SNDMORE) >= 0 || LOG_WARN("zmq_sendmsg: %s",zmq_strerror(errno));
zmq_msg_close(&metaMsg) && LOG_WARN("zmq_msg_close: %s",zmq_strerror(errno));
}
// data as the second part of a multipart message
zmq_msg_t publication;
ZMQ_PREPARE_DATA(publication, msg->data(), msg->size());
zmq_sendmsg(_socket, &publication, 0) >= 0 || LOG_WARN("zmq_sendmsg: %s",zmq_strerror(errno));
zmq_msg_close(&publication) && LOG_WARN("zmq_msg_close: %s",zmq_strerror(errno));
}
}<commit_msg>ifdef'd WIN32 for message closing when receiving subscriptions<commit_after>/**
* @file
* @author 2012 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
* @copyright Simplified BSD
*
* @cond
* This program is free software: you can redistribute it and/or modify
* it under the terms of the FreeBSD license as published by the FreeBSD
* project.
*
* 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.
*
* You should have received a copy of the FreeBSD license along with this
* program. If not, see <http://www.opensource.org/licenses/bsd-license>.
* @endcond
*/
#ifdef WIN32
#include <time.h>
#include <WinSock2.h>
#include <ws2tcpip.h>
#include <Windows.h>
#endif
#include "umundo/connection/zeromq/ZeroMQPublisher.h"
#include "umundo/connection/zeromq/ZeroMQNode.h"
#include "umundo/common/Message.h"
#include "umundo/common/UUID.h"
#include "umundo/common/Host.h"
#include "umundo/config.h"
#if defined UNIX || defined IOS || defined IOSSIM
#include <string.h> // strlen, memcpy
#include <stdio.h> // snprintf
#endif
namespace umundo {
shared_ptr<Implementation> ZeroMQPublisher::create(void* facade) {
shared_ptr<Implementation> instance(new ZeroMQPublisher());
boost::static_pointer_cast<ZeroMQPublisher>(instance)->_facade = facade;
return instance;
}
void ZeroMQPublisher::destroy() {
delete(this);
}
void ZeroMQPublisher::init(shared_ptr<Configuration> config) {
ScopeLock lock(_mutex);
_uuid = (_uuid.length() > 0 ? _uuid : UUID::getUUID());
_config = boost::static_pointer_cast<PublisherConfig>(config);
_transport = "tcp";
(_socket = zmq_socket(ZeroMQNode::getZeroMQContext(), ZMQ_XPUB)) || LOG_WARN("zmq_socket: %s",zmq_strerror(errno));
int hwm = NET_ZEROMQ_SND_HWM;
zmq_setsockopt(_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm)) && LOG_WARN("zmq_setsockopt: %s",zmq_strerror(errno));
std::stringstream ssInProc;
ssInProc << "inproc://" << _uuid;
zmq_bind(_socket, ssInProc.str().c_str()) && LOG_WARN("zmq_bind: %s",zmq_strerror(errno));
LOG_INFO("creating publisher for %s on uuid %s", _channelName.c_str(), ssInProc.str().c_str());
#ifndef PUBPORT_SHARING
_port = ZeroMQNode::bindToFreePort(_socket, _transport, "*");
LOG_INFO("creating publisher for %s on port %d", _channelName.c_str(), _port);
start();
#else
_port = ZeroMQNode::_sharedPubPort;
#endif
LOG_DEBUG("creating publisher on %s", ssInProc.str().c_str());
}
ZeroMQPublisher::ZeroMQPublisher() {
}
ZeroMQPublisher::~ZeroMQPublisher() {
LOG_INFO("deleting publisher for %s", _channelName.c_str());
stop();
join();
zmq_close(_socket) && LOG_WARN("zmq_close: %s",zmq_strerror(errno));
// clean up pending messages
map<string, std::list<std::pair<uint64_t, Message*> > >::iterator queuedMsgHostIter = _queuedMessages.begin();
while(queuedMsgHostIter != _queuedMessages.end()) {
std::list<std::pair<uint64_t, Message*> >::iterator queuedMsgIter = queuedMsgHostIter->second.begin();
while(queuedMsgIter != queuedMsgHostIter->second.end()) {
delete (queuedMsgIter->second);
queuedMsgIter++;
}
queuedMsgHostIter++;
}
}
void ZeroMQPublisher::join() {
Thread::join();
}
void ZeroMQPublisher::suspend() {
if (_isSuspended)
return;
ScopeLock lock(_mutex);
_isSuspended = true;
stop();
join();
zmq_close(_socket) && LOG_WARN("zmq_close: %s",zmq_strerror(errno));
}
void ZeroMQPublisher::resume() {
if (!_isSuspended)
return;
_isSuspended = false;
init(_config);
}
void ZeroMQPublisher::run() {
// read subscription requests from the pub socket
while(isStarted()) {
zmq_msg_t message;
zmq_msg_init(&message) && LOG_WARN("zmq_msg_init: %s", zmq_strerror(errno));
int rv = -1;
{
ScopeLock lock(_mutex);
while ((rv = zmq_recvmsg(_socket, &message, ZMQ_DONTWAIT)) < 0) {
if (errno == EAGAIN) // no messages available at the moment
break;
if (errno != EINTR)
LOG_WARN("zmq_recvmsg: %s",zmq_strerror(errno));
}
}
if (rv > 0) {
size_t msgSize = zmq_msg_size(&message);
// every subscriber will sent its uuid as a subscription as well
if (msgSize == 37) {
//ScopeLock lock(&_mutex);
char* data = (char*)zmq_msg_data(&message);
bool subscription = (data[0] == 0x1);
char* subId = data+1;
subId[msgSize - 1] = 0;
if (subscription) {
LOG_INFO("%s received ZMQ subscription from %s", _channelName.c_str(), subId);
_pendingZMQSubscriptions.insert(subId);
addedSubscriber("", subId);
} else {
LOG_INFO("%s received ZMQ unsubscription from %s", _channelName.c_str(), subId);
}
}
// this will cause a heap corruption on windows?
#ifndef WIN32
zmq_msg_close(&message) && LOG_WARN("zmq_msg_close: %s", zmq_strerror(errno));
#endif
} else {
Thread::sleepMs(50);
}
// try to send pending messages
ScopeLock lock(_mutex);
if (_queuedMessages.size() > 0) {
uint64_t now = Thread::getTimeStampMs();
map<string, std::list<std::pair<uint64_t, Message*> > >::iterator queuedMsgHostIter = _queuedMessages.begin();
while(queuedMsgHostIter != _queuedMessages.end()) {
std::list<std::pair<uint64_t, Message*> >::iterator queuedMsgIter = queuedMsgHostIter->second.begin();
if (_subUUIDs.find(queuedMsgHostIter->first) != _subUUIDs.end()) {
// node became available, send pending messages
LOG_INFO("Subscriber %s became available on %s - sending %d pending message", queuedMsgHostIter->first.c_str(), _channelName.c_str(), queuedMsgHostIter->second.size());
while(queuedMsgIter != queuedMsgHostIter->second.end()) {
send(queuedMsgIter->second);
delete queuedMsgIter->second;
queuedMsgHostIter->second.erase(queuedMsgIter++);
}
} else {
while(queuedMsgIter != queuedMsgHostIter->second.end()) {
if (now - queuedMsgIter->first > 5000) {
LOG_ERR("Pending message for %s on %s is too old - removing", queuedMsgHostIter->first.c_str(), _channelName.c_str());
delete queuedMsgIter->second;
queuedMsgIter = queuedMsgHostIter->second.erase(queuedMsgIter);
} else {
queuedMsgIter++;
}
}
}
if (queuedMsgHostIter->second.empty()) {
_queuedMessages.erase(queuedMsgHostIter++);
} else {
queuedMsgHostIter++;
}
}
}
}
}
/**
* Block until we have a given number of subscribers.
*/
int ZeroMQPublisher::waitForSubscribers(int count, int timeoutMs) {
ScopeLock lock(_mutex);
uint64_t now = Thread::getTimeStampMs();
while (_subscriptions.size() < (unsigned int)count) {
_pubLock.wait(_mutex, timeoutMs);
if (timeoutMs > 0 && Thread::getTimeStampMs() - timeoutMs > now)
break;
}
return _subscriptions.size();
}
void ZeroMQPublisher::addedSubscriber(const string remoteId, const string subId) {
ScopeLock lock(_mutex);
// ZeroMQPublisher::run calls us without a remoteId
if (remoteId.length() != 0) {
// we already know about this subscription
if (_pendingSubscriptions.find(subId) != _pendingSubscriptions.end())
return;
_pendingSubscriptions[subId] = remoteId;
}
// if we received a subscription from xpub and the node socket
if (_pendingSubscriptions.find(subId) == _pendingSubscriptions.end() ||
_pendingZMQSubscriptions.find(subId) == _pendingZMQSubscriptions.end()) {
return;
}
_subscriptions[subId] = _pendingSubscriptions[subId];
_pendingSubscriptions.erase(subId);
_pendingZMQSubscriptions.erase(subId);
_subUUIDs.insert(subId);
if (_greeter != NULL)
_greeter->welcome((Publisher*)_facade, _pendingSubscriptions[subId], subId);
UMUNDO_SIGNAL(_pubLock);
}
void ZeroMQPublisher::removedSubscriber(const string remoteId, const string subId) {
ScopeLock lock(_mutex);
if (_subscriptions.find(subId) == _subscriptions.end())
return;
_subscriptions.erase(subId);
_subUUIDs.erase(subId);
if (_greeter != NULL)
_greeter->farewell((Publisher*)_facade, _pendingSubscriptions[subId], subId);
UMUNDO_SIGNAL(_pubLock);
}
void ZeroMQPublisher::send(Message* msg) {
ScopeLock lock(_mutex);
//LOG_DEBUG("ZeroMQPublisher sending msg on %s", _channelName.c_str());
if (_isSuspended) {
LOG_WARN("Not sending message on suspended publisher");
return;
}
// topic name or explicit subscriber id is first message in envelope
zmq_msg_t channelEnvlp;
if (msg->getMeta().find("um.sub") != msg->getMeta().end()) {
// explicit destination
if (_subUUIDs.find(msg->getMeta("um.sub")) == _subUUIDs.end() && !msg->isQueued()) {
LOG_INFO("Subscriber %s is not (yet) connected on %s - queuing message", msg->getMeta("um.sub").c_str(), _channelName.c_str());
Message* queuedMsg = new Message(*msg); // copy message
queuedMsg->setQueued(true);
_queuedMessages[msg->getMeta("um.sub")].push_back(std::make_pair(Thread::getTimeStampMs(), queuedMsg));
return;
}
ZMQ_PREPARE_STRING(channelEnvlp, msg->getMeta("um.sub").c_str(), msg->getMeta("um.sub").size());
} else {
// everyone on channel
ZMQ_PREPARE_STRING(channelEnvlp, _channelName.c_str(), _channelName.size());
}
// mandatory meta fields
msg->putMeta("um.pub", _uuid);
msg->putMeta("um.proc", procUUID);
msg->putMeta("um.host", Host::getHostId());
map<string, string>::const_iterator metaIter = _mandatoryMeta.begin();
while(metaIter != _mandatoryMeta.end()) {
if (metaIter->second.length() > 0)
msg->putMeta(metaIter->first, metaIter->second);
metaIter++;
}
zmq_sendmsg(_socket, &channelEnvlp, ZMQ_SNDMORE) >= 0 || LOG_WARN("zmq_sendmsg: %s",zmq_strerror(errno));
zmq_msg_close(&channelEnvlp) && LOG_WARN("zmq_msg_close: %s",zmq_strerror(errno));
// all our meta information
for (metaIter = msg->getMeta().begin(); metaIter != msg->getMeta().end(); metaIter++) {
// string key(metaIter->first);
// string value(metaIter->second);
// std::cout << key << ": " << value << std::endl;
// string length of key + value + two null bytes as string delimiters
size_t metaSize = (metaIter->first).length() + (metaIter->second).length() + 2;
zmq_msg_t metaMsg;
ZMQ_PREPARE(metaMsg, metaSize);
char* writePtr = (char*)zmq_msg_data(&metaMsg);
memcpy(writePtr, (metaIter->first).data(), (metaIter->first).length());
// indexes start at zero, so length is the byte after the string
((char*)zmq_msg_data(&metaMsg))[(metaIter->first).length()] = '\0';
assert(strlen((char*)zmq_msg_data(&metaMsg)) == (metaIter->first).length());
assert(strlen(writePtr) == (metaIter->first).length()); // just to be sure
// increment write pointer
writePtr += (metaIter->first).length() + 1;
memcpy(writePtr,
(metaIter->second).data(),
(metaIter->second).length());
// first string + null byte + second string
((char*)zmq_msg_data(&metaMsg))[(metaIter->first).length() + 1 + (metaIter->second).length()] = '\0';
assert(strlen(writePtr) == (metaIter->second).length());
zmq_sendmsg(_socket, &metaMsg, ZMQ_SNDMORE) >= 0 || LOG_WARN("zmq_sendmsg: %s",zmq_strerror(errno));
zmq_msg_close(&metaMsg) && LOG_WARN("zmq_msg_close: %s",zmq_strerror(errno));
}
// data as the second part of a multipart message
zmq_msg_t publication;
ZMQ_PREPARE_DATA(publication, msg->data(), msg->size());
zmq_sendmsg(_socket, &publication, 0) >= 0 || LOG_WARN("zmq_sendmsg: %s",zmq_strerror(errno));
zmq_msg_close(&publication) && LOG_WARN("zmq_msg_close: %s",zmq_strerror(errno));
}
}<|endoftext|>
|
<commit_before><commit_msg>Delete dbformat.cc<commit_after><|endoftext|>
|
<commit_before>// @(#)root/io:$Id$
// Author: Elvin Sindrilaru 19/05/2011
/*************************************************************************
* Copyright (C) 1995-2011, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#include "TFilePrefetch.h"
#include "TTimeStamp.h"
#include "TVirtualPerfStats.h"
#include "TVirtualMonitoring.h"
#include <iostream>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cctype>
static const int kMAX_READ_SIZE = 2; //maximum size of the read list of blocks
inline int xtod(char c) { return (c>='0' && c<='9') ? c-'0' : ((c>='A' && c<='F') ? c-'A'+10 : ((c>='a' && c<='f') ? c-'a'+10 : 0)); }
using namespace std;
ClassImp(TFilePrefetch)
//____________________________________________________________________________________________
TFilePrefetch::TFilePrefetch(TFile* file)
{
// Constructor.
fConsumer = 0;
fFile = file;
fPendingBlocks = new TList();
fReadBlocks = new TList();
fMutexReadList = new TMutex();
fMutexPendingList = new TMutex();
fMutexSynch = new TMutex();
fNewBlockAdded = new TCondition(0);
fReadBlockAdded = new TCondition(0);
fSem = new TSemaphore(0);
}
//____________________________________________________________________________________________
TFilePrefetch::~TFilePrefetch()
{
// Destructor.
//killing consumer thread
fMutexSynch->Lock(); //wait fo thread to finish work
fMutexSynch->UnLock();
fSem->Post(); //send terminate signal
fNewBlockAdded->Signal();
fConsumer->Join();
SafeDelete(fConsumer);
SafeDelete(fPendingBlocks);
SafeDelete(fReadBlocks);
SafeDelete(fMutexReadList);
SafeDelete(fMutexPendingList);
SafeDelete(fMutexSynch);
SafeDelete(fNewBlockAdded);
SafeDelete(fReadBlockAdded);
SafeDelete(fSem);
}
//____________________________________________________________________________________________
void TFilePrefetch::ReadAsync(TFPBlock* block, Bool_t &inCache)
{
// Read one block and insert it in prefetchBuffers list.
char* path = 0;
if (CheckBlockInCache(path, block)){
block->SetBuffer(GetBlockFromCache(path, block->GetFullSize()));
inCache = kTRUE;
}
else{
fFile->ReadBuffers(block->GetBuffer(), block->GetPos(), block->GetLen(), block->GetNoElem());
if (fFile->GetArchive()){
for (Int_t i = 0; i < block->GetNoElem(); i++)
block->SetPos(i, block->GetPos(i) - fFile->GetArchiveOffset());
}
inCache =kFALSE;
}
delete[] path;
}
//____________________________________________________________________________________________
void TFilePrefetch::ReadListOfBlocks()
{
// Get blocks specified in prefetchBlocks.
Bool_t inCache = kFALSE;
TFPBlock* block = 0;
while((block = GetPendingBlock())){
ReadAsync(block, inCache);
AddReadBlock(block);
if (!inCache)
SaveBlockInCache(block);
}
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::BinarySearchReadList(TFPBlock* blockObj, Long64_t offset, Int_t len, Int_t* index)
{
// Search for a requested element in a block and return the index.
Int_t first = 0, last = -1, mid = -1;
last = (Int_t) blockObj->GetNoElem()-1;
while (first <= last){
mid = first + (last - first) / 2;
if ((offset >= blockObj->GetPos(mid) && offset <= (blockObj->GetPos(mid) + blockObj->GetLen(mid))
&& ( (offset + len) <= blockObj->GetPos(mid) + blockObj->GetLen(mid)))){
*index = mid;
return true;
}
else if (blockObj->GetPos(mid) < offset){
first = mid + 1;
}
else{
last = mid - 1;
}
}
return false;
}
//____________________________________________________________________________________________
Long64_t TFilePrefetch::GetWaitTime()
{
// Return the time spent wating for buffer to be read in microseconds.
return Long64_t(fWaitTime.RealTime()*1.e+6);
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::ReadBuffer(char* buf, Long64_t offset, Int_t len)
{
// Return a prefetched element.
Bool_t found = false;
TFPBlock* blockObj = 0;
TMutex *mutexBlocks = fMutexReadList;
Int_t index = -1;
while (1){
mutexBlocks->Lock();
TIter iter(fReadBlocks);
while ((blockObj = (TFPBlock*) iter.Next())){
index = -1;
if (BinarySearchReadList(blockObj, offset, len, &index)){
found = true;
break;
}
}
if (found)
break;
else{
mutexBlocks->UnLock();
fWaitTime.Start(kFALSE);
fReadBlockAdded->Wait(); //wait for a new block to be added
fWaitTime.Stop();
}
}
if (found){
Int_t auxInt = 0;
char* ptrInt = 0;
for(Int_t i=0; i < blockObj->GetNoElem(); i++){
ptrInt = blockObj->GetBuffer();
ptrInt += auxInt;
if (index == i){
ptrInt+= (offset - blockObj->GetPos(i));
memcpy(buf, ptrInt, len);
break;
}
auxInt += blockObj->GetLen(i);
}
}
mutexBlocks->UnLock();
return found;
}
//____________________________________________________________________________________________
void TFilePrefetch::ReadBlock(Long64_t* offset, Int_t* len, Int_t nblock)
{
// Create a TFPBlock object or recycle one and add it to the prefetchBlocks list.
TFPBlock* block = CreateBlockObj(offset, len, nblock);
AddPendingBlock(block);
}
//____________________________________________________________________________________________
void TFilePrefetch::AddPendingBlock(TFPBlock* block)
{
// Safe method to add a block to the pendingList.
TMutex *mutexBlocks = fMutexPendingList;
mutexBlocks->Lock();
fPendingBlocks->Add(block);
mutexBlocks->UnLock();
fNewBlockAdded->Signal();
}
//____________________________________________________________________________________________
TFPBlock* TFilePrefetch::GetPendingBlock()
{
// Safe method to remove a block from the pendingList.
TFPBlock* block = 0;
TMutex *mutexBlocks = fMutexPendingList;
mutexBlocks->Lock();
if (fPendingBlocks->GetSize()){
block = (TFPBlock*)fPendingBlocks->First();
block = (TFPBlock*)fPendingBlocks->Remove(block);
}
mutexBlocks->UnLock();
return block;
}
//____________________________________________________________________________________________
void TFilePrefetch::AddReadBlock(TFPBlock* block)
{
// Safe method to add a block to the readList.
TMutex *mutexBlocks = fMutexReadList;
mutexBlocks->Lock();
if (fReadBlocks->GetSize() >= kMAX_READ_SIZE){
TFPBlock* movedBlock = (TFPBlock*) fReadBlocks->First();
movedBlock = (TFPBlock*)fReadBlocks->Remove(movedBlock);
delete movedBlock;
movedBlock = 0;
}
fReadBlocks->Add(block);
mutexBlocks->UnLock();
fReadBlockAdded->Signal();
}
//____________________________________________________________________________________________
TFPBlock* TFilePrefetch::CreateBlockObj(Long64_t* offset, Int_t* len, Int_t noblock)
{
// Create a new block or recycle an old one.
TFPBlock* blockObj = 0;
TMutex *mutexRead = fMutexReadList;
mutexRead->Lock();
if (fReadBlocks->GetSize() >= kMAX_READ_SIZE){
blockObj = static_cast<TFPBlock*>(fReadBlocks->First());
fReadBlocks->Remove(blockObj);
blockObj->ReallocBlock(offset, len, noblock);
mutexRead->UnLock();
}
else{
mutexRead->UnLock();
blockObj = new TFPBlock(offset, len, noblock);
}
return blockObj;
}
//____________________________________________________________________________________________
TThread* TFilePrefetch::GetThread() const
{
// Return reference to the consumer thread.
return fConsumer;
}
//____________________________________________________________________________________________
void TFilePrefetch::SetFile(TFile *file)
{
// Change the file
fFile = file;
}
//____________________________________________________________________________________________
Int_t TFilePrefetch::ThreadStart()
{
// Used to start the consumer thread.
int rc;
fConsumer= new TThread((TThread::VoidRtnFunc_t) ThreadProc,
(void*) this);
rc = fConsumer->Run();
return rc;
}
//____________________________________________________________________________________________
TThread::VoidRtnFunc_t TFilePrefetch::ThreadProc(void* arg)
{
// Execution loop of the consumer thread.
TFilePrefetch* tmp = (TFilePrefetch*) arg;
tmp->fMutexSynch->Lock();
while(tmp->fSem->TryWait() !=0){
tmp->ReadListOfBlocks();
if (tmp->fSem->TryWait() == 0) break;
tmp->fMutexSynch->UnLock();
tmp->fNewBlockAdded->Wait();
tmp->fMutexSynch->Lock();
}
tmp->fMutexSynch->UnLock();
return (TThread::VoidRtnFunc_t) 1;
}
//########################################### CACHING PART ###############################################################
//____________________________________________________________________________________________
Int_t TFilePrefetch::SumHex(const char *hex)
{
// Sum up individual hex values to obtain a decimal value.
Int_t result = 0;
const char* ptr = hex;
for(Int_t i=0; i < (Int_t)strlen(hex); i++)
result += xtod(ptr[i]);
return result;
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::CheckBlockInCache(char*& path, TFPBlock* block)
{
// Test if the block is in cache.
if (fPathCache == "")
return false;
Bool_t found = false;
TString fullPath(fPathCache); // path of the cached files.
Int_t value = 0;
if (gSystem->OpenDirectory(fullPath) == 0)
gSystem->mkdir(fullPath);
//dir is SHA1 value modulo 16; filename is the value of the SHA1(offset+len)
TMD5* md = new TMD5();
TString concatStr;
for (Int_t i=0; i < block->GetNoElem(); i++){
concatStr.Form("%lld", block->GetPos(i));
md->Update((UChar_t*)concatStr.Data(), concatStr.Length());
}
md->Final();
TString fileName( md->AsString() );
value = SumHex(fileName);
value = value % 16;
TString dirName;
dirName.Form("%i", value);
fullPath += "/" + dirName + "/" + fileName;
FileStat_t stat;
if (gSystem->GetPathInfo(fullPath, stat) == 0) {
path = new char[fullPath.Length() + 1];
strlcpy(path, fullPath,fullPath.Length() + 1);
found = true;
} else
found = false;
delete md;
return found;
}
//____________________________________________________________________________________________
char* TFilePrefetch::GetBlockFromCache(const char* path, Int_t length)
{
// Return a buffer from cache.
char *buffer = 0;
TString strPath = path;
strPath += "?filetype=raw";
TFile* file = new TFile(strPath);
Double_t start = 0;
if (gPerfStats != 0) start = TTimeStamp();
buffer = (char*) calloc(length+1, sizeof(char));
file->ReadBuffer(buffer, 0, length);
fFile->fBytesRead += length;
fFile->fgBytesRead += length;
fFile->SetReadCalls(fFile->GetReadCalls() + 1);
fFile->fgReadCalls++;
if (gMonitoringWriter)
gMonitoringWriter->SendFileReadProgress(fFile);
if (gPerfStats != 0) {
gPerfStats->FileReadEvent(fFile, length, start);
}
delete file;
return buffer;
}
//____________________________________________________________________________________________
void TFilePrefetch::SaveBlockInCache(TFPBlock* block)
{
// Save the block content in cache.
if (fPathCache == "")
return;
//dir is SHA1 value modulo 16; filename is the value of the SHA1
TMD5* md = new TMD5();
TString concatStr;
for(Int_t i=0; i< block->GetNoElem(); i++){
concatStr.Form("%lld", block->GetPos(i));
md->Update((UChar_t*)concatStr.Data(), concatStr.Length());
}
md->Final();
TString fileName( md->AsString() );
Int_t value = SumHex(fileName);
value = value % 16;
TString fullPath( fPathCache );
TString dirName;
dirName.Form("%i", value);
fullPath += ("/" + dirName);
if (gSystem->OpenDirectory(fullPath) == false)
gSystem->mkdir(fullPath);
TFile* file = 0;
fullPath += ("/" + fileName);
FileStat_t stat;
if (gSystem->GetPathInfo(fullPath, stat) == 0) {
fullPath += "?filetype=raw";
file = TFile::Open(fullPath, "update");
} else{
fullPath += "?filetype=raw";
file = TFile::Open(fullPath, "new");
}
file->WriteBuffer(block->GetBuffer(), block->GetFullSize());
file->Close();
delete file;
delete md;
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::CheckCachePath(const char* locationCache)
{
// Validate the input file cache path.
Bool_t found = true;
TString path = locationCache;
Ssiz_t pos = path.Index(":/");
if (pos > 0) {
TSubString prot = path(0, pos);
TSubString dir = path(pos + 2, path.Length());
TString protocol(prot);
TString directory(dir);
for(Int_t i=0; i < directory.Sizeof()-1; i++)
if (!isdigit(directory[i]) && !isalpha(directory[i]) && directory[i] !='/' && directory[i] != ':'){
found = false;
break;
}
} else
found = false;
return found;
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::SetCache(const char* path)
{
// Set the path of the cache directory.
if (CheckCachePath(path)){
fPathCache = path;
if (!gSystem->OpenDirectory(path)){
gSystem->mkdir(path);
}
} else
return false;
return true;
}
<commit_msg>Avoid null pointer dereference (coverity #33794)<commit_after>// @(#)root/io:$Id$
// Author: Elvin Sindrilaru 19/05/2011
/*************************************************************************
* Copyright (C) 1995-2011, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#include "TFilePrefetch.h"
#include "TTimeStamp.h"
#include "TVirtualPerfStats.h"
#include "TVirtualMonitoring.h"
#include <iostream>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cctype>
static const int kMAX_READ_SIZE = 2; //maximum size of the read list of blocks
inline int xtod(char c) { return (c>='0' && c<='9') ? c-'0' : ((c>='A' && c<='F') ? c-'A'+10 : ((c>='a' && c<='f') ? c-'a'+10 : 0)); }
using namespace std;
ClassImp(TFilePrefetch)
//____________________________________________________________________________________________
TFilePrefetch::TFilePrefetch(TFile* file)
{
// Constructor.
fConsumer = 0;
fFile = file;
fPendingBlocks = new TList();
fReadBlocks = new TList();
fMutexReadList = new TMutex();
fMutexPendingList = new TMutex();
fMutexSynch = new TMutex();
fNewBlockAdded = new TCondition(0);
fReadBlockAdded = new TCondition(0);
fSem = new TSemaphore(0);
}
//____________________________________________________________________________________________
TFilePrefetch::~TFilePrefetch()
{
// Destructor.
//killing consumer thread
fMutexSynch->Lock(); //wait fo thread to finish work
fMutexSynch->UnLock();
fSem->Post(); //send terminate signal
fNewBlockAdded->Signal();
fConsumer->Join();
SafeDelete(fConsumer);
SafeDelete(fPendingBlocks);
SafeDelete(fReadBlocks);
SafeDelete(fMutexReadList);
SafeDelete(fMutexPendingList);
SafeDelete(fMutexSynch);
SafeDelete(fNewBlockAdded);
SafeDelete(fReadBlockAdded);
SafeDelete(fSem);
}
//____________________________________________________________________________________________
void TFilePrefetch::ReadAsync(TFPBlock* block, Bool_t &inCache)
{
// Read one block and insert it in prefetchBuffers list.
char* path = 0;
if (CheckBlockInCache(path, block)){
block->SetBuffer(GetBlockFromCache(path, block->GetFullSize()));
inCache = kTRUE;
}
else{
fFile->ReadBuffers(block->GetBuffer(), block->GetPos(), block->GetLen(), block->GetNoElem());
if (fFile->GetArchive()){
for (Int_t i = 0; i < block->GetNoElem(); i++)
block->SetPos(i, block->GetPos(i) - fFile->GetArchiveOffset());
}
inCache =kFALSE;
}
delete[] path;
}
//____________________________________________________________________________________________
void TFilePrefetch::ReadListOfBlocks()
{
// Get blocks specified in prefetchBlocks.
Bool_t inCache = kFALSE;
TFPBlock* block = 0;
while((block = GetPendingBlock())){
ReadAsync(block, inCache);
AddReadBlock(block);
if (!inCache)
SaveBlockInCache(block);
}
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::BinarySearchReadList(TFPBlock* blockObj, Long64_t offset, Int_t len, Int_t* index)
{
// Search for a requested element in a block and return the index.
Int_t first = 0, last = -1, mid = -1;
last = (Int_t) blockObj->GetNoElem()-1;
while (first <= last){
mid = first + (last - first) / 2;
if ((offset >= blockObj->GetPos(mid) && offset <= (blockObj->GetPos(mid) + blockObj->GetLen(mid))
&& ( (offset + len) <= blockObj->GetPos(mid) + blockObj->GetLen(mid)))){
*index = mid;
return true;
}
else if (blockObj->GetPos(mid) < offset){
first = mid + 1;
}
else{
last = mid - 1;
}
}
return false;
}
//____________________________________________________________________________________________
Long64_t TFilePrefetch::GetWaitTime()
{
// Return the time spent wating for buffer to be read in microseconds.
return Long64_t(fWaitTime.RealTime()*1.e+6);
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::ReadBuffer(char* buf, Long64_t offset, Int_t len)
{
// Return a prefetched element.
Bool_t found = false;
TFPBlock* blockObj = 0;
TMutex *mutexBlocks = fMutexReadList;
Int_t index = -1;
while (1){
mutexBlocks->Lock();
TIter iter(fReadBlocks);
while ((blockObj = (TFPBlock*) iter.Next())){
index = -1;
if (BinarySearchReadList(blockObj, offset, len, &index)){
found = true;
break;
}
}
if (found)
break;
else{
mutexBlocks->UnLock();
fWaitTime.Start(kFALSE);
fReadBlockAdded->Wait(); //wait for a new block to be added
fWaitTime.Stop();
}
}
if (found){
Int_t auxInt = 0;
char* ptrInt = 0;
for(Int_t i=0; i < blockObj->GetNoElem(); i++){
ptrInt = blockObj->GetBuffer();
ptrInt += auxInt;
if (index == i){
ptrInt+= (offset - blockObj->GetPos(i));
memcpy(buf, ptrInt, len);
break;
}
auxInt += blockObj->GetLen(i);
}
}
mutexBlocks->UnLock();
return found;
}
//____________________________________________________________________________________________
void TFilePrefetch::ReadBlock(Long64_t* offset, Int_t* len, Int_t nblock)
{
// Create a TFPBlock object or recycle one and add it to the prefetchBlocks list.
TFPBlock* block = CreateBlockObj(offset, len, nblock);
AddPendingBlock(block);
}
//____________________________________________________________________________________________
void TFilePrefetch::AddPendingBlock(TFPBlock* block)
{
// Safe method to add a block to the pendingList.
TMutex *mutexBlocks = fMutexPendingList;
mutexBlocks->Lock();
fPendingBlocks->Add(block);
mutexBlocks->UnLock();
fNewBlockAdded->Signal();
}
//____________________________________________________________________________________________
TFPBlock* TFilePrefetch::GetPendingBlock()
{
// Safe method to remove a block from the pendingList.
TFPBlock* block = 0;
TMutex *mutexBlocks = fMutexPendingList;
mutexBlocks->Lock();
if (fPendingBlocks->GetSize()){
block = (TFPBlock*)fPendingBlocks->First();
block = (TFPBlock*)fPendingBlocks->Remove(block);
}
mutexBlocks->UnLock();
return block;
}
//____________________________________________________________________________________________
void TFilePrefetch::AddReadBlock(TFPBlock* block)
{
// Safe method to add a block to the readList.
TMutex *mutexBlocks = fMutexReadList;
mutexBlocks->Lock();
if (fReadBlocks->GetSize() >= kMAX_READ_SIZE){
TFPBlock* movedBlock = (TFPBlock*) fReadBlocks->First();
movedBlock = (TFPBlock*)fReadBlocks->Remove(movedBlock);
delete movedBlock;
movedBlock = 0;
}
fReadBlocks->Add(block);
mutexBlocks->UnLock();
fReadBlockAdded->Signal();
}
//____________________________________________________________________________________________
TFPBlock* TFilePrefetch::CreateBlockObj(Long64_t* offset, Int_t* len, Int_t noblock)
{
// Create a new block or recycle an old one.
TFPBlock* blockObj = 0;
TMutex *mutexRead = fMutexReadList;
mutexRead->Lock();
if (fReadBlocks->GetSize() >= kMAX_READ_SIZE){
blockObj = static_cast<TFPBlock*>(fReadBlocks->First());
fReadBlocks->Remove(blockObj);
blockObj->ReallocBlock(offset, len, noblock);
mutexRead->UnLock();
}
else{
mutexRead->UnLock();
blockObj = new TFPBlock(offset, len, noblock);
}
return blockObj;
}
//____________________________________________________________________________________________
TThread* TFilePrefetch::GetThread() const
{
// Return reference to the consumer thread.
return fConsumer;
}
//____________________________________________________________________________________________
void TFilePrefetch::SetFile(TFile *file)
{
// Change the file
fFile = file;
}
//____________________________________________________________________________________________
Int_t TFilePrefetch::ThreadStart()
{
// Used to start the consumer thread.
int rc;
fConsumer= new TThread((TThread::VoidRtnFunc_t) ThreadProc,
(void*) this);
rc = fConsumer->Run();
return rc;
}
//____________________________________________________________________________________________
TThread::VoidRtnFunc_t TFilePrefetch::ThreadProc(void* arg)
{
// Execution loop of the consumer thread.
TFilePrefetch* tmp = (TFilePrefetch*) arg;
tmp->fMutexSynch->Lock();
while(tmp->fSem->TryWait() !=0){
tmp->ReadListOfBlocks();
if (tmp->fSem->TryWait() == 0) break;
tmp->fMutexSynch->UnLock();
tmp->fNewBlockAdded->Wait();
tmp->fMutexSynch->Lock();
}
tmp->fMutexSynch->UnLock();
return (TThread::VoidRtnFunc_t) 1;
}
//########################################### CACHING PART ###############################################################
//____________________________________________________________________________________________
Int_t TFilePrefetch::SumHex(const char *hex)
{
// Sum up individual hex values to obtain a decimal value.
Int_t result = 0;
const char* ptr = hex;
for(Int_t i=0; i < (Int_t)strlen(hex); i++)
result += xtod(ptr[i]);
return result;
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::CheckBlockInCache(char*& path, TFPBlock* block)
{
// Test if the block is in cache.
if (fPathCache == "")
return false;
Bool_t found = false;
TString fullPath(fPathCache); // path of the cached files.
Int_t value = 0;
if (gSystem->OpenDirectory(fullPath) == 0)
gSystem->mkdir(fullPath);
//dir is SHA1 value modulo 16; filename is the value of the SHA1(offset+len)
TMD5* md = new TMD5();
TString concatStr;
for (Int_t i=0; i < block->GetNoElem(); i++){
concatStr.Form("%lld", block->GetPos(i));
md->Update((UChar_t*)concatStr.Data(), concatStr.Length());
}
md->Final();
TString fileName( md->AsString() );
value = SumHex(fileName);
value = value % 16;
TString dirName;
dirName.Form("%i", value);
fullPath += "/" + dirName + "/" + fileName;
FileStat_t stat;
if (gSystem->GetPathInfo(fullPath, stat) == 0) {
path = new char[fullPath.Length() + 1];
strlcpy(path, fullPath,fullPath.Length() + 1);
found = true;
} else
found = false;
delete md;
return found;
}
//____________________________________________________________________________________________
char* TFilePrefetch::GetBlockFromCache(const char* path, Int_t length)
{
// Return a buffer from cache.
char *buffer = 0;
TString strPath = path;
strPath += "?filetype=raw";
TFile* file = new TFile(strPath);
Double_t start = 0;
if (gPerfStats != 0) start = TTimeStamp();
buffer = (char*) calloc(length+1, sizeof(char));
file->ReadBuffer(buffer, 0, length);
fFile->fBytesRead += length;
fFile->fgBytesRead += length;
fFile->SetReadCalls(fFile->GetReadCalls() + 1);
fFile->fgReadCalls++;
if (gMonitoringWriter)
gMonitoringWriter->SendFileReadProgress(fFile);
if (gPerfStats != 0) {
gPerfStats->FileReadEvent(fFile, length, start);
}
delete file;
return buffer;
}
//____________________________________________________________________________________________
void TFilePrefetch::SaveBlockInCache(TFPBlock* block)
{
// Save the block content in cache.
if (fPathCache == "")
return;
//dir is SHA1 value modulo 16; filename is the value of the SHA1
TMD5* md = new TMD5();
TString concatStr;
for(Int_t i=0; i< block->GetNoElem(); i++){
concatStr.Form("%lld", block->GetPos(i));
md->Update((UChar_t*)concatStr.Data(), concatStr.Length());
}
md->Final();
TString fileName( md->AsString() );
Int_t value = SumHex(fileName);
value = value % 16;
TString fullPath( fPathCache );
TString dirName;
dirName.Form("%i", value);
fullPath += ("/" + dirName);
if (gSystem->OpenDirectory(fullPath) == false)
gSystem->mkdir(fullPath);
TFile* file = 0;
fullPath += ("/" + fileName);
FileStat_t stat;
if (gSystem->GetPathInfo(fullPath, stat) == 0) {
fullPath += "?filetype=raw";
file = TFile::Open(fullPath, "update");
} else{
fullPath += "?filetype=raw";
file = TFile::Open(fullPath, "new");
}
if (file) {
file->WriteBuffer(block->GetBuffer(), block->GetFullSize());
file->Close();
delete file;
}
delete md;
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::CheckCachePath(const char* locationCache)
{
// Validate the input file cache path.
Bool_t found = true;
TString path = locationCache;
Ssiz_t pos = path.Index(":/");
if (pos > 0) {
TSubString prot = path(0, pos);
TSubString dir = path(pos + 2, path.Length());
TString protocol(prot);
TString directory(dir);
for(Int_t i=0; i < directory.Sizeof()-1; i++)
if (!isdigit(directory[i]) && !isalpha(directory[i]) && directory[i] !='/' && directory[i] != ':'){
found = false;
break;
}
} else
found = false;
return found;
}
//____________________________________________________________________________________________
Bool_t TFilePrefetch::SetCache(const char* path)
{
// Set the path of the cache directory.
if (CheckCachePath(path)){
fPathCache = path;
if (!gSystem->OpenDirectory(path)){
gSystem->mkdir(path);
}
} else
return false;
return true;
}
<|endoftext|>
|
<commit_before>/*******************************************************************************
Licensed to the OpenCOR team under one or more contributor license agreements.
See the NOTICE.txt file distributed with this work for additional information
regarding copyright ownership. The OpenCOR team licenses this file to you under
the Apache License, Version 2.0 (the "License"); you may not use this file
except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
*******************************************************************************/
//==============================================================================
// CellMLSupport plugin
//==============================================================================
#include "cellmlfilemanager.h"
#include "cellmlsupportplugin.h"
#include "filemanager.h"
//==============================================================================
#include <QFile>
#include <QFileInfo>
#include <QIODevice>
#include <QXmlStreamReader>
//==============================================================================
namespace OpenCOR {
namespace CellMLSupport {
//==============================================================================
PLUGININFO_FUNC CellMLSupportPluginInfo()
{
Descriptions descriptions;
descriptions.insert("en", QString::fromUtf8("a plugin to support <a href=\"http://www.cellml.org/\">CellML</a>."));
descriptions.insert("fr", QString::fromUtf8("une extension pour supporter <a href=\"http://www.cellml.org/\">CellML</a>."));
return new PluginInfo(PluginInfo::Support, false,
QStringList() << "Core" << "CellMLAPI" << "Compiler" << "CoreSolver",
descriptions);
}
//==============================================================================
// Core interface
//==============================================================================
void CellMLSupportPlugin::initialize()
{
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::finalize()
{
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::initialized(const Plugins &pLoadedPlugins)
{
Q_UNUSED(pLoadedPlugins);
// Make a call to the instance of the CellML file manager so that it gets
// properly set up before it actually gets used
// Note: we do it here rather than in initialize() since we need the Core
// plugin to be initialised (so we can get access to our 'global' file
// manager)...
CellmlFileManager::instance();
}
//==============================================================================
void CellMLSupportPlugin::loadSettings(QSettings *pSettings)
{
Q_UNUSED(pSettings);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::saveSettings(QSettings *pSettings) const
{
Q_UNUSED(pSettings);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::settingsLoaded(const Plugins &pLoadedPlugins)
{
Q_UNUSED(pLoadedPlugins);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::handleArguments(const QStringList &pArguments)
{
Q_UNUSED(pArguments);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::handleAction(const QUrl &pUrl)
{
Q_UNUSED(pUrl);
// We don't handle this interface...
}
//==============================================================================
// File interface
//==============================================================================
FileTypes CellMLSupportPlugin::fileTypes() const
{
// Return the CellML file type that the CellMLSupport plugin supports
return FileTypes() << FileType(qobject_cast<FileInterface *>(this),
CellmlMimeType, CellmlFileExtension);
}
//==============================================================================
QString CellMLSupportPlugin::fileTypeDescription(const QString &pMimeType) const
{
// Return the description for the requested MIME type, that is as long as it
// is for the CellML MIME type
if (!pMimeType.compare(CellmlMimeType))
return tr("CellML File");
else
// Not a MIME type that we can recognise, so...
return QString();
}
//==============================================================================
// GUI interface
//==============================================================================
void CellMLSupportPlugin::retranslateUi()
{
// We don't handle this interface...
}
//==============================================================================
// Plugin specific
//==============================================================================
bool isCellmlFile(const QString &pFileName)
{
// Return whether the file is a CellML file
if (!QFileInfo(pFileName).completeSuffix().compare(CellmlFileExtension))
// We are dealing with a file which file extension is that of a CellML
// file, so...
return true;
// The file doesn't have the 'correct' file extension, so check whether it's
// a new file
if (Core::FileManager::instance()->isNew(pFileName))
return true;
// The file neither has the 'correct' file extension nor is a new file, so
// quickly check its contents
QFile file(pFileName);
if (!file.open(QIODevice::ReadOnly))
// We can't open the file, so...
return false;
// Try to read the file as if it was an XML file
QXmlStreamReader xml(&file);
bool res = false;
xml.readNext();
while (!xml.atEnd()) {
if (xml.isStartElement()) {
// This is our root element, so for the file to be considered a
// CellML file it should be a model element in either the CellML 1.0
// or 1.1 namespace
if ( !xml.name().toString().compare("model")
&& ( (!xml.namespaceUri().toString().compare("http://www.cellml.org/cellml/1.0#"))
|| (!xml.namespaceUri().toString().compare("http://www.cellml.org/cellml/1.1#")))) {
// All the requirements are gathered for the file to be
// considered a CellML file, so...
res = true;
}
break;
}
xml.readNext();
}
file.close();
// We are done, so...
return res;
}
//==============================================================================
} // namespace CellMLSupport
} // namespace OpenCOR
//==============================================================================
// End of file
//==============================================================================
<commit_msg>Some minor cleaning up.<commit_after>/*******************************************************************************
Licensed to the OpenCOR team under one or more contributor license agreements.
See the NOTICE.txt file distributed with this work for additional information
regarding copyright ownership. The OpenCOR team licenses this file to you under
the Apache License, Version 2.0 (the "License"); you may not use this file
except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
*******************************************************************************/
//==============================================================================
// CellMLSupport plugin
//==============================================================================
#include "cellmlfilemanager.h"
#include "cellmlsupportplugin.h"
#include "filemanager.h"
//==============================================================================
#include <QFile>
#include <QFileInfo>
#include <QIODevice>
#include <QXmlStreamReader>
//==============================================================================
namespace OpenCOR {
namespace CellMLSupport {
//==============================================================================
PLUGININFO_FUNC CellMLSupportPluginInfo()
{
Descriptions descriptions;
descriptions.insert("en", QString::fromUtf8("a plugin to support <a href=\"http://www.cellml.org/\">CellML</a>."));
descriptions.insert("fr", QString::fromUtf8("une extension pour supporter <a href=\"http://www.cellml.org/\">CellML</a>."));
return new PluginInfo(PluginInfo::Support, false,
QStringList() << "Core" << "CellMLAPI" << "Compiler" << "CoreSolver",
descriptions);
}
//==============================================================================
// Core interface
//==============================================================================
void CellMLSupportPlugin::initialize()
{
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::finalize()
{
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::initialized(const Plugins &pLoadedPlugins)
{
Q_UNUSED(pLoadedPlugins);
// Make a call to the instance of the CellML file manager so that it gets
// properly set up before it actually gets used
// Note: we do it here rather than in initialize() since we need the Core
// plugin to be initialised (so we can get access to our 'global' file
// manager)...
CellmlFileManager::instance();
}
//==============================================================================
void CellMLSupportPlugin::loadSettings(QSettings *pSettings)
{
Q_UNUSED(pSettings);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::saveSettings(QSettings *pSettings) const
{
Q_UNUSED(pSettings);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::settingsLoaded(const Plugins &pLoadedPlugins)
{
Q_UNUSED(pLoadedPlugins);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::handleArguments(const QStringList &pArguments)
{
Q_UNUSED(pArguments);
// We don't handle this interface...
}
//==============================================================================
void CellMLSupportPlugin::handleAction(const QUrl &pUrl)
{
Q_UNUSED(pUrl);
// We don't handle this interface...
}
//==============================================================================
// File interface
//==============================================================================
FileTypes CellMLSupportPlugin::fileTypes() const
{
// Return the CellML file type that the CellMLSupport plugin supports
return FileTypes() << FileType(qobject_cast<FileInterface *>(this),
CellmlMimeType, CellmlFileExtension);
}
//==============================================================================
QString CellMLSupportPlugin::fileTypeDescription(const QString &pMimeType) const
{
// Return the description for the requested MIME type, that is as long as it
// is for the CellML MIME type
if (!pMimeType.compare(CellmlMimeType))
return tr("CellML File");
else
// Not a MIME type that we can recognise, so...
return QString();
}
//==============================================================================
// GUI interface
//==============================================================================
void CellMLSupportPlugin::retranslateUi()
{
// We don't handle this interface...
}
//==============================================================================
// Plugin specific
//==============================================================================
bool isCellmlFile(const QString &pFileName)
{
// Return whether the file is a CellML file
if (!QFileInfo(pFileName).completeSuffix().compare(CellmlFileExtension))
// We are dealing with a file which file extension is that of a CellML
// file, so...
return true;
// The file doesn't have the 'correct' file extension, so check whether it's
// a new file
if (Core::FileManager::instance()->isNew(pFileName))
return true;
// The file neither has the 'correct' file extension nor is a new file, so
// quickly check its contents
QFile file(pFileName);
if (!file.open(QIODevice::ReadOnly))
// We can't open the file, so...
return false;
// Try to read the file as if it was an XML file
QXmlStreamReader xml(&file);
bool res = false;
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
// This is our root element, so for the file to be considered a
// CellML file it should be a model element in either the CellML 1.0
// or 1.1 namespace
if ( !xml.name().toString().compare("model")
&& ( (!xml.namespaceUri().toString().compare("http://www.cellml.org/cellml/1.0#"))
|| (!xml.namespaceUri().toString().compare("http://www.cellml.org/cellml/1.1#")))) {
// All the requirements are gathered for the file to be
// considered a CellML file, so...
res = true;
}
break;
}
}
file.close();
// We are done, so...
return res;
}
//==============================================================================
} // namespace CellMLSupport
} // namespace OpenCOR
//==============================================================================
// End of file
//==============================================================================
<|endoftext|>
|
<commit_before>/******************************************************************************
* SOFA, Simulation Open-Framework Architecture, version 1.0 RC 1 *
* (c) 2006-2011 MGH, INRIA, USTL, UJF, CNRS *
* *
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA. *
*******************************************************************************
* SOFA :: Plugins *
* *
* Authors: The SOFA Team and external contributors (see Authors.txt) *
* *
* Contact information: contact@sofa-framework.org *
******************************************************************************/
#include "ScriptController.h"
#include "ScriptEnvironment.h"
#include "PythonEnvironment.h"
#include <sofa/core/objectmodel/GUIEvent.h>
#include <sofa/core/objectmodel/MouseEvent.h>
#include <sofa/core/objectmodel/KeypressedEvent.h>
#include <sofa/core/objectmodel/KeyreleasedEvent.h>
using namespace sofa::simulation;
namespace sofa
{
namespace component
{
namespace controller
{
ScriptController::ScriptController()
: Controller()
{
// various initialization stuff here...
f_listening = true; // par défaut, on écoute les events sinon le script va pas servir à grand chose
}
void ScriptController::parse(sofa::core::objectmodel::BaseObjectDescription *arg)
{
Controller::parse(arg);
//std::cout<<getName()<<" ScriptController::parse"<<std::endl;
// load & bind script
loadScript();
// call script notifications...
script_onLoaded( dynamic_cast<simulation::Node*>(getContext()) );
script_createGraph( dynamic_cast<simulation::Node*>(getContext()) );
ScriptEnvironment::initScriptNodes();
}
void ScriptController::init()
{
Controller::init();
// init the script
script_initGraph( dynamic_cast<simulation::Node*>(getContext()) );
ScriptEnvironment::initScriptNodes();
}
void ScriptController::storeResetState()
{
Controller::storeResetState();
// init the script
script_storeResetState();
ScriptEnvironment::initScriptNodes();
}
void ScriptController::reset()
{
Controller::reset();
// init the script
script_reset();
ScriptEnvironment::initScriptNodes();
}
void ScriptController::cleanup()
{
Controller::cleanup();
// init the script
script_cleanup();
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onBeginAnimationStep(const double dt)
{
script_onBeginAnimationStep(dt);
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onEndAnimationStep(const double dt)
{
script_onEndAnimationStep(dt);
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onMouseEvent(core::objectmodel::MouseEvent * evt)
{
switch(evt->getState())
{
case core::objectmodel::MouseEvent::Move:
break;
case core::objectmodel::MouseEvent::LeftPressed:
script_onMouseButtonLeft(evt->getPosX(),evt->getPosY(),true);
break;
case core::objectmodel::MouseEvent::LeftReleased:
script_onMouseButtonLeft(evt->getPosX(),evt->getPosY(),false);
break;
case core::objectmodel::MouseEvent::RightPressed:
script_onMouseButtonRight(evt->getPosX(),evt->getPosY(),true);
break;
case core::objectmodel::MouseEvent::RightReleased:
script_onMouseButtonRight(evt->getPosX(),evt->getPosY(),false);
break;
case core::objectmodel::MouseEvent::MiddlePressed:
script_onMouseButtonMiddle(evt->getPosX(),evt->getPosY(),true);
break;
case core::objectmodel::MouseEvent::MiddleReleased:
script_onMouseButtonMiddle(evt->getPosX(),evt->getPosY(),false);
break;
case core::objectmodel::MouseEvent::Wheel:
script_onMouseWheel(evt->getPosX(),evt->getPosY(),evt->getWheelDelta());
break;
case core::objectmodel::MouseEvent::Reset:
break;
default:
break;
}
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onKeyPressedEvent(core::objectmodel::KeypressedEvent * evt)
{
script_onKeyPressed(evt->getKey());
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onKeyReleasedEvent(core::objectmodel::KeyreleasedEvent * evt)
{
script_onKeyReleased(evt->getKey());
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onGUIEvent(core::objectmodel::GUIEvent *event)
{
script_onGUIEvent(event->getControlID().c_str(),
event->getValueName().c_str(),
event->getValue().c_str());
ScriptEnvironment::initScriptNodes();
}
void ScriptController::handleEvent(core::objectmodel::Event *event)
{
if (dynamic_cast<core::objectmodel::ScriptEvent *>(event))
{
script_onScriptEvent(static_cast<core::objectmodel::ScriptEvent *> (event));
ScriptEnvironment::initScriptNodes();
}
else Controller::handleEvent(event);
}
} // namespace controller
} // namespace component
} // namespace sofa
<commit_msg>r8847/sofa : FIX SofaPython components init<commit_after>/******************************************************************************
* SOFA, Simulation Open-Framework Architecture, version 1.0 RC 1 *
* (c) 2006-2011 MGH, INRIA, USTL, UJF, CNRS *
* *
* 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 Street, Fifth Floor, Boston, MA 02110-1301 USA. *
*******************************************************************************
* SOFA :: Plugins *
* *
* Authors: The SOFA Team and external contributors (see Authors.txt) *
* *
* Contact information: contact@sofa-framework.org *
******************************************************************************/
#include "ScriptController.h"
#include "ScriptEnvironment.h"
#include "PythonEnvironment.h"
#include <sofa/core/objectmodel/GUIEvent.h>
#include <sofa/core/objectmodel/MouseEvent.h>
#include <sofa/core/objectmodel/KeypressedEvent.h>
#include <sofa/core/objectmodel/KeyreleasedEvent.h>
using namespace sofa::simulation;
namespace sofa
{
namespace component
{
namespace controller
{
ScriptController::ScriptController()
: Controller()
{
// various initialization stuff here...
f_listening = true; // par défaut, on écoute les events sinon le script va pas servir à grand chose
}
void ScriptController::parse(sofa::core::objectmodel::BaseObjectDescription *arg)
{
Controller::parse(arg);
//std::cout<<getName()<<" ScriptController::parse"<<std::endl;
// load & bind script
loadScript();
// call script notifications...
script_onLoaded( dynamic_cast<simulation::Node*>(getContext()) );
script_createGraph( dynamic_cast<simulation::Node*>(getContext()) );
// ScriptEnvironment::initScriptNodes();
}
void ScriptController::init()
{
Controller::init();
// init the script
script_initGraph( dynamic_cast<simulation::Node*>(getContext()) );
// ScriptEnvironment::initScriptNodes();
}
void ScriptController::storeResetState()
{
Controller::storeResetState();
// init the script
script_storeResetState();
ScriptEnvironment::initScriptNodes();
}
void ScriptController::reset()
{
Controller::reset();
// init the script
script_reset();
ScriptEnvironment::initScriptNodes();
}
void ScriptController::cleanup()
{
Controller::cleanup();
// init the script
script_cleanup();
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onBeginAnimationStep(const double dt)
{
script_onBeginAnimationStep(dt);
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onEndAnimationStep(const double dt)
{
script_onEndAnimationStep(dt);
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onMouseEvent(core::objectmodel::MouseEvent * evt)
{
switch(evt->getState())
{
case core::objectmodel::MouseEvent::Move:
break;
case core::objectmodel::MouseEvent::LeftPressed:
script_onMouseButtonLeft(evt->getPosX(),evt->getPosY(),true);
break;
case core::objectmodel::MouseEvent::LeftReleased:
script_onMouseButtonLeft(evt->getPosX(),evt->getPosY(),false);
break;
case core::objectmodel::MouseEvent::RightPressed:
script_onMouseButtonRight(evt->getPosX(),evt->getPosY(),true);
break;
case core::objectmodel::MouseEvent::RightReleased:
script_onMouseButtonRight(evt->getPosX(),evt->getPosY(),false);
break;
case core::objectmodel::MouseEvent::MiddlePressed:
script_onMouseButtonMiddle(evt->getPosX(),evt->getPosY(),true);
break;
case core::objectmodel::MouseEvent::MiddleReleased:
script_onMouseButtonMiddle(evt->getPosX(),evt->getPosY(),false);
break;
case core::objectmodel::MouseEvent::Wheel:
script_onMouseWheel(evt->getPosX(),evt->getPosY(),evt->getWheelDelta());
break;
case core::objectmodel::MouseEvent::Reset:
break;
default:
break;
}
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onKeyPressedEvent(core::objectmodel::KeypressedEvent * evt)
{
script_onKeyPressed(evt->getKey());
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onKeyReleasedEvent(core::objectmodel::KeyreleasedEvent * evt)
{
script_onKeyReleased(evt->getKey());
ScriptEnvironment::initScriptNodes();
}
void ScriptController::onGUIEvent(core::objectmodel::GUIEvent *event)
{
script_onGUIEvent(event->getControlID().c_str(),
event->getValueName().c_str(),
event->getValue().c_str());
ScriptEnvironment::initScriptNodes();
}
void ScriptController::handleEvent(core::objectmodel::Event *event)
{
if (dynamic_cast<core::objectmodel::ScriptEvent *>(event))
{
script_onScriptEvent(static_cast<core::objectmodel::ScriptEvent *> (event));
ScriptEnvironment::initScriptNodes();
}
else Controller::handleEvent(event);
}
} // namespace controller
} // namespace component
} // namespace sofa
<|endoftext|>
|
<commit_before>//=============================================================================
// Copyright (c) 2017 Ryooooooga
// https://github.com/Ryooooooga
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom
// the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//=============================================================================
#ifndef INCLUDE_NENE_EXCEPTIONS_WINDOWS_DIRECTXEXCEPTION_HPP
#define INCLUDE_NENE_EXCEPTIONS_WINDOWS_DIRECTXEXCEPTION_HPP
#include "../../Platform.hpp"
#if defined(NENE_OS_WINDOWS)
#include "WindowsApiException.hpp"
namespace Nene::Windows
{
/**
* @brief Exception for signaling DirectX errors.
*/
class DirectXException
: public WindowsApiException
{
public:
/**
* @brief Constructor.
*
* @param[in] errorCode Error code.
* @param[in] message Error message.
*/
explicit DirectXException(HRESULT errorCode, std::string_view message)
: WindowsApiException(static_cast<DWORD>(errorCode), message) {}
/**
* @brief Destructor.
*/
virtual ~DirectXException() =default;
};
/**
* @brief Throws error when the given code represents error.
*
* @param[in] result The result code.
* @param[in] errorMessage The error message or generator function.
*
* @tparam String `std::string_view` or `() -> std::string`.
*/
template <typename String>
inline std::enable_if_t<std::is_function_v<String>> throwIfFailed(HRESULT result, const String& errorMessage)
{
if (FAILED(result))
{
throw DirectXException { result, errorMessage() };
}
}
template <typename String>
inline std::enable_if_t<!std::is_function_v<String>> throwIfFailed(HRESULT result, const String& errorMessage)
{
if (FAILED(result))
{
throw DirectXException { result, errorMessage };
}
}
}
#endif
#endif // #ifndef INCLUDE_NENE_EXCEPTIONS_WINDOWS_DIRECTXEXCEPTION_HPP
<commit_msg>:bug: Fix throwIfFailed().<commit_after>//=============================================================================
// Copyright (c) 2017 Ryooooooga
// https://github.com/Ryooooooga
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom
// the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//=============================================================================
#ifndef INCLUDE_NENE_EXCEPTIONS_WINDOWS_DIRECTXEXCEPTION_HPP
#define INCLUDE_NENE_EXCEPTIONS_WINDOWS_DIRECTXEXCEPTION_HPP
#include "../../Platform.hpp"
#if defined(NENE_OS_WINDOWS)
#include <functional>
#include "WindowsApiException.hpp"
namespace Nene::Windows
{
/**
* @brief Exception for signaling DirectX errors.
*/
class DirectXException
: public WindowsApiException
{
public:
/**
* @brief Constructor.
*
* @param[in] errorCode Error code.
* @param[in] message Error message.
*/
explicit DirectXException(HRESULT errorCode, std::string_view message)
: WindowsApiException(static_cast<DWORD>(errorCode), message) {}
/**
* @brief Destructor.
*/
virtual ~DirectXException() =default;
};
/**
* @brief Throws error when the given code represents error.
*
* @param[in] result The result code.
* @param[in] errorMessage The error message or generator function.
*/
inline void throwIfFailed(HRESULT result, std::string_view errorMessage)
{
if (FAILED(result))
{
throw DirectXException { result, errorMessage };
}
}
inline void throwIfFailed(HRESULT result, const std::function<std::string()>& errorMessage)
{
if (FAILED(result))
{
throw DirectXException { result, errorMessage() };
}
}
}
#endif
#endif // #ifndef INCLUDE_NENE_EXCEPTIONS_WINDOWS_DIRECTXEXCEPTION_HPP
<|endoftext|>
|
<commit_before>//
// Copyright (c) 2008-2014 the Urho3D project.
//
// 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 "Button.h"
#include "Camera.h"
#include "CoreEvents.h"
#include "Cursor.h"
#include "Engine.h"
#include "Graphics.h"
#include "Input.h"
#include "ResourceCache.h"
#include "Scene.h"
#include "UI.h"
#include "UIEvents.h"
#include "XMLFile.h"
#include "Zone.h"
#include "SceneAndUILoad.h"
#include "DebugNew.h"
DEFINE_APPLICATION_MAIN(SceneAndUILoad)
SceneAndUILoad::SceneAndUILoad(Context* context) :
Sample(context)
{
}
void SceneAndUILoad::Start()
{
// Execute base class startup
Sample::Start();
// Create the scene content
CreateScene();
// Create the UI content
CreateUI();
// Setup the viewport for displaying the scene
SetupViewport();
// Subscribe to global events for camera movement
SubscribeToEvents();
}
void SceneAndUILoad::CreateScene()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
scene_ = new Scene(context_);
// Load scene content prepared in the editor (XML format). GetFile() returns an open file from the resource system
// which scene.LoadXML() will read
SharedPtr<File> file = cache->GetFile("Scenes/SceneLoadExample.xml");
scene_->LoadXML(*file);
// Create the camera (not included in the scene file)
cameraNode_ = scene_->CreateChild("Camera");
cameraNode_->CreateComponent<Camera>();
// Set an initial position for the camera scene node above the plane
cameraNode_->SetPosition(Vector3(0.0f, 2.0f, -10.0f));
}
void SceneAndUILoad::CreateUI()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
UI* ui = GetSubsystem<UI>();
// Set up global UI style into the root UI element
XMLFile* style = cache->GetResource<XMLFile>("UI/DefaultStyle.xml");
ui->GetRoot()->SetDefaultStyle(style);
// Create a Cursor UI element because we want to be able to hide and show it at will. When hidden, the mouse cursor will
// control the camera, and when visible, it will interact with the UI
SharedPtr<Cursor> cursor(new Cursor(context_));
cursor->SetStyleAuto();
ui->SetCursor(cursor);
// Set starting position of the cursor at the rendering window center
Graphics* graphics = GetSubsystem<Graphics>();
cursor->SetPosition(graphics->GetWidth() / 2, graphics->GetHeight() / 2);
// Load UI content prepared in the editor and add to the UI hierarchy
SharedPtr<UIElement> layoutRoot = ui->LoadLayout(cache->GetResource<XMLFile>("UI/UILoadExample.xml"));
ui->GetRoot()->AddChild(layoutRoot);
// Subscribe to button actions (toggle scene lights when pressed then released)
Button* button = static_cast<Button*>(layoutRoot->GetChild("ToggleLight1", true));
if (button)
SubscribeToEvent(button, E_RELEASED, HANDLER(SceneAndUILoad, ToggleLight1));
button = static_cast<Button*>(layoutRoot->GetChild("ToggleLight2", true));
if (button)
SubscribeToEvent(button, E_RELEASED, HANDLER(SceneAndUILoad, ToggleLight2));
}
void SceneAndUILoad::SetupViewport()
{
Renderer* renderer = GetSubsystem<Renderer>();
// Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
SharedPtr<Viewport> viewport(new Viewport(context_, scene_, cameraNode_->GetComponent<Camera>()));
renderer->SetViewport(0, viewport);
}
void SceneAndUILoad::SubscribeToEvents()
{
// Subscribe HandleUpdate() function for camera motion
SubscribeToEvent(E_UPDATE, HANDLER(SceneAndUILoad, HandleUpdate));
}
void SceneAndUILoad::MoveCamera(float timeStep)
{
// Right mouse button controls mouse cursor visibility: hide when pressed
UI* ui = GetSubsystem<UI>();
Input* input = GetSubsystem<Input>();
ui->GetCursor()->SetVisible(!input->GetMouseButtonDown(MOUSEB_RIGHT));
// Do not move if the UI has a focused element
if (ui->GetFocusElement())
return;
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
// Only move the camera when the cursor is hidden
if (!ui->GetCursor()->IsVisible())
{
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
}
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
}
void SceneAndUILoad::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
// Take the frame time step, which is stored as a float
float timeStep = eventData[P_TIMESTEP].GetFloat();
// Move the camera, scale movement with time step
MoveCamera(timeStep);
}
void SceneAndUILoad::ToggleLight1(StringHash eventType, VariantMap& eventData)
{
Node* lightNode = scene_->GetChild("Light1", true);
if (lightNode)
lightNode->SetEnabled(!lightNode->IsEnabled());
}
void SceneAndUILoad::ToggleLight2(StringHash eventType, VariantMap& eventData)
{
Node* lightNode = scene_->GetChild("Light2", true);
if (lightNode)
lightNode->SetEnabled(!lightNode->IsEnabled());
}
<commit_msg>Refactor newly added sample app to use Urho3D SDK include path.<commit_after>//
// Copyright (c) 2008-2014 the Urho3D project.
//
// 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 <Urho3D/UI/Button.h>
#include <Urho3D/Graphics/Camera.h>
#include <Urho3D/Core/CoreEvents.h>
#include <Urho3D/UI/Cursor.h>
#include <Urho3D/Engine/Engine.h>
#include <Urho3D/Graphics/Graphics.h>
#include <Urho3D/Input/Input.h>
#include <Urho3D/Resource/ResourceCache.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/UI/UI.h>
#include <Urho3D/UI/UIEvents.h>
#include <Urho3D/Resource/XMLFile.h>
#include <Urho3D/Graphics/Zone.h>
#include "SceneAndUILoad.h"
#include <Urho3D/Container/DebugNew.h>
DEFINE_APPLICATION_MAIN(SceneAndUILoad)
SceneAndUILoad::SceneAndUILoad(Context* context) :
Sample(context)
{
}
void SceneAndUILoad::Start()
{
// Execute base class startup
Sample::Start();
// Create the scene content
CreateScene();
// Create the UI content
CreateUI();
// Setup the viewport for displaying the scene
SetupViewport();
// Subscribe to global events for camera movement
SubscribeToEvents();
}
void SceneAndUILoad::CreateScene()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
scene_ = new Scene(context_);
// Load scene content prepared in the editor (XML format). GetFile() returns an open file from the resource system
// which scene.LoadXML() will read
SharedPtr<File> file = cache->GetFile("Scenes/SceneLoadExample.xml");
scene_->LoadXML(*file);
// Create the camera (not included in the scene file)
cameraNode_ = scene_->CreateChild("Camera");
cameraNode_->CreateComponent<Camera>();
// Set an initial position for the camera scene node above the plane
cameraNode_->SetPosition(Vector3(0.0f, 2.0f, -10.0f));
}
void SceneAndUILoad::CreateUI()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
UI* ui = GetSubsystem<UI>();
// Set up global UI style into the root UI element
XMLFile* style = cache->GetResource<XMLFile>("UI/DefaultStyle.xml");
ui->GetRoot()->SetDefaultStyle(style);
// Create a Cursor UI element because we want to be able to hide and show it at will. When hidden, the mouse cursor will
// control the camera, and when visible, it will interact with the UI
SharedPtr<Cursor> cursor(new Cursor(context_));
cursor->SetStyleAuto();
ui->SetCursor(cursor);
// Set starting position of the cursor at the rendering window center
Graphics* graphics = GetSubsystem<Graphics>();
cursor->SetPosition(graphics->GetWidth() / 2, graphics->GetHeight() / 2);
// Load UI content prepared in the editor and add to the UI hierarchy
SharedPtr<UIElement> layoutRoot = ui->LoadLayout(cache->GetResource<XMLFile>("UI/UILoadExample.xml"));
ui->GetRoot()->AddChild(layoutRoot);
// Subscribe to button actions (toggle scene lights when pressed then released)
Button* button = static_cast<Button*>(layoutRoot->GetChild("ToggleLight1", true));
if (button)
SubscribeToEvent(button, E_RELEASED, HANDLER(SceneAndUILoad, ToggleLight1));
button = static_cast<Button*>(layoutRoot->GetChild("ToggleLight2", true));
if (button)
SubscribeToEvent(button, E_RELEASED, HANDLER(SceneAndUILoad, ToggleLight2));
}
void SceneAndUILoad::SetupViewport()
{
Renderer* renderer = GetSubsystem<Renderer>();
// Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
SharedPtr<Viewport> viewport(new Viewport(context_, scene_, cameraNode_->GetComponent<Camera>()));
renderer->SetViewport(0, viewport);
}
void SceneAndUILoad::SubscribeToEvents()
{
// Subscribe HandleUpdate() function for camera motion
SubscribeToEvent(E_UPDATE, HANDLER(SceneAndUILoad, HandleUpdate));
}
void SceneAndUILoad::MoveCamera(float timeStep)
{
// Right mouse button controls mouse cursor visibility: hide when pressed
UI* ui = GetSubsystem<UI>();
Input* input = GetSubsystem<Input>();
ui->GetCursor()->SetVisible(!input->GetMouseButtonDown(MOUSEB_RIGHT));
// Do not move if the UI has a focused element
if (ui->GetFocusElement())
return;
// Movement speed as world units per second
const float MOVE_SPEED = 20.0f;
// Mouse sensitivity as degrees per pixel
const float MOUSE_SENSITIVITY = 0.1f;
// Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
// Only move the camera when the cursor is hidden
if (!ui->GetCursor()->IsVisible())
{
IntVector2 mouseMove = input->GetMouseMove();
yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
pitch_ = Clamp(pitch_, -90.0f, 90.0f);
// Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));
}
// Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
if (input->GetKeyDown('W'))
cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
if (input->GetKeyDown('S'))
cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
if (input->GetKeyDown('A'))
cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
if (input->GetKeyDown('D'))
cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);
}
void SceneAndUILoad::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
// Take the frame time step, which is stored as a float
float timeStep = eventData[P_TIMESTEP].GetFloat();
// Move the camera, scale movement with time step
MoveCamera(timeStep);
}
void SceneAndUILoad::ToggleLight1(StringHash eventType, VariantMap& eventData)
{
Node* lightNode = scene_->GetChild("Light1", true);
if (lightNode)
lightNode->SetEnabled(!lightNode->IsEnabled());
}
void SceneAndUILoad::ToggleLight2(StringHash eventType, VariantMap& eventData)
{
Node* lightNode = scene_->GetChild("Light2", true);
if (lightNode)
lightNode->SetEnabled(!lightNode->IsEnabled());
}
<|endoftext|>
|
<commit_before>// =============================================================================
//
// Copyright (c) 2013 Christopher Baker <http://christopherbaker.net>
//
// 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 "AddonManager.h"
namespace of {
namespace Sketch {
const std::string AddonManager::DEFAULT_ADDON_PATH = "addons/";
AddonManager::AddonManager(const std::string& path):
_path(path)
{
Poco::Path fullPath(ofToDataPath(_path, true));
Poco::File file(fullPath);
if (!file.exists())
{
Poco::FileNotFoundException exc(fullPath.toString());
throw exc;
}
std::vector<Poco::File> files;
ofx::IO::DirectoryUtils::list(file, files, true, &_directoryFilter);
std::vector<Poco::File>::iterator iter = files.begin();
while (iter != files.end())
{
std::string addonPath = (*iter).path();
std::string addonName = Poco::Path(addonPath).getBaseName();
Poco::RegularExpression addonExpression("^ofx.+");
if (addonExpression.match(addonName))
{
_addons[addonName] = Addon::SharedPtr(new Addon(addonName, addonPath));
}
++iter;
}
_addonWatcher.registerAllEvents(this);
_addonWatcher.addPath(fullPath.toString(),
false,
true,
&_directoryFilter);
}
AddonManager::~AddonManager()
{
_addonWatcher.unregisterAllEvents(this);
}
void AddonManager::onDirectoryWatcherItemAdded(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemAdded") << evt.event << " " << evt.item.path();
std::string path = evt.item.path();
std::string name = Poco::Path(path).getBaseName();
_addons[name] = Addon::SharedPtr(new Addon(name, path));
}
void AddonManager::onDirectoryWatcherItemRemoved(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemRemoved") << evt.event << " " << evt.item.path();
std::string path = evt.item.path();
std::string name = Poco::Path(path).getBaseName();
std::map<std::string, Addon::SharedPtr>::iterator iter = _addons.find(name);
if (iter != _addons.end())
{
_addons.erase(iter);
}
else
{
ofLogError("AddonManager::onDirectoryWatcherItemRemoved") << "Unable to find " << path;
}
}
void AddonManager::onDirectoryWatcherItemModified(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemModified") << evt.event << " " << evt.item.path();
}
void AddonManager::onDirectoryWatcherItemMovedFrom(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemMovedFrom") << evt.event << " " << evt.item.path();
}
void AddonManager::onDirectoryWatcherItemMovedTo(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemMovedTo") << evt.event << " " << evt.item.path();
}
void AddonManager::onDirectoryWatcherError(const Poco::Exception& exc)
{
ofLogError("AddonManager::onDirectoryWatcherError") << exc.displayText();
}
std::vector<Addon::SharedPtr> AddonManager::getAddons() const
{
std::vector<Addon::SharedPtr> addons;
std::map<std::string, Addon::SharedPtr>::const_iterator iter = _addons.begin();
while (iter != _addons.end())
{
addons.push_back(iter->second);
++iter;
}
return addons;
}
} } // namespace of::Sketch
<commit_msg>Reversed Regex.<commit_after>// =============================================================================
//
// Copyright (c) 2013 Christopher Baker <http://christopherbaker.net>
//
// 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 "AddonManager.h"
namespace of {
namespace Sketch {
const std::string AddonManager::DEFAULT_ADDON_PATH = "addons/";
AddonManager::AddonManager(const std::string& path):
_path(path)
{
Poco::Path fullPath(ofToDataPath(_path, true));
Poco::File file(fullPath);
if (!file.exists())
{
Poco::FileNotFoundException exc(fullPath.toString());
throw exc;
}
std::vector<Poco::File> files;
ofx::IO::DirectoryUtils::list(file, files, true, &_directoryFilter);
std::vector<Poco::File>::iterator iter = files.begin();
while (iter != files.end())
{
std::string addonPath = (*iter).path();
std::string addonName = Poco::Path(addonPath).getBaseName();
Poco::RegularExpression addonExpression("ofx.+$", Poco::RegularExpression::RE_ANCHORED);
if (addonExpression.match(addonName))
{
_addons[addonName] = Addon::SharedPtr(new Addon(addonName, addonPath));
}
++iter;
}
_addonWatcher.registerAllEvents(this);
_addonWatcher.addPath(fullPath.toString(),
false,
true,
&_directoryFilter);
}
AddonManager::~AddonManager()
{
_addonWatcher.unregisterAllEvents(this);
}
void AddonManager::onDirectoryWatcherItemAdded(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemAdded") << evt.event << " " << evt.item.path();
std::string path = evt.item.path();
std::string name = Poco::Path(path).getBaseName();
_addons[name] = Addon::SharedPtr(new Addon(name, path));
}
void AddonManager::onDirectoryWatcherItemRemoved(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemRemoved") << evt.event << " " << evt.item.path();
std::string path = evt.item.path();
std::string name = Poco::Path(path).getBaseName();
std::map<std::string, Addon::SharedPtr>::iterator iter = _addons.find(name);
if (iter != _addons.end())
{
_addons.erase(iter);
}
else
{
ofLogError("AddonManager::onDirectoryWatcherItemRemoved") << "Unable to find " << path;
}
}
void AddonManager::onDirectoryWatcherItemModified(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemModified") << evt.event << " " << evt.item.path();
}
void AddonManager::onDirectoryWatcherItemMovedFrom(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemMovedFrom") << evt.event << " " << evt.item.path();
}
void AddonManager::onDirectoryWatcherItemMovedTo(const ofx::DirectoryWatcher::DirectoryEvent& evt)
{
ofLogNotice("AddonManager::onDirectoryWatcherItemMovedTo") << evt.event << " " << evt.item.path();
}
void AddonManager::onDirectoryWatcherError(const Poco::Exception& exc)
{
ofLogError("AddonManager::onDirectoryWatcherError") << exc.displayText();
}
std::vector<Addon::SharedPtr> AddonManager::getAddons() const
{
std::vector<Addon::SharedPtr> addons;
std::map<std::string, Addon::SharedPtr>::const_iterator iter = _addons.begin();
while (iter != _addons.end())
{
addons.push_back(iter->second);
++iter;
}
return addons;
}
} } // namespace of::Sketch
<|endoftext|>
|
<commit_before>
#include <iostream>
#include <cstdint>
#include <random>
int main()
{
#if 0
/* This should work, but doesn't accept m == 0 in GCC g++ 4.7.3. */
std::linear_congruential_engine<uint32_t, 69069u, 12345u, 0> cong;
#else
std::linear_congruential_engine<uint64_t, 69069u, 12345u, 0x100000000u> cong;
#endif
cong.seed(0);
std::cout << "Min: " << cong.min() << std::endl;
std::cout << "Max: " << cong.max() << std::endl;
std::cout << std::endl
<< "Values:" << std::endl;
for (size_t i = 0; i < 10; i++)
{
std::cout << cong() << std::endl;
}
}
<commit_msg>Test C++ SHR3 class in C++11 random API style, compared to Python simplerandom.random.SHR3.<commit_after>/* Test C++11 random API.
* Compare C++11 equivalent of simplerandom.iterators.Cong.
* Test C++11 uniform_real_distribution implementation with simplerandom.random.Cong.
*/
#include <iostream>
#include <iomanip>
#include <cstdint>
#include <random>
class SHR3
{
private:
uint32_t shr3;
public:
typedef uint32_t return_value;
SHR3(uint32_t seed1 = 0xFFFFFFFF)
{
seed(seed1);
}
void seed(uint32_t seed1)
{
if (seed1 == 0)
seed1 = 0xFFFFFFFF;
shr3 = seed1;
}
uint32_t operator()()
{
shr3 ^= (shr3 << 13);
shr3 ^= (shr3 >> 17);
shr3 ^= (shr3 << 5);
return shr3;
}
uint32_t min()
{
return 1;
}
uint32_t max()
{
return 0xFFFFFFFFu;
}
};
int main()
{
#if 0
/* This should work, but doesn't accept m == 0 in GCC g++ 4.7.3. */
std::linear_congruential_engine<uint32_t, 69069u, 12345u, 0> rng;
#elif 0
std::linear_congruential_engine<uint64_t, 69069u, 12345u, 0x100000000u> rng;
#else
SHR3 rng;
#endif
rng.seed(0);
std::cout << "Min: " << rng.min() << std::endl;
std::cout << "Max: " << rng.max() << std::endl;
std::cout << std::endl
<< "RNG(0) values:" << std::endl;
for (size_t i = 0; i < 10; ++i)
{
std::cout << rng() << std::endl;
}
std::cout << std::endl
<< "RNG(0) real values:" << std::endl;
std::uniform_real_distribution<> real_dist;
rng.seed(0);
for (size_t i = 0; i < 10; ++i)
{
std::cout << std::setprecision(17) << real_dist(rng) << std::endl;
}
}
<|endoftext|>
|
<commit_before>// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <memory>
#include "SurgSim/Physics/MassSpringRepresentationContact.h"
#include "SurgSim/Physics/ContactConstraintData.h"
#include "SurgSim/Physics/ConstraintImplementation.h"
#include "SurgSim/Physics/Localization.h"
#include "SurgSim/Physics/MassSpringRepresentationLocalization.h"
namespace SurgSim
{
namespace Physics
{
MassSpringRepresentationContact::MassSpringRepresentationContact()
{
}
MassSpringRepresentationContact::~MassSpringRepresentationContact()
{
}
void MassSpringRepresentationContact::doBuild(double dt,
const ConstraintData& data,
const std::shared_ptr<Localization>& localization,
MlcpPhysicsProblem* mlcp,
unsigned int indexOfRepresentation,
unsigned int indexOfConstraint,
ConstraintSideSign sign)
{
MlcpPhysicsProblem::Matrix& H = mlcp->H;
MlcpPhysicsProblem::Matrix& CHt = mlcp->CHt;
MlcpPhysicsProblem::Matrix& HCHt = mlcp->A;
MlcpPhysicsProblem::Vector& b = mlcp->b;
std::shared_ptr<Representation> representation = localization->getRepresentation();
std::shared_ptr<MassSpringRepresentation> massSpring = std::static_pointer_cast<MassSpringRepresentation>(representation);
if (!massSpring->isActive())
{
return;
}
const double scale = (sign == CONSTRAINT_POSITIVE_SIDE) ? 1.0 : -1.0;
const SurgSim::Math::Matrix& C = massSpring->getComplianceMatrix();
const ContactConstraintData& contactData = static_cast<const ContactConstraintData&>(data);
const SurgSim::Math::Vector3d& n = contactData.getNormal();
const double d = contactData.getDistance();
// FRICTIONLESS CONTACT in a LCP
// (n, d) defines the plane of contact
// P(t) the point of contact (usually after free motion)
//
// The constraint equation for a plane is
// n.P(t+dt) + d >= 0
// Using the Backward Euler numerical integration scheme
// n.[ P(t) + dt.V(t+dt) ] + d >= 0
// [n.dt].V(t+dt) + [n.P(t) + d] >= 0
// The solver requires an equation of the form
// H.V(t+dt) + b >= 0
// Therefore
// H = n.dt
// b = n.P(t) + d -> P(t) evaluated after free motion
// Fill up b with the constraint equation...
SurgSim::Math::Vector3d globalPosition = localization->calculatePosition();
double violation = n.dot(globalPosition) + d;
b[indexOfConstraint] += violation * scale;
// Fill up H with just the non null values
H.block<1,3>(indexOfConstraint, indexOfRepresentation + 0) += dt * scale * n;
// Fill up CH^t with just the non null values
for (unsigned int CHt_line = 0; CHt_line < massSpring->getNumDof(); CHt_line++)
{
CHt(indexOfRepresentation + CHt_line, indexOfConstraint) +=
C.block<1,3>(CHt_line, 0) * H.block<1,3>(indexOfConstraint, indexOfRepresentation).transpose();
}
// Fill up HCHt (add 1 line and 1 column to it)
// NOTE: HCHt is symmetric => we compute the last line and reflect it on the last column
for (unsigned int col = 0; col < indexOfConstraint; col++)
{
HCHt(indexOfConstraint, col) +=
H.block<1, 3>(indexOfConstraint, indexOfRepresentation) * CHt.block<3, 1>(indexOfRepresentation, col);
HCHt(col, indexOfConstraint) = HCHt(indexOfConstraint, col);
}
HCHt(indexOfConstraint, indexOfConstraint) +=
H.block<1, 3>(indexOfConstraint, indexOfRepresentation) *
CHt.block<3, 1>(indexOfRepresentation, indexOfConstraint);
}
SurgSim::Math::MlcpConstraintType MassSpringRepresentationContact::getMlcpConstraintType() const
{
return SurgSim::Math::MLCP_UNILATERAL_3D_FRICTIONLESS_CONSTRAINT;
}
SurgSim::Physics::RepresentationType MassSpringRepresentationContact::getRepresentationType() const
{
return REPRESENTATION_TYPE_MASSSPRING;
}
unsigned int MassSpringRepresentationContact::doGetNumDof() const
{
return 1;
}
}; // namespace Physics
}; // namespace SurgSim<commit_msg>Fix contact implementation<commit_after>// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <memory>
#include "SurgSim/Physics/MassSpringRepresentationContact.h"
#include "SurgSim/Physics/ContactConstraintData.h"
#include "SurgSim/Physics/ConstraintImplementation.h"
#include "SurgSim/Physics/Localization.h"
#include "SurgSim/Physics/MassSpringRepresentationLocalization.h"
namespace SurgSim
{
namespace Physics
{
MassSpringRepresentationContact::MassSpringRepresentationContact()
{
}
MassSpringRepresentationContact::~MassSpringRepresentationContact()
{
}
void MassSpringRepresentationContact::doBuild(double dt,
const ConstraintData& data,
const std::shared_ptr<Localization>& localization,
MlcpPhysicsProblem* mlcp,
unsigned int indexOfRepresentation,
unsigned int indexOfConstraint,
ConstraintSideSign sign)
{
MlcpPhysicsProblem::Matrix& H = mlcp->H;
MlcpPhysicsProblem::Matrix& CHt = mlcp->CHt;
MlcpPhysicsProblem::Matrix& HCHt = mlcp->A;
MlcpPhysicsProblem::Vector& b = mlcp->b;
unsigned int nodeId = std::static_pointer_cast<MassSpringRepresentationLocalization>(localization)->getLocalNode();
std::shared_ptr<Representation> representation = localization->getRepresentation();
std::shared_ptr<MassSpringRepresentation> massSpring = std::static_pointer_cast<MassSpringRepresentation>(representation);
if (!massSpring->isActive())
{
return;
}
const double scale = (sign == CONSTRAINT_POSITIVE_SIDE) ? 1.0 : -1.0;
const SurgSim::Math::Matrix& C = massSpring->getComplianceMatrix();
const ContactConstraintData& contactData = static_cast<const ContactConstraintData&>(data);
const SurgSim::Math::Vector3d& n = contactData.getNormal();
const double d = contactData.getDistance();
// FRICTIONLESS CONTACT in a LCP
// (n, d) defines the plane of contact
// P(t) the point of contact (usually after free motion)
//
// The constraint equation for a plane is
// n.P(t+dt) + d >= 0
// Using the Backward Euler numerical integration scheme
// n.[ P(t) + dt.V(t+dt) ] + d >= 0
// [n.dt].V(t+dt) + [n.P(t) + d] >= 0
// The solver requires an equation of the form
// H.V(t+dt) + b >= 0
// Therefore
// H = n.dt
// b = n.P(t) + d -> P(t) evaluated after free motion
// Fill up b with the constraint equation...
SurgSim::Math::Vector3d globalPosition = localization->calculatePosition();
double violation = n.dot(globalPosition) + d;
b[indexOfConstraint] += violation * scale;
// Fill matrices with just the non null values
// (H+H') = H+H'
// => H += H';
//
// C(H+H')t = CHt + CH't
// => CHt += CH't;
//
// (H+H')C(H+H')t = HCHt + HCH't + H'C(H+H')t
// => HCHt += H(CH't) + H'[C(H+H')t];
// H'
SurgSim::Math::Vector3d localH = dt * scale * n;
// CH't
SurgSim::Math::Vector localCHt = C.middleCols(indexOfRepresentation + 3*nodeId, 3) * localH;
// HCHt += H(CH't)
HCHt.col(indexOfConstraint) += H * localCHt;
// H += H'
H.block<1,3>(indexOfConstraint, indexOfRepresentation + 3*nodeId) += localH.transpose();
// CHt += CH't
CHt.col(indexOfConstraint) += localCHt;
// HCHt += H'[C(H+H')t]
HCHt.row(indexOfConstraint) += localH.transpose() * CHt.middleRows(indexOfRepresentation + 3*nodeId, 3);
}
SurgSim::Math::MlcpConstraintType MassSpringRepresentationContact::getMlcpConstraintType() const
{
return SurgSim::Math::MLCP_UNILATERAL_3D_FRICTIONLESS_CONSTRAINT;
}
SurgSim::Physics::RepresentationType MassSpringRepresentationContact::getRepresentationType() const
{
return REPRESENTATION_TYPE_MASSSPRING;
}
unsigned int MassSpringRepresentationContact::doGetNumDof() const
{
return 1;
}
}; // namespace Physics
}; // namespace SurgSim<|endoftext|>
|
<commit_before>/**
* MltPlaylist.cpp - MLT Wrapper
* Copyright (C) 2004-2005 Charles Yates
* Author: Charles Yates <charles.yates@pandora.be>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <string.h>
#include <stdlib.h>
#include "MltPlaylist.h"
#include "MltTransition.h"
using namespace Mlt;
ClipInfo::ClipInfo( ) :
clip( 0 ),
producer( NULL ),
cut( NULL ),
start( 0 ),
resource( NULL ),
frame_in( 0 ),
frame_out( 0 ),
frame_count( 0 ),
length( 0 ),
fps( 0 ),
repeat( 0 )
{
}
ClipInfo::ClipInfo( mlt_playlist_clip_info *info ) :
clip( info->clip ),
producer( new Producer( info->producer ) ),
cut( new Producer( info->cut ) ),
start( info->start ),
resource( info->resource? strdup( info->resource ) : 0 ),
frame_in( info->frame_in ),
frame_out( info->frame_out ),
frame_count( info->frame_count ),
length( info->length ),
fps( info->fps ),
repeat( info->repeat )
{
}
ClipInfo::~ClipInfo( )
{
delete producer;
delete cut;
free( resource );
}
void ClipInfo::update( mlt_playlist_clip_info *info )
{
delete producer;
delete cut;
free( resource );
clip = info->clip;
producer = new Producer( info->producer );
cut = new Producer( info->cut );
start = info->start;
resource = strdup( info->resource );
frame_in = info->frame_in;
frame_out = info->frame_out;
frame_count = info->frame_count;
length = info->length;
fps = info->fps;
repeat = info->repeat;
}
Playlist::Playlist( ) :
instance( NULL )
{
instance = mlt_playlist_init( );
}
Playlist::Playlist( Service &producer ) :
instance( NULL )
{
if ( producer.type( ) == playlist_type )
{
instance = ( mlt_playlist )producer.get_service( );
inc_ref( );
}
}
Playlist::Playlist( Playlist &playlist ) :
instance( playlist.get_playlist( ) )
{
inc_ref( );
}
Playlist::Playlist( mlt_playlist playlist ) :
instance( playlist )
{
inc_ref( );
}
Playlist::~Playlist( )
{
mlt_playlist_close( instance );
}
mlt_playlist Playlist::get_playlist( )
{
return instance;
}
mlt_producer Playlist::get_producer( )
{
return mlt_playlist_producer( get_playlist( ) );
}
int Playlist::count( )
{
return mlt_playlist_count( get_playlist( ) );
}
int Playlist::clear( )
{
return mlt_playlist_clear( get_playlist( ) );
}
int Playlist::append( Producer &producer, int in, int out )
{
return mlt_playlist_append_io( get_playlist( ), producer.get_producer( ), in, out );
}
int Playlist::blank( int length )
{
return mlt_playlist_blank( get_playlist( ), length );
}
int Playlist::clip( mlt_whence whence, int index )
{
return mlt_playlist_clip( get_playlist( ), whence, index );
}
int Playlist::current_clip( )
{
return mlt_playlist_current_clip( get_playlist( ) );
}
Producer *Playlist::current( )
{
return new Producer( mlt_playlist_current( get_playlist( ) ) );
}
ClipInfo *Playlist::clip_info( int index, ClipInfo *info )
{
mlt_playlist_clip_info clip_info;
mlt_playlist_get_clip_info( get_playlist( ), &clip_info, index );
if ( info == NULL )
return new ClipInfo( &clip_info );
info->update( &clip_info );
return info;
}
void Playlist::delete_clip_info( ClipInfo *info )
{
delete info;
}
int Playlist::insert( Producer &producer, int where, int in, int out )
{
return mlt_playlist_insert( get_playlist( ), producer.get_producer( ), where, in, out );
}
int Playlist::remove( int where )
{
return mlt_playlist_remove( get_playlist( ), where );
}
int Playlist::move( int from, int to )
{
return mlt_playlist_move( get_playlist( ), from, to );
}
int Playlist::resize_clip( int clip, int in, int out )
{
return mlt_playlist_resize_clip( get_playlist( ), clip, in, out );
}
int Playlist::split( int clip, int position )
{
return mlt_playlist_split( get_playlist( ), clip, position );
}
int Playlist::split_at( int position, bool left )
{
return mlt_playlist_split_at( get_playlist( ), position, left );
}
int Playlist::join( int clip, int count, int merge )
{
return mlt_playlist_join( get_playlist( ), clip, count, merge );
}
int Playlist::mix( int clip, int length, Transition *transition )
{
return mlt_playlist_mix( get_playlist( ), clip, length, transition == NULL ? NULL : transition->get_transition( ) );
}
int Playlist::mix_add( int clip, Transition *transition )
{
return mlt_playlist_mix_add( get_playlist( ), clip, transition == NULL ? NULL : transition->get_transition( ) );
}
int Playlist::repeat( int clip, int count )
{
return mlt_playlist_repeat_clip( get_playlist( ), clip, count );
}
Producer *Playlist::get_clip( int clip )
{
mlt_producer producer = mlt_playlist_get_clip( get_playlist( ), clip );
return producer != NULL ? new Producer( producer ) : NULL;
}
Producer *Playlist::get_clip_at( int position )
{
mlt_producer producer = mlt_playlist_get_clip_at( get_playlist( ), position );
return producer != NULL ? new Producer( producer ) : NULL;
}
int Playlist::get_clip_index_at( int position )
{
return mlt_playlist_get_clip_index_at( get_playlist( ), position );
}
bool Playlist::is_mix( int clip )
{
return mlt_playlist_clip_is_mix( get_playlist( ), clip ) != 0;
}
bool Playlist::is_blank( int clip )
{
return mlt_playlist_is_blank( get_playlist( ), clip ) != 0;
}
bool Playlist::is_blank_at( int position )
{
return mlt_playlist_is_blank_at( get_playlist( ), position ) != 0;
}
Producer *Playlist::replace_with_blank( int clip )
{
mlt_producer producer = mlt_playlist_replace_with_blank( get_playlist( ), clip );
Producer *object = producer != NULL ? new Producer( producer ) : NULL;
mlt_producer_close( producer );
return object;
}
void Playlist::consolidate_blanks( int keep_length )
{
return mlt_playlist_consolidate_blanks( get_playlist( ), keep_length );
}
void Playlist::insert_blank( int clip, int length )
{
mlt_playlist_insert_blank( get_playlist( ), clip, length );
}
void Playlist::pad_blanks( int position, int length, int find )
{
mlt_playlist_pad_blanks( get_playlist( ), position, length, find );
}
int Playlist::insert_at( int position, Producer *producer, int mode )
{
return mlt_playlist_insert_at( get_playlist( ), position, producer->get_producer( ), mode );
}
int Playlist::insert_at( int position, Producer &producer, int mode )
{
return mlt_playlist_insert_at( get_playlist( ), position, producer.get_producer( ), mode );
}
int Playlist::clip_start( int clip )
{
return mlt_playlist_clip_start( get_playlist( ), clip );
}
int Playlist::blanks_from( int clip, int bounded )
{
return mlt_playlist_blanks_from( get_playlist( ), clip, bounded );
}
int Playlist::clip_length( int clip )
{
return mlt_playlist_clip_length( get_playlist( ), clip );
}
int Playlist::remove_region( int position, int length )
{
return mlt_playlist_remove_region( get_playlist( ), position, length );
}
int Playlist::move_region( int position, int length, int new_position )
{
return mlt_playlist_move_region( get_playlist( ), position, length, new_position );
}
<commit_msg>MltPlaylist.cpp: return null on clip_info method if mlt_playlist_get_clip_info fails.<commit_after>/**
* MltPlaylist.cpp - MLT Wrapper
* Copyright (C) 2004-2005 Charles Yates
* Author: Charles Yates <charles.yates@pandora.be>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <string.h>
#include <stdlib.h>
#include "MltPlaylist.h"
#include "MltTransition.h"
using namespace Mlt;
ClipInfo::ClipInfo( ) :
clip( 0 ),
producer( NULL ),
cut( NULL ),
start( 0 ),
resource( NULL ),
frame_in( 0 ),
frame_out( 0 ),
frame_count( 0 ),
length( 0 ),
fps( 0 ),
repeat( 0 )
{
}
ClipInfo::ClipInfo( mlt_playlist_clip_info *info ) :
clip( info->clip ),
producer( new Producer( info->producer ) ),
cut( new Producer( info->cut ) ),
start( info->start ),
resource( info->resource? strdup( info->resource ) : 0 ),
frame_in( info->frame_in ),
frame_out( info->frame_out ),
frame_count( info->frame_count ),
length( info->length ),
fps( info->fps ),
repeat( info->repeat )
{
}
ClipInfo::~ClipInfo( )
{
delete producer;
delete cut;
free( resource );
}
void ClipInfo::update( mlt_playlist_clip_info *info )
{
delete producer;
delete cut;
free( resource );
clip = info->clip;
producer = new Producer( info->producer );
cut = new Producer( info->cut );
start = info->start;
resource = strdup( info->resource );
frame_in = info->frame_in;
frame_out = info->frame_out;
frame_count = info->frame_count;
length = info->length;
fps = info->fps;
repeat = info->repeat;
}
Playlist::Playlist( ) :
instance( NULL )
{
instance = mlt_playlist_init( );
}
Playlist::Playlist( Service &producer ) :
instance( NULL )
{
if ( producer.type( ) == playlist_type )
{
instance = ( mlt_playlist )producer.get_service( );
inc_ref( );
}
}
Playlist::Playlist( Playlist &playlist ) :
instance( playlist.get_playlist( ) )
{
inc_ref( );
}
Playlist::Playlist( mlt_playlist playlist ) :
instance( playlist )
{
inc_ref( );
}
Playlist::~Playlist( )
{
mlt_playlist_close( instance );
}
mlt_playlist Playlist::get_playlist( )
{
return instance;
}
mlt_producer Playlist::get_producer( )
{
return mlt_playlist_producer( get_playlist( ) );
}
int Playlist::count( )
{
return mlt_playlist_count( get_playlist( ) );
}
int Playlist::clear( )
{
return mlt_playlist_clear( get_playlist( ) );
}
int Playlist::append( Producer &producer, int in, int out )
{
return mlt_playlist_append_io( get_playlist( ), producer.get_producer( ), in, out );
}
int Playlist::blank( int length )
{
return mlt_playlist_blank( get_playlist( ), length );
}
int Playlist::clip( mlt_whence whence, int index )
{
return mlt_playlist_clip( get_playlist( ), whence, index );
}
int Playlist::current_clip( )
{
return mlt_playlist_current_clip( get_playlist( ) );
}
Producer *Playlist::current( )
{
return new Producer( mlt_playlist_current( get_playlist( ) ) );
}
ClipInfo *Playlist::clip_info( int index, ClipInfo *info )
{
mlt_playlist_clip_info clip_info;
if ( mlt_playlist_get_clip_info( get_playlist( ), &clip_info, index ) )
return NULL;
if ( info == NULL )
return new ClipInfo( &clip_info );
info->update( &clip_info );
return info;
}
void Playlist::delete_clip_info( ClipInfo *info )
{
delete info;
}
int Playlist::insert( Producer &producer, int where, int in, int out )
{
return mlt_playlist_insert( get_playlist( ), producer.get_producer( ), where, in, out );
}
int Playlist::remove( int where )
{
return mlt_playlist_remove( get_playlist( ), where );
}
int Playlist::move( int from, int to )
{
return mlt_playlist_move( get_playlist( ), from, to );
}
int Playlist::resize_clip( int clip, int in, int out )
{
return mlt_playlist_resize_clip( get_playlist( ), clip, in, out );
}
int Playlist::split( int clip, int position )
{
return mlt_playlist_split( get_playlist( ), clip, position );
}
int Playlist::split_at( int position, bool left )
{
return mlt_playlist_split_at( get_playlist( ), position, left );
}
int Playlist::join( int clip, int count, int merge )
{
return mlt_playlist_join( get_playlist( ), clip, count, merge );
}
int Playlist::mix( int clip, int length, Transition *transition )
{
return mlt_playlist_mix( get_playlist( ), clip, length, transition == NULL ? NULL : transition->get_transition( ) );
}
int Playlist::mix_add( int clip, Transition *transition )
{
return mlt_playlist_mix_add( get_playlist( ), clip, transition == NULL ? NULL : transition->get_transition( ) );
}
int Playlist::repeat( int clip, int count )
{
return mlt_playlist_repeat_clip( get_playlist( ), clip, count );
}
Producer *Playlist::get_clip( int clip )
{
mlt_producer producer = mlt_playlist_get_clip( get_playlist( ), clip );
return producer != NULL ? new Producer( producer ) : NULL;
}
Producer *Playlist::get_clip_at( int position )
{
mlt_producer producer = mlt_playlist_get_clip_at( get_playlist( ), position );
return producer != NULL ? new Producer( producer ) : NULL;
}
int Playlist::get_clip_index_at( int position )
{
return mlt_playlist_get_clip_index_at( get_playlist( ), position );
}
bool Playlist::is_mix( int clip )
{
return mlt_playlist_clip_is_mix( get_playlist( ), clip ) != 0;
}
bool Playlist::is_blank( int clip )
{
return mlt_playlist_is_blank( get_playlist( ), clip ) != 0;
}
bool Playlist::is_blank_at( int position )
{
return mlt_playlist_is_blank_at( get_playlist( ), position ) != 0;
}
Producer *Playlist::replace_with_blank( int clip )
{
mlt_producer producer = mlt_playlist_replace_with_blank( get_playlist( ), clip );
Producer *object = producer != NULL ? new Producer( producer ) : NULL;
mlt_producer_close( producer );
return object;
}
void Playlist::consolidate_blanks( int keep_length )
{
return mlt_playlist_consolidate_blanks( get_playlist( ), keep_length );
}
void Playlist::insert_blank( int clip, int length )
{
mlt_playlist_insert_blank( get_playlist( ), clip, length );
}
void Playlist::pad_blanks( int position, int length, int find )
{
mlt_playlist_pad_blanks( get_playlist( ), position, length, find );
}
int Playlist::insert_at( int position, Producer *producer, int mode )
{
return mlt_playlist_insert_at( get_playlist( ), position, producer->get_producer( ), mode );
}
int Playlist::insert_at( int position, Producer &producer, int mode )
{
return mlt_playlist_insert_at( get_playlist( ), position, producer.get_producer( ), mode );
}
int Playlist::clip_start( int clip )
{
return mlt_playlist_clip_start( get_playlist( ), clip );
}
int Playlist::blanks_from( int clip, int bounded )
{
return mlt_playlist_blanks_from( get_playlist( ), clip, bounded );
}
int Playlist::clip_length( int clip )
{
return mlt_playlist_clip_length( get_playlist( ), clip );
}
int Playlist::remove_region( int position, int length )
{
return mlt_playlist_remove_region( get_playlist( ), position, length );
}
int Playlist::move_region( int position, int length, int new_position )
{
return mlt_playlist_move_region( get_playlist( ), position, length, new_position );
}
<|endoftext|>
|
<commit_before>// Copyright (c) 2010 Hewlett-Packard Development Company, L.P. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
extern "C" {
#include <mlt/framework/mlt_transition.h>
#include <mlt/framework/mlt_frame.h>
#include <mlt/framework/mlt_log.h>
}
#include <cstring>
#include <webvfx/image.h>
#include "service_locker.h"
#include "service_manager.h"
#include "webvfx_service.h"
static int transitionGetImage(mlt_frame aFrame, uint8_t **image, mlt_image_format *format, int *width, int *height, int /*writable*/) {
int error = 0;
mlt_frame bFrame = mlt_frame_pop_frame(aFrame);
mlt_transition transition = (mlt_transition)mlt_frame_pop_service(aFrame);
mlt_properties transition_props = MLT_TRANSITION_PROPERTIES(transition);
mlt_properties a_props = MLT_FRAME_PROPERTIES(aFrame);
mlt_properties b_props = MLT_FRAME_PROPERTIES(bFrame);
// Set consumer_aspect_ratio for a and b frame
if (mlt_properties_get_double(a_props, "aspect_ratio") == 0.0)
mlt_properties_set_double(a_props, "aspect_ratio", mlt_properties_get_double(a_props, "consumer_aspect_ratio"));
if (mlt_properties_get_double(b_props, "aspect_ratio") == 0.0)
mlt_properties_set_double(b_props, "aspect_ratio", mlt_properties_get_double(a_props, "consumer_aspect_ratio"));
mlt_properties_set_double(b_props, "consumer_aspect_ratio", mlt_properties_get_double(a_props, "consumer_aspect_ratio"));
if (mlt_properties_get(b_props, "rescale.interp") == NULL || !std::strcmp(mlt_properties_get(b_props, "rescale.interp"), "none"))
mlt_properties_set(b_props, "rescale.interp", mlt_properties_get(a_props, "rescale.interp"));
mlt_position position = mlt_transition_get_position(transition, frame);
// Get the aFrame image, we will write our output to it
*format = mlt_image_rgb24;
if ((error = mlt_frame_get_image(aFrame, image, format, width, height, 1)) != 0)
return error;
// Get the bFrame image, we won't write to it
uint8_t *bImage = NULL;
int bWidth = 0, bHeight = 0;
if ((error = mlt_frame_get_image(bFrame, &bImage, format, &bWidth, &bHeight, 0)) != 0)
return error;
{ // Scope the lock
MLTWebVfx::ServiceLocker locker(MLT_TRANSITION_SERVICE(transition));
if (!locker.initialize(*width, *height))
return 1;
MLTWebVfx::ServiceManager* manager = locker.getManager();
WebVfx::Image renderedImage(*image, *width, *height, *width * *height * WebVfx::Image::BytesPerPixel);
manager->copyImageForName(manager->getSourceImageName(), renderedImage);
WebVfx::Image targetImage(bImage, bWidth, bHeight, bWidth * bHeight * WebVfx::Image::BytesPerPixel);
manager->copyImageForName(manager->getTargetImageName(), targetImage);
manager->render(renderedImage, position);
}
return error;
}
static mlt_frame transitionProcess(mlt_transition transition, mlt_frame aFrame, mlt_frame bFrame) {
mlt_frame_push_service(aFrame, transition);
mlt_frame_push_frame(aFrame, bFrame);
mlt_frame_push_get_image(aFrame, transitionGetImage);
return aFrame;
}
mlt_service MLTWebVfx::createTransition() {
mlt_transition self = mlt_transition_new();
if (self) {
self->process = transitionProcess;
// Video only transition
mlt_properties_set_int(MLT_TRANSITION_PROPERTIES(self), "_transition_type", 1);
return MLT_TRANSITION_SERVICE(self);
}
return 0;
}
<commit_msg>Fix typo.<commit_after>// Copyright (c) 2010 Hewlett-Packard Development Company, L.P. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
extern "C" {
#include <mlt/framework/mlt_transition.h>
#include <mlt/framework/mlt_frame.h>
#include <mlt/framework/mlt_log.h>
}
#include <cstring>
#include <webvfx/image.h>
#include "service_locker.h"
#include "service_manager.h"
#include "webvfx_service.h"
static int transitionGetImage(mlt_frame aFrame, uint8_t **image, mlt_image_format *format, int *width, int *height, int /*writable*/) {
int error = 0;
mlt_frame bFrame = mlt_frame_pop_frame(aFrame);
mlt_transition transition = (mlt_transition)mlt_frame_pop_service(aFrame);
mlt_properties a_props = MLT_FRAME_PROPERTIES(aFrame);
mlt_properties b_props = MLT_FRAME_PROPERTIES(bFrame);
// Set consumer_aspect_ratio for a and b frame
if (mlt_properties_get_double(a_props, "aspect_ratio") == 0.0)
mlt_properties_set_double(a_props, "aspect_ratio", mlt_properties_get_double(a_props, "consumer_aspect_ratio"));
if (mlt_properties_get_double(b_props, "aspect_ratio") == 0.0)
mlt_properties_set_double(b_props, "aspect_ratio", mlt_properties_get_double(a_props, "consumer_aspect_ratio"));
mlt_properties_set_double(b_props, "consumer_aspect_ratio", mlt_properties_get_double(a_props, "consumer_aspect_ratio"));
if (mlt_properties_get(b_props, "rescale.interp") == NULL || !std::strcmp(mlt_properties_get(b_props, "rescale.interp"), "none"))
mlt_properties_set(b_props, "rescale.interp", mlt_properties_get(a_props, "rescale.interp"));
mlt_position position = mlt_transition_get_position(transition, aFrame);
// Get the aFrame image, we will write our output to it
*format = mlt_image_rgb24;
if ((error = mlt_frame_get_image(aFrame, image, format, width, height, 1)) != 0)
return error;
// Get the bFrame image, we won't write to it
uint8_t *bImage = NULL;
int bWidth = 0, bHeight = 0;
if ((error = mlt_frame_get_image(bFrame, &bImage, format, &bWidth, &bHeight, 0)) != 0)
return error;
{ // Scope the lock
MLTWebVfx::ServiceLocker locker(MLT_TRANSITION_SERVICE(transition));
if (!locker.initialize(*width, *height))
return 1;
MLTWebVfx::ServiceManager* manager = locker.getManager();
WebVfx::Image renderedImage(*image, *width, *height, *width * *height * WebVfx::Image::BytesPerPixel);
manager->copyImageForName(manager->getSourceImageName(), renderedImage);
WebVfx::Image targetImage(bImage, bWidth, bHeight, bWidth * bHeight * WebVfx::Image::BytesPerPixel);
manager->copyImageForName(manager->getTargetImageName(), targetImage);
manager->render(renderedImage, position);
}
return error;
}
static mlt_frame transitionProcess(mlt_transition transition, mlt_frame aFrame, mlt_frame bFrame) {
mlt_frame_push_service(aFrame, transition);
mlt_frame_push_frame(aFrame, bFrame);
mlt_frame_push_get_image(aFrame, transitionGetImage);
return aFrame;
}
mlt_service MLTWebVfx::createTransition() {
mlt_transition self = mlt_transition_new();
if (self) {
self->process = transitionProcess;
// Video only transition
mlt_properties_set_int(MLT_TRANSITION_PROPERTIES(self), "_transition_type", 1);
return MLT_TRANSITION_SERVICE(self);
}
return 0;
}
<|endoftext|>
|
<commit_before>// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "webkit/glue/resource_fetcher.h"
#include "base/logging.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
using base::TimeDelta;
using WebKit::WebFrame;
using WebKit::WebURLError;
using WebKit::WebURLLoader;
using WebKit::WebURLRequest;
using WebKit::WebURLResponse;
namespace webkit_glue {
ResourceFetcher::ResourceFetcher(const GURL& url, WebFrame* frame,
Callback* c)
: url_(url),
callback_(c),
completed_(false) {
// Can't do anything without a frame. However, delegate can be NULL (so we
// can do a http request and ignore the results).
DCHECK(frame);
Start(frame);
}
ResourceFetcher::~ResourceFetcher() {
if (!completed_ && loader_.get())
loader_->cancel();
}
void ResourceFetcher::Cancel() {
if (!completed_) {
loader_->cancel();
completed_ = true;
}
}
void ResourceFetcher::Start(WebFrame* frame) {
WebURLRequest request(url_);
frame->dispatchWillSendRequest(request);
loader_.reset(WebKit::webKitClient()->createURLLoader());
loader_->loadAsynchronously(request, this);
}
void ResourceFetcher::RunCallback(const WebURLResponse& response,
const std::string& data) {
if (!callback_.get())
return;
// Take care to clear callback_ before running the callback as it may lead to
// our destruction.
scoped_ptr<Callback> callback;
callback.swap(callback_);
callback->Run(response, data);
}
/////////////////////////////////////////////////////////////////////////////
// WebURLLoaderClient methods
void ResourceFetcher::willSendRequest(
WebURLLoader* loader, WebURLRequest& new_request,
const WebURLResponse& redirect_response) {
}
void ResourceFetcher::didSendData(
WebURLLoader* loader, unsigned long long bytes_sent,
unsigned long long total_bytes_to_be_sent) {
}
void ResourceFetcher::didReceiveResponse(
WebURLLoader* loader, const WebURLResponse& response) {
DCHECK(!completed_);
response_ = response;
}
void ResourceFetcher::didReceiveData(
WebURLLoader* loader, const char* data, int data_length) {
DCHECK(!completed_);
DCHECK(data_length > 0);
data_.append(data, data_length);
}
void ResourceFetcher::didReceiveCachedMetadata(
WebURLLoader* loader, const char* data, int data_length) {
DCHECK(!completed_);
DCHECK(data_length > 0);
metadata_.assign(data, data_length);
}
void ResourceFetcher::didFinishLoading(
WebURLLoader* loader, double finishTime) {
DCHECK(!completed_);
completed_ = true;
RunCallback(response_, data_);
}
void ResourceFetcher::didFail(WebURLLoader* loader, const WebURLError& error) {
DCHECK(!completed_);
completed_ = true;
// Go ahead and tell our delegate that we're done.
RunCallback(WebURLResponse(), std::string());
}
/////////////////////////////////////////////////////////////////////////////
// A resource fetcher with a timeout
ResourceFetcherWithTimeout::ResourceFetcherWithTimeout(
const GURL& url, WebFrame* frame, int timeout_secs, Callback* c)
: ResourceFetcher(url, frame, c) {
timeout_timer_.Start(TimeDelta::FromSeconds(timeout_secs), this,
&ResourceFetcherWithTimeout::TimeoutFired);
}
ResourceFetcherWithTimeout::~ResourceFetcherWithTimeout() {
}
void ResourceFetcherWithTimeout::TimeoutFired() {
if (!completed_) {
loader_->cancel();
didFail(NULL, WebURLError());
}
}
} // namespace webkit_glue
<commit_msg>Fix build oops.<commit_after>// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "webkit/glue/resource_fetcher.h"
#include "base/logging.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebKitClient.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLError.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLLoader.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURLRequest.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
using base::TimeDelta;
using WebKit::WebFrame;
using WebKit::WebURLError;
using WebKit::WebURLLoader;
using WebKit::WebURLRequest;
using WebKit::WebURLResponse;
namespace webkit_glue {
ResourceFetcher::ResourceFetcher(const GURL& url, WebFrame* frame,
Callback* c)
: url_(url),
completed_(false),
callback_(c) {
// Can't do anything without a frame. However, delegate can be NULL (so we
// can do a http request and ignore the results).
DCHECK(frame);
Start(frame);
}
ResourceFetcher::~ResourceFetcher() {
if (!completed_ && loader_.get())
loader_->cancel();
}
void ResourceFetcher::Cancel() {
if (!completed_) {
loader_->cancel();
completed_ = true;
}
}
void ResourceFetcher::Start(WebFrame* frame) {
WebURLRequest request(url_);
frame->dispatchWillSendRequest(request);
loader_.reset(WebKit::webKitClient()->createURLLoader());
loader_->loadAsynchronously(request, this);
}
void ResourceFetcher::RunCallback(const WebURLResponse& response,
const std::string& data) {
if (!callback_.get())
return;
// Take care to clear callback_ before running the callback as it may lead to
// our destruction.
scoped_ptr<Callback> callback;
callback.swap(callback_);
callback->Run(response, data);
}
/////////////////////////////////////////////////////////////////////////////
// WebURLLoaderClient methods
void ResourceFetcher::willSendRequest(
WebURLLoader* loader, WebURLRequest& new_request,
const WebURLResponse& redirect_response) {
}
void ResourceFetcher::didSendData(
WebURLLoader* loader, unsigned long long bytes_sent,
unsigned long long total_bytes_to_be_sent) {
}
void ResourceFetcher::didReceiveResponse(
WebURLLoader* loader, const WebURLResponse& response) {
DCHECK(!completed_);
response_ = response;
}
void ResourceFetcher::didReceiveData(
WebURLLoader* loader, const char* data, int data_length) {
DCHECK(!completed_);
DCHECK(data_length > 0);
data_.append(data, data_length);
}
void ResourceFetcher::didReceiveCachedMetadata(
WebURLLoader* loader, const char* data, int data_length) {
DCHECK(!completed_);
DCHECK(data_length > 0);
metadata_.assign(data, data_length);
}
void ResourceFetcher::didFinishLoading(
WebURLLoader* loader, double finishTime) {
DCHECK(!completed_);
completed_ = true;
RunCallback(response_, data_);
}
void ResourceFetcher::didFail(WebURLLoader* loader, const WebURLError& error) {
DCHECK(!completed_);
completed_ = true;
// Go ahead and tell our delegate that we're done.
RunCallback(WebURLResponse(), std::string());
}
/////////////////////////////////////////////////////////////////////////////
// A resource fetcher with a timeout
ResourceFetcherWithTimeout::ResourceFetcherWithTimeout(
const GURL& url, WebFrame* frame, int timeout_secs, Callback* c)
: ResourceFetcher(url, frame, c) {
timeout_timer_.Start(TimeDelta::FromSeconds(timeout_secs), this,
&ResourceFetcherWithTimeout::TimeoutFired);
}
ResourceFetcherWithTimeout::~ResourceFetcherWithTimeout() {
}
void ResourceFetcherWithTimeout::TimeoutFired() {
if (!completed_) {
loader_->cancel();
didFail(NULL, WebURLError());
}
}
} // namespace webkit_glue
<|endoftext|>
|
<commit_before><commit_msg>PathVector::pathAtRank now returns a copy of with constraints<commit_after><|endoftext|>
|
<commit_before><commit_msg>Make some global variables less-global (static)<commit_after><|endoftext|>
|
<commit_before>/**************************************************************************************/
/* */
/* Visualization Library */
/* http://www.visualizationlibrary.com */
/* */
/* Copyright (c) 2005-2010, Michele Bosi */
/* 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. */
/* */
/**************************************************************************************/
#ifndef PatchParameter_INCLUDE_ONCE
#define PatchParameter_INCLUDE_ONCE
#include <vl/Object.hpp>
namespace vl
{
//------------------------------------------------------------------------------
// PatchParameter
//------------------------------------------------------------------------------
//! Wrapper of glPatchParameter() - specifies the parameters for patch primitives, see also http://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameter.xml
class PatchParameter: public Object
{
public:
//! Constructor
PatchParameter(): mPatchVertices(0), mPatchDefaultOuterLevel(NULL), mPatchDefaultInnerLevel(NULL) {}
//! Applies the glPatchParameter values.
//! If patchDefaultOuterLevel() is NULL no default outer level will be applied.
//! If patchDefaultInnerLevel() is NULL no default inner level will be applied.
void apply()
{
VL_CHECK(GLEW_ARB_tessellation_shader);
if (GLEW_ARB_tessellation_shader)
{
glPatchParameteri(GL_PATCH_VERTICES, mPatchVertices); VL_CHECK_OGL();
if (mPatchDefaultOuterLevel)
{
glPatchParameterfv(GL_PATCH_DEFAULT_OUTER_LEVEL, mPatchDefaultOuterLevel); VL_CHECK_OGL();
}
if (mPatchDefaultInnerLevel)
{
glPatchParameterfv(GL_PATCH_DEFAULT_INNER_LEVEL, mPatchDefaultInnerLevel); VL_CHECK_OGL();
}
}
}
//! Specifies the number of vertices that will be used to make up a single patch primitive.
//! Patch primitives are consumed by the tessellation control shader (if present) and subsequently
//! used for tessellation. When primitives are specified using glDrawArrays or a similar function,
//! each patch will be made from \a vertices control points, each represented by a vertex taken from
//! the enabeld vertex arrays. \a vertices must be greater than zero, and less than or equal to the
//! value of GL_MAX_PATCH_VERTICES.
void setPatchVertices(int vertices) { mPatchVertices = vertices; }
//! Returns the number of vertices that will be used to make up a single patch primitive.
int patchVertices() const { return mPatchVertices; }
//! Defines the address of an array containing the default outer tessellation level
//! to be used when no tessellation control shader is present.
void setPatchDefaultOuterLevel(const float* level) { mPatchDefaultOuterLevel = level; }
//! Returns the address of an array containing the default outer tessellation level
//! to be used when no tessellation control shader is present.
const float* patchDefaultOuterLevel() const { return mPatchDefaultOuterLevel; }
//! Defines the address of an array containing the default inner tessellation level
//! to be used when no tessellation control shader is present.
void setPatchDefaultInnerLevel(const float* level) { mPatchDefaultInnerLevel = level; }
//! Returns the address of an array containing the default inner tessellation level
//! to be used when no tessellation control shader is present.
const float* patchDefaultInnerLevel() const { return mPatchDefaultInnerLevel; }
protected:
int mPatchVertices;
const float* mPatchDefaultOuterLevel;
const float* mPatchDefaultInnerLevel;
};
}
#endif
<commit_msg>fixed PatchParameter<commit_after>/**************************************************************************************/
/* */
/* Visualization Library */
/* http://www.visualizationlibrary.com */
/* */
/* Copyright (c) 2005-2010, Michele Bosi */
/* 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. */
/* */
/**************************************************************************************/
#ifndef PatchParameter_INCLUDE_ONCE
#define PatchParameter_INCLUDE_ONCE
#include <vl/Object.hpp>
namespace vl
{
//------------------------------------------------------------------------------
// PatchParameter
//------------------------------------------------------------------------------
//! Wrapper of glPatchParameter() - specifies the parameters for patch primitives, see also http://www.opengl.org/sdk/docs/man4/xhtml/glPatchParameter.xml
class PatchParameter: public Object
{
public:
//! Constructor
PatchParameter(): mPatchVertices(0) {}
//! Applies the glPatchParameter values.
void apply()
{
VL_CHECK(GLEW_ARB_tessellation_shader);
if (GLEW_ARB_tessellation_shader)
{
glPatchParameteri(GL_PATCH_VERTICES, mPatchVertices); VL_CHECK_OGL();
glPatchParameterfv(GL_PATCH_DEFAULT_OUTER_LEVEL, mPatchDefaultOuterLevel.ptr()); VL_CHECK_OGL();
glPatchParameterfv(GL_PATCH_DEFAULT_INNER_LEVEL, mPatchDefaultInnerLevel.ptr()); VL_CHECK_OGL();
}
}
//! Specifies the number of vertices that will be used to make up a single patch primitive.
//! Patch primitives are consumed by the tessellation control shader (if present) and subsequently
//! used for tessellation. When primitives are specified using glDrawArrays or a similar function,
//! each patch will be made from \a vertices control points, each represented by a vertex taken from
//! the enabeld vertex arrays. \a vertices must be greater than zero, and less than or equal to the
//! value of GL_MAX_PATCH_VERTICES.
void setPatchVertices(int vertices) { mPatchVertices = vertices; }
//! Returns the number of vertices that will be used to make up a single patch primitive.
int patchVertices() const { return mPatchVertices; }
//! The four floating-point values corresponding to the four outer tessellation levels
//! for each subsequent patch to be used when no tessellation control shader is present.
void setPatchDefaultOuterLevel(const fvec4& level) { mPatchDefaultOuterLevel = level; }
//! The four floating-point values corresponding to the four outer tessellation levels
//! for each subsequent patch to be used when no tessellation control shader is present.
const fvec4& patchDefaultOuterLevel() const { return mPatchDefaultOuterLevel; }
//! The two floating-point values corresponding to the tow inner tessellation levels
//! for each subsequent patch to be used when no tessellation control shader is present.
void setPatchDefaultInnerLevel(const fvec2& level) { mPatchDefaultInnerLevel = level; }
//! The two floating-point values corresponding to the tow inner tessellation levels
//! for each subsequent patch to be used when no tessellation control shader is present.
const fvec2& patchDefaultInnerLevel() const { return mPatchDefaultInnerLevel; }
protected:
int mPatchVertices;
fvec4 mPatchDefaultOuterLevel;
fvec2 mPatchDefaultInnerLevel;
};
}
#endif
<|endoftext|>
|
<commit_before>/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: PresenterPreviewCache.cxx,v $
*
* $Revision: 1.5 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"
#include "PresenterPreviewCache.hxx"
#include "cache/SlsCacheContext.hxx"
#include "tools/IdleDetection.hxx"
#include "sdpage.hxx"
#include <cppcanvas/vclfactory.hxx>
#include <com/sun/star/drawing/XDrawPage.hpp>
#include <com/sun/star/rendering/XBitmapCanvas.hpp>
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::sd::slidesorter::cache;
using ::rtl::OUString;
namespace sd { namespace presenter {
class PresenterPreviewCache::PresenterCacheContext : public CacheContext
{
public:
PresenterCacheContext (void);
virtual ~PresenterCacheContext (void);
void SetDocumentSlides (
const Reference<container::XIndexAccess>& rxSlides,
const Reference<XInterface>& rxDocument);
void SetVisibleSlideRange (
const sal_Int32 nFirstVisibleSlideIndex,
const sal_Int32 nLastVisibleSlideIndex);
const SdrPage* GetPage (const sal_Int32 nSlideIndex) const;
void AddPreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
void RemovePreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
// CacheContext
virtual void NotifyPreviewCreation (
CacheKey aKey, const ::boost::shared_ptr<BitmapEx>& rPreview);
virtual bool IsIdle (void);
virtual bool IsVisible (CacheKey aKey);
virtual const SdrPage* GetPage (CacheKey aKey);
virtual ::boost::shared_ptr<std::vector<CacheKey> > GetEntryList (bool bVisible);
virtual sal_Int32 GetPriority (CacheKey aKey);
virtual ::com::sun::star::uno::Reference<com::sun::star::uno::XInterface> GetModel (void);
private:
Reference<container::XIndexAccess> mxSlides;
Reference<XInterface> mxDocument;
sal_Int32 mnFirstVisibleSlideIndex;
sal_Int32 mnLastVisibleSlideIndex;
typedef ::std::vector<css::uno::Reference<css::drawing::XSlidePreviewCacheListener> > ListenerContainer;
ListenerContainer maListeners;
void CallListeners (const sal_Int32 nSlideIndex);
};
//===== Service ===============================================================
Reference<XInterface> SAL_CALL PresenterPreviewCache_createInstance (
const Reference<XComponentContext>& rxContext)
{
return Reference<XInterface>(static_cast<XWeak*>(new PresenterPreviewCache(rxContext)));
}
::rtl::OUString PresenterPreviewCache_getImplementationName (void) throw(RuntimeException)
{
return OUString::createFromAscii("com.sun.star.comp.Draw.PresenterPreviewCache");
}
Sequence<rtl::OUString> SAL_CALL PresenterPreviewCache_getSupportedServiceNames (void)
throw (RuntimeException)
{
static const ::rtl::OUString sServiceName(
::rtl::OUString::createFromAscii("com.sun.star.drawing.PresenterPreviewCache"));
return Sequence<rtl::OUString>(&sServiceName, 1);
}
//===== PresenterPreviewCache =================================================
PresenterPreviewCache::PresenterPreviewCache (const Reference<XComponentContext>& rxContext)
: PresenterPreviewCacheInterfaceBase(m_aMutex),
maPreviewSize(Size(200,200)),
mpCacheContext(new PresenterCacheContext()),
mpCache(new PageCache(maPreviewSize, mpCacheContext))
{
(void)rxContext;
}
PresenterPreviewCache::~PresenterPreviewCache (void)
{
}
//----- XInitialize -----------------------------------------------------------
void SAL_CALL PresenterPreviewCache::initialize (const Sequence<Any>& rArguments)
throw(Exception, RuntimeException)
{
if (rArguments.getLength() != 0)
throw RuntimeException();
}
//----- XSlidePreviewCache ----------------------------------------------------
void SAL_CALL PresenterPreviewCache::setDocumentSlides (
const Reference<container::XIndexAccess>& rxSlides,
const Reference<XInterface>& rxDocument)
throw (RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCacheContext.get()!=NULL);
mpCacheContext->SetDocumentSlides(rxSlides, rxDocument);
}
void SAL_CALL PresenterPreviewCache::setVisibleRange (
sal_Int32 nFirstVisibleSlideIndex,
sal_Int32 nLastVisibleSlideIndex)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCacheContext.get()!=NULL);
mpCacheContext->SetVisibleSlideRange (nFirstVisibleSlideIndex, nLastVisibleSlideIndex);
}
void SAL_CALL PresenterPreviewCache::setPreviewSize (
const css::geometry::IntegerSize2D& rSize)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCache.get()!=NULL);
maPreviewSize = Size(rSize.Width, rSize.Height);
mpCache->ChangeSize(maPreviewSize);
}
Reference<rendering::XBitmap> SAL_CALL PresenterPreviewCache::getSlidePreview (
sal_Int32 nSlideIndex,
const Reference<rendering::XCanvas>& rxCanvas)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCacheContext.get()!=NULL);
cppcanvas::BitmapCanvasSharedPtr pCanvas (
cppcanvas::VCLFactory::getInstance().createCanvas(
Reference<rendering::XBitmapCanvas>(rxCanvas, UNO_QUERY)));
const SdrPage* pPage = mpCacheContext->GetPage(nSlideIndex);
if (pPage == NULL)
throw RuntimeException();
const BitmapEx aPreview (mpCache->GetPreviewBitmap(pPage, maPreviewSize));
if (aPreview.IsEmpty())
return NULL;
else
return cppcanvas::VCLFactory::getInstance().createBitmap(
pCanvas,
aPreview)->getUNOBitmap();
}
void SAL_CALL PresenterPreviewCache::addPreviewCreationNotifyListener (
const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
throw (css::uno::RuntimeException)
{
if (rBHelper.bDisposed || rBHelper.bInDispose)
return;
if (rxListener.is())
mpCacheContext->AddPreviewCreationNotifyListener(rxListener);
}
void SAL_CALL PresenterPreviewCache::removePreviewCreationNotifyListener (
const css::uno::Reference<css::drawing::XSlidePreviewCacheListener>& rxListener)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
mpCacheContext->RemovePreviewCreationNotifyListener(rxListener);
}
void SAL_CALL PresenterPreviewCache::pause (void)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCache.get()!=NULL);
mpCache->Pause();
}
void SAL_CALL PresenterPreviewCache::resume (void)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCache.get()!=NULL);
mpCache->Resume();
}
//-----------------------------------------------------------------------------
void PresenterPreviewCache::ThrowIfDisposed (void)
throw (::com::sun::star::lang::DisposedException)
{
if (rBHelper.bDisposed || rBHelper.bInDispose)
{
throw lang::DisposedException (
::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"PresenterPreviewCache object has already been disposed")),
static_cast<uno::XWeak*>(this));
}
}
//===== PresenterPreviewCache::PresenterCacheContext ==========================
PresenterPreviewCache::PresenterCacheContext::PresenterCacheContext (void)
: mxSlides(),
mxDocument(),
mnFirstVisibleSlideIndex(-1),
mnLastVisibleSlideIndex(-1),
maListeners()
{
}
PresenterPreviewCache::PresenterCacheContext::~PresenterCacheContext (void)
{
}
void PresenterPreviewCache::PresenterCacheContext::SetDocumentSlides (
const Reference<container::XIndexAccess>& rxSlides,
const Reference<XInterface>& rxDocument)
{
mxSlides = rxSlides;
mxDocument = rxDocument;
mnFirstVisibleSlideIndex = -1;
mnLastVisibleSlideIndex = -1;
}
void PresenterPreviewCache::PresenterCacheContext::SetVisibleSlideRange (
const sal_Int32 nFirstVisibleSlideIndex,
const sal_Int32 nLastVisibleSlideIndex)
{
if (nFirstVisibleSlideIndex > nLastVisibleSlideIndex || nFirstVisibleSlideIndex<0)
{
mnFirstVisibleSlideIndex = -1;
mnLastVisibleSlideIndex = -1;
}
else
{
mnFirstVisibleSlideIndex = nFirstVisibleSlideIndex;
mnLastVisibleSlideIndex = nLastVisibleSlideIndex;
}
if (mxSlides.is() && mnLastVisibleSlideIndex >= mxSlides->getCount())
mnLastVisibleSlideIndex = mxSlides->getCount() - 1;
}
void PresenterPreviewCache::PresenterCacheContext::AddPreviewCreationNotifyListener (
const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
{
maListeners.push_back(rxListener);
}
void PresenterPreviewCache::PresenterCacheContext::RemovePreviewCreationNotifyListener (
const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
{
ListenerContainer::iterator iListener;
for (iListener=maListeners.begin(); iListener!=maListeners.end(); ++iListener)
if (*iListener == rxListener)
{
maListeners.erase(iListener);
return;
}
}
//----- CacheContext ----------------------------------------------------------
void PresenterPreviewCache::PresenterCacheContext::NotifyPreviewCreation (
CacheKey aKey,
const ::boost::shared_ptr<BitmapEx>& rPreview)
{
(void)rPreview;
if ( ! mxSlides.is())
return;
const sal_Int32 nCount(mxSlides->getCount());
for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
if (aKey == GetPage(nIndex))
CallListeners(nIndex);
}
bool PresenterPreviewCache::PresenterCacheContext::IsIdle (void)
{
return true;
/*
sal_Int32 nIdleState (tools::IdleDetection::GetIdleState(NULL));
if (nIdleState == tools::IdleDetection::IDET_IDLE)
return true;
else
return false;
*/
}
bool PresenterPreviewCache::PresenterCacheContext::IsVisible (CacheKey aKey)
{
if (mnFirstVisibleSlideIndex < 0)
return false;
for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
{
const SdrPage* pPage = GetPage(nIndex);
if (pPage == static_cast<const SdrPage*>(aKey))
return true;
}
return false;
}
const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (CacheKey aKey)
{
return static_cast<const SdrPage*>(aKey);
}
::boost::shared_ptr<std::vector<CacheKey> >
PresenterPreviewCache::PresenterCacheContext::GetEntryList (bool bVisible)
{
::boost::shared_ptr<std::vector<CacheKey> > pKeys (new std::vector<CacheKey>());
if ( ! mxSlides.is())
return pKeys;
const sal_Int32 nFirstIndex (bVisible ? mnFirstVisibleSlideIndex : 0);
const sal_Int32 nLastIndex (bVisible ? mnLastVisibleSlideIndex : mxSlides->getCount()-1);
if (nFirstIndex < 0)
return pKeys;
for (sal_Int32 nIndex=nFirstIndex; nIndex<=nLastIndex; ++nIndex)
{
pKeys->push_back(GetPage(nIndex));
}
return pKeys;
}
sal_Int32 PresenterPreviewCache::PresenterCacheContext::GetPriority (CacheKey aKey)
{
if ( ! mxSlides.is())
return 0;
const sal_Int32 nCount (mxSlides->getCount());
for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
if (aKey == GetPage(nIndex))
return -nCount-1+nIndex;
for (sal_Int32 nIndex=0; nIndex<=nCount; ++nIndex)
if (aKey == GetPage(nIndex))
return nIndex;
return 0;
}
Reference<XInterface> PresenterPreviewCache::PresenterCacheContext::GetModel (void)
{
return mxDocument;
}
//-----------------------------------------------------------------------------
const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (
const sal_Int32 nSlideIndex) const
{
if ( ! mxSlides.is())
return NULL;
if (nSlideIndex < 0 || nSlideIndex >= mxSlides->getCount())
return NULL;
Reference<drawing::XDrawPage> xSlide (mxSlides->getByIndex(nSlideIndex), UNO_QUERY);
const SdPage* pPage = SdPage::getImplementation(xSlide);
return dynamic_cast<const SdrPage*>(pPage);
}
void PresenterPreviewCache::PresenterCacheContext::CallListeners (
const sal_Int32 nIndex)
{
ListenerContainer aListeners (maListeners);
ListenerContainer::const_iterator iListener;
for (iListener=aListeners.begin(); iListener!=aListeners.end(); ++iListener)
{
try
{
(*iListener)->notifyPreviewCreation(nIndex);
}
catch (lang::DisposedException&)
{
RemovePreviewCreationNotifyListener(*iListener);
}
}
}
} } // end of namespace ::sd::presenter
<commit_msg>INTEGRATION: CWS impress143 (1.3.18); FILE MERGED 2008/05/13 13:59:51 af 1.3.18.1: #i88765# Added include statement for precompiled headers.<commit_after>/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: PresenterPreviewCache.cxx,v $
*
* $Revision: 1.6 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"
#include "precompiled_sd.hxx"
#include "PresenterPreviewCache.hxx"
#include "cache/SlsCacheContext.hxx"
#include "tools/IdleDetection.hxx"
#include "sdpage.hxx"
#include <cppcanvas/vclfactory.hxx>
#include <com/sun/star/drawing/XDrawPage.hpp>
#include <com/sun/star/rendering/XBitmapCanvas.hpp>
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::sd::slidesorter::cache;
using ::rtl::OUString;
namespace sd { namespace presenter {
class PresenterPreviewCache::PresenterCacheContext : public CacheContext
{
public:
PresenterCacheContext (void);
virtual ~PresenterCacheContext (void);
void SetDocumentSlides (
const Reference<container::XIndexAccess>& rxSlides,
const Reference<XInterface>& rxDocument);
void SetVisibleSlideRange (
const sal_Int32 nFirstVisibleSlideIndex,
const sal_Int32 nLastVisibleSlideIndex);
const SdrPage* GetPage (const sal_Int32 nSlideIndex) const;
void AddPreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
void RemovePreviewCreationNotifyListener (const Reference<drawing::XSlidePreviewCacheListener>& rxListener);
// CacheContext
virtual void NotifyPreviewCreation (
CacheKey aKey, const ::boost::shared_ptr<BitmapEx>& rPreview);
virtual bool IsIdle (void);
virtual bool IsVisible (CacheKey aKey);
virtual const SdrPage* GetPage (CacheKey aKey);
virtual ::boost::shared_ptr<std::vector<CacheKey> > GetEntryList (bool bVisible);
virtual sal_Int32 GetPriority (CacheKey aKey);
virtual ::com::sun::star::uno::Reference<com::sun::star::uno::XInterface> GetModel (void);
private:
Reference<container::XIndexAccess> mxSlides;
Reference<XInterface> mxDocument;
sal_Int32 mnFirstVisibleSlideIndex;
sal_Int32 mnLastVisibleSlideIndex;
typedef ::std::vector<css::uno::Reference<css::drawing::XSlidePreviewCacheListener> > ListenerContainer;
ListenerContainer maListeners;
void CallListeners (const sal_Int32 nSlideIndex);
};
//===== Service ===============================================================
Reference<XInterface> SAL_CALL PresenterPreviewCache_createInstance (
const Reference<XComponentContext>& rxContext)
{
return Reference<XInterface>(static_cast<XWeak*>(new PresenterPreviewCache(rxContext)));
}
::rtl::OUString PresenterPreviewCache_getImplementationName (void) throw(RuntimeException)
{
return OUString::createFromAscii("com.sun.star.comp.Draw.PresenterPreviewCache");
}
Sequence<rtl::OUString> SAL_CALL PresenterPreviewCache_getSupportedServiceNames (void)
throw (RuntimeException)
{
static const ::rtl::OUString sServiceName(
::rtl::OUString::createFromAscii("com.sun.star.drawing.PresenterPreviewCache"));
return Sequence<rtl::OUString>(&sServiceName, 1);
}
//===== PresenterPreviewCache =================================================
PresenterPreviewCache::PresenterPreviewCache (const Reference<XComponentContext>& rxContext)
: PresenterPreviewCacheInterfaceBase(m_aMutex),
maPreviewSize(Size(200,200)),
mpCacheContext(new PresenterCacheContext()),
mpCache(new PageCache(maPreviewSize, mpCacheContext))
{
(void)rxContext;
}
PresenterPreviewCache::~PresenterPreviewCache (void)
{
}
//----- XInitialize -----------------------------------------------------------
void SAL_CALL PresenterPreviewCache::initialize (const Sequence<Any>& rArguments)
throw(Exception, RuntimeException)
{
if (rArguments.getLength() != 0)
throw RuntimeException();
}
//----- XSlidePreviewCache ----------------------------------------------------
void SAL_CALL PresenterPreviewCache::setDocumentSlides (
const Reference<container::XIndexAccess>& rxSlides,
const Reference<XInterface>& rxDocument)
throw (RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCacheContext.get()!=NULL);
mpCacheContext->SetDocumentSlides(rxSlides, rxDocument);
}
void SAL_CALL PresenterPreviewCache::setVisibleRange (
sal_Int32 nFirstVisibleSlideIndex,
sal_Int32 nLastVisibleSlideIndex)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCacheContext.get()!=NULL);
mpCacheContext->SetVisibleSlideRange (nFirstVisibleSlideIndex, nLastVisibleSlideIndex);
}
void SAL_CALL PresenterPreviewCache::setPreviewSize (
const css::geometry::IntegerSize2D& rSize)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCache.get()!=NULL);
maPreviewSize = Size(rSize.Width, rSize.Height);
mpCache->ChangeSize(maPreviewSize);
}
Reference<rendering::XBitmap> SAL_CALL PresenterPreviewCache::getSlidePreview (
sal_Int32 nSlideIndex,
const Reference<rendering::XCanvas>& rxCanvas)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCacheContext.get()!=NULL);
cppcanvas::BitmapCanvasSharedPtr pCanvas (
cppcanvas::VCLFactory::getInstance().createCanvas(
Reference<rendering::XBitmapCanvas>(rxCanvas, UNO_QUERY)));
const SdrPage* pPage = mpCacheContext->GetPage(nSlideIndex);
if (pPage == NULL)
throw RuntimeException();
const BitmapEx aPreview (mpCache->GetPreviewBitmap(pPage, maPreviewSize));
if (aPreview.IsEmpty())
return NULL;
else
return cppcanvas::VCLFactory::getInstance().createBitmap(
pCanvas,
aPreview)->getUNOBitmap();
}
void SAL_CALL PresenterPreviewCache::addPreviewCreationNotifyListener (
const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
throw (css::uno::RuntimeException)
{
if (rBHelper.bDisposed || rBHelper.bInDispose)
return;
if (rxListener.is())
mpCacheContext->AddPreviewCreationNotifyListener(rxListener);
}
void SAL_CALL PresenterPreviewCache::removePreviewCreationNotifyListener (
const css::uno::Reference<css::drawing::XSlidePreviewCacheListener>& rxListener)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
mpCacheContext->RemovePreviewCreationNotifyListener(rxListener);
}
void SAL_CALL PresenterPreviewCache::pause (void)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCache.get()!=NULL);
mpCache->Pause();
}
void SAL_CALL PresenterPreviewCache::resume (void)
throw (css::uno::RuntimeException)
{
ThrowIfDisposed();
OSL_ASSERT(mpCache.get()!=NULL);
mpCache->Resume();
}
//-----------------------------------------------------------------------------
void PresenterPreviewCache::ThrowIfDisposed (void)
throw (::com::sun::star::lang::DisposedException)
{
if (rBHelper.bDisposed || rBHelper.bInDispose)
{
throw lang::DisposedException (
::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
"PresenterPreviewCache object has already been disposed")),
static_cast<uno::XWeak*>(this));
}
}
//===== PresenterPreviewCache::PresenterCacheContext ==========================
PresenterPreviewCache::PresenterCacheContext::PresenterCacheContext (void)
: mxSlides(),
mxDocument(),
mnFirstVisibleSlideIndex(-1),
mnLastVisibleSlideIndex(-1),
maListeners()
{
}
PresenterPreviewCache::PresenterCacheContext::~PresenterCacheContext (void)
{
}
void PresenterPreviewCache::PresenterCacheContext::SetDocumentSlides (
const Reference<container::XIndexAccess>& rxSlides,
const Reference<XInterface>& rxDocument)
{
mxSlides = rxSlides;
mxDocument = rxDocument;
mnFirstVisibleSlideIndex = -1;
mnLastVisibleSlideIndex = -1;
}
void PresenterPreviewCache::PresenterCacheContext::SetVisibleSlideRange (
const sal_Int32 nFirstVisibleSlideIndex,
const sal_Int32 nLastVisibleSlideIndex)
{
if (nFirstVisibleSlideIndex > nLastVisibleSlideIndex || nFirstVisibleSlideIndex<0)
{
mnFirstVisibleSlideIndex = -1;
mnLastVisibleSlideIndex = -1;
}
else
{
mnFirstVisibleSlideIndex = nFirstVisibleSlideIndex;
mnLastVisibleSlideIndex = nLastVisibleSlideIndex;
}
if (mxSlides.is() && mnLastVisibleSlideIndex >= mxSlides->getCount())
mnLastVisibleSlideIndex = mxSlides->getCount() - 1;
}
void PresenterPreviewCache::PresenterCacheContext::AddPreviewCreationNotifyListener (
const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
{
maListeners.push_back(rxListener);
}
void PresenterPreviewCache::PresenterCacheContext::RemovePreviewCreationNotifyListener (
const Reference<drawing::XSlidePreviewCacheListener>& rxListener)
{
ListenerContainer::iterator iListener;
for (iListener=maListeners.begin(); iListener!=maListeners.end(); ++iListener)
if (*iListener == rxListener)
{
maListeners.erase(iListener);
return;
}
}
//----- CacheContext ----------------------------------------------------------
void PresenterPreviewCache::PresenterCacheContext::NotifyPreviewCreation (
CacheKey aKey,
const ::boost::shared_ptr<BitmapEx>& rPreview)
{
(void)rPreview;
if ( ! mxSlides.is())
return;
const sal_Int32 nCount(mxSlides->getCount());
for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex)
if (aKey == GetPage(nIndex))
CallListeners(nIndex);
}
bool PresenterPreviewCache::PresenterCacheContext::IsIdle (void)
{
return true;
/*
sal_Int32 nIdleState (tools::IdleDetection::GetIdleState(NULL));
if (nIdleState == tools::IdleDetection::IDET_IDLE)
return true;
else
return false;
*/
}
bool PresenterPreviewCache::PresenterCacheContext::IsVisible (CacheKey aKey)
{
if (mnFirstVisibleSlideIndex < 0)
return false;
for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
{
const SdrPage* pPage = GetPage(nIndex);
if (pPage == static_cast<const SdrPage*>(aKey))
return true;
}
return false;
}
const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (CacheKey aKey)
{
return static_cast<const SdrPage*>(aKey);
}
::boost::shared_ptr<std::vector<CacheKey> >
PresenterPreviewCache::PresenterCacheContext::GetEntryList (bool bVisible)
{
::boost::shared_ptr<std::vector<CacheKey> > pKeys (new std::vector<CacheKey>());
if ( ! mxSlides.is())
return pKeys;
const sal_Int32 nFirstIndex (bVisible ? mnFirstVisibleSlideIndex : 0);
const sal_Int32 nLastIndex (bVisible ? mnLastVisibleSlideIndex : mxSlides->getCount()-1);
if (nFirstIndex < 0)
return pKeys;
for (sal_Int32 nIndex=nFirstIndex; nIndex<=nLastIndex; ++nIndex)
{
pKeys->push_back(GetPage(nIndex));
}
return pKeys;
}
sal_Int32 PresenterPreviewCache::PresenterCacheContext::GetPriority (CacheKey aKey)
{
if ( ! mxSlides.is())
return 0;
const sal_Int32 nCount (mxSlides->getCount());
for (sal_Int32 nIndex=mnFirstVisibleSlideIndex; nIndex<=mnLastVisibleSlideIndex; ++nIndex)
if (aKey == GetPage(nIndex))
return -nCount-1+nIndex;
for (sal_Int32 nIndex=0; nIndex<=nCount; ++nIndex)
if (aKey == GetPage(nIndex))
return nIndex;
return 0;
}
Reference<XInterface> PresenterPreviewCache::PresenterCacheContext::GetModel (void)
{
return mxDocument;
}
//-----------------------------------------------------------------------------
const SdrPage* PresenterPreviewCache::PresenterCacheContext::GetPage (
const sal_Int32 nSlideIndex) const
{
if ( ! mxSlides.is())
return NULL;
if (nSlideIndex < 0 || nSlideIndex >= mxSlides->getCount())
return NULL;
Reference<drawing::XDrawPage> xSlide (mxSlides->getByIndex(nSlideIndex), UNO_QUERY);
const SdPage* pPage = SdPage::getImplementation(xSlide);
return dynamic_cast<const SdrPage*>(pPage);
}
void PresenterPreviewCache::PresenterCacheContext::CallListeners (
const sal_Int32 nIndex)
{
ListenerContainer aListeners (maListeners);
ListenerContainer::const_iterator iListener;
for (iListener=aListeners.begin(); iListener!=aListeners.end(); ++iListener)
{
try
{
(*iListener)->notifyPreviewCreation(nIndex);
}
catch (lang::DisposedException&)
{
RemovePreviewCreationNotifyListener(*iListener);
}
}
}
} } // end of namespace ::sd::presenter
<|endoftext|>
|
<commit_before>/*
* opencog/atoms/reduct/PlusLink.cc
*
* Copyright (C) 2015 Linas Vepstas
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License v3 as
* published by the Free Software Foundation and including the exceptions
* at http://opencog.org/wiki/Licenses
*
* 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 Affero General Public License
* along with this program; if not, write to:
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <opencog/atoms/base/atom_types.h>
#include <opencog/atoms/base/ClassServer.h>
#include <opencog/atoms/core/NumberNode.h>
#include "PlusLink.h"
#include "TimesLink.h"
using namespace opencog;
PlusLink::PlusLink(const HandleSeq& oset, Type t)
: ArithmeticLink(oset, t)
{
init();
}
PlusLink::PlusLink(const Handle& a, const Handle& b)
: ArithmeticLink(PLUS_LINK, a, b)
{
init();
}
PlusLink::PlusLink(Type t, const Handle& a, const Handle& b)
: ArithmeticLink(t, a, b)
{
init();
}
PlusLink::PlusLink(const Link& l)
: ArithmeticLink(l)
{
init();
}
void PlusLink::init(void)
{
Type tscope = get_type();
if (not classserver().isA(tscope, PLUS_LINK))
throw InvalidParamException(TRACE_INFO, "Expecting a PlusLink");
knil = Handle(createNumberNode(0));
_commutative = true;
}
// ============================================================
static inline double get_double(const Handle& h)
{
return NumberNodeCast(h)->get_value();
}
Handle PlusLink::kons(const Handle& fi, const Handle& fj) const
{
Type fitype = fi->get_type();
Type fjtype = fj->get_type();
// Are they numbers?
if (NUMBER_NODE == fitype and NUMBER_NODE == fjtype)
{
double sum = get_double(fi) + get_double(fj);
return Handle(createNumberNode(sum));
}
// If either one is the unit, then just drop it.
if (content_eq(fi, knil))
return fj;
if (content_eq(fj, knil))
return fi;
// Is either one a PlusLink? If so, then flatten.
if (PLUS_LINK == fitype or PLUS_LINK == fjtype)
{
HandleSeq seq;
// flatten the left
if (PLUS_LINK == fitype)
{
for (const Handle& lhs: fi->getOutgoingSet())
seq.push_back(lhs);
}
else
{
seq.push_back(fi);
}
// flatten the right
if (PLUS_LINK == fjtype)
{
for (const Handle& rhs: fj->getOutgoingSet())
seq.push_back(rhs);
}
else
{
seq.push_back(fj);
}
Handle foo(createLink(seq, PLUS_LINK));
PlusLinkPtr ap = PlusLinkCast(foo);
return ap->reduce();
}
// Is fi identical to fj? If so, then replace by 2*fi
if (content_eq(fi, fj))
{
Handle two(createNumberNode("2"));
return Handle(createTimesLink(fi, two));
}
// If j is (TimesLink x a) and i is identical to x,
// then create (TimesLink x (a+1))
//
// If j is (TimesLink x a) and i is (TimesLink x b)
// then create (TimesLink x (a+b))
//
if (fjtype == TIMES_LINK)
{
bool do_add = false;
HandleSeq rest;
Handle exx = fj->getOutgoingAtom(0);
// Handle the (a+1) case described above.
if (fi == exx)
{
Handle one(createNumberNode("1"));
rest.push_back(one);
do_add = true;
}
// Handle the (a+b) case described above.
else if (fitype == TIMES_LINK and
fi->getOutgoingAtom(0) == exx)
{
const HandleSeq& ilpo = fi->getOutgoingSet();
size_t ilpsz = ilpo.size();
for (size_t k=1; k<ilpsz; k++)
rest.push_back(ilpo[k]);
do_add = true;
}
if (do_add)
{
const HandleSeq& jlpo = fj->getOutgoingSet();
size_t jlpsz = jlpo.size();
for (size_t k=1; k<jlpsz; k++)
rest.push_back(jlpo[k]);
// a_plus is now (a+1) or (a+b) as described above.
// We need to insert into the atomspace, else reduce() horks
// up the knil compares during reduction.
Handle foo(createLink(rest, PLUS_LINK));
PlusLinkPtr ap = PlusLinkCast(foo);
Handle a_plus(ap->reduce());
return Handle(createTimesLink(a_plus, exx));
}
}
// If we are here, we've been asked to add two things of the same
// type, but they are not of a type that we know how to add.
// For example, fi and fj might be two different VariableNodes.
return Handle(createPlusLink(fi, fj)->reorder());
}
DEFINE_LINK_FACTORY(PlusLink, PLUS_LINK);
// ============================================================
<commit_msg>Order is important<commit_after>/*
* opencog/atoms/reduct/PlusLink.cc
*
* Copyright (C) 2015 Linas Vepstas
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License v3 as
* published by the Free Software Foundation and including the exceptions
* at http://opencog.org/wiki/Licenses
*
* 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 Affero General Public License
* along with this program; if not, write to:
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <opencog/atoms/base/atom_types.h>
#include <opencog/atoms/base/ClassServer.h>
#include <opencog/atoms/core/NumberNode.h>
#include "PlusLink.h"
#include "TimesLink.h"
using namespace opencog;
PlusLink::PlusLink(const HandleSeq& oset, Type t)
: ArithmeticLink(oset, t)
{
init();
}
PlusLink::PlusLink(const Handle& a, const Handle& b)
: ArithmeticLink(PLUS_LINK, a, b)
{
init();
}
PlusLink::PlusLink(Type t, const Handle& a, const Handle& b)
: ArithmeticLink(t, a, b)
{
init();
}
PlusLink::PlusLink(const Link& l)
: ArithmeticLink(l)
{
init();
}
void PlusLink::init(void)
{
Type tscope = get_type();
if (not classserver().isA(tscope, PLUS_LINK))
throw InvalidParamException(TRACE_INFO, "Expecting a PlusLink");
knil = Handle(createNumberNode(0));
_commutative = true;
}
// ============================================================
static inline double get_double(const Handle& h)
{
return NumberNodeCast(h)->get_value();
}
Handle PlusLink::kons(const Handle& fi, const Handle& fj) const
{
Type fitype = fi->get_type();
Type fjtype = fj->get_type();
// Are they numbers?
if (NUMBER_NODE == fitype and NUMBER_NODE == fjtype)
{
double sum = get_double(fi) + get_double(fj);
return Handle(createNumberNode(sum));
}
// If either one is the unit, then just drop it.
if (content_eq(fi, knil))
return fj;
if (content_eq(fj, knil))
return fi;
// Is either one a PlusLink? If so, then flatten.
if (PLUS_LINK == fitype or PLUS_LINK == fjtype)
{
HandleSeq seq;
// flatten the left
if (PLUS_LINK == fitype)
{
for (const Handle& lhs: fi->getOutgoingSet())
seq.push_back(lhs);
}
else
{
seq.push_back(fi);
}
// flatten the right
if (PLUS_LINK == fjtype)
{
for (const Handle& rhs: fj->getOutgoingSet())
seq.push_back(rhs);
}
else
{
seq.push_back(fj);
}
Handle foo(createLink(seq, PLUS_LINK));
PlusLinkPtr ap = PlusLinkCast(foo);
return ap->reduce();
}
// Is fi identical to fj? If so, then replace by 2*fi
if (content_eq(fi, fj))
{
Handle two(createNumberNode("2"));
return Handle(createTimesLink(fi, two));
}
// If j is (TimesLink x a) and i is identical to x,
// then create (TimesLink x (a+1))
//
// If j is (TimesLink x a) and i is (TimesLink x b)
// then create (TimesLink x (a+b))
//
if (fjtype == TIMES_LINK)
{
bool do_add = false;
HandleSeq rest;
Handle exx = fj->getOutgoingAtom(0);
// Handle the (a+1) case described above.
if (fi == exx)
{
Handle one(createNumberNode("1"));
rest.push_back(one);
do_add = true;
}
// Handle the (a+b) case described above.
else if (fitype == TIMES_LINK and
fi->getOutgoingAtom(0) == exx)
{
const HandleSeq& ilpo = fi->getOutgoingSet();
size_t ilpsz = ilpo.size();
for (size_t k=1; k<ilpsz; k++)
rest.push_back(ilpo[k]);
do_add = true;
}
if (do_add)
{
const HandleSeq& jlpo = fj->getOutgoingSet();
size_t jlpsz = jlpo.size();
for (size_t k=1; k<jlpsz; k++)
rest.push_back(jlpo[k]);
// a_plus is now (a+1) or (a+b) as described above.
// We need to insert into the atomspace, else reduce() horks
// up the knil compares during reduction.
Handle foo(createLink(rest, PLUS_LINK));
PlusLinkPtr ap = PlusLinkCast(foo);
Handle a_plus(ap->reduce());
return Handle(createTimesLink(exx, a_plus));
}
}
// If we are here, we've been asked to add two things of the same
// type, but they are not of a type that we know how to add.
// For example, fi and fj might be two different VariableNodes.
return Handle(createPlusLink(fi, fj)->reorder());
}
DEFINE_LINK_FACTORY(PlusLink, PLUS_LINK);
// ============================================================
<|endoftext|>
|
<commit_before>/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "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 Digia Plc and its Subsidiary(-ies) 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."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "notepad.h"
#include "ui_notepad.h"
//! [0]
#include <QFileDialog>
#include <QFile>
#include <QMessageBox>
#include <QTextStream>
//! [0]
Notepad::Notepad(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::Notepad)
{
ui->setupUi(this);
}
Notepad::~Notepad()
{
delete ui;
}
//! [1]
void Notepad::on_quitButton_clicked()
{
qApp->quit();
}
//! [1]
//! [2]
void Notepad::on_actionOpen_triggered()
{
QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QString(),
tr("Text Files (*.txt);;C++ Files (*.cpp *.h)"));
if (!fileName.isEmpty()) {
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly)) {
QMessageBox::critical(this, tr("Error"), tr("Could not open file"));
return;
}
QTextStream in(&file);
ui->textEdit->setText(in.readAll());
file.close();
}
}
//! [2]
//! [3]
void Notepad::on_actionSave_triggered()
{
QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"), QString(),
tr("Text Files (*.txt);;C++ Files (*.cpp *.h)"));
if (!fileName.isEmpty()) {
QFile file(fileName);
if (!file.open(QIODevice::WriteOnly)) {
// error message
} else {
QTextStream stream(&file);
stream << ui->textEdit->toPlainText();
stream.flush();
file.close();
}
}
}
//! [3]
<commit_msg>Doc: (WS only) Fix misaligned snippet indents<commit_after>/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "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 Digia Plc and its Subsidiary(-ies) 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."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "notepad.h"
#include "ui_notepad.h"
//! [0]
#include <QFileDialog>
#include <QFile>
#include <QMessageBox>
#include <QTextStream>
//! [0]
Notepad::Notepad(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::Notepad)
{
ui->setupUi(this);
}
Notepad::~Notepad()
{
delete ui;
}
//! [1]
void Notepad::on_quitButton_clicked()
{
qApp->quit();
}
//! [1]
//! [2]
void Notepad::on_actionOpen_triggered()
{
QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QString(),
tr("Text Files (*.txt);;C++ Files (*.cpp *.h)"));
if (!fileName.isEmpty()) {
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly)) {
QMessageBox::critical(this, tr("Error"), tr("Could not open file"));
return;
}
QTextStream in(&file);
ui->textEdit->setText(in.readAll());
file.close();
}
}
//! [2]
//! [3]
void Notepad::on_actionSave_triggered()
{
QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"), QString(),
tr("Text Files (*.txt);;C++ Files (*.cpp *.h)"));
if (!fileName.isEmpty()) {
QFile file(fileName);
if (!file.open(QIODevice::WriteOnly)) {
// error message
} else {
QTextStream stream(&file);
stream << ui->textEdit->toPlainText();
stream.flush();
file.close();
}
}
}
//! [3]
<|endoftext|>
|
<commit_before>/*
* Copyright 2007-2020 CM4all GmbH
* All rights reserved.
*
* author: Max Kellermann <mk@cm4all.com>
*
* 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 "Launch.hxx"
#include "spawn/Interface.hxx"
#include "spawn/Prepared.hxx"
#include "spawn/ChildOptions.hxx"
#include "system/Error.hxx"
#include "util/ConstBuffer.hxx"
#include "util/Compiler.h"
#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
WasProcess
was_launch(SpawnService &spawn_service,
const char *name,
const char *executable_path,
ConstBuffer<const char *> args,
const ChildOptions &options,
UniqueFileDescriptor stderr_fd,
ExitListener *listener)
{
auto s = WasSocket::CreatePair();
WasProcess process(std::move(s.first));
process.input.SetNonBlocking();
process.output.SetNonBlocking();
/* allocate 256 kB for each pipe to reduce the system call and
latency overhead for splicing */
static constexpr int PIPE_BUFFER_SIZE = 256 * 1024;
fcntl(process.input.Get(), F_SETPIPE_SZ, PIPE_BUFFER_SIZE);
fcntl(process.output.Get(), F_SETPIPE_SZ, PIPE_BUFFER_SIZE);
PreparedChildProcess p;
p.SetControl(std::move(s.second.control));
p.SetStdout(std::move(s.second.output));
p.SetStdin(std::move(s.second.input));
p.Append(executable_path);
for (auto i : args)
p.Append(i);
options.CopyTo(p, true, nullptr);
if (p.stderr_fd < 0 && stderr_fd.IsDefined())
p.SetStderr(std::move(stderr_fd));
process.pid = spawn_service.SpawnChildProcess(name, std::move(p),
listener);
return process;
}
<commit_msg>was/Launch: move code to new function<commit_after>/*
* Copyright 2007-2020 CM4all GmbH
* All rights reserved.
*
* author: Max Kellermann <mk@cm4all.com>
*
* 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 "Launch.hxx"
#include "spawn/Interface.hxx"
#include "spawn/Prepared.hxx"
#include "spawn/ChildOptions.hxx"
#include "system/Error.hxx"
#include "util/ConstBuffer.hxx"
#include "util/Compiler.h"
#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
static int
WasLaunch(SpawnService &spawn_service,
const char *name,
const char *executable_path,
ConstBuffer<const char *> args,
const ChildOptions &options,
UniqueFileDescriptor &&stderr_fd,
ExitListener *listener,
WasSocket &&socket)
{
PreparedChildProcess p;
p.SetControl(std::move(socket.control));
p.SetStdout(std::move(socket.output));
p.SetStdin(std::move(socket.input));
p.Append(executable_path);
for (auto i : args)
p.Append(i);
options.CopyTo(p, true, nullptr);
if (p.stderr_fd < 0 && stderr_fd.IsDefined())
p.SetStderr(std::move(stderr_fd));
return spawn_service.SpawnChildProcess(name, std::move(p), listener);
}
WasProcess
was_launch(SpawnService &spawn_service,
const char *name,
const char *executable_path,
ConstBuffer<const char *> args,
const ChildOptions &options,
UniqueFileDescriptor stderr_fd,
ExitListener *listener)
{
auto s = WasSocket::CreatePair();
WasProcess process(std::move(s.first));
process.input.SetNonBlocking();
process.output.SetNonBlocking();
/* allocate 256 kB for each pipe to reduce the system call and
latency overhead for splicing */
static constexpr int PIPE_BUFFER_SIZE = 256 * 1024;
fcntl(process.input.Get(), F_SETPIPE_SZ, PIPE_BUFFER_SIZE);
fcntl(process.output.Get(), F_SETPIPE_SZ, PIPE_BUFFER_SIZE);
process.pid = WasLaunch(spawn_service, name, executable_path, args,
options, std::move(stderr_fd),
listener, std::move(s.second));
return process;
}
<|endoftext|>
|
<commit_before>#include "CameraForm.h"
#include "Object.h"
#include "Director.h"
using namespace Math;
using namespace std;
using namespace Rendering::Buffer;
using namespace Rendering::Light;
using namespace Intersection;
using namespace Device;
using namespace Core;
using namespace Rendering::Camera;
using namespace Rendering::Manager;
CameraForm::CameraForm(Usage usage)
: Component(), _frustum(nullptr), _renderTarget(nullptr), _camMatConstBuffer(nullptr), _usage(usage)
{
}
CameraForm::~CameraForm(void)
{
Destroy();
}
void CameraForm::Initialize(const Math::Rect<float>& renderRect)
{
_fieldOfViewDegree = 45.0f;
_clippingNear = 0.1f;
_clippingFar = 1000.0f;
const Size<unsigned int>& backBufferSize = Director::SharedInstance()->GetBackBufferSize();
_aspect = (float)backBufferSize.w / (float)backBufferSize.h;
_projectionType = ProjectionType::Perspective;
_clearColor = Color(0.5f, 0.5f, 1.0f, 1.0f);
_frustum = new Frustum(0.0f);
_renderTarget = new Texture::RenderTexture;
_renderTarget->Initialize(backBufferSize, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, 0, 0);
//_clearFlag = ClearFlag::FlagSolidColor;
_renderRect = renderRect;
_camMatConstBuffer = new ConstBuffer;
_camMatConstBuffer->Initialize(sizeof(CameraCBData));
Device::Director::SharedInstance()->GetCurrentScene()->GetCameraManager()->Add(this);
}
void CameraForm::Destroy()
{
SAFE_DELETE(_frustum);
SAFE_DELETE(_renderTarget);
SAFE_DELETE(_camMatConstBuffer);
}
void CameraForm::CalcAspect()
{
const Size<unsigned int>& backBufferSize = Device::Director::SharedInstance()->GetBackBufferSize();
_aspect = (float)backBufferSize.w / (float)backBufferSize.h;
}
void CameraForm::GetPerspectiveMatrix(Math::Matrix &outMatrix, bool isInverted) const
{
float fovRadian = Math::Common::Deg2Rad(_fieldOfViewDegree);
float clippingNear = _clippingNear;
float clippingFar = _clippingFar;
if(isInverted)
{
clippingNear = _clippingFar;
clippingFar = _clippingNear;
}
Matrix::PerspectiveFovLH(outMatrix, _aspect, fovRadian, clippingNear, clippingFar);
}
void CameraForm::GetOrthogonalMatrix(Math::Matrix &outMatrix, bool isInverted, const Math::Size<uint>* customWH) const
{
const Size<uint>& wh = customWH ? (*customWH) : Device::Director::SharedInstance()->GetBackBufferSize();
float clippingNear = _clippingNear;
float clippingFar = _clippingFar;
if(isInverted)
{
clippingNear = _clippingFar;
clippingFar = _clippingNear;
}
Matrix::OrthoLH(outMatrix, (float)(wh.w), (float)(wh.h), clippingNear, clippingFar);
}
void CameraForm::GetProjectionMatrix(Math::Matrix& outMatrix, bool isInverted) const
{
if(_projectionType == ProjectionType::Perspective)
GetPerspectiveMatrix(outMatrix, isInverted);
else if(_projectionType == ProjectionType::Orthographic)
GetOrthogonalMatrix(outMatrix, isInverted);
}
void CameraForm::GetViewMatrix(Math::Matrix &outMatrix, const Math::Matrix &worldMatrix)
{
outMatrix = worldMatrix;
Vector3 worldPos;
worldPos.x = worldMatrix._41;
worldPos.y = worldMatrix._42;
worldPos.z = worldMatrix._43;
Math::Vector3 right = Math::Vector3(worldMatrix._11, worldMatrix._21, worldMatrix._31);
Math::Vector3 up = Math::Vector3(worldMatrix._12, worldMatrix._22, worldMatrix._32);
Math::Vector3 forward = Math::Vector3(worldMatrix._13, worldMatrix._23, worldMatrix._33);
Vector3 p;
p.x = -Vector3::Dot(right, worldPos);
p.y = -Vector3::Dot(up, worldPos);
p.z = -Vector3::Dot(forward, worldPos);
outMatrix._41 = p.x;
outMatrix._42 = p.y;
outMatrix._43 = p.z;
outMatrix._44 = 1.0f;
}
void CameraForm::GetViewMatrix(Math::Matrix& outMatrix) const
{
Matrix worldMat;
_owner->GetTransform()->FetchWorldMatrix(worldMat);
GetViewMatrix(outMatrix, worldMat);
}
void CameraForm::GetViewportMatrix(Math::Matrix& outMat, const Math::Rect<float>& rect)
{
outMat._11 = rect.size.w / 2.0f;
outMat._12 = 0.0f;
outMat._13 = 0.0f;
outMat._14 = 0.0f;
outMat._21 = 0.0f;
outMat._22 = -rect.size.h / 2.0f;
outMat._23 = 0.0f;
outMat._24 = 0.0f;
outMat._31 = 0.0f;
outMat._32 = 0.0f;
outMat._33 = 1.0f;
outMat._34 = 0.0f;
outMat._41 = rect.x + rect.size.w / 2.0f;
outMat._42 = rect.y + rect.size.h / 2.0f;
outMat._43 = 0.0f;
outMat._44 = 1.0f;
}
void CameraForm::GetInvViewportMatrix(Math::Matrix& outMat, const Math::Rect<float>& rect)
{
Math::Matrix viewportMat;
GetViewportMatrix(viewportMat, rect);
Math::Matrix::Inverse(outMat, viewportMat);
}
void CameraForm::CullingWithUpdateCB(const Device::DirectX* dx, const std::vector<Core::Object*>& objects, const LightManager* lightManager)
{
CameraCBData cbData;
{
Matrix worldMat;
_owner->GetTransform()->FetchWorldMatrix(worldMat);
Matrix& viewMat = cbData.viewMat;
GetViewMatrix(cbData.viewMat, worldMat);
Matrix projMat;
GetProjectionMatrix(projMat, true);
cbData.viewProjMat = viewMat * projMat;
cbData.worldPos = Vector4(worldMat._41, worldMat._42, worldMat._43, 1.0f);
}
bool updatedVP = memcmp(&_prevCamMatCBData, &cbData, sizeof(CameraCBData)) != 0;
if(updatedVP)
{
// Make Frustum
{
Matrix notInvProj;
GetProjectionMatrix(notInvProj, false);
_frustum->Make(cbData.viewMat * notInvProj);
}
_prevCamMatCBData = cbData;
Matrix::Transpose(cbData.viewMat, cbData.viewMat);
Matrix::Transpose(cbData.viewProjMat, cbData.viewProjMat);
_camMatConstBuffer->UpdateSubResource(dx->GetContext(), &cbData);
}
for(auto iter = objects.begin(); iter != objects.end(); ++iter)
(*iter)->Culling(_frustum);
}
void CameraForm::SortTransparentMeshRenderQueue(RenderQueue& inoutTranparentMeshQ, const Transform* ownerTF, const RenderManager* renderMgr)
{
const RenderManager::MeshList& transparentList = renderMgr->GetTransparentMeshes();
if( transparentList.updateCounter != inoutTranparentMeshQ.updateCounter )
{
const auto& transparentMeshAddrSet = transparentList.meshes.GetVector();
auto& thisCamMeshes = inoutTranparentMeshQ.meshes;
thisCamMeshes.clear();
for(auto addrSetIter = transparentMeshAddrSet.begin();
addrSetIter != transparentMeshAddrSet.end(); ++addrSetIter)
{
for(auto iter = addrSetIter->begin(); iter != addrSetIter->end(); ++iter)
{
RenderManager::MeshList::meshkey addr = *iter;
const Geometry::Mesh* mesh = reinterpret_cast<const Geometry::Mesh*>(addr);
thisCamMeshes.push_back(mesh);
}
}
inoutTranparentMeshQ.updateCounter = transparentList.updateCounter;
}
Math::Vector3 camPos;
ownerTF->FetchWorldPosition(camPos);
auto SortingByDistance = [&](const Geometry::Mesh*& left, const Geometry::Mesh*& right) -> bool
{
float leftDistance = D3D11_FLOAT32_MAX;
{
Math::Vector3 leftPos;
left->GetOwner()->GetTransform()->FetchWorldPosition(leftPos);
leftDistance = Math::Vector3::Distance(leftPos, camPos);
}
float rightDistance = D3D11_FLOAT32_MAX;
{
Math::Vector3 rightPos;
right->GetOwner()->GetTransform()->FetchWorldPosition(rightPos);
rightDistance = Math::Vector3::Distance(rightPos, camPos);
}
return leftDistance < rightDistance;
};
std::sort(inoutTranparentMeshQ.meshes.begin(), inoutTranparentMeshQ.meshes.end(), SortingByDistance);
}
void CameraForm::_Clone(CameraForm* newCam) const
{
memcpy(newCam, this, sizeof(CameraForm));
newCam->_frustum = new Frustum(0.0f);
newCam->_renderTarget = new Texture::RenderTexture;
{
const Size<unsigned int>& size = Director::SharedInstance()->GetBackBufferSize();
D3D11_TEXTURE2D_DESC desc;
newCam->_renderTarget->GetTexture()->GetDesc(&desc);
newCam->_renderTarget->Initialize(size, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, desc.BindFlags, desc.SampleDesc.Count);
}
}
bool CameraForm::ComparePrevCameraCBData(const CameraCBData& cbData) const
{
return memcmp(&_prevCamMatCBData, &cbData, sizeof(Matrix) * 2) != 0;
}
<commit_msg>CameraForm.cpp - _camCBChangeState 에 따라 camCB 업데이트가 되도록 함 #53<commit_after>#include "CameraForm.h"
#include "Object.h"
#include "Director.h"
using namespace Math;
using namespace std;
using namespace Rendering;
using namespace Rendering::Buffer;
using namespace Rendering::Light;
using namespace Intersection;
using namespace Device;
using namespace Core;
using namespace Rendering::Camera;
using namespace Rendering::Manager;
CameraForm::CameraForm(Usage usage)
: Component(), _frustum(nullptr), _renderTarget(nullptr), _camMatConstBuffer(nullptr), _usage(usage),
_camCBChangeState(TransformCB::ChangeState::No)
{
}
CameraForm::~CameraForm(void)
{
Destroy();
}
void CameraForm::Initialize(const Math::Rect<float>& renderRect)
{
_fieldOfViewDegree = 45.0f;
_clippingNear = 0.1f;
_clippingFar = 1000.0f;
const Size<unsigned int>& backBufferSize = Director::SharedInstance()->GetBackBufferSize();
_aspect = (float)backBufferSize.w / (float)backBufferSize.h;
_projectionType = ProjectionType::Perspective;
_clearColor = Color(0.5f, 0.5f, 1.0f, 1.0f);
_frustum = new Frustum(0.0f);
_renderTarget = new Texture::RenderTexture;
_renderTarget->Initialize(backBufferSize, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT, 0, 0);
//_clearFlag = ClearFlag::FlagSolidColor;
_renderRect = renderRect;
_camMatConstBuffer = new ConstBuffer;
_camMatConstBuffer->Initialize(sizeof(CameraCBData));
Device::Director::SharedInstance()->GetCurrentScene()->GetCameraManager()->Add(this);
}
void CameraForm::Destroy()
{
SAFE_DELETE(_frustum);
SAFE_DELETE(_renderTarget);
SAFE_DELETE(_camMatConstBuffer);
}
void CameraForm::CalcAspect()
{
const Size<unsigned int>& backBufferSize = Device::Director::SharedInstance()->GetBackBufferSize();
_aspect = (float)backBufferSize.w / (float)backBufferSize.h;
}
void CameraForm::GetPerspectiveMatrix(Math::Matrix &outMatrix, bool isInverted) const
{
float fovRadian = Math::Common::Deg2Rad(_fieldOfViewDegree);
float clippingNear = _clippingNear;
float clippingFar = _clippingFar;
if(isInverted)
{
clippingNear = _clippingFar;
clippingFar = _clippingNear;
}
Matrix::PerspectiveFovLH(outMatrix, _aspect, fovRadian, clippingNear, clippingFar);
}
void CameraForm::GetOrthogonalMatrix(Math::Matrix &outMatrix, bool isInverted, const Math::Size<uint>* customWH) const
{
const Size<uint>& wh = customWH ? (*customWH) : Device::Director::SharedInstance()->GetBackBufferSize();
float clippingNear = _clippingNear;
float clippingFar = _clippingFar;
if(isInverted)
{
clippingNear = _clippingFar;
clippingFar = _clippingNear;
}
Matrix::OrthoLH(outMatrix, (float)(wh.w), (float)(wh.h), clippingNear, clippingFar);
}
void CameraForm::GetProjectionMatrix(Math::Matrix& outMatrix, bool isInverted) const
{
if(_projectionType == ProjectionType::Perspective)
GetPerspectiveMatrix(outMatrix, isInverted);
else if(_projectionType == ProjectionType::Orthographic)
GetOrthogonalMatrix(outMatrix, isInverted);
}
void CameraForm::GetViewMatrix(Math::Matrix &outMatrix, const Math::Matrix &worldMatrix)
{
outMatrix = worldMatrix;
Vector3 worldPos;
worldPos.x = worldMatrix._41;
worldPos.y = worldMatrix._42;
worldPos.z = worldMatrix._43;
Math::Vector3 right = Math::Vector3(worldMatrix._11, worldMatrix._21, worldMatrix._31);
Math::Vector3 up = Math::Vector3(worldMatrix._12, worldMatrix._22, worldMatrix._32);
Math::Vector3 forward = Math::Vector3(worldMatrix._13, worldMatrix._23, worldMatrix._33);
Vector3 p;
p.x = -Vector3::Dot(right, worldPos);
p.y = -Vector3::Dot(up, worldPos);
p.z = -Vector3::Dot(forward, worldPos);
outMatrix._41 = p.x;
outMatrix._42 = p.y;
outMatrix._43 = p.z;
outMatrix._44 = 1.0f;
}
void CameraForm::GetViewMatrix(Math::Matrix& outMatrix) const
{
Matrix worldMat;
_owner->GetTransform()->FetchWorldMatrix(worldMat);
GetViewMatrix(outMatrix, worldMat);
}
void CameraForm::GetViewportMatrix(Math::Matrix& outMat, const Math::Rect<float>& rect)
{
outMat._11 = rect.size.w / 2.0f;
outMat._12 = 0.0f;
outMat._13 = 0.0f;
outMat._14 = 0.0f;
outMat._21 = 0.0f;
outMat._22 = -rect.size.h / 2.0f;
outMat._23 = 0.0f;
outMat._24 = 0.0f;
outMat._31 = 0.0f;
outMat._32 = 0.0f;
outMat._33 = 1.0f;
outMat._34 = 0.0f;
outMat._41 = rect.x + rect.size.w / 2.0f;
outMat._42 = rect.y + rect.size.h / 2.0f;
outMat._43 = 0.0f;
outMat._44 = 1.0f;
}
void CameraForm::GetInvViewportMatrix(Math::Matrix& outMat, const Math::Rect<float>& rect)
{
Math::Matrix viewportMat;
GetViewportMatrix(viewportMat, rect);
Math::Matrix::Inverse(outMat, viewportMat);
}
void CameraForm::CullingWithUpdateCB(const Device::DirectX* dx, const std::vector<Core::Object*>& objects, const LightManager* lightManager)
{
Matrix worldMat;
_owner->GetTransform()->FetchWorldMatrix(worldMat);
CameraCBData cbData;
{
Matrix& viewMat = cbData.viewMat;
GetViewMatrix(cbData.viewMat, worldMat);
Matrix projMat;
GetProjectionMatrix(projMat, true);
cbData.viewProjMat = viewMat * projMat;
}
bool isChanged = ComparePrevCameraCBData(cbData);
if(isChanged)
{
// Make Frustum
{
Matrix notInvProj;
GetProjectionMatrix(notInvProj, false);
_frustum->Make(cbData.viewMat * notInvProj);
}
_camCBChangeState = TransformCB::ChangeState::HasChanged;
}
bool isUpdate = (_camCBChangeState != TransformCB::ChangeState::No);
if(isUpdate)
{
cbData.worldPos = Vector4(worldMat._41, worldMat._42, worldMat._43, 1.0f);
cbData.prevViewProjMat = _prevCamMatCBData.viewProjMat;
_prevCamMatCBData = cbData;
Matrix::Transpose(cbData.viewMat, cbData.viewMat);
Matrix::Transpose(cbData.viewProjMat, cbData.viewProjMat);
Matrix::Transpose(cbData.prevViewProjMat, cbData.prevViewProjMat);
_camMatConstBuffer->UpdateSubResource(dx->GetContext(), &cbData);
_camCBChangeState = (static_cast<uint>(_camCBChangeState) + 1) % static_cast<uint>(TransformCB::ChangeState::MAX);
}
for(auto iter = objects.begin(); iter != objects.end(); ++iter)
(*iter)->Culling(_frustum);
}
void CameraForm::SortTransparentMeshRenderQueue(RenderQueue& inoutTranparentMeshQ, const Transform* ownerTF, const RenderManager* renderMgr)
{
const RenderManager::MeshList& transparentList = renderMgr->GetTransparentMeshes();
if( transparentList.updateCounter != inoutTranparentMeshQ.updateCounter )
{
const auto& transparentMeshAddrSet = transparentList.meshes.GetVector();
auto& thisCamMeshes = inoutTranparentMeshQ.meshes;
thisCamMeshes.clear();
for(auto addrSetIter = transparentMeshAddrSet.begin();
addrSetIter != transparentMeshAddrSet.end(); ++addrSetIter)
{
for(auto iter = addrSetIter->begin(); iter != addrSetIter->end(); ++iter)
{
RenderManager::MeshList::meshkey addr = *iter;
const Geometry::Mesh* mesh = reinterpret_cast<const Geometry::Mesh*>(addr);
thisCamMeshes.push_back(mesh);
}
}
inoutTranparentMeshQ.updateCounter = transparentList.updateCounter;
}
Math::Vector3 camPos;
ownerTF->FetchWorldPosition(camPos);
auto SortingByDistance = [&](const Geometry::Mesh*& left, const Geometry::Mesh*& right) -> bool
{
float leftDistance = D3D11_FLOAT32_MAX;
{
Math::Vector3 leftPos;
left->GetOwner()->GetTransform()->FetchWorldPosition(leftPos);
leftDistance = Math::Vector3::Distance(leftPos, camPos);
}
float rightDistance = D3D11_FLOAT32_MAX;
{
Math::Vector3 rightPos;
right->GetOwner()->GetTransform()->FetchWorldPosition(rightPos);
rightDistance = Math::Vector3::Distance(rightPos, camPos);
}
return leftDistance < rightDistance;
};
std::sort(inoutTranparentMeshQ.meshes.begin(), inoutTranparentMeshQ.meshes.end(), SortingByDistance);
}
void CameraForm::_Clone(CameraForm* newCam) const
{
memcpy(newCam, this, sizeof(CameraForm));
newCam->_frustum = new Frustum(0.0f);
newCam->_renderTarget = new Texture::RenderTexture;
{
const Size<unsigned int>& size = Director::SharedInstance()->GetBackBufferSize();
D3D11_TEXTURE2D_DESC desc;
newCam->_renderTarget->GetTexture()->GetDesc(&desc);
newCam->_renderTarget->Initialize(size, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM, desc.BindFlags, desc.SampleDesc.Count);
}
}
bool CameraForm::ComparePrevCameraCBData(const CameraCBData& cbData) const
{
return memcmp(&_prevCamMatCBData, &cbData, sizeof(Matrix) * 2) != 0;
}
<|endoftext|>
|
<commit_before>#pragma once
//=====================================================================//
/*! @file
@brief SEEDA03 (RX64M) メイン @n
Copyright 2017 Kunihito Hiramatsu
@author 平松邦仁 (hira@rvf-rc45.net)
*/
//=====================================================================//
#include "common/renesas.hpp"
#include "common/rspi_io.hpp"
#include "common/spi_io.hpp"
#include "common/sdc_io.hpp"
#include "common/command.hpp"
#include "common/fifo.hpp"
#include "common/format.hpp"
#include "common/input.hpp"
#include "common/flash_man.hpp"
#include "common/time.h"
#include "chip/LTC2348_16.hpp"
#include "sample.hpp"
namespace seeda {
static const int seeda_version_ = 110;
static const uint32_t build_id_ = B_ID;
typedef utils::command<256> CMD;
#ifdef SEEDA
typedef device::PORT<device::PORT6, device::bitpos::B7> SW1;
typedef device::PORT<device::PORT6, device::bitpos::B6> SW2;
#endif
// Soft SDC 用 SPI 定義（SPI）
#ifdef SEEDA
typedef device::PORT<device::PORTD, device::bitpos::B6> MISO;
typedef device::PORT<device::PORTD, device::bitpos::B4> MOSI;
typedef device::PORT<device::PORTD, device::bitpos::B5> SPCK;
typedef device::spi_io<MISO, MOSI, SPCK> SPI;
typedef device::PORT<device::PORTD, device::bitpos::B3> SDC_SELECT; ///< カード選択信号
typedef device::NULL_PORT SDC_POWER; ///< カード電源制御（常に電源ＯＮ）
typedef device::PORT<device::PORTE, device::bitpos::B6> SDC_DETECT; ///< カード検出
#else
// SDC 用 SPI 定義（RSPI）
typedef device::rspi_io<device::RSPI> SPI;
typedef device::PORT<device::PORTC, device::bitpos::B4> SDC_SELECT; ///< カード選択信号
typedef device::NULL_PORT SDC_POWER; ///< カード電源制御（常に電源ＯＮ）
typedef device::PORT<device::PORTB, device::bitpos::B7> SDC_DETECT; ///< カード検出
#endif
typedef utils::sdc_io<SPI, SDC_SELECT, SDC_POWER, SDC_DETECT> SDC;
#ifdef SEEDA
// LTC2348-16 A/D 制御ポート定義
typedef device::PORT<device::PORT4, device::bitpos::B0> LTC_CSN; // P40(141)
typedef device::PORT<device::PORTC, device::bitpos::B6> LTC_CNV; // PC6(61)
typedef device::PORT<device::PORTD, device::bitpos::B0> LTC_BUSY; // PD0/IRQ0(126)
typedef device::PORT<device::PORT5, device::bitpos::B3> LTC_PD; // P53(53)
typedef device::PORT<device::PORT5, device::bitpos::B6> LTC_SDI; // P56(50)
typedef device::PORT<device::PORT8, device::bitpos::B6> LTC_SCKO; // P86(41)
typedef device::PORT<device::PORT8, device::bitpos::B7> LTC_SCKI; // P87(39)
typedef device::PORT<device::PORT2, device::bitpos::B0> LTC_SDO0; // P20(37)
typedef device::PORT<device::PORT2, device::bitpos::B1> LTC_SDO2; // P21(36)
typedef device::PORT<device::PORT2, device::bitpos::B2> LTC_SDO4; // P22(35)
typedef device::PORT<device::PORT2, device::bitpos::B3> LTC_SDO6; // P23(34)
typedef struct chip::LTC2348_SDO_t<LTC_SCKO, LTC_SDO0, LTC_SDO2, LTC_SDO4, LTC_SDO6> LTC_SDO;
typedef chip::LTC2348_16<LTC_CSN, LTC_CNV, LTC_BUSY, LTC_PD, LTC_SDI, LTC_SCKI, LTC_SDO> EADC;
#endif
typedef device::flash_io FLASH_IO;
typedef utils::flash_man<FLASH_IO> FLASH_MAN;
//-----------------------------------------------------------------//
/*!
@brief SDC_IO クラスへの参照
@return SDC_IO クラス
*/
//-----------------------------------------------------------------//
SDC& at_sdc();
#ifdef SEEDA
//-----------------------------------------------------------------//
/*!
@brief EADC クラスへの参照
@return EADC クラス
*/
//-----------------------------------------------------------------//
EADC& at_eadc();
#endif
//-----------------------------------------------------------------//
/*!
@brief EADC サーバー
*/
//-----------------------------------------------------------------//
void eadc_server();
//-----------------------------------------------------------------//
/*!
@brief EADC サーバー許可
@param[in] ena 「false」の場合不許可
*/
//-----------------------------------------------------------------//
void enable_eadc_server(bool ena = true);
//-----------------------------------------------------------------//
/*!
@brief 時間の作成
@param[in] date 日付
@param[in] time 時間
*/
//-----------------------------------------------------------------//
size_t make_time(const char* date, const char* time);
//-----------------------------------------------------------------//
/*!
@brief GMT 時間の設定
@param[in] t GMT 時間
*/
//-----------------------------------------------------------------//
void set_time(time_t t);
//-----------------------------------------------------------------//
/*!
@brief 時間の表示
@param[in] t 時間
@param[in] dst 出力文字列
@param[in] size 文字列の大きさ
@return 生成された文字列の長さ
*/
//-----------------------------------------------------------------//
int disp_time(time_t t, char* dst = nullptr, uint32_t size = 0);
//-----------------------------------------------------------------//
/*!
@brief 設定スイッチの状態を取得
@return 設定スイッチの状態
*/
//-----------------------------------------------------------------//
uint8_t get_switch()
{
#ifdef SEEDA
return static_cast<uint8_t>(!SW1::P()) | (static_cast<uint8_t>(!SW2::P()) << 1);
#else
return 0; // for only develope mode
#endif
}
//-----------------------------------------------------------------//
/*!
@brief A/D サンプルの参照
@param[in] ch チャネル（０～７）
@return A/D サンプル
*/
//-----------------------------------------------------------------//
sample_t& at_sample(uint8_t ch);
//-----------------------------------------------------------------//
/*!
@brief A/D サンプルの取得
@param[in] ch チャネル（０～７）
@return A/D サンプル
*/
//-----------------------------------------------------------------//
const sample_t& get_sample(uint8_t ch);
//-----------------------------------------------------------------//
/*!
@brief 内臓 A/D 変換値の取得
@param[in] ch チャネル（５、６、７）
@return A/D 変換値
*/
//-----------------------------------------------------------------//
uint16_t get_adc(uint32_t ch);
}
extern "C" {
//-----------------------------------------------------------------//
/*!
@brief GMT 時間の取得
@return GMT 時間
*/
//-----------------------------------------------------------------//
time_t get_time();
};
<commit_msg>update EUI chip<commit_after>#pragma once
//=====================================================================//
/*! @file
@brief SEEDA03 (RX64M) メイン @n
Copyright 2017 Kunihito Hiramatsu
@author 平松邦仁 (hira@rvf-rc45.net)
*/
//=====================================================================//
#include "common/renesas.hpp"
#include "common/rspi_io.hpp"
#include "common/spi_io.hpp"
#include "common/sdc_io.hpp"
#include "common/command.hpp"
#include "common/fifo.hpp"
#include "common/format.hpp"
#include "common/input.hpp"
#include "common/flash_man.hpp"
#include "common/time.h"
#include "chip/LTC2348_16.hpp"
#include "sample.hpp"
#include "chip/EUI_XX.hpp"
namespace seeda {
static const int seeda_version_ = 110;
static const uint32_t build_id_ = B_ID;
typedef utils::command<256> CMD;
#ifdef SEEDA
typedef device::PORT<device::PORT6, device::bitpos::B7> SW1;
typedef device::PORT<device::PORT6, device::bitpos::B6> SW2;
#endif
// Soft SDC 用 SPI 定義（SPI）
#ifdef SEEDA
typedef device::PORT<device::PORTD, device::bitpos::B6> MISO;
typedef device::PORT<device::PORTD, device::bitpos::B4> MOSI;
typedef device::PORT<device::PORTD, device::bitpos::B5> SPCK;
typedef device::spi_io<MISO, MOSI, SPCK> SPI;
typedef device::PORT<device::PORTD, device::bitpos::B3> SDC_SELECT; ///< カード選択信号
typedef device::NULL_PORT SDC_POWER; ///< カード電源制御（常に電源ＯＮ）
typedef device::PORT<device::PORTE, device::bitpos::B6> SDC_DETECT; ///< カード検出
#else
// SDC 用 SPI 定義（RSPI）
typedef device::rspi_io<device::RSPI> SPI;
typedef device::PORT<device::PORTC, device::bitpos::B4> SDC_SELECT; ///< カード選択信号
typedef device::NULL_PORT SDC_POWER; ///< カード電源制御（常に電源ＯＮ）
typedef device::PORT<device::PORTB, device::bitpos::B7> SDC_DETECT; ///< カード検出
#endif
typedef utils::sdc_io<SPI, SDC_SELECT, SDC_POWER, SDC_DETECT> SDC;
#ifdef SEEDA
// LTC2348-16 A/D 制御ポート定義
typedef device::PORT<device::PORT4, device::bitpos::B0> LTC_CSN; // P40(141)
typedef device::PORT<device::PORTC, device::bitpos::B6> LTC_CNV; // PC6(61)
typedef device::PORT<device::PORTD, device::bitpos::B0> LTC_BUSY; // PD0/IRQ0(126)
typedef device::PORT<device::PORT5, device::bitpos::B3> LTC_PD; // P53(53)
typedef device::PORT<device::PORT5, device::bitpos::B6> LTC_SDI; // P56(50)
typedef device::PORT<device::PORT8, device::bitpos::B6> LTC_SCKO; // P86(41)
typedef device::PORT<device::PORT8, device::bitpos::B7> LTC_SCKI; // P87(39)
typedef device::PORT<device::PORT2, device::bitpos::B0> LTC_SDO0; // P20(37)
typedef device::PORT<device::PORT2, device::bitpos::B1> LTC_SDO2; // P21(36)
typedef device::PORT<device::PORT2, device::bitpos::B2> LTC_SDO4; // P22(35)
typedef device::PORT<device::PORT2, device::bitpos::B3> LTC_SDO6; // P23(34)
typedef struct chip::LTC2348_SDO_t<LTC_SCKO, LTC_SDO0, LTC_SDO2, LTC_SDO4, LTC_SDO6> LTC_SDO;
typedef chip::LTC2348_16<LTC_CSN, LTC_CNV, LTC_BUSY, LTC_PD, LTC_SDI, LTC_SCKI, LTC_SDO> EADC;
#endif
typedef device::flash_io FLASH_IO;
typedef utils::flash_man<FLASH_IO> FLASH_MAN;
//-----------------------------------------------------------------//
/*!
@brief SDC_IO クラスへの参照
@return SDC_IO クラス
*/
//-----------------------------------------------------------------//
SDC& at_sdc();
#ifdef SEEDA
//-----------------------------------------------------------------//
/*!
@brief EADC クラスへの参照
@return EADC クラス
*/
//-----------------------------------------------------------------//
EADC& at_eadc();
#endif
//-----------------------------------------------------------------//
/*!
@brief EADC サーバー
*/
//-----------------------------------------------------------------//
void eadc_server();
//-----------------------------------------------------------------//
/*!
@brief EADC サーバー許可
@param[in] ena 「false」の場合不許可
*/
//-----------------------------------------------------------------//
void enable_eadc_server(bool ena = true);
//-----------------------------------------------------------------//
/*!
@brief 時間の作成
@param[in] date 日付
@param[in] time 時間
*/
//-----------------------------------------------------------------//
size_t make_time(const char* date, const char* time);
//-----------------------------------------------------------------//
/*!
@brief GMT 時間の設定
@param[in] t GMT 時間
*/
//-----------------------------------------------------------------//
void set_time(time_t t);
//-----------------------------------------------------------------//
/*!
@brief 時間の表示
@param[in] t 時間
@param[in] dst 出力文字列
@param[in] size 文字列の大きさ
@return 生成された文字列の長さ
*/
//-----------------------------------------------------------------//
int disp_time(time_t t, char* dst = nullptr, uint32_t size = 0);
//-----------------------------------------------------------------//
/*!
@brief 設定スイッチの状態を取得
@return 設定スイッチの状態
*/
//-----------------------------------------------------------------//
uint8_t get_switch()
{
#ifdef SEEDA
return static_cast<uint8_t>(!SW1::P()) | (static_cast<uint8_t>(!SW2::P()) << 1);
#else
return 0; // for only develope mode
#endif
}
//-----------------------------------------------------------------//
/*!
@brief A/D サンプルの参照
@param[in] ch チャネル（０～７）
@return A/D サンプル
*/
//-----------------------------------------------------------------//
sample_t& at_sample(uint8_t ch);
//-----------------------------------------------------------------//
/*!
@brief A/D サンプルの取得
@param[in] ch チャネル（０～７）
@return A/D サンプル
*/
//-----------------------------------------------------------------//
const sample_t& get_sample(uint8_t ch);
//-----------------------------------------------------------------//
/*!
@brief 内臓 A/D 変換値の取得
@param[in] ch チャネル（５、６、７）
@return A/D 変換値
*/
//-----------------------------------------------------------------//
uint16_t get_adc(uint32_t ch);
}
extern "C" {
//-----------------------------------------------------------------//
/*!
@brief GMT 時間の取得
@return GMT 時間
*/
//-----------------------------------------------------------------//
time_t get_time();
};
<|endoftext|>
|
<commit_before>/*
* Copyright (c) 2018, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
*
* 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 "mbed.h"
#include "greentea-client/test_env.h"
#include "networkinterface_tests.h"
#include "unity/unity.h"
#include "utest.h"
using namespace utest::v1;
namespace {
NetworkInterface *net;
rtos::Semaphore status_semaphore;
int status_write_counter = 0;
int status_read_counter = 0;
const int repeats = 5;
const int status_buffer_size = 100;
nsapi_connection_status_t current_status = NSAPI_STATUS_ERROR_UNSUPPORTED;
nsapi_connection_status_t statuses[status_buffer_size];
}
void status_cb(nsapi_event_t event, intptr_t value)
{
if (event != NSAPI_EVENT_CONNECTION_STATUS_CHANGE) {
return;
}
statuses[status_write_counter] = static_cast<nsapi_connection_status_t>(value);
status_write_counter++;
if (status_write_counter >= status_buffer_size) {
TEST_ASSERT(0);
}
status_semaphore.release();
}
nsapi_connection_status_t wait_status_callback()
{
nsapi_connection_status_t status;
while (true) {
status_semaphore.acquire();
status = statuses[status_read_counter];
status_read_counter++;
if (status != current_status) {
current_status = status;
return status;
}
}
}
void NETWORKINTERFACE_STATUS()
{
nsapi_connection_status_t status;
status_write_counter = 0;
status_read_counter = 0;
current_status = NSAPI_STATUS_ERROR_UNSUPPORTED;
net = NetworkInterface::get_default_instance();
net->attach(status_cb);
net->set_blocking(true);
for (int i = 0; i < repeats; i++) {
nsapi_error_t err = net->connect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_CONNECTING, status);
status = wait_status_callback();
if (status == NSAPI_STATUS_LOCAL_UP) {
status = wait_status_callback();
}
TEST_ASSERT_EQUAL(NSAPI_STATUS_GLOBAL_UP, status);
err = net->disconnect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, status);
}
net->attach(NULL);
}
void NETWORKINTERFACE_STATUS_NONBLOCK()
{
nsapi_connection_status_t status;
status_write_counter = 0;
status_read_counter = 0;
current_status = NSAPI_STATUS_ERROR_UNSUPPORTED;
net = NetworkInterface::get_default_instance();
net->attach(status_cb);
net->set_blocking(false);
for (int i = 0; i < repeats; i++) {
nsapi_error_t err = net->connect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_CONNECTING, status);
status = wait_status_callback();
if (status == NSAPI_STATUS_LOCAL_UP) {
status = wait_status_callback();
}
TEST_ASSERT_EQUAL(NSAPI_STATUS_GLOBAL_UP, status);
err = net->disconnect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, status);
ThisThread::sleep_for(1); // In cellular there might still come disconnected messages from the network which are sent to callback.
// This would cause this test to fail as next connect is already ongoing. So wait here a while until (hopefully)
// all messages also from the network have arrived.
}
net->attach(NULL);
net->set_blocking(true);
}
void NETWORKINTERFACE_STATUS_GET()
{
net = NetworkInterface::get_default_instance();
net->set_blocking(true);
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, net->get_connection_status());
for (int i = 0; i < repeats; i++) {
nsapi_error_t err = net->connect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
while (net->get_connection_status() != NSAPI_STATUS_GLOBAL_UP) {
ThisThread::sleep_for(500);
}
#if MBED_CONF_LWIP_IPV6_ENABLED
/* if IPv6 is enabled, validate ipv6_link_local_address API*/
SocketAddress ipv6_link_local_address = NULL;
err = net->get_ipv6_link_local_address(&ipv6_link_local_address);
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
TEST_ASSERT_NOT_NULL(ipv6_link_local_address.get_ip_address());
TEST_ASSERT_EQUAL(NSAPI_IPv6, ipv6_link_local_address.get_ip_version());
#endif
err = net->disconnect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, net->get_connection_status());
}
net->attach(NULL);
}
<commit_msg>TESTS: Allow ipv6_link_local_address() as unsupported<commit_after>/*
* Copyright (c) 2018, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
*
* 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 "mbed.h"
#include "greentea-client/test_env.h"
#include "networkinterface_tests.h"
#include "unity/unity.h"
#include "utest.h"
using namespace utest::v1;
namespace {
NetworkInterface *net;
rtos::Semaphore status_semaphore;
int status_write_counter = 0;
int status_read_counter = 0;
const int repeats = 5;
const int status_buffer_size = 100;
nsapi_connection_status_t current_status = NSAPI_STATUS_ERROR_UNSUPPORTED;
nsapi_connection_status_t statuses[status_buffer_size];
}
void status_cb(nsapi_event_t event, intptr_t value)
{
if (event != NSAPI_EVENT_CONNECTION_STATUS_CHANGE) {
return;
}
statuses[status_write_counter] = static_cast<nsapi_connection_status_t>(value);
status_write_counter++;
if (status_write_counter >= status_buffer_size) {
TEST_ASSERT(0);
}
status_semaphore.release();
}
nsapi_connection_status_t wait_status_callback()
{
nsapi_connection_status_t status;
while (true) {
status_semaphore.acquire();
status = statuses[status_read_counter];
status_read_counter++;
if (status != current_status) {
current_status = status;
return status;
}
}
}
void NETWORKINTERFACE_STATUS()
{
nsapi_connection_status_t status;
status_write_counter = 0;
status_read_counter = 0;
current_status = NSAPI_STATUS_ERROR_UNSUPPORTED;
net = NetworkInterface::get_default_instance();
net->attach(status_cb);
net->set_blocking(true);
for (int i = 0; i < repeats; i++) {
nsapi_error_t err = net->connect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_CONNECTING, status);
status = wait_status_callback();
if (status == NSAPI_STATUS_LOCAL_UP) {
status = wait_status_callback();
}
TEST_ASSERT_EQUAL(NSAPI_STATUS_GLOBAL_UP, status);
err = net->disconnect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, status);
}
net->attach(NULL);
}
void NETWORKINTERFACE_STATUS_NONBLOCK()
{
nsapi_connection_status_t status;
status_write_counter = 0;
status_read_counter = 0;
current_status = NSAPI_STATUS_ERROR_UNSUPPORTED;
net = NetworkInterface::get_default_instance();
net->attach(status_cb);
net->set_blocking(false);
for (int i = 0; i < repeats; i++) {
nsapi_error_t err = net->connect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_CONNECTING, status);
status = wait_status_callback();
if (status == NSAPI_STATUS_LOCAL_UP) {
status = wait_status_callback();
}
TEST_ASSERT_EQUAL(NSAPI_STATUS_GLOBAL_UP, status);
err = net->disconnect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
status = wait_status_callback();
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, status);
ThisThread::sleep_for(1); // In cellular there might still come disconnected messages from the network which are sent to callback.
// This would cause this test to fail as next connect is already ongoing. So wait here a while until (hopefully)
// all messages also from the network have arrived.
}
net->attach(NULL);
net->set_blocking(true);
}
void NETWORKINTERFACE_STATUS_GET()
{
net = NetworkInterface::get_default_instance();
net->set_blocking(true);
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, net->get_connection_status());
for (int i = 0; i < repeats; i++) {
nsapi_error_t err = net->connect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
while (net->get_connection_status() != NSAPI_STATUS_GLOBAL_UP) {
ThisThread::sleep_for(500);
}
#if MBED_CONF_LWIP_IPV6_ENABLED
/* if IPv6 is enabled, validate ipv6_link_local_address API*/
SocketAddress ipv6_link_local_address(NULL);
err = net->get_ipv6_link_local_address(&ipv6_link_local_address);
if (err != NSAPI_ERROR_UNSUPPORTED) {
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
TEST_ASSERT_NOT_NULL(ipv6_link_local_address.get_ip_address());
TEST_ASSERT_EQUAL(NSAPI_IPv6, ipv6_link_local_address.get_ip_version());
}
#endif
err = net->disconnect();
TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, err);
TEST_ASSERT_EQUAL(NSAPI_STATUS_DISCONNECTED, net->get_connection_status());
}
net->attach(NULL);
}
<|endoftext|>
|
<commit_before>// Copyright 2015-2017 Joy Machine, LLC. All rights reserved.
#include "steelhunters.h"
#include "ObjectPool.h"
#include "DateTime.h"
#include "IPooledObject.h"
// Forces any pooled object to be a derivative of UObject.
// NOTE: I don't want to force IPooledObject to derive from UObject, so this is the only real solution I can think of.
#if !UE_BUILD_SHIPPING
#define OBJECT_POOL_FORCE_UOBJECT true
#else
#define OBJECT_POOL_FORCE_UOBJECT false
#endif
// Console variable definition.
static TAutoConsoleVariable< bool > CVarDebugObjectPooling( TEXT( "joy.DebugObjectPooling" ),
false,
TEXT( "Verbose output from the object pooling system for debugging." ),
ECVF_Default );
// Static class definitions.
const int64 UObjectPool::kDefaultPruneStaleSeconds = 60;
uint32 UObjectPool::IDCounter = 0;
uint32 UObjectPool::PoolCount = 0;
//----------------------------------------------------------------------------------------------------
UObjectPool::UObjectPool( const class FObjectInitializer& ObjectInitializer )
: Name( *FString::Printf( TEXT( "Pool-%d" ), PoolCount ) )
, PoolID( PoolCount )
, PoolSizeOptimal( 256 )
, PoolSizeMaximum( 2048 )
, PruneStale( false )
, PruneLastTimestamp( FDateTime::Now( ).ToUnixTimestamp( ) )
, PruneStale_Seconds( kDefaultPruneStaleSeconds )
{
Pool.Empty( );
// Set this pool ID.
PoolID = ++PoolCount;
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Just toss out some debug information.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Creating new pool (Pool Count: %d)." ), PoolCount );
}
}
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::OnObjectReturn( IPooledObject* pObject )
{
check( pObject != nullptr );
// Reset the object (pure virtual method, so the logic is reliant on the child class).
pObject->IsActive = false;
pObject->Reset( );
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::Prune( )
{
const int64 currentTime = FDateTime::Now( ).ToUnixTimestamp( );
int32 prunedObjectCount = Pool.RemoveAll( [&]( IPooledObject* pObject ) {
if( !pObject->GetIsActive( ) && !pObject->Check( ) || ( PruneStale && ( ( currentTime - pObject->LastActiveTimestamp ) > PruneStale_Seconds ) ) )
{
// This object is invalid or stale. Remove it.
if( pObject != nullptr )
{
// Just in case any logic in ::Deactivate is necessary, execute that, and then the ::Destroy method.
pObject->ReturnToPool.Unbind( );
pObject->DestroyInstance( );
pObject = nullptr;
}
return true;
}
return false;
} );
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Log the number of pruned objects.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Pool pruning logic completed (Pool: %s, Object Count: %d, Pruned Count: %d." ), Name, Pool.Num( ), prunedObjectCount );
}
}
PruneLastTimestamp = currentTime;
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::SetName( const FName& PoolName )
{
// Just set the pool name; doesn't have to be unique.
Name = GenerateName( PoolName );
}
//----------------------------------------------------------------------------------------------------
FName UObjectPool::GenerateName( const FName& BaseName )
{
return( *FString::Printf( TEXT( "%s-%d" ), BaseName, PoolCount ) );
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::Empty( bool SeparateActiveInstances )
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
// Remove all objects from the pool and destroy them (unless SeparateActiveInstances is true, in which case leave them alone for now).
int32 destroyedObjectCount = Pool.RemoveAll( [&]( IPooledObject* pObject ) {
if( !( SeparateActiveInstances && ( pObject != nullptr ) && pObject->GetIsActive( ) ) )
{
// Just in case any logic in ::Deactivate is necessary, execute that, and then the ::Destroy method.
pObject->ReturnToPool.Unbind( );
pObject->DestroyInstance( );
pObject = nullptr;
return true;
}
return false;
} );
if( !SeparateActiveInstances )
{
if( debug )
{
// Log the object destroyed count and the destruction of the pool.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Pool destroy completed (Pool: %s, Destroyed Object Count: %d)." ), Name, destroyedObjectCount );
}
return;
}
// Now handle the separation of objects.
int32 separatedObjectCount = Pool.RemoveAll( [&]( IPooledObject* pObject ) {
pObject->ReturnToPool.Unbind( );
pObject->OnPoolRemovalWhileActive( );
return true;
} );
if( debug )
{
// Log the object destroyed count and the destruction of the pool.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Pool destroy completed with object separation (Pool: %s, Separated Object Count: %d, Destroyed Object Count: %d)." ), Name, separatedObjectCount, destroyedObjectCount );
}
#if !UE_BUILD_SHIPPING
ensure( Pool.Num( ) == 0 );
#endif
}
//----------------------------------------------------------------------------------------------------
bool UObjectPool::Add( IPooledObject* ObjectIn, bool Active )
{
check( ObjectIn != nullptr );
#if OBJECT_POOL_FORCE_UOBJECT
{
// Check to ensure that IPooledObject is a derivative of UObject.
UObject* pUObject = dynamic_cast< UObject* >( ObjectIn );
ensure( IsValid( pUObject ) );
}
#endif
// Predicate to check if this object is already in the pool.
const uint32 objectID = ObjectIn->ID;
if( Pool.ContainsByPredicate( [objectID]( const IPooledObject* pObject ) {
return( objectID == pObject->ID );
} ) )
{
// Object is already in the pool.
return false;
}
// Set whether or not the object is active (if being added, it usually is), and give it an ID.
ObjectIn->IsActive = Active;
ObjectIn->ID = IDCounter++;
// Setup the object's pool return delegate (executed when the object is deactivated).
ObjectIn->ReturnToPool.BindSP( this, &UObjectPool::OnObjectReturn );
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Debug logging.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Adding object to pool (Pool: %s, Object Count: %d)." ), Name, Pool.Num( ) );
}
}
}
//----------------------------------------------------------------------------------------------------
template< typename T >
T* UObjectPool::GetPooledObject( )
{
T* pPooledObject = GetPooledObject( );
if( pPooledObject == nullptr )
{
// No valid pooled objects.
return nullptr;
}
{
UObject* pUObject = static_cast< UObject* >( pPooledObject );
if( pUObject != nullptr )
{
pPooledObject = Cast< T >( pUObject );
check( IsValid( pPooledObject ) );
return pPooledObject;
}
}
// Not a UObject-derived class; use standard checks.
T* pCastPooledObject = static_cast< T* >( pPooledObject );
check( pCastPooledObject != nullptr );
return pCastPooledObject;
}
//----------------------------------------------------------------------------------------------------
IPooledObject* UObjectPool::GetPooledObject( )
{
const int64 currentTime = FDateTime::Now( ).ToUnixTimestamp( );
bool executePrune = PruneStale && ( ( currentTime - PruneLastTimestamp ) > PruneStale_Seconds ); // If this isn't true, then it may be time to prune anyway if the search finds an invalid object.
// Find the first inactive and valid object.
int32 idx = Pool.IndexOfByPredicate( [&]( IPooledObject* pObject ) {
if( !pObject->GetIsActive( ) )
{
if( !pObject->Check( ) )
{
// This object is invalid. Prune the pool after this search.
executePrune = true;
return false;
}
return true;
}
return false;
} );
if( idx == INDEX_NONE )
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Debug logging.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Unable to get a free object from the pool using ::GetPooledObject (Pool: %s, Object Count: %d)." ), Name, Pool.Num( ) );
}
}
// Get the found valid object, remove its place in the array, and add it to the back for a more efficient check later.
// NOTE (trent, 12/10/17): Ensure that this is actually an optimization.
UObject* pUObject = Pool[idx].Get( );
IPooledObject* pValidObject = dynamic_cast< IPooledObject* >( pUObject );
Pool.RemoveAtSwap( idx, 1, false );
Pool.Add( pUObject );
// Activate the object.
pValidObject->IsActive = true;
pValidObject->LastActiveTimestamp = FDateTime::Now( ).ToUnixTimestamp( );
if( executePrune )
{
// Prune the pool if need be (or if it's just time).
// NOTE: Since the object that was just found has already been reactivated and given an updated timestamp, it won't be pruned.
Prune( );
}
return pValidObject;
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::SetPruneStale( bool PruneStaleIn )
{
PruneStale = PruneStaleIn;
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::SetPruneInactiveTime( int64 PruneInactivitySeconds )
{
PruneStale_Seconds = PruneInactivitySeconds;
}<commit_msg>I swear, this object pooling thing was so much prettier and simpler when I started it. UHT/UE4 do not make non-UObject interfaces easy to deal with whatsoever.<commit_after>// Copyright 2015-2017 Joy Machine, LLC. All rights reserved.
#include "steelhunters.h"
#include "ObjectPool.h"
#include "DateTime.h"
#include "IPooledObject.h"
// Console variable definition.
static TAutoConsoleVariable< bool > CVarDebugObjectPooling( TEXT( "joy.DebugObjectPooling" ),
false,
TEXT( "Verbose output from the object pooling system for debugging." ),
ECVF_Default );
// Static class definitions.
const int64 UObjectPool::kDefaultPruneStaleSeconds = 60;
uint32 UObjectPool::IDCounter = 0;
uint32 UObjectPool::PoolCount = 0;
//----------------------------------------------------------------------------------------------------
UObjectPool::UObjectPool( const class FObjectInitializer& ObjectInitializer )
: Name( *FString::Printf( TEXT( "Pool-%d" ), PoolCount ) )
, PoolID( PoolCount )
, PoolSizeOptimal( 256 )
, PoolSizeMaximum( 2048 )
, PruneStale( false )
, PruneLastTimestamp( FDateTime::Now( ).ToUnixTimestamp( ) )
, PruneStale_Seconds( kDefaultPruneStaleSeconds )
{
Pool.Empty( );
// Set this pool ID.
PoolID = ++PoolCount;
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Just toss out some debug information.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Creating new pool (Pool Count: %d)." ), PoolCount );
}
}
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::OnObjectReturn( IPooledObject* pObject )
{
check( pObject != nullptr );
// Reset the object (pure virtual method, so the logic is reliant on the child class).
pObject->IsActive = false;
pObject->Reset( );
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::Prune( )
{
const int64 currentTime = FDateTime::Now( ).ToUnixTimestamp( );
int32 prunedObjectCount = Pool.RemoveAll( [&]( TWeakObjectPtr< UObject > pObject ) {
if( !pObject.IsStale( ) && pObject.IsValid( ) )
{
// The object pointer is either stale or no longer valid.
return false;
}
IPooledObject* pPooledObject = dynamic_cast< IPooledObject* >( pObject.Get( ) );
if( !pPooledObject->GetIsActive( ) && !pPooledObject->Check( ) || ( PruneStale && ( ( currentTime - pPooledObject->LastActiveTimestamp ) > PruneStale_Seconds ) ) )
{
// This object is invalid or stale. Remove it.
if( pPooledObject != nullptr )
{
// Just in case any logic in ::Deactivate is necessary, execute that, and then the ::Destroy method.
pPooledObject->ReturnToPool.Unbind( );
pPooledObject->DestroyInstance( );
pPooledObject = nullptr;
}
return true;
}
return false;
} );
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Log the number of pruned objects.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Pool pruning logic completed (Pool: %s, Object Count: %d, Pruned Count: %d." ), *Name.ToString( ), Pool.Num( ), prunedObjectCount );
}
}
PruneLastTimestamp = currentTime;
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::SetName( const FName& PoolName )
{
// Just set the pool name; doesn't have to be unique.
Name = GenerateName( PoolName );
}
//----------------------------------------------------------------------------------------------------
FName UObjectPool::GenerateName( const FName& BaseName )
{
return( *FString::Printf( TEXT( "%s-%d" ), *BaseName.ToString( ), PoolCount ) );
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::Empty( bool SeparateActiveInstances )
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
// Remove all objects from the pool and destroy them (unless SeparateActiveInstances is true, in which case leave them alone for now).
int32 destroyedObjectCount = Pool.RemoveAll( [&]( TWeakObjectPtr< UObject > pObject ) {
IPooledObject* pPooledObject = dynamic_cast< IPooledObject* >( pObject.Get( ) );
if( !( SeparateActiveInstances && ( pPooledObject != nullptr ) && pPooledObject->GetIsActive( ) ) )
{
// Just in case any logic in ::Deactivate is necessary, execute that, and then the ::Destroy method.
pPooledObject->ReturnToPool.Unbind( );
pPooledObject->DestroyInstance( );
pPooledObject = nullptr;
return true;
}
return false;
} );
if( !SeparateActiveInstances )
{
if( debug )
{
// Log the object destroyed count and the destruction of the pool.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Pool destroy completed (Pool: %s, Destroyed Object Count: %d)." ), *Name.ToString( ), destroyedObjectCount );
}
return;
}
// Now handle the separation of objects.
int32 separatedObjectCount = Pool.RemoveAll( [&]( TWeakObjectPtr< UObject > pObject ) {
IPooledObject* pPooledObject = dynamic_cast< IPooledObject* >( pObject.Get( ) );
pPooledObject->ReturnToPool.Unbind( );
pPooledObject->OnPoolRemovalWhileActive( );
return true;
} );
if( debug )
{
// Log the object destroyed count and the destruction of the pool.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Pool destroy completed with object separation (Pool: %s, Separated Object Count: %d, Destroyed Object Count: %d)." ), *Name.ToString( ), separatedObjectCount, destroyedObjectCount );
}
#if !UE_BUILD_SHIPPING
ensure( Pool.Num( ) == 0 );
#endif // !UE_BUILD_SHIPPING.
}
//----------------------------------------------------------------------------------------------------
bool UObjectPool::Add( IPooledObject* ObjectIn, bool Active )
{
check( ObjectIn != nullptr );
// Check to ensure that IPooledObject is a derivative of UObject.
UObject* pUObject = dynamic_cast< UObject* >( ObjectIn );
#if !UE_BUILD_SHIPPING
ensure( IsValid( pUObject ) );
#endif // !UE_BUILD_SHIPPING.
// Predicate to check if this object is already in the pool.
const uint32 objectID = ObjectIn->ID;
if( Pool.ContainsByPredicate( [objectID]( TWeakObjectPtr< UObject > pObject ) {
IPooledObject* pPooledObject = dynamic_cast< IPooledObject* >( pObject.Get( ) );
return( objectID == pPooledObject->ID );
} ) )
{
// Object is already in the pool.
return false;
}
// Add this object to the pool.
Pool.Add( pUObject );
// Set whether or not the object is active (if being added, it usually is), and give it an ID.
ObjectIn->IsActive = Active;
ObjectIn->ID = IDCounter++;
// Setup the object's pool return delegate (executed when the object is deactivated).
ObjectIn->ReturnToPool.BindSP( this, &UObjectPool::OnObjectReturn );
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Debug logging.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Adding object to pool (Pool: %s, Object Count: %d)." ), *Name.ToString( ), Pool.Num( ) );
}
}
}
//----------------------------------------------------------------------------------------------------
template< typename T >
T* UObjectPool::GetPooledObject( )
{
IPooledObject* pPooledObject = GetPooledObject( );
if( pPooledObject == nullptr )
{
// No valid pooled objects.
return nullptr;
}
T* pTemplateObject = Cast< T >( pPooledObject );
check( IsValid( pTemplateObject ) );
return pTemplateObject;
}
//----------------------------------------------------------------------------------------------------
IPooledObject* UObjectPool::GetPooledObject( )
{
const int64 currentTime = FDateTime::Now( ).ToUnixTimestamp( );
bool executePrune = PruneStale && ( ( currentTime - PruneLastTimestamp ) > PruneStale_Seconds ); // If this isn't true, then it may be time to prune anyway if the search finds an invalid object.
// Find the first inactive and valid object.
int32 idx = Pool.IndexOfByPredicate( [&]( TWeakObjectPtr< UObject > pObject ) {
IPooledObject* pPooledObject = dynamic_cast< IPooledObject* >( pObject.Get( ) );
if( !pPooledObject->GetIsActive( ) )
{
if( !pPooledObject->Check( ) )
{
// This object is invalid. Prune the pool after this search.
executePrune = true;
return false;
}
return true;
}
return false;
} );
if( idx == INDEX_NONE )
{
const bool debug = CVarDebugObjectPooling.GetValueOnGameThread( );
if( debug )
{
// Debug logging.
UE_LOG( SteelHuntersLog, Log, TEXT( "[UObjectPool] Unable to get a free object from the pool using ::GetPooledObject (Pool: %s, Object Count: %d)." ), *Name.ToString( ), Pool.Num( ) );
}
}
// Get the found valid object, remove its place in the array, and add it to the back for a more efficient check later.
// NOTE (trent, 12/10/17): Ensure that this is actually an optimization.
UObject* pUObject = Pool[idx].Get( );
IPooledObject* pValidObject = dynamic_cast< IPooledObject* >( pUObject );
Pool.RemoveAtSwap( idx, 1, false );
Pool.Add( pUObject );
// Activate the object.
pValidObject->IsActive = true;
pValidObject->LastActiveTimestamp = FDateTime::Now( ).ToUnixTimestamp( );
if( executePrune )
{
// Prune the pool if need be (or if it's just time).
// NOTE: Since the object that was just found has already been reactivated and given an updated timestamp, it won't be pruned.
Prune( );
}
return pValidObject;
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::SetPruneStale( bool PruneStaleIn )
{
PruneStale = PruneStaleIn;
}
//----------------------------------------------------------------------------------------------------
void UObjectPool::SetPruneInactiveTime( int64 PruneInactivitySeconds )
{
PruneStale_Seconds = PruneInactivitySeconds;
}<|endoftext|>
|
<commit_before>/*
* Copyright (C) 2015 ScyllaDB
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <map>
#include <memory>
#include <iosfwd>
#include "database_fwd.hh"
#include "dht/i_partitioner.hh"
#include "schema.hh"
#include "encoding_stats.hh"
#include "mutation_reader.hh"
#include "db/commitlog/replay_position.hh"
#include "db/commitlog/rp_set.hh"
#include "utils/extremum_tracking.hh"
#include "utils/logalloc.hh"
#include "partition_version.hh"
#include "flat_mutation_reader.hh"
class frozen_mutation;
namespace bi = boost::intrusive;
class memtable_entry {
bi::set_member_hook<> _link;
schema_ptr _schema;
dht::decorated_key _key;
partition_entry _pe;
public:
friend class memtable;
memtable_entry(schema_ptr s, dht::decorated_key key, mutation_partition p)
: _schema(std::move(s))
, _key(std::move(key))
, _pe(std::move(p))
{ }
memtable_entry(memtable_entry&& o) noexcept;
const dht::decorated_key& key() const { return _key; }
dht::decorated_key& key() { return _key; }
const partition_entry& partition() const { return _pe; }
partition_entry& partition() { return _pe; }
const schema_ptr& schema() const { return _schema; }
schema_ptr& schema() { return _schema; }
lw_shared_ptr<partition_snapshot> snapshot(memtable& mtbl);
size_t external_memory_usage_without_rows() const {
return _key.key().external_memory_usage();
}
size_t size_in_allocator_without_rows(allocation_strategy& allocator) {
return allocator.object_memory_size_in_allocator(this) + external_memory_usage_without_rows();
}
size_t size_in_allocator(allocation_strategy& allocator) {
auto size = size_in_allocator_without_rows(allocator);
for (auto&& v : _pe.versions()) {
size += v.size_in_allocator(allocator);
}
return size;
}
struct compare {
dht::decorated_key::less_comparator _c;
compare(schema_ptr s)
: _c(std::move(s))
{}
bool operator()(const dht::decorated_key& k1, const memtable_entry& k2) const {
return _c(k1, k2._key);
}
bool operator()(const memtable_entry& k1, const memtable_entry& k2) const {
return _c(k1._key, k2._key);
}
bool operator()(const memtable_entry& k1, const dht::decorated_key& k2) const {
return _c(k1._key, k2);
}
bool operator()(const memtable_entry& k1, const dht::ring_position& k2) const {
return _c(k1._key, k2);
}
bool operator()(const dht::ring_position& k1, const memtable_entry& k2) const {
return _c(k1, k2._key);
}
};
friend std::ostream& operator<<(std::ostream&, const memtable_entry&);
};
class dirty_memory_manager;
// Managed by lw_shared_ptr<>.
class memtable final : public enable_lw_shared_from_this<memtable>, private logalloc::region {
public:
using partitions_type = bi::set<memtable_entry,
bi::member_hook<memtable_entry, bi::set_member_hook<>, &memtable_entry::_link>,
bi::compare<memtable_entry::compare>>;
private:
dirty_memory_manager& _dirty_mgr;
memtable_list *_memtable_list;
schema_ptr _schema;
logalloc::allocating_section _read_section;
logalloc::allocating_section _allocating_section;
partitions_type partitions;
db::replay_position _replay_position;
db::rp_set _rp_set;
// mutation source to which reads fall-back after mark_flushed()
// so that memtable contents can be moved away while there are
// still active readers. This is needed for this mutation_source
// to be monotonic (not loose writes). Monotonicity of each
// mutation_source is necessary for the combined mutation source to be
// monotonic. That combined source in this case is cache + memtable.
mutation_source_opt _underlying;
uint64_t _flushed_memory = 0;
class encoding_stats_collector {
private:
min_tracker<api::timestamp_type> min_timestamp;
min_tracker<uint32_t> min_local_deletion_time;
min_tracker<uint32_t> min_ttl;
void update_timestamp(api::timestamp_type ts) {
if (ts != api::missing_timestamp) {
min_timestamp.update(ts);
}
}
public:
encoding_stats_collector()
: min_timestamp(encoding_stats::timestamp_epoch)
, min_local_deletion_time(encoding_stats::deletion_time_epoch)
, min_ttl(encoding_stats::ttl_epoch)
{}
void update(atomic_cell_view cell) {
update_timestamp(cell.timestamp());
if (cell.is_live_and_has_ttl()) {
min_ttl.update(cell.ttl().count());
min_local_deletion_time.update(cell.expiry().time_since_epoch().count());
} else if (!cell.is_live()) {
min_local_deletion_time.update(cell.deletion_time().time_since_epoch().count());
}
}
void update(tombstone tomb) {
if (tomb) {
update_timestamp(tomb.timestamp);
min_local_deletion_time.update(tomb.deletion_time.time_since_epoch().count());
}
}
void update(const schema& s, const row& r, column_kind kind) {
r.for_each_cell([this, &s, kind](column_id id, const atomic_cell_or_collection& item) {
auto& col = s.column_at(kind, id);
if (col.is_atomic()) {
update(item.as_atomic_cell());
} else {
auto mview = collection_type_impl::deserialize_mutation_form(item.as_collection_mutation());
update(mview.tomb);
for (auto& entry : mview.cells) {
update(entry.second);
}
}
});
}
void update(const range_tombstone& rt) {
update(rt.tomb);
}
void update(const row_marker& marker) {
update_timestamp(marker.timestamp());
if (!marker.is_missing()) {
if (!marker.is_live()) {
min_local_deletion_time.update(marker.deletion_time().time_since_epoch().count());
} else if (marker.is_expiring()) {
min_ttl.update(marker.ttl().count());
min_local_deletion_time.update(marker.expiry().time_since_epoch().count());
}
}
}
void update(const schema& s, const deletable_row& dr) {
update(dr.marker());
update(dr.deleted_at().tomb());
update(s, dr.cells(), column_kind::regular_column);
}
void update(const schema& s, const mutation_partition& mp) {
update(s, mp.static_row(), column_kind::static_column);
for (auto&& row_entry : mp.clustered_rows()) {
update(s, row_entry.row());
}
for (auto&& rt : mp.row_tombstones()) {
update(rt);
}
}
encoding_stats get() const {
return { min_timestamp.get(), min_local_deletion_time.get(), min_ttl.get() };
}
} _stats_collector;
void update(db::rp_handle&&);
friend class row_cache;
friend class memtable_entry;
friend class flush_reader;
friend class flush_memory_accounter;
private:
boost::iterator_range<partitions_type::const_iterator> slice(const dht::partition_range& r) const;
partition_entry& find_or_create_partition(const dht::decorated_key& key);
partition_entry& find_or_create_partition_slow(partition_key_view key);
void upgrade_entry(memtable_entry&);
void add_flushed_memory(uint64_t);
void remove_flushed_memory(uint64_t);
void clear() noexcept;
uint64_t dirty_size() const;
public:
explicit memtable(schema_ptr schema, dirty_memory_manager&, memtable_list *memtable_list = nullptr);
// Used for testing that want to control the flush process.
explicit memtable(schema_ptr schema);
~memtable();
// Clears this memtable gradually without consuming the whole CPU.
// Never resolves with a failed future.
future<> clear_gently() noexcept;
schema_ptr schema() const { return _schema; }
void set_schema(schema_ptr) noexcept;
future<> apply(memtable&);
// Applies mutation to this memtable.
// The mutation is upgraded to current schema.
void apply(const mutation& m, db::rp_handle&& = {});
// The mutation is upgraded to current schema.
void apply(const frozen_mutation& m, const schema_ptr& m_schema, db::rp_handle&& = {});
static memtable& from_region(logalloc::region& r) {
return static_cast<memtable&>(r);
}
const logalloc::region& region() const {
return *this;
}
logalloc::region& region() {
return *this;
}
logalloc::region_group* region_group() {
return group();
}
encoding_stats get_stats() const {
return _stats_collector.get();
}
public:
memtable_list* get_memtable_list() {
return _memtable_list;
}
size_t partition_count() const;
logalloc::occupancy_stats occupancy() const;
// Creates a reader of data in this memtable for given partition range.
//
// Live readers share ownership of the memtable instance, so caller
// doesn't need to ensure that memtable remains live.
//
// The 'range' parameter must be live as long as the reader is being used
//
// Mutations returned by the reader will all have given schema.
flat_mutation_reader make_flat_reader(schema_ptr,
const dht::partition_range& range,
const query::partition_slice& slice,
const io_priority_class& pc = default_priority_class(),
tracing::trace_state_ptr trace_state_ptr = nullptr,
streamed_mutation::forwarding fwd = streamed_mutation::forwarding::no,
mutation_reader::forwarding fwd_mr = mutation_reader::forwarding::yes);
flat_mutation_reader make_flat_reader(schema_ptr s,
const dht::partition_range& range = query::full_partition_range) {
auto& full_slice = s->full_slice();
return make_flat_reader(s, range, full_slice);
}
flat_mutation_reader make_flush_reader(schema_ptr, const io_priority_class& pc);
mutation_source as_data_source();
bool empty() const { return partitions.empty(); }
void mark_flushed(mutation_source) noexcept;
bool is_flushed() const;
void on_detach_from_region_group() noexcept;
void revert_flushed_memory() noexcept;
const db::replay_position& replay_position() const {
return _replay_position;
}
const db::rp_set& rp_set() const {
return _rp_set;
}
friend class iterator_reader;
dirty_memory_manager& get_dirty_memory_manager() {
return _dirty_mgr;
}
friend std::ostream& operator<<(std::ostream&, memtable&);
};
<commit_msg>memtable: Collect statistics from partition-level tombstone.<commit_after>/*
* Copyright (C) 2015 ScyllaDB
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <map>
#include <memory>
#include <iosfwd>
#include "database_fwd.hh"
#include "dht/i_partitioner.hh"
#include "schema.hh"
#include "encoding_stats.hh"
#include "mutation_reader.hh"
#include "db/commitlog/replay_position.hh"
#include "db/commitlog/rp_set.hh"
#include "utils/extremum_tracking.hh"
#include "utils/logalloc.hh"
#include "partition_version.hh"
#include "flat_mutation_reader.hh"
class frozen_mutation;
namespace bi = boost::intrusive;
class memtable_entry {
bi::set_member_hook<> _link;
schema_ptr _schema;
dht::decorated_key _key;
partition_entry _pe;
public:
friend class memtable;
memtable_entry(schema_ptr s, dht::decorated_key key, mutation_partition p)
: _schema(std::move(s))
, _key(std::move(key))
, _pe(std::move(p))
{ }
memtable_entry(memtable_entry&& o) noexcept;
const dht::decorated_key& key() const { return _key; }
dht::decorated_key& key() { return _key; }
const partition_entry& partition() const { return _pe; }
partition_entry& partition() { return _pe; }
const schema_ptr& schema() const { return _schema; }
schema_ptr& schema() { return _schema; }
lw_shared_ptr<partition_snapshot> snapshot(memtable& mtbl);
size_t external_memory_usage_without_rows() const {
return _key.key().external_memory_usage();
}
size_t size_in_allocator_without_rows(allocation_strategy& allocator) {
return allocator.object_memory_size_in_allocator(this) + external_memory_usage_without_rows();
}
size_t size_in_allocator(allocation_strategy& allocator) {
auto size = size_in_allocator_without_rows(allocator);
for (auto&& v : _pe.versions()) {
size += v.size_in_allocator(allocator);
}
return size;
}
struct compare {
dht::decorated_key::less_comparator _c;
compare(schema_ptr s)
: _c(std::move(s))
{}
bool operator()(const dht::decorated_key& k1, const memtable_entry& k2) const {
return _c(k1, k2._key);
}
bool operator()(const memtable_entry& k1, const memtable_entry& k2) const {
return _c(k1._key, k2._key);
}
bool operator()(const memtable_entry& k1, const dht::decorated_key& k2) const {
return _c(k1._key, k2);
}
bool operator()(const memtable_entry& k1, const dht::ring_position& k2) const {
return _c(k1._key, k2);
}
bool operator()(const dht::ring_position& k1, const memtable_entry& k2) const {
return _c(k1, k2._key);
}
};
friend std::ostream& operator<<(std::ostream&, const memtable_entry&);
};
class dirty_memory_manager;
// Managed by lw_shared_ptr<>.
class memtable final : public enable_lw_shared_from_this<memtable>, private logalloc::region {
public:
using partitions_type = bi::set<memtable_entry,
bi::member_hook<memtable_entry, bi::set_member_hook<>, &memtable_entry::_link>,
bi::compare<memtable_entry::compare>>;
private:
dirty_memory_manager& _dirty_mgr;
memtable_list *_memtable_list;
schema_ptr _schema;
logalloc::allocating_section _read_section;
logalloc::allocating_section _allocating_section;
partitions_type partitions;
db::replay_position _replay_position;
db::rp_set _rp_set;
// mutation source to which reads fall-back after mark_flushed()
// so that memtable contents can be moved away while there are
// still active readers. This is needed for this mutation_source
// to be monotonic (not loose writes). Monotonicity of each
// mutation_source is necessary for the combined mutation source to be
// monotonic. That combined source in this case is cache + memtable.
mutation_source_opt _underlying;
uint64_t _flushed_memory = 0;
class encoding_stats_collector {
private:
min_tracker<api::timestamp_type> min_timestamp;
min_tracker<uint32_t> min_local_deletion_time;
min_tracker<uint32_t> min_ttl;
void update_timestamp(api::timestamp_type ts) {
if (ts != api::missing_timestamp) {
min_timestamp.update(ts);
}
}
public:
encoding_stats_collector()
: min_timestamp(encoding_stats::timestamp_epoch)
, min_local_deletion_time(encoding_stats::deletion_time_epoch)
, min_ttl(encoding_stats::ttl_epoch)
{}
void update(atomic_cell_view cell) {
update_timestamp(cell.timestamp());
if (cell.is_live_and_has_ttl()) {
min_ttl.update(cell.ttl().count());
min_local_deletion_time.update(cell.expiry().time_since_epoch().count());
} else if (!cell.is_live()) {
min_local_deletion_time.update(cell.deletion_time().time_since_epoch().count());
}
}
void update(tombstone tomb) {
if (tomb) {
update_timestamp(tomb.timestamp);
min_local_deletion_time.update(tomb.deletion_time.time_since_epoch().count());
}
}
void update(const schema& s, const row& r, column_kind kind) {
r.for_each_cell([this, &s, kind](column_id id, const atomic_cell_or_collection& item) {
auto& col = s.column_at(kind, id);
if (col.is_atomic()) {
update(item.as_atomic_cell());
} else {
auto mview = collection_type_impl::deserialize_mutation_form(item.as_collection_mutation());
update(mview.tomb);
for (auto& entry : mview.cells) {
update(entry.second);
}
}
});
}
void update(const range_tombstone& rt) {
update(rt.tomb);
}
void update(const row_marker& marker) {
update_timestamp(marker.timestamp());
if (!marker.is_missing()) {
if (!marker.is_live()) {
min_local_deletion_time.update(marker.deletion_time().time_since_epoch().count());
} else if (marker.is_expiring()) {
min_ttl.update(marker.ttl().count());
min_local_deletion_time.update(marker.expiry().time_since_epoch().count());
}
}
}
void update(const schema& s, const deletable_row& dr) {
update(dr.marker());
update(dr.deleted_at().tomb());
update(s, dr.cells(), column_kind::regular_column);
}
void update(const schema& s, const mutation_partition& mp) {
update(mp.partition_tombstone());
update(s, mp.static_row(), column_kind::static_column);
for (auto&& row_entry : mp.clustered_rows()) {
update(s, row_entry.row());
}
for (auto&& rt : mp.row_tombstones()) {
update(rt);
}
}
encoding_stats get() const {
return { min_timestamp.get(), min_local_deletion_time.get(), min_ttl.get() };
}
} _stats_collector;
void update(db::rp_handle&&);
friend class row_cache;
friend class memtable_entry;
friend class flush_reader;
friend class flush_memory_accounter;
private:
boost::iterator_range<partitions_type::const_iterator> slice(const dht::partition_range& r) const;
partition_entry& find_or_create_partition(const dht::decorated_key& key);
partition_entry& find_or_create_partition_slow(partition_key_view key);
void upgrade_entry(memtable_entry&);
void add_flushed_memory(uint64_t);
void remove_flushed_memory(uint64_t);
void clear() noexcept;
uint64_t dirty_size() const;
public:
explicit memtable(schema_ptr schema, dirty_memory_manager&, memtable_list *memtable_list = nullptr);
// Used for testing that want to control the flush process.
explicit memtable(schema_ptr schema);
~memtable();
// Clears this memtable gradually without consuming the whole CPU.
// Never resolves with a failed future.
future<> clear_gently() noexcept;
schema_ptr schema() const { return _schema; }
void set_schema(schema_ptr) noexcept;
future<> apply(memtable&);
// Applies mutation to this memtable.
// The mutation is upgraded to current schema.
void apply(const mutation& m, db::rp_handle&& = {});
// The mutation is upgraded to current schema.
void apply(const frozen_mutation& m, const schema_ptr& m_schema, db::rp_handle&& = {});
static memtable& from_region(logalloc::region& r) {
return static_cast<memtable&>(r);
}
const logalloc::region& region() const {
return *this;
}
logalloc::region& region() {
return *this;
}
logalloc::region_group* region_group() {
return group();
}
encoding_stats get_stats() const {
return _stats_collector.get();
}
public:
memtable_list* get_memtable_list() {
return _memtable_list;
}
size_t partition_count() const;
logalloc::occupancy_stats occupancy() const;
// Creates a reader of data in this memtable for given partition range.
//
// Live readers share ownership of the memtable instance, so caller
// doesn't need to ensure that memtable remains live.
//
// The 'range' parameter must be live as long as the reader is being used
//
// Mutations returned by the reader will all have given schema.
flat_mutation_reader make_flat_reader(schema_ptr,
const dht::partition_range& range,
const query::partition_slice& slice,
const io_priority_class& pc = default_priority_class(),
tracing::trace_state_ptr trace_state_ptr = nullptr,
streamed_mutation::forwarding fwd = streamed_mutation::forwarding::no,
mutation_reader::forwarding fwd_mr = mutation_reader::forwarding::yes);
flat_mutation_reader make_flat_reader(schema_ptr s,
const dht::partition_range& range = query::full_partition_range) {
auto& full_slice = s->full_slice();
return make_flat_reader(s, range, full_slice);
}
flat_mutation_reader make_flush_reader(schema_ptr, const io_priority_class& pc);
mutation_source as_data_source();
bool empty() const { return partitions.empty(); }
void mark_flushed(mutation_source) noexcept;
bool is_flushed() const;
void on_detach_from_region_group() noexcept;
void revert_flushed_memory() noexcept;
const db::replay_position& replay_position() const {
return _replay_position;
}
const db::rp_set& rp_set() const {
return _rp_set;
}
friend class iterator_reader;
dirty_memory_manager& get_dirty_memory_manager() {
return _dirty_mgr;
}
friend std::ostream& operator<<(std::ostream&, memtable&);
};
<|endoftext|>
|
<commit_before>#pragma once
#ifndef STACKALLOCATOR_HPP
# define STACKALLOCATOR_HPP
#include <cassert>
#include <cstddef>
#include <functional>
#include <new>
#include <utility>
namespace generic
{
template <std::size_t N>
class stack_store
{
public:
stack_store() = default;
stack_store(stack_store const&) = delete;
stack_store& operator=(stack_store const&) = delete;
char* allocate(std::size_t n)
{
assert(pointer_in_buffer(ptr_) &&
"stack_allocator has outlived stack_store");
n = align(n);
if (buf_ + N >= ptr_ + n)
{
auto r(ptr_);
ptr_ += n;
return r;
}
else
{
return static_cast<char*>(::operator new(n));
}
}
void deallocate(char* const p, std::size_t n) noexcept
{
assert(pointer_in_buffer(ptr_) &&
"stack_allocator has outlived stack_store");
if (pointer_in_buffer(p))
{
n = align(n);
if (p + n == ptr_)
{
ptr_ = p;
}
// else do nothing
}
else
{
::operator delete(p);
}
}
void reset() noexcept { ptr_ = buf_; }
static constexpr ::std::size_t size() noexcept { return N; }
::std::size_t used() const noexcept { return ::std::size_t(ptr_ - buf_); }
private:
static constexpr ::std::size_t align(::std::size_t const n) noexcept
{
return (n + (alignment - 1)) & -alignment;
}
bool pointer_in_buffer(char* const p) noexcept
{
return (buf_ <= p) && (p <= buf_ + N);
}
private:
static constexpr auto const alignment = alignof(::max_align_t);
char* ptr_{buf_};
alignas(::max_align_t) char buf_[N];
};
template <class T, std::size_t N>
class stack_allocator
{
public:
using store_type = stack_store<N>;
using size_type = ::std::size_t;
using difference_type = ::std::ptrdiff_t;
using pointer = T*;
using const_pointer = T const*;
using reference = T&;
using const_reference = T const&;
using value_type = T;
template <class U> struct rebind { using other = stack_allocator<U, N>; };
stack_allocator() = default;
stack_allocator(stack_store<N>& s) noexcept : store_(&s) { }
template <class U>
stack_allocator(stack_allocator<U, N> const& other) noexcept :
store_(other.store_)
{
}
stack_allocator& operator=(stack_allocator const&) = delete;
T* allocate(::std::size_t const n)
{
return static_cast<T*>(static_cast<void*>(
store_->allocate(n * sizeof(T))));
}
void deallocate(T* const p, ::std::size_t const n) noexcept
{
store_->deallocate(static_cast<char*>(static_cast<void*>(p)),
n * sizeof(T));
}
template <class U, class ...A>
void construct(U* const p, A&& ...args)
{
new (p) U(::std::forward<A>(args)...);
}
template <class U>
void destroy(U* const p)
{
p->~U();
}
template <class U, std::size_t M>
inline bool operator==(stack_allocator<U, M> const& rhs) const noexcept
{
return store_ == rhs.store_;
}
template <class U, std::size_t M>
inline bool operator!=(stack_allocator<U, M> const& rhs) const noexcept
{
return !(*this == rhs);
}
private:
template <class U, std::size_t M> friend class stack_allocator;
store_type* store_{};
};
}
namespace std
{
// map
template<class Key, class T, class Compare, class Allocator> class map;
// string
template<class CharT> class char_traits;
template<class CharT, class Traits, class Allocator> class basic_string;
// unordered_map
template<class Key, class T, class Hash, class Pred, class Alloc>
class unordered_map;
// vector
template <class T, class Alloc> class vector;
}
template <class Key, class T, class Compare = ::std::less<Key> >
using stack_map = ::std::map<Key, T, Compare,
::generic::stack_allocator<::std::pair<Key const, T>, 256> >;
using stack_string = ::std::basic_string<char, ::std::char_traits<char>,
::generic::stack_allocator<char, 128> >;
template <class Key, class T, class Hash = ::std::hash<Key>,
class Pred = ::std::equal_to<Key> >
using stack_unordered_map = ::std::unordered_map<Key, T, Hash, Pred,
::generic::stack_allocator<::std::pair<Key const, T>, 256> >;
template <typename T>
using ::generic::stack_vector = ::std::vector<T, stack_allocator<T, 256> >;
#endif // STACKALLOCATOR_HPP
<commit_msg>some fixes<commit_after>#pragma once
#ifndef STACKALLOCATOR_HPP
# define STACKALLOCATOR_HPP
#include <cassert>
#include <cstddef>
#include <functional>
#include <new>
#include <utility>
namespace generic
{
template <std::size_t N>
class stack_store
{
public:
stack_store() = default;
stack_store(stack_store const&) = delete;
stack_store& operator=(stack_store const&) = delete;
char* allocate(std::size_t n)
{
assert(pointer_in_buffer(ptr_) &&
"stack_allocator has outlived stack_store");
n = align(n);
if (buf_ + N >= ptr_ + n)
{
auto r(ptr_);
ptr_ += n;
return r;
}
else
{
return static_cast<char*>(::operator new(n));
}
}
void deallocate(char* const p, std::size_t n) noexcept
{
assert(pointer_in_buffer(ptr_) &&
"stack_allocator has outlived stack_store");
if (pointer_in_buffer(p))
{
n = align(n);
if (p + n == ptr_)
{
ptr_ = p;
}
// else do nothing
}
else
{
::operator delete(p);
}
}
void reset() noexcept { ptr_ = buf_; }
static constexpr ::std::size_t size() noexcept { return N; }
::std::size_t used() const noexcept { return ::std::size_t(ptr_ - buf_); }
private:
static constexpr ::std::size_t align(::std::size_t const n) noexcept
{
return (n + (alignment - 1)) & -alignment;
}
bool pointer_in_buffer(char* const p) noexcept
{
return (buf_ <= p) && (p <= buf_ + N);
}
private:
static constexpr auto const alignment = alignof(::max_align_t);
char* ptr_{buf_};
alignas(::max_align_t) char buf_[N];
};
template <class T, std::size_t N>
class stack_allocator
{
public:
using store_type = stack_store<N>;
using size_type = ::std::size_t;
using difference_type = ::std::ptrdiff_t;
using pointer = T*;
using const_pointer = T const*;
using reference = T&;
using const_reference = T const&;
using value_type = T;
template <class U> struct rebind { using other = stack_allocator<U, N>; };
stack_allocator() = default;
stack_allocator(stack_store<N>& s) noexcept : store_(&s) { }
template <class U>
stack_allocator(stack_allocator<U, N> const& other) noexcept :
store_(other.store_)
{
}
stack_allocator& operator=(stack_allocator const&) = delete;
T* allocate(::std::size_t const n)
{
return static_cast<T*>(static_cast<void*>(
store_->allocate(n * sizeof(T))));
}
void deallocate(T* const p, ::std::size_t const n) noexcept
{
store_->deallocate(static_cast<char*>(static_cast<void*>(p)),
n * sizeof(T));
}
template <class U, class ...A>
void construct(U* const p, A&& ...args)
{
new (p) U(::std::forward<A>(args)...);
}
template <class U>
void destroy(U* const p)
{
p->~U();
}
template <class U, std::size_t M>
inline bool operator==(stack_allocator<U, M> const& rhs) const noexcept
{
return store_ == rhs.store_;
}
template <class U, std::size_t M>
inline bool operator!=(stack_allocator<U, M> const& rhs) const noexcept
{
return !(*this == rhs);
}
private:
template <class U, std::size_t M> friend class stack_allocator;
store_type* store_{};
};
}
namespace std
{
// map
template<class Key, class T, class Compare, class Allocator> class map;
// string
template<class CharT> class char_traits;
template<class CharT, class Traits, class Allocator> class basic_string;
// unordered_map
template<class Key, class T, class Hash, class Pred, class Alloc>
class unordered_map;
// vector
template <class T, class Alloc> class vector;
}
template <class Key, class T, class Compare = ::std::less<Key> >
using stack_map = ::std::map<Key, T, Compare,
::generic::stack_allocator<::std::pair<Key const, T>, 256> >;
using stack_string = ::std::basic_string<char, ::std::char_traits<char>,
::generic::stack_allocator<char, 128> >;
template <class Key, class T, class Hash = ::std::hash<Key>,
class Pred = ::std::equal_to<Key> >
using stack_unordered_map = ::std::unordered_map<Key, T, Hash, Pred,
::generic::stack_allocator<::std::pair<Key const, T>, 256> >;
template <typename T>
using stack_vector = ::std::vector<T, ::generic::stack_allocator<T, 256> >;
#endif // STACKALLOCATOR_HPP
<|endoftext|>
|
<commit_before>// Copyright (c) 2018 Chris Ohk, Youngjoong Kim, SeungHyun Jeon
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
#include "gtest/gtest.h"
#include <hspp/Cards/Cards.hpp>
#include <hspp/Models/Game.hpp>
#include <hspp/Tasks/SimpleTasks/DrawTask.hpp>
using namespace Hearthstonepp;
using namespace SimpleTasks;
TEST(DrawTask, GetTaskID)
{
const DrawTask draw(1);
EXPECT_EQ(draw.GetTaskID(), +TaskID::DRAW);
}
TEST(DrawTask, Run)
{
std::vector<Card> cards;
std::vector<Entity*> entities;
const auto Generate = [&](std::string&& id) -> Entity* {
cards.emplace_back(Card());
Card card = cards.back();
card.id = std::move(id);
entities.emplace_back(new Entity(card));
return entities.back();
};
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
const std::string id = "card";
for (char i = '0'; i < '3'; ++i)
{
p.GetDeck().emplace_back(Generate(id + i));
}
DrawTask draw(3);
TaskStatus result = draw.Run(p);
EXPECT_EQ(result, TaskStatus::DRAW_SUCCESS);
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(3));
for (size_t i = 0; i < 3; ++i)
{
EXPECT_EQ(p.GetHand()[i]->card->id,
id + static_cast<char>(2 - i + 0x30));
}
}
TEST(DrawTask, RunExhaust)
{
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
DrawTask draw(3);
TaskStatus result = draw.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_EXHAUST);
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetNumCardAfterExhaust(), 3);
// Health: 30 - (1 + 2 + 3)
EXPECT_EQ(p.GetHero()->health, static_cast<size_t>(24));
Card card;
card.id = "card1";
auto entity = new Entity(card);
p.GetDeck().emplace_back(entity);
result = draw.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_EXHAUST);
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(1));
EXPECT_EQ(p.GetHand()[0]->card->id, "card1");
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetNumCardAfterExhaust(), 5);
// Health: 30 - (1 + 2 + 3 + 4 + 5)
EXPECT_EQ(p.GetHero()->health, static_cast<size_t>(15));
}
TEST(DrawTask, RunOverDraw)
{
std::vector<Card> cards;
std::vector<Entity*> entities;
const auto Generate = [&](std::string&& id) -> Entity* {
cards.emplace_back(Card());
Card card = cards.back();
card.id = std::move(id);
entities.emplace_back(new Entity(card));
return entities.back();
};
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
const std::string id = "card";
for (char i = '0'; i < '3'; ++i)
{
p.GetDeck().emplace_back(Generate(id + i));
}
p.GetHand().resize(10);
DrawTask draw(3);
TaskStatus result = draw.Run(p);
EXPECT_EQ(result, TaskStatus::DRAW_OVERDRAW);
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(10));
// TaskMeta burnt;
// game.GetTaskMeta(burnt);
// EXPECT_EQ(burnt.GetID(), +TaskID::OVERDRAW);
// EXPECT_EQ(burnt.GetStatus(), TaskStatus::DRAW_OVERDRAW);
// EXPECT_EQ(burnt.GetUserID(), p.GetID());
// auto burntCard =
// TaskMeta::ConvertTo<FlatData::EntityVector>(burnt)->vector();
// EXPECT_EQ(burntCard->size(), static_cast<flatbuffers::uoffset_t>(3));
// for (flatbuffers::uoffset_t i = 0; i < 3; ++i)
// {
// auto card = burntCard->Get(i)->card();
// EXPECT_EQ(card->id()->str(), id + static_cast<char>(2 - i + 0x30));
// }
}
TEST(DrawTask, RunExhaustOverdraw)
{
std::vector<Card> cards;
std::vector<Entity*> entities;
const auto Generate = [&](std::string&& id) -> Entity* {
cards.emplace_back(Card());
Card card = cards.back();
card.id = std::move(id);
entities.emplace_back(new Entity(card));
return entities.back();
};
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
const std::string id = "card";
for (char i = '0'; i < '3'; ++i)
{
p.GetDeck().emplace_back(Generate(id + i));
}
p.GetHand().resize(9);
DrawTask draw(4);
TaskStatus result = draw.Run(p);
EXPECT_EQ(result, TaskStatus::DRAW_EXHAUST_OVERDRAW);
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(10));
EXPECT_EQ(p.GetHand()[9]->card->id, "card0");
// TaskMeta burnt;
// agent.GetTaskMeta(burnt);
// EXPECT_EQ(burnt.GetID(), +TaskID::OVERDRAW);
// EXPECT_EQ(burnt.GetStatus(), TaskStatus::DRAW_EXHAUST_OVERDRAW);
// EXPECT_EQ(burnt.GetUserID(), p.GetID());
// auto burntCard =
// TaskMeta::ConvertTo<FlatData::EntityVector>(burnt)->vector();
// EXPECT_EQ(burntCard->size(), static_cast<flatbuffers::uoffset_t>(2));
// for (flatbuffers::uoffset_t i = 0; i < 2; ++i)
// {
// auto card = burntCard->Get(i)->card();
// EXPECT_EQ(card->id()->str(), id + static_cast<char>(2 - i + 0x30));
// }
}
TEST(DrawCardTask, GetTaskID)
{
const Card card{};
const DrawCardTask draw(card);
EXPECT_EQ(draw.GetTaskID(), +TaskID::DRAW);
}
TEST(DrawCardTask, Run)
{
Cards& instance = Cards::GetInstance();
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Card nerubian = instance.FindCardByID("AT_036t");
EXPECT_NE(nerubian.id, "");
EXPECT_EQ(nerubian.name, "Nerubian");
Card poisonedBlade = instance.FindCardByID("AT_034");
EXPECT_NE(poisonedBlade.id, "");
EXPECT_EQ(poisonedBlade.name, "Poisoned Blade");
auto minionNerubian = new Entity(nerubian);
auto weaponPoisonedBlade = new Entity(poisonedBlade);
game.GetPlayer1().GetDeck().emplace_back(weaponPoisonedBlade);
game.GetPlayer1().GetDeck().emplace_back(minionNerubian);
DrawCardTask drawNerubian(nerubian);
TaskStatus result = drawNerubian.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_SUCCESS);
EXPECT_EQ(game.GetPlayer1().GetHand().size(), static_cast<size_t>(1));
EXPECT_EQ(game.GetPlayer1().GetHand()[0]->card->id, nerubian.id);
EXPECT_EQ(game.GetPlayer1().GetDeck().size(), static_cast<size_t>(1));
EXPECT_EQ(game.GetPlayer1().GetDeck()[0]->card->id, poisonedBlade.id);
DrawCardTask drawPoisonedBlade(poisonedBlade);
result = drawPoisonedBlade.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_SUCCESS);
EXPECT_EQ(game.GetPlayer1().GetHand().size(), static_cast<size_t>(2));
EXPECT_EQ(game.GetPlayer1().GetHand()[1]->card->id, poisonedBlade.id);
EXPECT_EQ(game.GetPlayer1().GetDeck().size(), static_cast<size_t>(0));
delete minionNerubian;
delete weaponPoisonedBlade;
}
<commit_msg>feat(DrawTaskTests): Implement overdraw tests<commit_after>// Copyright (c) 2018 Chris Ohk, Youngjoong Kim, SeungHyun Jeon
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
#include "gtest/gtest.h"
#include <hspp/Cards/Cards.hpp>
#include <hspp/Commons/Utils.hpp>
#include <hspp/Models/Game.hpp>
#include <hspp/Policy/BasicPolicy.hpp>
#include <hspp/Tasks/SimpleTasks/DrawTask.hpp>
using namespace Hearthstonepp;
using namespace SimpleTasks;
class DrawTestPolicy : public BasicPolicy
{
public:
DrawTestPolicy(std::function<void(const TaskMeta&)>&& overdrawHandler)
: m_overdrawHandler(std::move(overdrawHandler))
{
}
void NotifyOverDraw(const TaskMeta& meta) override
{
m_overdrawHandler(meta);
}
private:
std::function<void(const TaskMeta&)> m_overdrawHandler;
};
TEST(DrawTask, GetTaskID)
{
const DrawTask draw(1);
EXPECT_EQ(draw.GetTaskID(), +TaskID::DRAW);
}
TEST(DrawTask, Run)
{
std::vector<Card> cards;
std::vector<Entity*> entities;
const auto Generate = [&](std::string&& id) -> Entity* {
cards.emplace_back(Card());
Card card = cards.back();
card.id = std::move(id);
entities.emplace_back(new Entity(card));
return entities.back();
};
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
const std::string id = "card";
for (char i = '0'; i < '3'; ++i)
{
p.GetDeck().emplace_back(Generate(id + i));
}
DrawTask draw(3);
TaskStatus result = draw.Run(p);
EXPECT_EQ(result, TaskStatus::DRAW_SUCCESS);
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(3));
for (size_t i = 0; i < 3; ++i)
{
EXPECT_EQ(p.GetHand()[i]->card->id,
id + static_cast<char>(2 - i + 0x30));
}
}
TEST(DrawTask, RunExhaust)
{
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
DrawTask draw(3);
TaskStatus result = draw.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_EXHAUST);
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetNumCardAfterExhaust(), 3);
// Health: 30 - (1 + 2 + 3)
EXPECT_EQ(p.GetHero()->health, static_cast<size_t>(24));
Card card;
card.id = "card1";
auto entity = new Entity(card);
p.GetDeck().emplace_back(entity);
result = draw.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_EXHAUST);
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(1));
EXPECT_EQ(p.GetHand()[0]->card->id, "card1");
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetNumCardAfterExhaust(), 5);
// Health: 30 - (1 + 2 + 3 + 4 + 5)
EXPECT_EQ(p.GetHero()->health, static_cast<size_t>(15));
}
TEST(DrawTask, RunOverDraw)
{
std::vector<Card> cards;
std::vector<Entity*> entities;
const auto Generate = [&](std::string&& id) -> Entity* {
cards.emplace_back(Card());
Card card = cards.back();
card.id = std::move(id);
entities.emplace_back(new Entity(card));
return entities.back();
};
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
const std::string id = "card";
for (char i = '0'; i < '3'; ++i)
{
p.GetDeck().emplace_back(Generate(id + i));
}
p.GetHand().resize(10);
DrawTask draw(3);
DrawTestPolicy policy([&](const TaskMeta& burnt) {
EXPECT_EQ(burnt.GetID(), +TaskID::OVERDRAW);
EXPECT_EQ(burnt.GetStatus(), TaskStatus::DRAW_OVERDRAW);
EXPECT_EQ(burnt.GetUserID(), p.GetID());
EXPECT_TRUE(burnt.HasObjects());
const Box<Entity*>& entities = burnt.GetObject<Box<Entity*>>();
for (size_t i = 0; i < 3; ++i)
{
EXPECT_EQ(entities[i]->card->id,
id + static_cast<char>(2 - i + 0x30));
}
});
p.SetPolicy(&policy);
TaskStatus result = draw.Run(p);
EXPECT_EQ(result, TaskStatus::DRAW_OVERDRAW);
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(10));
}
TEST(DrawTask, RunExhaustOverdraw)
{
std::vector<Card> cards;
std::vector<Entity*> entities;
const auto Generate = [&](std::string&& id) -> Entity* {
cards.emplace_back(Card());
Card card = cards.back();
card.id = std::move(id);
entities.emplace_back(new Entity(card));
return entities.back();
};
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Player& p = game.GetPlayer1();
const std::string id = "card";
for (char i = '0'; i < '3'; ++i)
{
p.GetDeck().emplace_back(Generate(id + i));
}
p.GetHand().resize(9);
DrawTask draw(4);
DrawTestPolicy policy([&](const TaskMeta& burnt) {
EXPECT_EQ(burnt.GetID(), +TaskID::OVERDRAW);
EXPECT_EQ(burnt.GetStatus(), TaskStatus::DRAW_OVERDRAW);
EXPECT_EQ(burnt.GetUserID(), p.GetID());
EXPECT_TRUE(burnt.HasObjects());
const Box<Entity*>& entities = burnt.GetObject<Box<Entity*>>();
for (size_t i = 0; i < 2; ++i)
{
EXPECT_EQ(entities[i]->card->id,
id + static_cast<char>(2 - i + 0x30));
}
});
p.SetPolicy(&policy);
TaskStatus result = draw.Run(p);
EXPECT_EQ(result, TaskStatus::DRAW_EXHAUST_OVERDRAW);
EXPECT_EQ(p.GetDeck().size(), static_cast<size_t>(0));
EXPECT_EQ(p.GetHand().size(), static_cast<size_t>(10));
EXPECT_EQ(p.GetHand()[9]->card->id, "card0");
}
TEST(DrawCardTask, GetTaskID)
{
const Card card{};
const DrawCardTask draw(card);
EXPECT_EQ(draw.GetTaskID(), +TaskID::DRAW);
}
TEST(DrawCardTask, Run)
{
Cards& instance = Cards::GetInstance();
Game game(CardClass::ROGUE, CardClass::DRUID, PlayerType::PLAYER1);
Card nerubian = instance.FindCardByID("AT_036t");
EXPECT_NE(nerubian.id, "");
EXPECT_EQ(nerubian.name, "Nerubian");
Card poisonedBlade = instance.FindCardByID("AT_034");
EXPECT_NE(poisonedBlade.id, "");
EXPECT_EQ(poisonedBlade.name, "Poisoned Blade");
auto minionNerubian = new Entity(nerubian);
auto weaponPoisonedBlade = new Entity(poisonedBlade);
game.GetPlayer1().GetDeck().emplace_back(weaponPoisonedBlade);
game.GetPlayer1().GetDeck().emplace_back(minionNerubian);
DrawCardTask drawNerubian(nerubian);
TaskStatus result = drawNerubian.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_SUCCESS);
EXPECT_EQ(game.GetPlayer1().GetHand().size(), static_cast<size_t>(1));
EXPECT_EQ(game.GetPlayer1().GetHand()[0]->card->id, nerubian.id);
EXPECT_EQ(game.GetPlayer1().GetDeck().size(), static_cast<size_t>(1));
EXPECT_EQ(game.GetPlayer1().GetDeck()[0]->card->id, poisonedBlade.id);
DrawCardTask drawPoisonedBlade(poisonedBlade);
result = drawPoisonedBlade.Run(game.GetPlayer1());
EXPECT_EQ(result, TaskStatus::DRAW_SUCCESS);
EXPECT_EQ(game.GetPlayer1().GetHand().size(), static_cast<size_t>(2));
EXPECT_EQ(game.GetPlayer1().GetHand()[1]->card->id, poisonedBlade.id);
EXPECT_EQ(game.GetPlayer1().GetDeck().size(), static_cast<size_t>(0));
delete minionNerubian;
delete weaponPoisonedBlade;
}
<|endoftext|>
|
<commit_before>/*
* Copyright (C) 2004-2012 See the AUTHORS file for details.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published
* by the Free Software Foundation.
*/
#include <znc/znc.h>
#include <znc/IRCNetwork.h>
#include <znc/IRCSock.h>
struct reply {
const char *szReply;
bool bLastResponse;
};
// TODO this list is far from complete, no errors are handled
static const struct {
const char *szRequest;
struct reply vReplies[10];
} vRouteReplies[] = {
{"WHO", {
{"352", false},
{"354", false}, // e.g. Quaknet uses this for WHO #chan %n
{"403", true}, // No such chan
{"315", true},
{NULL, true}
}},
{"LIST", {
{"321", false},
{"322", false},
{"323", true},
{NULL, true}
}},
{"NAMES", {
{"353", false},
{"366", true},
// No such nick/channel
{"401", true},
{NULL, true},
}},
{"LUSERS", {
{"251", false},
{"252", false},
{"253", false},
{"254", false},
{"255", false},
{"265", false},
{"266", true},
// We don't handle 250 here since some IRCds don't sent it
//{"250", true},
{NULL, true}
}},
{"WHOIS", {
{"311", false},
{"319", false},
{"312", false},
// "<ip> :actually using host"
{"338", false},
{"318", true},
// No such nick/channel
{"401", true},
// No such server
{"402", true},
{NULL, true}
}},
{"PING", {
{"PONG", true},
{NULL, true}
}},
{"USERHOST", {
{"302", true},
{NULL, true}
}},
{"TIME", {
{"391", true},
{NULL, true}
}},
{"WHOWAS", {
{"312", false},
{"314", false},
{"369", true},
{NULL, true}
}},
{"ISON", {
{"303", true},
{NULL, true}
}},
{"LINKS", {
{"364", false},
{"365", true},
{NULL, true}
}},
{"MAP", {
{"006", false},
// inspircd
{"270", false},
// SilverLeo wants this two added
{"015", false},
{"017", true},
{"007", true},
{NULL, true}
}},
{"TRACE", {
{"200", false},
{"205", false},
{"262", true},
{NULL, true}
}},
{"USERS", {
{"265", false},
{"266", true},
{NULL, true},
}},
// This is just a list of all possible /mode replies stuffed together.
// Since there should never be more than one of these going on, this
// should work fine and makes the code simpler.
{"MODE", {
// "You're not a channel operator"
{"482", true},
// MODE I
{"346", false},
{"347", true},
// MODE b
{"367", false},
{"368", true},
// MODE e
{"348", false},
{"349", true},
{NULL, true},
}},
// END (last item!)
{NULL, {{NULL, true}}}
};
class CRouteTimeout : public CTimer {
public:
CRouteTimeout(CModule* pModule, unsigned int uInterval, unsigned int uCycles,
const CString& sLabel, const CString& sDescription)
: CTimer(pModule, uInterval, uCycles, sLabel, sDescription) {}
virtual ~CRouteTimeout() {}
protected:
virtual void RunJob();
};
struct queued_req {
CString sLine;
const struct reply *reply;
};
typedef std::map<CClient *, std::vector<struct queued_req> > requestQueue;
class CRouteRepliesMod : public CModule
{
public:
MODCONSTRUCTOR(CRouteRepliesMod)
{
m_pDoing = NULL;
m_pReplies = NULL;
}
virtual ~CRouteRepliesMod() {
requestQueue::iterator it;
while (!m_vsPending.empty()) {
it = m_vsPending.begin();
while (!it->second.empty()) {
PutIRC(it->second[0].sLine);
it->second.erase(it->second.begin());
}
m_vsPending.erase(it);
}
}
virtual void OnIRCConnected()
{
m_pDoing = NULL;
m_pReplies = NULL;
m_vsPending.clear();
// No way we get a reply, so stop the timer (If it's running)
RemTimer("RouteTimeout");
}
virtual void OnIRCDisconnected()
{
OnIRCConnected(); // Let's keep it in one place
}
virtual void OnClientDisconnect()
{
requestQueue::iterator it;
if (m_pClient == m_pDoing) {
// The replies which aren't received yet will be
// broadcasted to everyone, but at least nothing breaks
RemTimer("RouteTimeout");
m_pDoing = NULL;
m_pReplies = NULL;
}
it = m_vsPending.find(m_pClient);
if (it != m_vsPending.end())
m_vsPending.erase(it);
SendRequest();
}
virtual EModRet OnRaw(CString& sLine)
{
CString sCmd = sLine.Token(1).AsUpper();
size_t i = 0;
if (!m_pReplies)
return CONTINUE;
// Is this a "not enough arguments" error?
if (sCmd == "461") {
// :server 461 nick WHO :Not enough parameters
CString sOrigCmd = sLine.Token(3);
if (m_sLastRequest.Token(0).Equals(sOrigCmd)) {
// This is the reply to the last request
if (RouteReply(sLine, true))
return HALTCORE;
return CONTINUE;
}
}
while (m_pReplies[i].szReply != NULL) {
if (m_pReplies[i].szReply == sCmd) {
if (RouteReply(sLine, m_pReplies[i].bLastResponse, sCmd == "353"))
return HALTCORE;
return CONTINUE;
}
i++;
}
// TODO HALTCORE is wrong, it should not be passed to
// the clients, but the core itself should still handle it!
return CONTINUE;
}
virtual EModRet OnUserRaw(CString& sLine)
{
CString sCmd = sLine.Token(0).AsUpper();
if (!m_pNetwork->GetIRCSock())
return CONTINUE;
if (sCmd.Equals("MODE")) {
// Check if this is a mode request that needs to be handled
// If there are arguments to a mode change,
// we must not route it.
if (!sLine.Token(3, true).empty())
return CONTINUE;
// Grab the mode change parameter
CString sMode = sLine.Token(2);
// If this is a channel mode request, znc core replies to it
if (sMode.empty())
return CONTINUE;
// Check if this is a mode change or a specific
// mode request (the later needs to be routed).
sMode.TrimPrefix("+");
if (sMode.length() != 1)
return CONTINUE;
// Now just check if it's one of the supported modes
switch (sMode[0]) {
case 'I':
case 'b':
case 'e':
break;
default:
return CONTINUE;
}
// Ok, this looks like we should route it.
// Fall through to the next loop
}
for (size_t i = 0; vRouteReplies[i].szRequest != NULL; i++) {
if (vRouteReplies[i].szRequest == sCmd) {
struct queued_req req = {
sLine, vRouteReplies[i].vReplies
};
m_vsPending[m_pClient].push_back(req);
SendRequest();
return HALTCORE;
}
}
return CONTINUE;
}
void Timeout()
{
// The timer will be deleted after this by the event loop
if (GetNV("silent_timeouts") != "yes") {
PutModule("This module hit a timeout which is possibly a bug.");
PutModule("To disable this message, do \"/msg " + GetModNick()
+ " silent yes\"");
PutModule("Last request: " + m_sLastRequest);
PutModule("Expected replies: ");
for (size_t i = 0; m_pReplies[i].szReply != NULL; i++) {
if (m_pReplies[i].bLastResponse)
PutModule(m_pReplies[i].szReply +
CString(" (last)"));
else
PutModule(m_pReplies[i].szReply);
}
}
m_pDoing = NULL;
m_pReplies = NULL;
SendRequest();
}
private:
bool RouteReply(const CString& sLine, bool bFinished = false, bool bIsRaw353 = false)
{
if (!m_pDoing)
return false;
// 353 needs special treatment due to NAMESX and UHNAMES
if (bIsRaw353)
m_pNetwork->GetIRCSock()->ForwardRaw353(sLine, m_pDoing);
else
m_pDoing->PutClient(sLine);
if (bFinished) {
// Stop the timeout
RemTimer("RouteTimeout");
m_pDoing = NULL;
m_pReplies = NULL;
SendRequest();
}
return true;
}
void SendRequest()
{
requestQueue::iterator it;
if (m_pDoing || m_pReplies)
return;
if (m_vsPending.empty())
return;
it = m_vsPending.begin();
if (it->second.empty()) {
m_vsPending.erase(it);
SendRequest();
return;
}
// When we are called from the timer, we need to remove it.
// We can't delete it (segfault on return), thus we
// just stop it. The main loop will delete it.
CTimer *pTimer = FindTimer("RouteTimeout");
if (pTimer) {
pTimer->Stop();
UnlinkTimer(pTimer);
}
AddTimer(new CRouteTimeout(this, 60, 1, "RouteTimeout",
"Recover from missing / wrong server replies"));
m_pDoing = it->first;
m_pReplies = it->second[0].reply;
m_sLastRequest = it->second[0].sLine;
PutIRC(it->second[0].sLine);
it->second.erase(it->second.begin());
}
virtual void OnModCommand(const CString& sCommand) {
const CString sCmd = sCommand.Token(0);
const CString sArgs = sCommand.Token(1, true);
if (sCmd.Equals("silent")) {
if (sArgs.Equals("yes")) {
SetNV("silent_timeouts", "yes");
PutModule("Disabled timeout messages");
} else if (sArgs.Equals("no")) {
DelNV("silent_timeouts");
PutModule("Enabled timeout messages");
} else if (sArgs.empty()) {
if (GetNV("silent_timeouts") == "yes")
PutModule("Timeout messages are disabled");
else
PutModule("Timeout message are enabled");
} else
PutModule("Invalid argument");
} else {
PutModule("Available commands: silent [yes/no], silent");
}
}
CClient *m_pDoing;
const struct reply *m_pReplies;
requestQueue m_vsPending;
// This field is only used for display purpose.
CString m_sLastRequest;
};
void CRouteTimeout::RunJob()
{
CRouteRepliesMod *pMod = (CRouteRepliesMod *) m_pModule;
pMod->Timeout();
}
template<> void TModInfo<CRouteRepliesMod>(CModInfo& Info) {
Info.SetWikiPage("route_replies");
}
NETWORKMODULEDEFS(CRouteRepliesMod, "Send replies (e.g. to /who) to the right client only")
<commit_msg>route_replies: Use CModCommand<commit_after>/*
* Copyright (C) 2004-2012 See the AUTHORS file for details.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published
* by the Free Software Foundation.
*/
#include <znc/znc.h>
#include <znc/IRCNetwork.h>
#include <znc/IRCSock.h>
struct reply {
const char *szReply;
bool bLastResponse;
};
// TODO this list is far from complete, no errors are handled
static const struct {
const char *szRequest;
struct reply vReplies[10];
} vRouteReplies[] = {
{"WHO", {
{"352", false},
{"354", false}, // e.g. Quaknet uses this for WHO #chan %n
{"403", true}, // No such chan
{"315", true},
{NULL, true}
}},
{"LIST", {
{"321", false},
{"322", false},
{"323", true},
{NULL, true}
}},
{"NAMES", {
{"353", false},
{"366", true},
// No such nick/channel
{"401", true},
{NULL, true},
}},
{"LUSERS", {
{"251", false},
{"252", false},
{"253", false},
{"254", false},
{"255", false},
{"265", false},
{"266", true},
// We don't handle 250 here since some IRCds don't sent it
//{"250", true},
{NULL, true}
}},
{"WHOIS", {
{"311", false},
{"319", false},
{"312", false},
// "<ip> :actually using host"
{"338", false},
{"318", true},
// No such nick/channel
{"401", true},
// No such server
{"402", true},
{NULL, true}
}},
{"PING", {
{"PONG", true},
{NULL, true}
}},
{"USERHOST", {
{"302", true},
{NULL, true}
}},
{"TIME", {
{"391", true},
{NULL, true}
}},
{"WHOWAS", {
{"312", false},
{"314", false},
{"369", true},
{NULL, true}
}},
{"ISON", {
{"303", true},
{NULL, true}
}},
{"LINKS", {
{"364", false},
{"365", true},
{NULL, true}
}},
{"MAP", {
{"006", false},
// inspircd
{"270", false},
// SilverLeo wants this two added
{"015", false},
{"017", true},
{"007", true},
{NULL, true}
}},
{"TRACE", {
{"200", false},
{"205", false},
{"262", true},
{NULL, true}
}},
{"USERS", {
{"265", false},
{"266", true},
{NULL, true},
}},
// This is just a list of all possible /mode replies stuffed together.
// Since there should never be more than one of these going on, this
// should work fine and makes the code simpler.
{"MODE", {
// "You're not a channel operator"
{"482", true},
// MODE I
{"346", false},
{"347", true},
// MODE b
{"367", false},
{"368", true},
// MODE e
{"348", false},
{"349", true},
{NULL, true},
}},
// END (last item!)
{NULL, {{NULL, true}}}
};
class CRouteTimeout : public CTimer {
public:
CRouteTimeout(CModule* pModule, unsigned int uInterval, unsigned int uCycles,
const CString& sLabel, const CString& sDescription)
: CTimer(pModule, uInterval, uCycles, sLabel, sDescription) {}
virtual ~CRouteTimeout() {}
protected:
virtual void RunJob();
};
struct queued_req {
CString sLine;
const struct reply *reply;
};
typedef std::map<CClient *, std::vector<struct queued_req> > requestQueue;
class CRouteRepliesMod : public CModule
{
public:
MODCONSTRUCTOR(CRouteRepliesMod)
{
m_pDoing = NULL;
m_pReplies = NULL;
AddHelpCommand();
AddCommand("Silent", static_cast<CModCommand::ModCmdFunc>(&CRouteRepliesMod::SilentCommand),
"[yes|no]");
}
virtual ~CRouteRepliesMod() {
requestQueue::iterator it;
while (!m_vsPending.empty()) {
it = m_vsPending.begin();
while (!it->second.empty()) {
PutIRC(it->second[0].sLine);
it->second.erase(it->second.begin());
}
m_vsPending.erase(it);
}
}
virtual void OnIRCConnected()
{
m_pDoing = NULL;
m_pReplies = NULL;
m_vsPending.clear();
// No way we get a reply, so stop the timer (If it's running)
RemTimer("RouteTimeout");
}
virtual void OnIRCDisconnected()
{
OnIRCConnected(); // Let's keep it in one place
}
virtual void OnClientDisconnect()
{
requestQueue::iterator it;
if (m_pClient == m_pDoing) {
// The replies which aren't received yet will be
// broadcasted to everyone, but at least nothing breaks
RemTimer("RouteTimeout");
m_pDoing = NULL;
m_pReplies = NULL;
}
it = m_vsPending.find(m_pClient);
if (it != m_vsPending.end())
m_vsPending.erase(it);
SendRequest();
}
virtual EModRet OnRaw(CString& sLine)
{
CString sCmd = sLine.Token(1).AsUpper();
size_t i = 0;
if (!m_pReplies)
return CONTINUE;
// Is this a "not enough arguments" error?
if (sCmd == "461") {
// :server 461 nick WHO :Not enough parameters
CString sOrigCmd = sLine.Token(3);
if (m_sLastRequest.Token(0).Equals(sOrigCmd)) {
// This is the reply to the last request
if (RouteReply(sLine, true))
return HALTCORE;
return CONTINUE;
}
}
while (m_pReplies[i].szReply != NULL) {
if (m_pReplies[i].szReply == sCmd) {
if (RouteReply(sLine, m_pReplies[i].bLastResponse, sCmd == "353"))
return HALTCORE;
return CONTINUE;
}
i++;
}
// TODO HALTCORE is wrong, it should not be passed to
// the clients, but the core itself should still handle it!
return CONTINUE;
}
virtual EModRet OnUserRaw(CString& sLine)
{
CString sCmd = sLine.Token(0).AsUpper();
if (!m_pNetwork->GetIRCSock())
return CONTINUE;
if (sCmd.Equals("MODE")) {
// Check if this is a mode request that needs to be handled
// If there are arguments to a mode change,
// we must not route it.
if (!sLine.Token(3, true).empty())
return CONTINUE;
// Grab the mode change parameter
CString sMode = sLine.Token(2);
// If this is a channel mode request, znc core replies to it
if (sMode.empty())
return CONTINUE;
// Check if this is a mode change or a specific
// mode request (the later needs to be routed).
sMode.TrimPrefix("+");
if (sMode.length() != 1)
return CONTINUE;
// Now just check if it's one of the supported modes
switch (sMode[0]) {
case 'I':
case 'b':
case 'e':
break;
default:
return CONTINUE;
}
// Ok, this looks like we should route it.
// Fall through to the next loop
}
for (size_t i = 0; vRouteReplies[i].szRequest != NULL; i++) {
if (vRouteReplies[i].szRequest == sCmd) {
struct queued_req req = {
sLine, vRouteReplies[i].vReplies
};
m_vsPending[m_pClient].push_back(req);
SendRequest();
return HALTCORE;
}
}
return CONTINUE;
}
void Timeout()
{
// The timer will be deleted after this by the event loop
if (!GetNV("silent_timeouts").ToBool()) {
PutModule("This module hit a timeout which is possibly a bug.");
PutModule("To disable this message, do \"/msg " + GetModNick()
+ " silent yes\"");
PutModule("Last request: " + m_sLastRequest);
PutModule("Expected replies: ");
for (size_t i = 0; m_pReplies[i].szReply != NULL; i++) {
if (m_pReplies[i].bLastResponse)
PutModule(m_pReplies[i].szReply +
CString(" (last)"));
else
PutModule(m_pReplies[i].szReply);
}
}
m_pDoing = NULL;
m_pReplies = NULL;
SendRequest();
}
private:
bool RouteReply(const CString& sLine, bool bFinished = false, bool bIsRaw353 = false)
{
if (!m_pDoing)
return false;
// 353 needs special treatment due to NAMESX and UHNAMES
if (bIsRaw353)
m_pNetwork->GetIRCSock()->ForwardRaw353(sLine, m_pDoing);
else
m_pDoing->PutClient(sLine);
if (bFinished) {
// Stop the timeout
RemTimer("RouteTimeout");
m_pDoing = NULL;
m_pReplies = NULL;
SendRequest();
}
return true;
}
void SendRequest()
{
requestQueue::iterator it;
if (m_pDoing || m_pReplies)
return;
if (m_vsPending.empty())
return;
it = m_vsPending.begin();
if (it->second.empty()) {
m_vsPending.erase(it);
SendRequest();
return;
}
// When we are called from the timer, we need to remove it.
// We can't delete it (segfault on return), thus we
// just stop it. The main loop will delete it.
CTimer *pTimer = FindTimer("RouteTimeout");
if (pTimer) {
pTimer->Stop();
UnlinkTimer(pTimer);
}
AddTimer(new CRouteTimeout(this, 60, 1, "RouteTimeout",
"Recover from missing / wrong server replies"));
m_pDoing = it->first;
m_pReplies = it->second[0].reply;
m_sLastRequest = it->second[0].sLine;
PutIRC(it->second[0].sLine);
it->second.erase(it->second.begin());
}
void SilentCommand(const CString& sLine) {
const CString sValue = sLine.Token(1);
if (!sValue.empty()) {
SetNV("silent_timeouts", sValue);
}
CString sPrefix = GetNV("silent_timeouts").ToBool() ? "dis" : "en";
PutModule("Timeout messages are " + sPrefix + "abled.");
}
CClient *m_pDoing;
const struct reply *m_pReplies;
requestQueue m_vsPending;
// This field is only used for display purpose.
CString m_sLastRequest;
};
void CRouteTimeout::RunJob()
{
CRouteRepliesMod *pMod = (CRouteRepliesMod *) m_pModule;
pMod->Timeout();
}
template<> void TModInfo<CRouteRepliesMod>(CModInfo& Info) {
Info.SetWikiPage("route_replies");
}
NETWORKMODULEDEFS(CRouteRepliesMod, "Send replies (e.g. to /who) to the right client only")
<|endoftext|>
|
<commit_before>#include "PackAnimation.h"
#include "PackNodeFactory.h"
#include "PackAnchor.h"
#include "PackClipbox.h"
#include "Utility.h"
#include "typedef.h"
#include "AnimToLuaString.h"
#include "AnimFromLua.h"
#include "AnimToBin.h"
#include "AnimFromBin.h"
#include <ee/Sprite.h>
#include <ee/SymbolFile.h>
#include <ee/ImageSprite.h>
#include <ee/SymbolFile.h>
#include <sprite2/SymType.h>
#include <sprite2/RenderColor.h>
#include <sprite2/RenderShader.h>
#include <sprite2/RenderCamera.h>
#include <sprite2/RenderFilter.h>
#include <gum/trans_color.h>
namespace erespacker
{
PackAnimation::PackAnimation(int id)
: IPackNode(id)
{
}
void PackAnimation::PackToLuaString(ebuilder::CodeGenerator& gen,
const ee::TexturePacker& tp,
float scale) const
{
AnimToLuaString::Pack(this, gen);
}
void PackAnimation::UnpackFromLua(lua_State* L, const std::vector<ee::Image*>& images)
{
AnimFromLua::Unpack(L, this);
}
int PackAnimation::SizeOfPackToBin() const
{
return AnimToBin::Size(this);
}
void PackAnimation::PackToBin(uint8_t** ptr,
const ee::TexturePacker& tp,
float scale) const
{
AnimToBin::Pack(this, ptr);
}
int PackAnimation::SizeOfUnpackFromBin() const
{
return AnimFromBin::Size(this);
}
void PackAnimation::UnpackFromBin(uint8_t** ptr, const std::vector<ee::Image*>& images)
{
AnimFromBin::Unpack(ptr, this);
}
bool PackAnimation::CreateFramePart(const ee::Sprite* spr, Frame& frame)
{
const IPackNode* node = PackNodeFactory::Instance()->Create(spr);
PackAnimation::Part part;
std::string name = "";
if (Utility::IsNameValid(spr->GetName())) {
name = spr->GetName();
}
bool force_mat = false;
bool new_comp = AddComponent(node, name, part.comp_idx, force_mat);
PackAnimation::LoadSprTrans(spr, part.t, force_mat);
frame.parts.push_back(part);
return new_comp;
}
void PackAnimation::CreateClipboxFramePart(const PackClipbox* cb, Frame& frame)
{
PackAnimation::Part part;
bool force_mat;
AddComponent(cb, "", part.comp_idx, force_mat);
part.t.mat[0] = part.t.mat[3] = 1024;
part.t.mat[1] = part.t.mat[2] = 0;
part.t.mat[4] = static_cast<int>(cb->x * SCALE);
part.t.mat[5] =-static_cast<int>(cb->y * SCALE);
frame.parts.push_back(part);
}
void PackAnimation::Clear()
{
export_name.clear();
components.clear();
actions.clear();
frames.clear();
}
bool PackAnimation::AddComponent(const IPackNode* node, const std::string& name, int& comp_idx, bool& force_mat)
{
bool new_comp = false;
bool is_anchor = false;
if (const PackAnchor* anchor = dynamic_cast<const PackAnchor*>(node)) {
is_anchor = true;
for (int i = 0, n = components.size(); i < n; ++i) {
if (dynamic_cast<const PackAnchor*>(components[i].node) && components[i].name == name) {
comp_idx = i;
force_mat = true;
return new_comp;
}
}
} else {
for (int i = 0, n = components.size(); i < n; ++i) {
if (components[i].node == node && components[i].name == name) {
comp_idx = i;
force_mat = true;
return new_comp;
}
}
for (int i = 0, n = components.size(); i < n; ++i) {
if (components[i].node->GetFilepath() == node->GetFilepath()
&& components[i].name == name
&& !name.empty())
{
int type = ee::SymbolFile::Instance()->Type(node->GetFilepath());
switch (type)
{
case s2::SYM_IMAGE:
comp_idx = i;
force_mat = false;
return new_comp;
case s2::SYM_COMPLEX: case s2::SYM_ANIMATION: case s2::SYM_TEXTBOX: case s2::SYM_MASK: case s2::SYM_PARTICLE3D:
comp_idx = i;
force_mat = true;
return new_comp;
}
}
}
}
Component comp;
comp.node = node;
comp.name = name;
components.push_back(comp);
comp_idx = components.size() - 1;
new_comp = true;
if (is_anchor) {
force_mat = true;
} else if (ee::SymbolFile::Instance()->Type(node->GetFilepath()) == s2::SYM_IMAGE) {
force_mat = false;
} else {
force_mat = !name.empty();
}
return new_comp;
}
void PackAnimation::LoadSprTrans(const ee::Sprite* spr, SpriteTrans& trans, bool force_mat)
{
LoadSprMat(spr, trans, force_mat);
LoadSprColor(spr, trans);
trans.blend = static_cast<int>(spr->GetShader().GetBlend());
if (spr->GetShader().GetFilter()) {
trans.filter = static_cast<int>(spr->GetShader().GetFilter()->GetMode());
} else {
trans.filter = s2::FM_NULL;
}
trans.camera = static_cast<int>(spr->GetCamera().mode);
}
void PackAnimation::LoadSprMat(const ee::Sprite* spr, SpriteTrans& trans, bool force)
{
if (!force && dynamic_cast<const ee::ImageSprite*>(spr)) {
return;
}
float mat[6];
// | 1 ky | | sx | | c s | | 1 |
// | kx 1 | | sy | | -s c | | 1 |
// | 1 | | 1 | | 1 | | x y 1 |
// skew scale rotate move
mat[1] = mat[2] = mat[4] = mat[5] = 0;
mat[0] = mat[3] = 1;
sm::vec2 center = spr->GetCenter();
float sx = spr->GetScale().x,
sy = spr->GetScale().y;
float c = cos(-spr->GetAngle()),
s = sin(-spr->GetAngle());
float kx = -spr->GetShear().x,
ky = -spr->GetShear().y;
mat[0] = sx*c - ky*sy*s;
mat[1] = sx*s + ky*sy*c;
mat[2] = kx*sx*c - sy*s;
mat[3] = kx*sx*s + sy*c;
mat[4] = center.x/* * m_scale*/;
mat[5] = center.y/* * m_scale*/;
for (size_t i = 0; i < 4; ++i) {
trans.mat[i] = static_cast<int>(floor(mat[i] * 1024 + 0.5f));
}
for (size_t i = 4; i < 6; ++i) {
trans.mat[i] = static_cast<int>(floor(mat[i] * 16 + 0.5f));
}
// flip y
trans.mat[5] = -trans.mat[5];
}
void PackAnimation::LoadSprColor(const ee::Sprite* spr, SpriteTrans& trans)
{
const s2::RenderColor& rc = spr->GetColor();
trans.color = gum::color2int(rc.mul, gum::ARGB);
trans.additive = gum::color2int(rc.add, gum::ARGB);
trans.rmap = rc.rmap.ToRGBA();
trans.gmap = rc.gmap.ToRGBA();
trans.bmap = rc.bmap.ToRGBA();
}
bool PackAnimation::IsMatrixIdentity(const int* mat)
{
return mat[0] == 1024 && mat[3] == 1024
&& mat[1] == 0 && mat[2] == 0 && mat[4] == 0 && mat[5] == 0;
}
}<commit_msg>[FIXED] pack img<commit_after>#include "PackAnimation.h"
#include "PackNodeFactory.h"
#include "PackAnchor.h"
#include "PackClipbox.h"
#include "Utility.h"
#include "typedef.h"
#include "AnimToLuaString.h"
#include "AnimFromLua.h"
#include "AnimToBin.h"
#include "AnimFromBin.h"
#include <ee/Sprite.h>
#include <ee/SymbolFile.h>
#include <ee/ImageSprite.h>
#include <ee/SymbolFile.h>
#include <sprite2/SymType.h>
#include <sprite2/RenderColor.h>
#include <sprite2/RenderShader.h>
#include <sprite2/RenderCamera.h>
#include <sprite2/RenderFilter.h>
#include <gum/trans_color.h>
namespace erespacker
{
PackAnimation::PackAnimation(int id)
: IPackNode(id)
{
}
void PackAnimation::PackToLuaString(ebuilder::CodeGenerator& gen,
const ee::TexturePacker& tp,
float scale) const
{
AnimToLuaString::Pack(this, gen);
}
void PackAnimation::UnpackFromLua(lua_State* L, const std::vector<ee::Image*>& images)
{
AnimFromLua::Unpack(L, this);
}
int PackAnimation::SizeOfPackToBin() const
{
return AnimToBin::Size(this);
}
void PackAnimation::PackToBin(uint8_t** ptr,
const ee::TexturePacker& tp,
float scale) const
{
AnimToBin::Pack(this, ptr);
}
int PackAnimation::SizeOfUnpackFromBin() const
{
return AnimFromBin::Size(this);
}
void PackAnimation::UnpackFromBin(uint8_t** ptr, const std::vector<ee::Image*>& images)
{
AnimFromBin::Unpack(ptr, this);
}
bool PackAnimation::CreateFramePart(const ee::Sprite* spr, Frame& frame)
{
const IPackNode* node = PackNodeFactory::Instance()->Create(spr);
PackAnimation::Part part;
std::string name = "";
if (Utility::IsNameValid(spr->GetName())) {
name = spr->GetName();
}
bool force_mat = false;
bool new_comp = AddComponent(node, name, part.comp_idx, force_mat);
PackAnimation::LoadSprTrans(spr, part.t, force_mat);
frame.parts.push_back(part);
return new_comp;
}
void PackAnimation::CreateClipboxFramePart(const PackClipbox* cb, Frame& frame)
{
PackAnimation::Part part;
bool force_mat;
AddComponent(cb, "", part.comp_idx, force_mat);
part.t.mat[0] = part.t.mat[3] = 1024;
part.t.mat[1] = part.t.mat[2] = 0;
part.t.mat[4] = static_cast<int>(cb->x * SCALE);
part.t.mat[5] =-static_cast<int>(cb->y * SCALE);
frame.parts.push_back(part);
}
void PackAnimation::Clear()
{
export_name.clear();
components.clear();
actions.clear();
frames.clear();
}
bool PackAnimation::AddComponent(const IPackNode* node, const std::string& name, int& comp_idx, bool& force_mat)
{
bool new_comp = false;
bool is_anchor = false;
if (const PackAnchor* anchor = dynamic_cast<const PackAnchor*>(node)) {
is_anchor = true;
for (int i = 0, n = components.size(); i < n; ++i) {
if (dynamic_cast<const PackAnchor*>(components[i].node) && components[i].name == name) {
comp_idx = i;
force_mat = true;
return new_comp;
}
}
} else {
for (int i = 0, n = components.size(); i < n; ++i) {
if (components[i].node == node && components[i].name == name) {
comp_idx = i;
force_mat = true;
return new_comp;
}
}
for (int i = 0, n = components.size(); i < n; ++i) {
if (components[i].node->GetFilepath() == node->GetFilepath()
&& components[i].name == name
&& !name.empty())
{
int type = ee::SymbolFile::Instance()->Type(node->GetFilepath());
switch (type)
{
case s2::SYM_IMAGE: case s2::SYM_COMPLEX: case s2::SYM_ANIMATION: case s2::SYM_TEXTBOX: case s2::SYM_MASK: case s2::SYM_PARTICLE3D:
comp_idx = i;
force_mat = true;
return new_comp;
}
}
}
}
Component comp;
comp.node = node;
comp.name = name;
components.push_back(comp);
comp_idx = components.size() - 1;
new_comp = true;
if (is_anchor) {
force_mat = true;
} else if (ee::SymbolFile::Instance()->Type(node->GetFilepath()) == s2::SYM_IMAGE) {
force_mat = false;
} else {
force_mat = !name.empty();
}
return new_comp;
}
void PackAnimation::LoadSprTrans(const ee::Sprite* spr, SpriteTrans& trans, bool force_mat)
{
LoadSprMat(spr, trans, force_mat);
LoadSprColor(spr, trans);
trans.blend = static_cast<int>(spr->GetShader().GetBlend());
if (spr->GetShader().GetFilter()) {
trans.filter = static_cast<int>(spr->GetShader().GetFilter()->GetMode());
} else {
trans.filter = s2::FM_NULL;
}
trans.camera = static_cast<int>(spr->GetCamera().mode);
}
void PackAnimation::LoadSprMat(const ee::Sprite* spr, SpriteTrans& trans, bool force)
{
if (!force) {
return;
}
float mat[6];
// | 1 ky | | sx | | c s | | 1 |
// | kx 1 | | sy | | -s c | | 1 |
// | 1 | | 1 | | 1 | | x y 1 |
// skew scale rotate move
mat[1] = mat[2] = mat[4] = mat[5] = 0;
mat[0] = mat[3] = 1;
sm::vec2 center = spr->GetCenter();
float sx = spr->GetScale().x,
sy = spr->GetScale().y;
float c = cos(-spr->GetAngle()),
s = sin(-spr->GetAngle());
float kx = -spr->GetShear().x,
ky = -spr->GetShear().y;
mat[0] = sx*c - ky*sy*s;
mat[1] = sx*s + ky*sy*c;
mat[2] = kx*sx*c - sy*s;
mat[3] = kx*sx*s + sy*c;
mat[4] = center.x/* * m_scale*/;
mat[5] = center.y/* * m_scale*/;
for (size_t i = 0; i < 4; ++i) {
trans.mat[i] = static_cast<int>(floor(mat[i] * 1024 + 0.5f));
}
for (size_t i = 4; i < 6; ++i) {
trans.mat[i] = static_cast<int>(floor(mat[i] * 16 + 0.5f));
}
// flip y
trans.mat[5] = -trans.mat[5];
}
void PackAnimation::LoadSprColor(const ee::Sprite* spr, SpriteTrans& trans)
{
const s2::RenderColor& rc = spr->GetColor();
trans.color = gum::color2int(rc.mul, gum::ARGB);
trans.additive = gum::color2int(rc.add, gum::ARGB);
trans.rmap = rc.rmap.ToRGBA();
trans.gmap = rc.gmap.ToRGBA();
trans.bmap = rc.bmap.ToRGBA();
}
bool PackAnimation::IsMatrixIdentity(const int* mat)
{
return mat[0] == 1024 && mat[3] == 1024
&& mat[1] == 0 && mat[2] == 0 && mat[4] == 0 && mat[5] == 0;
}
}<|endoftext|>
|
<commit_before>/*************************************************************************
*
* $RCSfile: emptylayer.hxx,v $
*
* $Revision: 1.1 $
*
* last change: $Author: jb $ $Date: 2002-11-28 09:05:14 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef CONFIGMGR_BACKEND_EMPTYLAYER_HXX
#define CONFIGMGR_BACKEND_EMPTYLAYER_HXX
#include <drafts/com/sun/star/configuration/backend/XLayer.hpp>
// -----------------------------------------------------------------------------
namespace configmgr
{
// -----------------------------------------------------------------------------
namespace backend
{
// -----------------------------------------------------------------------------
namespace uno = ::com::sun::star::uno;
namespace backenduno = drafts::com::sun::star::configuration::backend;
// -----------------------------------------------------------------------------
uno::Reference< backenduno::XLayer > createEmptyLayer();
bool checkEmptyLayer(uno::Reference< backenduno::XLayer > const & xLayer );
// -----------------------------------------------------------------------------
} // namespace xml
// -----------------------------------------------------------------------------
} // namespace configmgr
#endif <commit_msg>#105114# Added newline at end of file for compiler.<commit_after>/*************************************************************************
*
* $RCSfile: emptylayer.hxx,v $
*
* $Revision: 1.2 $
*
* last change: $Author: cyrillem $ $Date: 2002-11-29 14:06:17 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef CONFIGMGR_BACKEND_EMPTYLAYER_HXX
#define CONFIGMGR_BACKEND_EMPTYLAYER_HXX
#include <drafts/com/sun/star/configuration/backend/XLayer.hpp>
// -----------------------------------------------------------------------------
namespace configmgr
{
// -----------------------------------------------------------------------------
namespace backend
{
// -----------------------------------------------------------------------------
namespace uno = ::com::sun::star::uno;
namespace backenduno = drafts::com::sun::star::configuration::backend;
// -----------------------------------------------------------------------------
uno::Reference< backenduno::XLayer > createEmptyLayer();
bool checkEmptyLayer(uno::Reference< backenduno::XLayer > const & xLayer );
// -----------------------------------------------------------------------------
} // namespace xml
// -----------------------------------------------------------------------------
} // namespace configmgr
#endif
<|endoftext|>
|
<commit_before>/*
Request handlers for WSGI apps and static files
Copyright (c) 2016 Roman Miroshnychenko <romanvm@yandex.ua>
License: MIT, see License.txt
*/
#include "request_handlers.h"
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/copy.hpp>
#include <fstream>
#include <iostream>
#include <sstream>
#include <utility>
using namespace std;
namespace py = boost::python;
namespace fs = boost::filesystem;
namespace sys = boost::system;
namespace alg = boost::algorithm;
namespace wsgi_boost
{
#pragma region StaticRequestHandler
void StaticRequestHandler::handle()
{
if (m_request.method != "GET" && m_request.method != "HEAD")
{
m_response.send_mesage("405 Method Not Allowed", "Invalid HTTP method! Only GET and HEAD are allowed.");
return;
}
const auto content_dir_path = fs::path{ m_request.content_dir };
if (!fs::exists(content_dir_path))
{
m_response.send_html("500 Internal Server Error",
"Error 500",
"Internal Server Error",
"Invalid static content directory is configured.");
return;
}
open_file(content_dir_path);
}
void StaticRequestHandler::open_file(const fs::path& content_dir_path)
{
fs::path path = content_dir_path;
path /= boost::regex_replace(m_request.path, m_request.path_regex, "");
path = fs::canonical(path);
// Checking if path is inside content_dir
if (distance(content_dir_path.begin(), content_dir_path.end()) <= distance(path.begin(), path.end()) &&
equal(content_dir_path.begin(), content_dir_path.end(), path.begin()))
{
if (fs::is_directory(path))
{
path /= "index.html";
}
if (fs::exists(path) && fs::is_regular_file(path))
{
ifstream ifs;
ifs.open(path.string(), ifstream::in | ios::binary);
if (ifs)
{
headers_type out_headers;
out_headers.emplace_back("Cache-Control", m_cache_control);
time_t last_modified = fs::last_write_time(path);
out_headers.emplace_back("Last-Modified", time_to_header(last_modified));
// Use hex representation of the last modified POSIX timestamp as ETag
string etag = "\"" + hex(static_cast<size_t>(last_modified)) + "\"";
out_headers.emplace_back("ETag", etag);
string ims = m_request.get_header("If-Modified-Since");
if (m_request.get_header("If-None-Match") == etag || (!ims.empty() && header_to_time(ims) >= last_modified))
{
out_headers.emplace_back("Content-Length", "0");
m_response.send_header("304 Not Modified", out_headers);
ifs.close();
return;
}
string ext = path.extension().string();
out_headers.emplace_back("Content-Type", get_mime(ext));
if (m_use_gzip && m_request.check_header("Accept-Encoding", "gzip") && is_compressable(ext))
{
boost::iostreams::filtering_istream gzstream;
gzstream.push(boost::iostreams::gzip_compressor());
gzstream.push(ifs);
stringstream compressed;
boost::iostreams::copy(gzstream, compressed);
out_headers.emplace_back("Content-Encoding", "gzip");
send_file(compressed, out_headers);
}
else
{
out_headers.emplace_back("Accept-Ranges", "bytes");
send_file(ifs, out_headers);
}
ifs.close();
return;
}
}
}
m_response.send_html("404 Not Found",
"Error 404", "Not Found",
"The requested path <code>" + m_request.path + "</code> was not found on this server.");
}
void StaticRequestHandler::send_file(istream& content_stream, headers_type& headers)
{
content_stream.seekg(0, ios::end);
size_t length = content_stream.tellg();
size_t start_pos = 0;
size_t end_pos = length - 1;
string requested_range = m_request.get_header("Range");
pair<string, string> range;
if (requested_range != "" && ((range = parse_range(requested_range)) != pair<string, string>()))
{
if (range.first != string())
start_pos = stoull(range.first);
else
range.first = to_string(start_pos);
if (range.second != string())
end_pos = stoull(range.second);
else
range.second = to_string(end_pos);
if (start_pos > end_pos || start_pos >= length || end_pos >= length)
{
m_response.send_mesage("416 Range Not Satisfiable", "Invalid bytes range!");
return;
}
else
{
headers.emplace_back("Content-Length", to_string(end_pos - start_pos));
headers.emplace_back("Content-Range", "bytes " + range.first + "-" + range.second + "/" + to_string(length));
m_response.send_header("206 Partial Content", headers);
}
}
else
{
headers.emplace_back("Content-Length", to_string(length));
m_response.send_header("200 OK", headers);
}
if (m_request.method == "GET")
{
if (start_pos > 0)
content_stream.seekg(start_pos);
else
content_stream.seekg(0, ios::beg);
const size_t buffer_size = 131072;
vector<char> buffer(buffer_size);
size_t read_length;
size_t bytes_left = end_pos - start_pos + 1;
while (bytes_left > 0 &&
((read_length = content_stream.read(&buffer[0], min(bytes_left, buffer_size)).gcount()) > 0))
{
sys::error_code ec = m_response.send_data(string{ &buffer[0], read_length });
if (ec)
return;
bytes_left -= read_length;
}
}
}
#pragma endregion
#pragma region WsgiRequestHandler
WsgiRequestHandler::WsgiRequestHandler(Request& request, Response& response, py::object& app,
string& scheme, string& host, unsigned short local_port, bool multithread) :
BaseRequestHandler(request, response), m_app{ app },
m_url_scheme{ scheme }, m_host_name{ host },
m_local_port{ local_port }, m_multithread{ multithread }
{
m_write = create_write();
m_start_response = create_start_response();
}
py::object WsgiRequestHandler::create_write()
{
function<void(py::object)> wr{
[this](py::object data)
{
string cpp_data = py::extract<string>(data);
GilRelease release_gil;
// Read/write operations executed from inside Python must be syncronous!
sys::error_code ec = this->m_response.send_header(this->m_status, this->m_out_headers, false);
if (ec)
return;
size_t data_len = cpp_data.length();
if (data_len > 0)
{
if (this->m_content_length == -1)
cpp_data = hex(data_len) + "\r\n" + cpp_data + "\r\n";
// Read/write operations executed from inside Python must be syncronous!
this->m_response.send_data(cpp_data, false);
}
}
};
return py::make_function(wr, py::default_call_policies(),
py::args("data"), boost::mpl::vector<void, py::object>());
}
py::object WsgiRequestHandler::create_start_response()
{
function<py::object(py::str, py::list, py::object)> sr{
[this](py::str status, py::list headers, py::object exc_info = py::object())
{
if (!exc_info.is_none() && this->m_response.header_sent())
{
py::object t = exc_info[0];
py::object v = exc_info[1];
py::object tb = exc_info[2];
cerr << "The WSGI app passed exc_info after sending headers to the client!\n";
py::import("traceback").attr("print_exception")(t, v, tb);
PyErr_Restore(t.ptr(), v.ptr(), tb.ptr());
py::throw_error_already_set();
}
this->m_status = py::extract<string>(status);
this->m_out_headers.clear();
for (py::ssize_t i = 0; i < py::len(headers); ++i)
{
string header_name = py::extract<string>(headers[i][0]);
string header_value = py::extract<string>(headers[i][1]);
if (alg::iequals(header_name, "Content-Length"))
{
try
{
this->m_content_length = stoll(header_value);
}
catch (const logic_error&) {}
}
this->m_out_headers.emplace_back(header_name, header_value);
}
if (this->m_content_length == -1)
{
// If a WSGI app does not provide Content-Length header (e.g. Django)
// we use Transfer-Encoding: chunked
this->m_out_headers.emplace_back("Transfer-Encoding", "chunked");
}
return this->m_write;
}
};
return py::make_function(sr, py::default_call_policies(),
(py::arg("status"), py::arg("headers"), py::arg("exc_info") = py::object()),
boost::mpl::vector<py::object, py::str, py::list, py::object>());
}
void WsgiRequestHandler::prepare_environ()
{
m_environ["REQUEST_METHOD"] = m_request.method;
m_environ["SCRIPT_NAME"] = "";
pair<string, string> path_and_query = split_path(m_request.path);
m_environ["PATH_INFO"] = path_and_query.first;
m_environ["QUERY_STRING"] = path_and_query.second;
m_environ["CONTENT_TYPE"] = m_request.get_header("Content-Type");
m_environ["CONTENT_LENGTH"] = m_request.get_header("Content-Length");
m_environ["SERVER_NAME"] = m_host_name;
m_environ["SERVER_PORT"] = to_string(m_local_port);
m_environ["SERVER_PROTOCOL"] = m_request.http_version;
m_environ["REMOTE_ADDR"] = m_environ["REMOTE_HOST"] = m_request.remote_address();
m_environ["REMOTE_PORT"] = to_string(m_request.remote_port());
for (const auto& header : m_request.headers)
{
string env_header = header.first;
transform_header(env_header);
if (env_header == "HTTP_CONTENT_TYPE" || env_header == "HTTP_CONTENT_LENGTH")
continue;
// Headers are already checked for duplicates during parsing
m_environ[env_header] = header.second;
}
m_environ["wsgi.version"] = py::make_tuple<int, int>(1, 0);
m_environ["wsgi.url_scheme"] = m_url_scheme;
m_environ["wsgi.input"] = InputStream{ m_request.connection() };
m_environ["wsgi.errors"] = ErrorStream{};
m_environ["wsgi.file_wrapper"] = FileWrapper{};
m_environ["wsgi.multithread"] = m_multithread;
m_environ["wsgi.multiprocess"] = false;
m_environ["wsgi.run_once"] = false;
}
void WsgiRequestHandler::handle()
{
if (m_app.is_none())
{
m_response.send_html("500 Internal Server Error",
"Error 500", "Internal Server Error",
"A WSGI application is not set.");
return;
}
prepare_environ();
Iterable iterable{ move(m_app(m_environ, m_start_response)) };
send_iterable(iterable);
}
void WsgiRequestHandler::send_iterable(Iterable& iterable)
{
py::object iterator = iterable.attr("__iter__")();
while (true)
{
try
{
#if PY_MAJOR_VERSION < 3
std::string chunk = py::extract<string>(iterator.attr("next")());
#else
std::string chunk = py::extract<string>(iterator.attr("__next__")());
#endif
// Releasing GIL around async operations not only allows other Python threads to run
// but also allows io_service to safely transfer control to another coroutine
// that may acquire GIL again.
// I found this scheme by accident and if we do not release GIL at this point
// Python will crash!
GilRelease release_gil;
sys::error_code ec;
if (!m_response.header_sent())
{
ec = m_response.send_header(m_status, m_out_headers);
if (ec)
break;
}
if (m_content_length == -1)
{
size_t length = chunk.length();
// Skip 0-length chunks, if any
if (length == 0)
continue;
chunk = hex(length) + "\r\n" + chunk + "\r\n";
}
ec = m_response.send_data(chunk);
if (ec)
break;
}
catch (const py::error_already_set&)
{
if (PyErr_ExceptionMatches(PyExc_StopIteration))
{
PyErr_Clear();
if (m_content_length == -1)
m_response.send_data("0\r\n\r\n");
break;
}
throw;
}
}
}
#pragma endregion
}
<commit_msg>Minor refactoring<commit_after>/*
Request handlers for WSGI apps and static files
Copyright (c) 2016 Roman Miroshnychenko <romanvm@yandex.ua>
License: MIT, see License.txt
*/
#include "request_handlers.h"
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/copy.hpp>
#include <fstream>
#include <iostream>
#include <sstream>
#include <utility>
using namespace std;
namespace py = boost::python;
namespace fs = boost::filesystem;
namespace sys = boost::system;
namespace alg = boost::algorithm;
namespace wsgi_boost
{
#pragma region StaticRequestHandler
void StaticRequestHandler::handle()
{
if (m_request.method != "GET" && m_request.method != "HEAD")
{
m_response.send_mesage("405 Method Not Allowed", "Invalid HTTP method! Only GET and HEAD are allowed.");
return;
}
const auto content_dir_path = fs::path{ m_request.content_dir };
if (!fs::exists(content_dir_path))
{
m_response.send_html("500 Internal Server Error",
"Error 500",
"Internal Server Error",
"Invalid static content directory is configured.");
return;
}
open_file(content_dir_path);
}
void StaticRequestHandler::open_file(const fs::path& content_dir_path)
{
fs::path path = content_dir_path;
path /= boost::regex_replace(m_request.path, m_request.path_regex, "");
path = fs::canonical(path);
// Checking if path is inside content_dir
if (distance(content_dir_path.begin(), content_dir_path.end()) <= distance(path.begin(), path.end()) &&
equal(content_dir_path.begin(), content_dir_path.end(), path.begin()))
{
if (fs::is_directory(path))
{
path /= "index.html";
}
if (fs::exists(path) && fs::is_regular_file(path))
{
ifstream ifs;
ifs.open(path.string(), ifstream::in | ios::binary);
if (ifs)
{
headers_type out_headers;
out_headers.emplace_back("Cache-Control", m_cache_control);
time_t last_modified = fs::last_write_time(path);
out_headers.emplace_back("Last-Modified", time_to_header(last_modified));
// Use hex representation of the last modified POSIX timestamp as ETag
string etag = "\"" + hex(static_cast<size_t>(last_modified)) + "\"";
out_headers.emplace_back("ETag", etag);
string ims = m_request.get_header("If-Modified-Since");
if (m_request.get_header("If-None-Match") == etag || (!ims.empty() && header_to_time(ims) >= last_modified))
{
out_headers.emplace_back("Content-Length", "0");
m_response.send_header("304 Not Modified", out_headers);
ifs.close();
return;
}
string ext = path.extension().string();
out_headers.emplace_back("Content-Type", get_mime(ext));
if (m_use_gzip && m_request.check_header("Accept-Encoding", "gzip") && is_compressable(ext))
{
boost::iostreams::filtering_istream gzstream;
gzstream.push(boost::iostreams::gzip_compressor());
gzstream.push(ifs);
stringstream compressed;
boost::iostreams::copy(gzstream, compressed);
out_headers.emplace_back("Content-Encoding", "gzip");
send_file(compressed, out_headers);
}
else
{
out_headers.emplace_back("Accept-Ranges", "bytes");
send_file(ifs, out_headers);
}
ifs.close();
return;
}
}
}
m_response.send_html("404 Not Found",
"Error 404", "Not Found",
"The requested path <code>" + m_request.path + "</code> was not found on this server.");
}
void StaticRequestHandler::send_file(istream& content_stream, headers_type& headers)
{
content_stream.seekg(0, ios::end);
size_t length = content_stream.tellg();
size_t start_pos = 0;
size_t end_pos = length - 1;
string requested_range = m_request.get_header("Range");
pair<string, string> range;
if (!requested_range.empty() && ((range = parse_range(requested_range)) != pair<string, string>()))
{
if (!range.first.empty())
start_pos = stoull(range.first);
else
range.first = to_string(start_pos);
if (!range.second.empty())
end_pos = stoull(range.second);
else
range.second = to_string(end_pos);
if (start_pos > end_pos || start_pos >= length || end_pos >= length)
{
m_response.send_mesage("416 Range Not Satisfiable", "Invalid bytes range!");
return;
}
else
{
headers.emplace_back("Content-Length", to_string(end_pos - start_pos));
headers.emplace_back("Content-Range", "bytes " + range.first + "-" + range.second + "/" + to_string(length));
m_response.send_header("206 Partial Content", headers);
}
}
else
{
headers.emplace_back("Content-Length", to_string(length));
m_response.send_header("200 OK", headers);
}
if (m_request.method == "GET")
{
if (start_pos > 0)
content_stream.seekg(start_pos);
else
content_stream.seekg(0, ios::beg);
const size_t buffer_size = 131072;
vector<char> buffer(buffer_size);
size_t read_length;
size_t bytes_left = end_pos - start_pos + 1;
while (bytes_left > 0 &&
((read_length = content_stream.read(&buffer[0], min(bytes_left, buffer_size)).gcount()) > 0))
{
sys::error_code ec = m_response.send_data(string{ &buffer[0], read_length });
if (ec)
return;
bytes_left -= read_length;
}
}
}
#pragma endregion
#pragma region WsgiRequestHandler
WsgiRequestHandler::WsgiRequestHandler(Request& request, Response& response, py::object& app,
string& scheme, string& host, unsigned short local_port, bool multithread) :
BaseRequestHandler(request, response), m_app{ app },
m_url_scheme{ scheme }, m_host_name{ host },
m_local_port{ local_port }, m_multithread{ multithread }
{
m_write = create_write();
m_start_response = create_start_response();
}
py::object WsgiRequestHandler::create_write()
{
function<void(py::object)> wr{
[this](py::object data)
{
string cpp_data = py::extract<string>(data);
GilRelease release_gil;
// Read/write operations executed from inside Python must be syncronous!
sys::error_code ec = this->m_response.send_header(this->m_status, this->m_out_headers, false);
if (ec)
return;
size_t data_len = cpp_data.length();
if (data_len > 0)
{
if (this->m_content_length == -1)
cpp_data = hex(data_len) + "\r\n" + cpp_data + "\r\n";
// Read/write operations executed from inside Python must be syncronous!
this->m_response.send_data(cpp_data, false);
}
}
};
return py::make_function(wr, py::default_call_policies(),
py::args("data"), boost::mpl::vector<void, py::object>());
}
py::object WsgiRequestHandler::create_start_response()
{
function<py::object(py::str, py::list, py::object)> sr{
[this](py::str status, py::list headers, py::object exc_info = py::object())
{
if (!exc_info.is_none() && this->m_response.header_sent())
{
py::object t = exc_info[0];
py::object v = exc_info[1];
py::object tb = exc_info[2];
cerr << "The WSGI app passed exc_info after sending headers to the client!\n";
py::import("traceback").attr("print_exception")(t, v, tb);
PyErr_Restore(t.ptr(), v.ptr(), tb.ptr());
py::throw_error_already_set();
}
this->m_status = py::extract<string>(status);
this->m_out_headers.clear();
for (py::ssize_t i = 0; i < py::len(headers); ++i)
{
string header_name = py::extract<string>(headers[i][0]);
string header_value = py::extract<string>(headers[i][1]);
if (alg::iequals(header_name, "Content-Length"))
{
try
{
this->m_content_length = stoll(header_value);
}
catch (const logic_error&) {}
}
this->m_out_headers.emplace_back(header_name, header_value);
}
if (this->m_content_length == -1)
{
// If a WSGI app does not provide Content-Length header (e.g. Django)
// we use Transfer-Encoding: chunked
this->m_out_headers.emplace_back("Transfer-Encoding", "chunked");
}
return this->m_write;
}
};
return py::make_function(sr, py::default_call_policies(),
(py::arg("status"), py::arg("headers"), py::arg("exc_info") = py::object()),
boost::mpl::vector<py::object, py::str, py::list, py::object>());
}
void WsgiRequestHandler::prepare_environ()
{
m_environ["REQUEST_METHOD"] = m_request.method;
m_environ["SCRIPT_NAME"] = "";
pair<string, string> path_and_query = split_path(m_request.path);
m_environ["PATH_INFO"] = path_and_query.first;
m_environ["QUERY_STRING"] = path_and_query.second;
m_environ["CONTENT_TYPE"] = m_request.get_header("Content-Type");
m_environ["CONTENT_LENGTH"] = m_request.get_header("Content-Length");
m_environ["SERVER_NAME"] = m_host_name;
m_environ["SERVER_PORT"] = to_string(m_local_port);
m_environ["SERVER_PROTOCOL"] = m_request.http_version;
m_environ["REMOTE_ADDR"] = m_environ["REMOTE_HOST"] = m_request.remote_address();
m_environ["REMOTE_PORT"] = to_string(m_request.remote_port());
for (const auto& header : m_request.headers)
{
string env_header = header.first;
transform_header(env_header);
if (env_header == "HTTP_CONTENT_TYPE" || env_header == "HTTP_CONTENT_LENGTH")
continue;
// Headers are already checked for duplicates during parsing
m_environ[env_header] = header.second;
}
m_environ["wsgi.version"] = py::make_tuple<int, int>(1, 0);
m_environ["wsgi.url_scheme"] = m_url_scheme;
m_environ["wsgi.input"] = InputStream{ m_request.connection() };
m_environ["wsgi.errors"] = ErrorStream{};
m_environ["wsgi.file_wrapper"] = FileWrapper{};
m_environ["wsgi.multithread"] = m_multithread;
m_environ["wsgi.multiprocess"] = false;
m_environ["wsgi.run_once"] = false;
}
void WsgiRequestHandler::handle()
{
if (m_app.is_none())
{
m_response.send_html("500 Internal Server Error",
"Error 500", "Internal Server Error",
"A WSGI application is not set.");
return;
}
prepare_environ();
Iterable iterable{ move(m_app(m_environ, m_start_response)) };
send_iterable(iterable);
}
void WsgiRequestHandler::send_iterable(Iterable& iterable)
{
py::object iterator = iterable.attr("__iter__")();
while (true)
{
try
{
#if PY_MAJOR_VERSION < 3
std::string chunk = py::extract<string>(iterator.attr("next")());
#else
std::string chunk = py::extract<string>(iterator.attr("__next__")());
#endif
// Releasing GIL around async operations not only allows other Python threads to run
// but also allows io_service to safely transfer control to another coroutine
// that may acquire GIL again.
// I found this scheme by accident and if we do not release GIL at this point
// Python will crash!
GilRelease release_gil;
sys::error_code ec;
if (!m_response.header_sent())
{
ec = m_response.send_header(m_status, m_out_headers);
if (ec)
break;
}
if (m_content_length == -1)
{
size_t length = chunk.length();
// Skip 0-length chunks, if any
if (length == 0)
continue;
chunk = hex(length) + "\r\n" + chunk + "\r\n";
}
ec = m_response.send_data(chunk);
if (ec)
break;
}
catch (const py::error_already_set&)
{
if (PyErr_ExceptionMatches(PyExc_StopIteration))
{
PyErr_Clear();
if (m_content_length == -1)
m_response.send_data("0\r\n\r\n");
break;
}
throw;
}
}
}
#pragma endregion
}
<|endoftext|>
|
<commit_before>/*
* Copyright (c) 2014 Eran Pe'er.
*
* This program is made available under the terms of the MIT License.
*
* Created on Mar 10, 2014
*/
#include <string>
#include <iostream>
#include <stdexcept>
#include <tuple>
#include "tpunit++.hpp"
#include "fakeit.hpp"
#include "mockutils/Formatter.hpp"
using namespace fakeit;
struct DefaultErrorFormatting: tpunit::TestFixture {
DefaultErrorFormatting() :
tpunit::TestFixture(
//
TEST(DefaultErrorFormatting::parse_UnmockedMethodCallException),
TEST(DefaultErrorFormatting::parse_UnmatchedMethodCallException),
TEST(DefaultErrorFormatting::parse_AnyArguments),
TEST(DefaultErrorFormatting::parse_Exactly_Once),
TEST(DefaultErrorFormatting::parse_Atleast_Once),
TEST(DefaultErrorFormatting::parse_NoMoreInvocations_VerificationFailure),
TEST(DefaultErrorFormatting::parse_UserDefinedMatcher_in_expected_pattern),
TEST(DefaultErrorFormatting::parse_actual_arguments)
) //
{
}
fakeit::DefaultErrorFormatter formatter;
template <typename T> std::string to_string(T& val){
std::stringstream stream;
stream << val;
return stream.str();
}
struct SomeInterface {
virtual int func(int) = 0;
virtual void proc(int) = 0;
virtual int all_types(
char,
bool,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
double,
long double) = 0;
};
void parse_UnmockedMethodCallException() {
Mock<SomeInterface> mock;
SomeInterface &i = mock.get();
try {
i.func(1);
FAIL();
}
catch (UnexpectedMethodCallException& e)
{
std::string expectedMsg{"Unexpected method invocation: An unmocked method was invoked. All used virtual methods must be stubbed!"};
std::string actual{to_string(e)};
ASSERT_EQUAL(expectedMsg, actual);
}
}
void parse_UnmatchedMethodCallException() {
Mock<SomeInterface> mock;
Fake(Method(mock,func).Using(3));
SomeInterface &i = mock.get();
try {
i.func(1);
FAIL();
}
catch (UnexpectedMethodCallException& e)
{
std::string expectedMsg{"Unexpected method invocation: mock.func(1)\n Could not find any recorded behavior to support this method call."};
std::string actual{to_string(e)};
ASSERT_EQUAL(expectedMsg, actual);
}
}
void parse_AnyArguments() {
Mock<SomeInterface> mock;
try {
fakeit::Verify(Method(mock, func)).setFileInfo("test file",1,"test method").Exactly(Once);
}
catch (SequenceVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( any arguments )\n";
expectedMsg += "Expected matches: exactly 1\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg{to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_Exactly_Once() {
Mock<SomeInterface> mock;
try {
fakeit::Verify(Method(mock, func)).setFileInfo("test file",1,"test method").Exactly(Once);
}
catch (SequenceVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( any arguments )\n";
expectedMsg += "Expected matches: exactly 1\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg{to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_Atleast_Once() {
Mock<SomeInterface> mock;
try {
fakeit::Verify(Method(mock, func)).setFileInfo("test file",1,"test method").AtLeast(Once);
}
catch (SequenceVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( any arguments )\n";
expectedMsg += "Expected matches: at least 1\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg {to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_NoMoreInvocations_VerificationFailure() {
Mock<SomeInterface> mock;
try {
Fake(Method(mock, func));
mock.get().func(1);
mock.get().func(2);
fakeit::Verify(Method(mock, func).Using(1)).setFileInfo("test file",1,"test method");
fakeit::VerifyNoOtherInvocations(Method(mock, func)) //
.setFileInfo("test file",1,"test method");
}
catch (NoMoreInvocationsVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected no more invocations!! But the following unverified invocations were found:\n";
expectedMsg += " mock.func(2)";//
std::string actualMsg{to_string(e)};//
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_UserDefinedMatcher_in_expected_pattern() {
Mock<SomeInterface> mock;
When(Method(mock, func)).Return(0);
//SomeInterface &i = mock.get();
try {
fakeit::Verify(Method(mock, func).Matching([](...){return true; })) //
.setFileInfo("test file",1,"test method").Exactly(2);
FAIL();
}
catch (SequenceVerificationException& e)
{
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( user defined matcher )\n";
expectedMsg += "Expected matches: exactly 2\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg {to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_actual_arguments() {
Mock<SomeInterface> mock;
When(Method(mock, all_types)).Return(0);
//SomeInterface &i = mock.get();
try {
mock().all_types('a', true, 1, 1, 1, 1, 1, 1, 1, 1);
fakeit::Verify(Method(mock, all_types)) //
.setFileInfo("test file",1,"test method").Exactly(2);
FAIL();
}
catch (SequenceVerificationException& e)
{
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.all_types( any arguments )\n";
expectedMsg += "Expected matches: exactly 2\n";
expectedMsg += "Actual matches : 1\n";
expectedMsg += "Actual sequence : total of 1 actual invocations:";
expectedMsg += " mock.all_types(?, true, 1, 1, 1, 1, 1, 1, 1.0, 1.0)";
std::string actualMsg {to_string(e)};
//ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_expected_arguments() {
Mock<SomeInterface> mock;
When(Method(mock, all_types)).Return(0);
//SomeInterface &i = mock.get();
try {
fakeit::Verify(Method(mock, all_types).Using('a', true, 1, 1, 1, 1, 1, 1, 1, 1))//
.setFileInfo("test file", 1, "test method").Exactly(2);
FAIL();
}
catch (SequenceVerificationException& e)
{
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.all_types( 'a', true, 1, 1, 1, 1, 1, 1, 1.0, 1.0 )\n";
expectedMsg += "Expected matches: exactly 2\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actual {to_string(e)};
ASSERT_EQUAL(expectedMsg, actual);
}
}
} __DefaultErrorFormatting;
<commit_msg>fix test<commit_after>/*
* Copyright (c) 2014 Eran Pe'er.
*
* This program is made available under the terms of the MIT License.
*
* Created on Mar 10, 2014
*/
#include <string>
#include <iostream>
#include <stdexcept>
#include <tuple>
#include "tpunit++.hpp"
#include "fakeit.hpp"
#include "mockutils/Formatter.hpp"
using namespace fakeit;
struct DefaultErrorFormatting: tpunit::TestFixture {
DefaultErrorFormatting() :
tpunit::TestFixture(
//
TEST(DefaultErrorFormatting::parse_UnmockedMethodCallException),
TEST(DefaultErrorFormatting::parse_UnmatchedMethodCallException),
TEST(DefaultErrorFormatting::parse_AnyArguments),
TEST(DefaultErrorFormatting::parse_Exactly_Once),
TEST(DefaultErrorFormatting::parse_Atleast_Once),
TEST(DefaultErrorFormatting::parse_NoMoreInvocations_VerificationFailure),
TEST(DefaultErrorFormatting::parse_UserDefinedMatcher_in_expected_pattern),
TEST(DefaultErrorFormatting::parse_actual_arguments)
) //
{
}
fakeit::DefaultErrorFormatter formatter;
template <typename T> std::string to_string(T& val){
std::stringstream stream;
stream << val;
return stream.str();
}
struct SomeInterface {
virtual int func(int) = 0;
virtual void proc(int) = 0;
virtual int all_types(
char,
bool,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
double,
long double) = 0;
};
void parse_UnmockedMethodCallException() {
Mock<SomeInterface> mock;
SomeInterface &i = mock.get();
try {
i.func(1);
FAIL();
}
catch (UnexpectedMethodCallException& e)
{
std::string expectedMsg{"Unexpected method invocation: An unmocked method was invoked. All used virtual methods must be stubbed!"};
std::string actual{to_string(e)};
ASSERT_EQUAL(expectedMsg, actual);
}
}
void parse_UnmatchedMethodCallException() {
Mock<SomeInterface> mock;
Fake(Method(mock,func).Using(3));
SomeInterface &i = mock.get();
try {
i.func(1);
FAIL();
}
catch (UnexpectedMethodCallException& e)
{
std::string expectedMsg{"Unexpected method invocation: mock.func(1)\n Could not find any recorded behavior to support this method call."};
std::string actual{to_string(e)};
ASSERT_EQUAL(expectedMsg, actual);
}
}
void parse_AnyArguments() {
Mock<SomeInterface> mock;
try {
fakeit::Verify(Method(mock, func)).setFileInfo("test file",1,"test method").Exactly(Once);
}
catch (SequenceVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( any arguments )\n";
expectedMsg += "Expected matches: exactly 1\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg{to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_Exactly_Once() {
Mock<SomeInterface> mock;
try {
fakeit::Verify(Method(mock, func)).setFileInfo("test file",1,"test method").Exactly(Once);
}
catch (SequenceVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( any arguments )\n";
expectedMsg += "Expected matches: exactly 1\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg{to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_Atleast_Once() {
Mock<SomeInterface> mock;
try {
fakeit::Verify(Method(mock, func)).setFileInfo("test file",1,"test method").AtLeast(Once);
}
catch (SequenceVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( any arguments )\n";
expectedMsg += "Expected matches: at least 1\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg {to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_NoMoreInvocations_VerificationFailure() {
Mock<SomeInterface> mock;
try {
Fake(Method(mock, func));
mock.get().func(1);
mock.get().func(2);
fakeit::Verify(Method(mock, func).Using(1)).setFileInfo("test file",1,"test method");
fakeit::VerifyNoOtherInvocations(Method(mock, func)) //
.setFileInfo("test file",1,"test method");
}
catch (NoMoreInvocationsVerificationException& e) {
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected no more invocations!! But the following unverified invocations were found:\n";
expectedMsg += " mock.func(2)";//
std::string actualMsg{to_string(e)};//
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_UserDefinedMatcher_in_expected_pattern() {
Mock<SomeInterface> mock;
When(Method(mock, func)).Return(0);
//SomeInterface &i = mock.get();
try {
fakeit::Verify(Method(mock, func).Matching([](...){return true; })) //
.setFileInfo("test file",1,"test method").Exactly(2);
FAIL();
}
catch (SequenceVerificationException& e)
{
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.func( user defined matcher )\n";
expectedMsg += "Expected matches: exactly 2\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actualMsg {to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_actual_arguments() {
Mock<SomeInterface> mock;
When(Method(mock, all_types)).Return(0);
//SomeInterface &i = mock.get();
try {
mock().all_types('a', true, 1, 1, 1, 1, 1, 1, 1, 1);
fakeit::Verify(Method(mock, all_types)) //
.setFileInfo("test file",1,"test method").Exactly(2);
FAIL();
}
catch (SequenceVerificationException& e)
{
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.all_types( any arguments )\n";
expectedMsg += "Expected matches: exactly 2\n";
expectedMsg += "Actual matches : 1\n";
expectedMsg += "Actual sequence : total of 1 actual invocations:\n";
expectedMsg += " mock.all_types(?, true, 1, 1, 1, 1, 1, 1, 1.000000, 1.000000)";
std::string actualMsg {to_string(e)};
ASSERT_EQUAL(expectedMsg, actualMsg);
}
}
void parse_expected_arguments() {
Mock<SomeInterface> mock;
When(Method(mock, all_types)).Return(0);
//SomeInterface &i = mock.get();
try {
fakeit::Verify(Method(mock, all_types).Using('a', true, 1, 1, 1, 1, 1, 1, 1, 1))//
.setFileInfo("test file", 1, "test method").Exactly(2);
FAIL();
}
catch (SequenceVerificationException& e)
{
std::string expectedMsg;
expectedMsg += "test file:1: Verification error\n";
expectedMsg += "Expected pattern: mock.all_types( 'a', true, 1, 1, 1, 1, 1, 1, 1.0, 1.0 )\n";
expectedMsg += "Expected matches: exactly 2\n";
expectedMsg += "Actual matches : 0\n";
expectedMsg += "Actual sequence : total of 0 actual invocations.";
std::string actual {to_string(e)};
ASSERT_EQUAL(expectedMsg, actual);
}
}
} __DefaultErrorFormatting;
<|endoftext|>
|
<commit_before><commit_msg>Fix index buffer offsets<commit_after><|endoftext|>
|
<commit_before>
#include "include/config.h"
#include "osd/OSDCluster.h"
//#define MDS_CACHE_SIZE 4*10000 -> <20mb
//#define MDS_CACHE_SIZE 80000 62mb
#define AVG_PER_INODE_SIZE 450
#define MDS_CACHE_MB_TO_INODES(x) ((x)*1000000/AVG_PER_INODE_SIZE)
//#define MDS_CACHE_SIZE MDS_CACHE_MB_TO_INODES( 50 )
#define MDS_CACHE_SIZE 1500000
// hack hack hack ugly FIXME
long buffer_total_alloc = 0;
Mutex bufferlock;
OSDFileLayout g_OSD_FileLayout( 1<<20, 1, 1<<20 ); // stripe files over whole objects
//OSDFileLayout g_OSD_FileLayout( 1<<17, 4, 1<<20 ); // 128k stripes over sets of 4
// ??
OSDFileLayout g_OSD_MDDirLayout( 1<<14, 1<<2, 1<<19 );
// stripe mds log over 128 byte bits (see mds_log_pad_entry below to match!)
OSDFileLayout g_OSD_MDLogLayout( 1<<7, 32, 1<<20 ); // new (good?) way
//OSDFileLayout g_OSD_MDLogLayout( 57, 32, 1<<20 ); // pathological case to test striping buffer mapping
//OSDFileLayout g_OSD_MDLogLayout( 1<<20, 1, 1<<20 ); // old way
md_config_t g_conf = {
num_mds: 1,
num_osd: 4,
num_client: 1,
// profiling and debugging
log: true,
log_interval: 1,
log_name: (char*)0,
log_messages: true,
log_pins: true,
fake_clock: false,
fakemessenger_serialize: true,
debug: 1,
debug_mds_balancer: 1,
debug_mds_log: 1,
debug_buffer: 0,
debug_filer: 0,
debug_client: 0,
debug_osd: 0,
// --- client ---
client_cache_size: 300,
client_cache_mid: .5,
client_cache_stat_ttl: 10, // seconds until cached stat results become invalid
client_use_random_mds: false,
client_sync_writes: 0,
client_bcache: 1,
client_bcache_alloc_minsize: 1024,
client_bcache_alloc_maxsize: 262144,
client_bcache_ttl: 30, // seconds until dirty buffers are written to disk
client_bcache_size: 2147483648, // 2GB
client_bcache_lowater: 60, // % of size
client_bcache_hiwater: 80, // % of size
client_bcache_maxfrag: 10, // max actual relative # of bheads over opt rel # of bheads
client_trace: 0,
fuse_direct_io: 1,
// --- mds ---
mds_cache_size: MDS_CACHE_SIZE,
mds_cache_mid: .7,
mds_log: true,
mds_log_max_len: MDS_CACHE_SIZE / 3,
mds_log_max_trimming: 256,
mds_log_read_inc: 1<<20,
mds_log_pad_entry: 64,
mds_log_before_reply: true,
mds_log_flush_on_shutdown: true,
mds_bal_replicate_threshold: 8000,
mds_bal_unreplicate_threshold: 1000,
mds_bal_interval: 30, // seconds
mds_bal_idle_threshold: .1,
mds_bal_max: -1,
mds_bal_max_until: -1,
mds_commit_on_shutdown: true,
mds_verify_export_dirauth: true,
// --- osd ---
osd_nrep: 1,
osd_fsync: true,
osd_writesync: false,
osd_maxthreads: 10,
// --- fakeclient (mds regression testing) ---
num_fakeclient: 100,
fakeclient_requests: 100,
fakeclient_deterministic: false,
fakeclient_op_statfs: false,
// loosely based on Roselli workload paper numbers
fakeclient_op_stat: 610,
fakeclient_op_lstat: false,
fakeclient_op_utime: 0,
fakeclient_op_chmod: 1,
fakeclient_op_chown: 1,
fakeclient_op_readdir: 2,
fakeclient_op_mknod: 30,
fakeclient_op_link: false,
fakeclient_op_unlink: 20,
fakeclient_op_rename: 0,//40,
fakeclient_op_mkdir: 10,
fakeclient_op_rmdir: 20,
fakeclient_op_symlink: 20,
fakeclient_op_openrd: 200,
fakeclient_op_openwr: 0,
fakeclient_op_openwrc: 0,
fakeclient_op_read: false, // osd!
fakeclient_op_write: false, // osd!
fakeclient_op_truncate: false,
fakeclient_op_fsync: false,
fakeclient_op_close: 200
};
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
void parse_config_options(int argc, char **argv,
int& nargc, char**&nargv,
bool barf_on_extras)
{
// alloc new argc
nargv = (char**)malloc(sizeof(char*) * argc);
nargc = 0;
nargv[nargc++] = argv[0];
int extras = 0;
for (int i=1; i<argc; i++) {
if (strcmp(argv[i], "--nummds") == 0)
g_conf.num_mds = atoi(argv[++i]);
else if (strcmp(argv[i], "--numclient") == 0)
g_conf.num_client = atoi(argv[++i]);
else if (strcmp(argv[i], "--numosd") == 0)
g_conf.num_osd = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug") == 0)
g_conf.debug = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_mds_balancer") == 0)
g_conf.debug_mds_balancer = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_mds_log") == 0)
g_conf.debug_mds_log = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_buffer") == 0)
g_conf.debug_buffer = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_filer") == 0)
g_conf.debug_filer = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_client") == 0)
g_conf.debug_client = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_osd") == 0)
g_conf.debug_osd = atoi(argv[++i]);
else if (strcmp(argv[i], "--log") == 0)
g_conf.log = atoi(argv[++i]);
else if (strcmp(argv[i], "--log_name") == 0)
g_conf.log_name = argv[++i];
else if (strcmp(argv[i], "--fakemessenger_serialize") == 0)
g_conf.fakemessenger_serialize = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_cache_size") == 0)
g_conf.mds_cache_size = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log") == 0)
g_conf.mds_log = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_before_reply") == 0)
g_conf.mds_log_before_reply = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_max_len") == 0)
g_conf.mds_log_max_len = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_read_inc") == 0)
g_conf.mds_log_read_inc = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_max_trimming") == 0)
g_conf.mds_log_max_trimming = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_commit_on_shutdown") == 0)
g_conf.mds_commit_on_shutdown = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_flush_on_shutdown") == 0)
g_conf.mds_log_flush_on_shutdown = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_interval") == 0)
g_conf.mds_bal_interval = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_replicate_threshold") == 0)
g_conf.mds_bal_replicate_threshold = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_unreplicate_threshold") == 0)
g_conf.mds_bal_unreplicate_threshold = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_max") == 0)
g_conf.mds_bal_max = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_max_until") == 0)
g_conf.mds_bal_max_until = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_cache_size") == 0)
g_conf.client_cache_size = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_cache_stat_ttl") == 0)
g_conf.client_cache_stat_ttl = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_trace") == 0)
g_conf.client_trace = atoi(argv[++i]);
else if (strcmp(argv[i], "--fuse_direct_io") == 0)
g_conf.fuse_direct_io = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_sync_writes") == 0)
g_conf.client_sync_writes = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_bcache") == 0)
g_conf.client_bcache = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_nrep") == 0)
g_conf.osd_nrep = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_fsync") == 0)
g_conf.osd_fsync = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_writesync") == 0)
g_conf.osd_writesync = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_maxthreads") == 0)
g_conf.osd_maxthreads = atoi(argv[++i]);
else {
nargv[nargc++] = argv[i];
if (barf_on_extras) {
cerr << "extra arg " << argv[i] << endl;
extras++;
} else {
dout(2) << "passing arg " << argv[i] << endl;
}
}
}
if (barf_on_extras) {
cerr << extras << " extra args" << endl;
exit(0);
}
}
<commit_msg>*** empty log message ***<commit_after>
#include "include/config.h"
#include "osd/OSDCluster.h"
//#define MDS_CACHE_SIZE 4*10000 -> <20mb
//#define MDS_CACHE_SIZE 80000 62mb
#define AVG_PER_INODE_SIZE 450
#define MDS_CACHE_MB_TO_INODES(x) ((x)*1000000/AVG_PER_INODE_SIZE)
//#define MDS_CACHE_SIZE MDS_CACHE_MB_TO_INODES( 50 )
#define MDS_CACHE_SIZE 1500000
// hack hack hack ugly FIXME
long buffer_total_alloc = 0;
Mutex bufferlock;
OSDFileLayout g_OSD_FileLayout( 1<<20, 1, 1<<20 ); // stripe files over whole objects
//OSDFileLayout g_OSD_FileLayout( 1<<17, 4, 1<<20 ); // 128k stripes over sets of 4
// ??
OSDFileLayout g_OSD_MDDirLayout( 1<<14, 1<<2, 1<<19 );
// stripe mds log over 128 byte bits (see mds_log_pad_entry below to match!)
OSDFileLayout g_OSD_MDLogLayout( 1<<7, 32, 1<<20 ); // new (good?) way
//OSDFileLayout g_OSD_MDLogLayout( 57, 32, 1<<20 ); // pathological case to test striping buffer mapping
//OSDFileLayout g_OSD_MDLogLayout( 1<<20, 1, 1<<20 ); // old way
md_config_t g_conf = {
num_mds: 1,
num_osd: 4,
num_client: 1,
// profiling and debugging
log: true,
log_interval: 1,
log_name: (char*)0,
log_messages: true,
log_pins: true,
fake_clock: false,
fakemessenger_serialize: true,
debug: 1,
debug_mds_balancer: 1,
debug_mds_log: 1,
debug_buffer: 0,
debug_filer: 0,
debug_client: 0,
debug_osd: 0,
// --- client ---
client_cache_size: 300,
client_cache_mid: .5,
client_cache_stat_ttl: 10, // seconds until cached stat results become invalid
client_use_random_mds: false,
client_sync_writes: 0,
client_bcache: 1,
client_bcache_alloc_minsize: 1024,
client_bcache_alloc_maxsize: 262144,
client_bcache_ttl: 30, // seconds until dirty buffers are written to disk
client_bcache_size: 2147483648, // 2GB
client_bcache_lowater: 60, // % of size
client_bcache_hiwater: 80, // % of size
client_bcache_maxfrag: 10, // max actual relative # of bheads over opt rel # of bheads
client_trace: 0,
fuse_direct_io: 1,
// --- mds ---
mds_cache_size: MDS_CACHE_SIZE,
mds_cache_mid: .7,
mds_log: true,
mds_log_max_len: MDS_CACHE_SIZE / 3,
mds_log_max_trimming: 256,
mds_log_read_inc: 1<<20,
mds_log_pad_entry: 64,
mds_log_before_reply: true,
mds_log_flush_on_shutdown: true,
mds_bal_replicate_threshold: 8000,
mds_bal_unreplicate_threshold: 1000,
mds_bal_interval: 30, // seconds
mds_bal_idle_threshold: .1,
mds_bal_max: -1,
mds_bal_max_until: -1,
mds_commit_on_shutdown: true,
mds_verify_export_dirauth: true,
// --- osd ---
osd_nrep: 1,
osd_fsync: true,
osd_writesync: false,
osd_maxthreads: 10,
// --- fakeclient (mds regression testing) ---
num_fakeclient: 100,
fakeclient_requests: 100,
fakeclient_deterministic: false,
fakeclient_op_statfs: false,
// loosely based on Roselli workload paper numbers
fakeclient_op_stat: 610,
fakeclient_op_lstat: false,
fakeclient_op_utime: 0,
fakeclient_op_chmod: 1,
fakeclient_op_chown: 1,
fakeclient_op_readdir: 2,
fakeclient_op_mknod: 30,
fakeclient_op_link: false,
fakeclient_op_unlink: 20,
fakeclient_op_rename: 0,//40,
fakeclient_op_mkdir: 10,
fakeclient_op_rmdir: 20,
fakeclient_op_symlink: 20,
fakeclient_op_openrd: 200,
fakeclient_op_openwr: 0,
fakeclient_op_openwrc: 0,
fakeclient_op_read: false, // osd!
fakeclient_op_write: false, // osd!
fakeclient_op_truncate: false,
fakeclient_op_fsync: false,
fakeclient_op_close: 200
};
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
void parse_config_options(int argc, char **argv,
int& nargc, char**&nargv,
bool barf_on_extras)
{
// alloc new argc
nargv = (char**)malloc(sizeof(char*) * argc);
nargc = 0;
nargv[nargc++] = argv[0];
int extras = 0;
for (int i=1; i<argc; i++) {
if (strcmp(argv[i], "--nummds") == 0)
g_conf.num_mds = atoi(argv[++i]);
else if (strcmp(argv[i], "--numclient") == 0)
g_conf.num_client = atoi(argv[++i]);
else if (strcmp(argv[i], "--numosd") == 0)
g_conf.num_osd = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug") == 0)
g_conf.debug = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_mds_balancer") == 0)
g_conf.debug_mds_balancer = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_mds_log") == 0)
g_conf.debug_mds_log = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_buffer") == 0)
g_conf.debug_buffer = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_filer") == 0)
g_conf.debug_filer = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_client") == 0)
g_conf.debug_client = atoi(argv[++i]);
else if (strcmp(argv[i], "--debug_osd") == 0)
g_conf.debug_osd = atoi(argv[++i]);
else if (strcmp(argv[i], "--log") == 0)
g_conf.log = atoi(argv[++i]);
else if (strcmp(argv[i], "--log_name") == 0)
g_conf.log_name = argv[++i];
else if (strcmp(argv[i], "--fakemessenger_serialize") == 0)
g_conf.fakemessenger_serialize = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_cache_size") == 0)
g_conf.mds_cache_size = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log") == 0)
g_conf.mds_log = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_before_reply") == 0)
g_conf.mds_log_before_reply = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_max_len") == 0)
g_conf.mds_log_max_len = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_read_inc") == 0)
g_conf.mds_log_read_inc = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_max_trimming") == 0)
g_conf.mds_log_max_trimming = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_commit_on_shutdown") == 0)
g_conf.mds_commit_on_shutdown = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_log_flush_on_shutdown") == 0)
g_conf.mds_log_flush_on_shutdown = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_interval") == 0)
g_conf.mds_bal_interval = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_replicate_threshold") == 0)
g_conf.mds_bal_replicate_threshold = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_unreplicate_threshold") == 0)
g_conf.mds_bal_unreplicate_threshold = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_max") == 0)
g_conf.mds_bal_max = atoi(argv[++i]);
else if (strcmp(argv[i], "--mds_bal_max_until") == 0)
g_conf.mds_bal_max_until = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_cache_size") == 0)
g_conf.client_cache_size = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_cache_stat_ttl") == 0)
g_conf.client_cache_stat_ttl = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_trace") == 0)
g_conf.client_trace = atoi(argv[++i]);
else if (strcmp(argv[i], "--fuse_direct_io") == 0)
g_conf.fuse_direct_io = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_sync_writes") == 0)
g_conf.client_sync_writes = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_bcache") == 0)
g_conf.client_bcache = atoi(argv[++i]);
else if (strcmp(argv[i], "--client_bcache_ttl") == 0)
g_conf.client_bcache_ttl = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_nrep") == 0)
g_conf.osd_nrep = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_fsync") == 0)
g_conf.osd_fsync = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_writesync") == 0)
g_conf.osd_writesync = atoi(argv[++i]);
else if (strcmp(argv[i], "--osd_maxthreads") == 0)
g_conf.osd_maxthreads = atoi(argv[++i]);
else {
nargv[nargc++] = argv[i];
if (barf_on_extras) {
cerr << "extra arg " << argv[i] << endl;
extras++;
} else {
dout(2) << "passing arg " << argv[i] << endl;
}
}
}
if (barf_on_extras) {
cerr << extras << " extra args" << endl;
exit(0);
}
}
<|endoftext|>
|
<commit_before>#define CATCH_CONFIG_MAIN
#include "../../vendor/catch/catch.hpp"
#include "boost_defs.hpp"
#include "filesystem.hpp"
#include "local_datagram/client.hpp"
#include "local_datagram/client_manager.hpp"
#include "local_datagram/server.hpp"
#include "local_datagram/server_manager.hpp"
#include "thread_utility.hpp"
#include <boost/optional/optional_io.hpp>
TEST_CASE("initialize") {
krbn::thread_utility::register_main_thread();
}
namespace {
const std::string socket_path("tmp/server.sock");
size_t server_buffer_size(32 * 1024);
const std::chrono::milliseconds server_check_interval(100);
class test_server final {
public:
test_server(void) : closed_(false),
received_count_(0) {
unlink(socket_path.c_str());
server_ = std::make_unique<krbn::local_datagram::server>();
server_->bound.connect([this] {
bound_ = true;
});
server_->bind_failed.connect([this](auto&& error_code) {
bound_ = false;
});
server_->closed.connect([this] {
closed_ = true;
});
server_->received.connect([this](auto&& buffer) {
krbn::logger::get_logger().info("server received {0}", buffer.size());
received_count_ += buffer.size();
});
server_->bind(socket_path,
server_buffer_size,
server_check_interval);
// Roughly wait
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
~test_server(void) {
server_ = nullptr;
}
boost::optional<bool> get_bound(void) const {
return bound_;
}
bool get_closed(void) const {
return closed_;
}
size_t get_received_count(void) const {
return received_count_;
}
private:
boost::optional<bool> bound_;
bool closed_;
size_t received_count_;
std::unique_ptr<krbn::local_datagram::server> server_;
};
class test_client final {
public:
test_client(void) : closed_(false) {
client_ = std::make_unique<krbn::local_datagram::client>();
client_->connected.connect([this] {
connected_ = true;
});
client_->connect_failed.connect([this](auto&& error_code) {
connected_ = false;
std::cout << error_code.message() << std::endl;
});
client_->closed.connect([this] {
closed_ = true;
});
client_->connect(socket_path,
server_check_interval);
// Roughly wait
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
~test_client(void) {
client_ = nullptr;
}
boost::optional<bool> get_connected(void) const {
return connected_;
}
bool get_closed(void) const {
return closed_;
}
void async_send(void) {
std::vector<uint8_t> client_buffer(32);
if (client_) {
client_->async_send(client_buffer);
}
}
void destroy_client(void) {
client_ = nullptr;
}
private:
boost::optional<bool> connected_;
bool closed_;
std::unique_ptr<krbn::local_datagram::client> client_;
};
} // namespace
TEST_CASE("socket file") {
unlink(socket_path.c_str());
REQUIRE(!krbn::filesystem::exists(socket_path));
{
krbn::local_datagram::server server;
server.bind(socket_path,
server_buffer_size,
server_check_interval);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(krbn::filesystem::exists(socket_path));
}
REQUIRE(!krbn::filesystem::exists(socket_path));
}
TEST_CASE("fail to create socket file") {
krbn::local_datagram::server server;
bool failed = false;
server.bind_failed.connect([&](auto&& error_code) {
failed = true;
});
server.bind("/not_found/server.sock",
server_buffer_size,
server_check_interval);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(failed == true);
}
TEST_CASE("keep existing file in destructor") {
std::string regular_file_path("tmp/regular_file");
{
std::ofstream file(regular_file_path);
file << regular_file_path << std::endl;
}
REQUIRE(krbn::filesystem::exists(regular_file_path));
{
krbn::local_datagram::server server;
server.bind(regular_file_path,
server_buffer_size,
server_check_interval);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
REQUIRE(krbn::filesystem::exists(regular_file_path));
}
TEST_CASE("permission error") {
{
auto server = std::make_unique<test_server>();
// ----
chmod(socket_path.c_str(), 0000);
{
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == false);
}
REQUIRE(server->get_closed());
}
{
auto server = std::make_unique<test_server>();
// -r--
chmod(socket_path.c_str(), 0400);
{
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == false);
}
REQUIRE(server->get_closed());
}
{
auto server = std::make_unique<test_server>();
// -rw-
chmod(socket_path.c_str(), 0600);
{
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == true);
}
REQUIRE(!server->get_closed());
}
}
TEST_CASE("close when socket erased") {
auto server = std::make_unique<test_server>();
unlink(socket_path.c_str());
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(server->get_closed());
}
TEST_CASE("local_datagram::server") {
{
auto server = std::make_unique<test_server>();
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == true);
client->async_send();
client->async_send();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(!client->get_closed());
REQUIRE(server->get_received_count() == 64);
// Destroy server
server = nullptr;
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(client->get_closed());
}
// Send after server is destroyed.
{
REQUIRE(!krbn::filesystem::exists(socket_path));
test_client client;
REQUIRE(client.get_connected() == false);
client.async_send();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(!client.get_closed());
}
// Create client before server
{
test_client client;
REQUIRE(client.get_connected() == false);
test_server server;
REQUIRE(server.get_received_count() == 0);
client.async_send();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(server.get_received_count() == 0);
}
// `closed` is called in destructor.
{
test_server server;
test_client client;
REQUIRE(client.get_connected() == true);
client.destroy_client();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(client.get_closed());
}
// `closed` is not called in destructor if not connected.
{
test_client client;
client.destroy_client();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(!client.get_closed());
}
}
TEST_CASE("local_datagram::client_manager") {
{
size_t connected_count = 0;
size_t connect_failed_count = 0;
size_t closed_count = 0;
std::chrono::milliseconds reconnect_interval(100);
auto client_manager = std::make_unique<krbn::local_datagram::client_manager>(socket_path,
server_check_interval,
reconnect_interval);
client_manager->connected.connect([&] {
++connected_count;
krbn::logger::get_logger().info("client_manager connected: {0}", connected_count);
});
client_manager->connect_failed.connect([&](auto&& error_code) {
++connect_failed_count;
krbn::logger::get_logger().info("client_manager connect_failed: {0}", connect_failed_count);
});
client_manager->closed.connect([&] {
++closed_count;
krbn::logger::get_logger().info("client_manager closed: {0}", closed_count);
});
// Create client before server
client_manager->start();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(connected_count == 0);
REQUIRE(connect_failed_count > 2);
REQUIRE(closed_count == 0);
// Create server
auto server = std::make_shared<test_server>();
REQUIRE(connected_count == 1);
// Shtudown servr
connect_failed_count = 0;
server = nullptr;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
REQUIRE(connected_count == 1);
REQUIRE(connect_failed_count > 2);
REQUIRE(closed_count == 1);
// Recreate server
server = std::make_shared<test_server>();
REQUIRE(connected_count == 2);
}
}
<commit_msg>update tests<commit_after>#define CATCH_CONFIG_MAIN
#include "../../vendor/catch/catch.hpp"
#include "boost_defs.hpp"
#include "filesystem.hpp"
#include "local_datagram/client.hpp"
#include "local_datagram/client_manager.hpp"
#include "local_datagram/server.hpp"
#include "local_datagram/server_manager.hpp"
#include "thread_utility.hpp"
#include <boost/optional/optional_io.hpp>
TEST_CASE("initialize") {
krbn::thread_utility::register_main_thread();
}
namespace {
const std::string socket_path("tmp/server.sock");
size_t server_buffer_size(32 * 1024);
const std::chrono::milliseconds server_check_interval(100);
class test_server final {
public:
test_server(void) : closed_(false),
received_count_(0) {
unlink(socket_path.c_str());
server_ = std::make_unique<krbn::local_datagram::server>();
server_->bound.connect([this] {
bound_ = true;
});
server_->bind_failed.connect([this](auto&& error_code) {
bound_ = false;
});
server_->closed.connect([this] {
closed_ = true;
});
server_->received.connect([this](auto&& buffer) {
krbn::logger::get_logger().info("server received {0}", buffer.size());
received_count_ += buffer.size();
});
server_->bind(socket_path,
server_buffer_size,
server_check_interval);
// Wait server initialization roughly
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
~test_server(void) {
server_ = nullptr;
}
boost::optional<bool> get_bound(void) const {
return bound_;
}
bool get_closed(void) const {
return closed_;
}
size_t get_received_count(void) const {
return received_count_;
}
private:
boost::optional<bool> bound_;
bool closed_;
size_t received_count_;
std::unique_ptr<krbn::local_datagram::server> server_;
};
class test_client final {
public:
test_client(void) : closed_(false) {
client_ = std::make_unique<krbn::local_datagram::client>();
client_->connected.connect([this] {
connected_ = true;
});
client_->connect_failed.connect([this](auto&& error_code) {
connected_ = false;
std::cout << error_code.message() << std::endl;
});
client_->closed.connect([this] {
closed_ = true;
});
client_->connect(socket_path,
server_check_interval);
// Wait client initialization roughly
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
~test_client(void) {
client_ = nullptr;
}
boost::optional<bool> get_connected(void) const {
return connected_;
}
bool get_closed(void) const {
return closed_;
}
void async_send(void) {
std::vector<uint8_t> client_buffer(32);
if (client_) {
client_->async_send(client_buffer);
}
}
void destroy_client(void) {
client_ = nullptr;
}
private:
boost::optional<bool> connected_;
bool closed_;
std::unique_ptr<krbn::local_datagram::client> client_;
};
} // namespace
TEST_CASE("socket file") {
unlink(socket_path.c_str());
REQUIRE(!krbn::filesystem::exists(socket_path));
{
krbn::local_datagram::server server;
server.bind(socket_path,
server_buffer_size,
server_check_interval);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(krbn::filesystem::exists(socket_path));
}
REQUIRE(!krbn::filesystem::exists(socket_path));
}
TEST_CASE("fail to create socket file") {
krbn::local_datagram::server server;
bool failed = false;
server.bind_failed.connect([&](auto&& error_code) {
failed = true;
});
server.bind("/not_found/server.sock",
server_buffer_size,
server_check_interval);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(failed == true);
}
TEST_CASE("keep existing file in destructor") {
std::string regular_file_path("tmp/regular_file");
{
std::ofstream file(regular_file_path);
file << regular_file_path << std::endl;
}
REQUIRE(krbn::filesystem::exists(regular_file_path));
{
krbn::local_datagram::server server;
server.bind(regular_file_path,
server_buffer_size,
server_check_interval);
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
REQUIRE(krbn::filesystem::exists(regular_file_path));
}
TEST_CASE("permission error") {
{
auto server = std::make_unique<test_server>();
// ----
chmod(socket_path.c_str(), 0000);
{
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == false);
}
REQUIRE(server->get_closed());
}
{
auto server = std::make_unique<test_server>();
// -r--
chmod(socket_path.c_str(), 0400);
{
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == false);
}
REQUIRE(server->get_closed());
}
{
auto server = std::make_unique<test_server>();
// -rw-
chmod(socket_path.c_str(), 0600);
{
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == true);
}
REQUIRE(!server->get_closed());
}
}
TEST_CASE("close when socket erased") {
auto server = std::make_unique<test_server>();
unlink(socket_path.c_str());
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(server->get_closed());
}
TEST_CASE("local_datagram::server") {
{
auto server = std::make_unique<test_server>();
auto client = std::make_unique<test_client>();
REQUIRE(client->get_connected() == true);
client->async_send();
client->async_send();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(!client->get_closed());
REQUIRE(server->get_received_count() == 64);
// Destroy server
server = nullptr;
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(client->get_closed());
}
// Send after server is destroyed.
{
REQUIRE(!krbn::filesystem::exists(socket_path));
test_client client;
REQUIRE(client.get_connected() == false);
client.async_send();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(!client.get_closed());
}
// Create client before server
{
test_client client;
REQUIRE(client.get_connected() == false);
test_server server;
REQUIRE(server.get_received_count() == 0);
client.async_send();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(server.get_received_count() == 0);
}
// `closed` is called in destructor.
{
test_server server;
test_client client;
REQUIRE(client.get_connected() == true);
client.destroy_client();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(client.get_closed());
}
// `closed` is not called in destructor if not connected.
{
test_client client;
client.destroy_client();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(!client.get_closed());
}
}
TEST_CASE("local_datagram::client_manager") {
{
size_t connected_count = 0;
size_t connect_failed_count = 0;
size_t closed_count = 0;
std::chrono::milliseconds reconnect_interval(100);
auto client_manager = std::make_unique<krbn::local_datagram::client_manager>(socket_path,
server_check_interval,
reconnect_interval);
client_manager->connected.connect([&] {
++connected_count;
krbn::logger::get_logger().info("client_manager connected: {0}", connected_count);
});
client_manager->connect_failed.connect([&](auto&& error_code) {
++connect_failed_count;
krbn::logger::get_logger().info("client_manager connect_failed: {0}", connect_failed_count);
});
client_manager->closed.connect([&] {
++closed_count;
krbn::logger::get_logger().info("client_manager closed: {0}", closed_count);
});
// Create client before server
client_manager->start();
std::this_thread::sleep_for(std::chrono::milliseconds(500));
REQUIRE(connected_count == 0);
REQUIRE(connect_failed_count > 2);
REQUIRE(closed_count == 0);
// Create server
auto server = std::make_shared<test_server>();
REQUIRE(connected_count == 1);
// Shtudown servr
connect_failed_count = 0;
server = nullptr;
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
REQUIRE(connected_count == 1);
REQUIRE(connect_failed_count > 2);
REQUIRE(closed_count == 1);
// Recreate server
server = std::make_shared<test_server>();
REQUIRE(connected_count == 2);
}
}
<|endoftext|>
|
<commit_before>// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include "generic_peek.h"
#include <vespa/eval/eval/nested_loop.h>
#include <vespa/eval/eval/wrap_param.h>
#include <vespa/vespalib/util/overload.h>
#include <vespa/vespalib/util/stash.h>
#include <vespa/vespalib/util/typify.h>
#include <vespa/vespalib/util/visit_ranges.h>
#include <vespa/vespalib/util/shared_string_repo.h>
#include <cassert>
#include <map>
using namespace vespalib::eval::tensor_function;
namespace vespalib::eval::instruction {
using State = InterpretedFunction::State;
using Instruction = InterpretedFunction::Instruction;
using Handle = SharedStringRepo::Handle;
namespace {
static constexpr size_t npos = -1;
using Spec = GenericPeek::SpecMap;
size_t count_children(const Spec &spec)
{
// accounts for "input" child:
size_t num_children = 1;
for (const auto & [dim_name, child_or_label] : spec) {
if (std::holds_alternative<size_t>(child_or_label)) {
++num_children;
}
}
return num_children;
}
struct DimSpec {
enum class DimType { CHILD_IDX, LABEL_IDX, LABEL_STR };
DimType dim_type;
Handle str;
size_t idx;
static DimSpec from_child(size_t child_idx) {
return {DimType::CHILD_IDX, Handle(), child_idx};
}
static DimSpec from_label(const TensorSpec::Label &label) {
if (label.is_mapped()) {
return {DimType::LABEL_STR, Handle(label.name), 0};
} else {
assert(label.is_indexed());
return {DimType::LABEL_IDX, Handle(), label.index};
}
}
~DimSpec();
bool has_child() const {
return (dim_type == DimType::CHILD_IDX);
}
bool has_label() const {
return (dim_type != DimType::CHILD_IDX);
}
size_t get_child_idx() const {
assert(dim_type == DimType::CHILD_IDX);
return idx;
}
string_id get_label_name() const {
assert(dim_type == DimType::LABEL_STR);
return str.id();
}
size_t get_label_index() const {
assert(dim_type == DimType::LABEL_IDX);
return idx;
}
};
DimSpec::~DimSpec() = default;
struct ExtractedSpecs {
using Dimension = ValueType::Dimension;
struct MyComp {
bool operator() (const Dimension &a, const Spec::value_type &b) { return a.name < b.first; }
bool operator() (const Spec::value_type &a, const Dimension &b) { return a.first < b.name; }
};
std::vector<Dimension> dimensions;
std::map<vespalib::string, DimSpec> specs;
ExtractedSpecs(bool indexed,
const std::vector<Dimension> &input_dims,
const Spec &spec)
{
auto visitor = overload
{
[&](visit_ranges_first, const auto &a) {
if (a.is_indexed() == indexed) dimensions.push_back(a);
},
[&](visit_ranges_second, const auto &) {
// spec has unknown dimension
abort();
},
[&](visit_ranges_both, const auto &a, const auto &b) {
if (a.is_indexed() == indexed) {
dimensions.push_back(a);
const auto & [spec_dim_name, child_or_label] = b;
assert(a.name == spec_dim_name);
if (std::holds_alternative<size_t>(child_or_label)) {
specs[a.name] = DimSpec::from_child(std::get<size_t>(child_or_label));
} else {
specs[a.name] = DimSpec::from_label(std::get<TensorSpec::Label>(child_or_label));
}
}
}
};
visit_ranges(visitor,
input_dims.begin(), input_dims.end(),
spec.begin(), spec.end(), MyComp());
}
~ExtractedSpecs();
};
ExtractedSpecs::~ExtractedSpecs() = default;
struct DenseSizes {
SmallVector<size_t> size;
SmallVector<size_t> stride;
size_t cur_size;
DenseSizes(const std::vector<ValueType::Dimension> &dims)
: size(), stride(dims.size()), cur_size(1)
{
for (const auto &dim : dims) {
assert(dim.is_indexed());
size.push_back(dim.size);
}
for (size_t i = size.size(); i-- > 0; ) {
stride[i] = cur_size;
cur_size *= size[i];
}
}
};
/** Compute input offsets for all output cells */
struct DensePlan {
size_t in_dense_size;
size_t out_dense_size;
SmallVector<size_t> loop_cnt;
SmallVector<size_t> in_stride;
size_t verbatim_offset = 0;
struct Child {
size_t idx;
size_t stride;
size_t limit;
};
SmallVector<Child,4> children;
DensePlan(const ValueType &input_type, const Spec &spec)
{
const ExtractedSpecs mine(true, input_type.dimensions(), spec);
DenseSizes sizes(mine.dimensions);
in_dense_size = sizes.cur_size;
out_dense_size = 1;
for (size_t i = 0; i < mine.dimensions.size(); ++i) {
const auto &dim = mine.dimensions[i];
auto pos = mine.specs.find(dim.name);
if (pos == mine.specs.end()) {
loop_cnt.push_back(sizes.size[i]);
in_stride.push_back(sizes.stride[i]);
out_dense_size *= sizes.size[i];
} else {
if (pos->second.has_child()) {
children.push_back(Child{pos->second.get_child_idx(), sizes.stride[i], sizes.size[i]});
} else {
assert(pos->second.has_label());
size_t label_index = pos->second.get_label_index();
assert(label_index < sizes.size[i]);
verbatim_offset += label_index * sizes.stride[i];
}
}
}
}
/** Get initial offset (from verbatim labels and child values) */
template <typename Getter>
size_t get_offset(const Getter &get_child_value) const {
size_t offset = verbatim_offset;
for (size_t i = 0; i < children.size(); ++i) {
size_t from_child = get_child_value(children[i].idx);
if (from_child < children[i].limit) {
offset += from_child * children[i].stride;
} else {
return npos;
}
}
return offset;
}
template<typename F> void execute(size_t offset, const F &f) const {
run_nested_loop<F>(offset, loop_cnt, in_stride, f);
}
};
struct SparseState {
SmallVector<Handle> handles;
SmallVector<string_id> view_addr;
SmallVector<const string_id *> lookup_refs;
SmallVector<string_id> output_addr;
SmallVector<string_id *> fetch_addr;
SparseState(SmallVector<Handle> handles_in, SmallVector<string_id> view_addr_in, size_t out_dims)
: handles(std::move(handles_in)),
view_addr(std::move(view_addr_in)),
lookup_refs(view_addr.size()),
output_addr(out_dims),
fetch_addr(out_dims)
{
for (size_t i = 0; i < view_addr.size(); ++i) {
lookup_refs[i] = &view_addr[i];
}
for (size_t i = 0; i < out_dims; ++i) {
fetch_addr[i] = &output_addr[i];
}
}
~SparseState();
};
SparseState::~SparseState() = default;
struct SparsePlan {
size_t out_mapped_dims;
SmallVector<DimSpec> lookup_specs;
SmallVector<size_t> view_dims;
SparsePlan(const ValueType &input_type,
const GenericPeek::SpecMap &spec)
: out_mapped_dims(0),
view_dims()
{
ExtractedSpecs mine(false, input_type.dimensions(), spec);
for (size_t dim_idx = 0; dim_idx < mine.dimensions.size(); ++dim_idx) {
const auto & dim = mine.dimensions[dim_idx];
auto pos = mine.specs.find(dim.name);
if (pos == mine.specs.end()) {
++out_mapped_dims;
} else {
view_dims.push_back(dim_idx);
lookup_specs.push_back(pos->second);
}
}
}
~SparsePlan();
template <typename Getter>
SparseState make_state(const Getter &get_child_value) const {
SmallVector<Handle> handles;
SmallVector<string_id> view_addr;
for (const auto & dim : lookup_specs) {
if (dim.has_child()) {
int64_t child_value = get_child_value(dim.get_child_idx());
handles.emplace_back(vespalib::make_string("%" PRId64, child_value));
view_addr.push_back(handles.back().id());
} else {
view_addr.push_back(dim.get_label_name());
}
}
assert(view_addr.size() == view_dims.size());
return SparseState(std::move(handles), std::move(view_addr), out_mapped_dims);
}
};
SparsePlan::~SparsePlan() = default;
struct PeekParam {
const ValueType res_type;
DensePlan dense_plan;
SparsePlan sparse_plan;
size_t num_children;
const ValueBuilderFactory &factory;
PeekParam(const ValueType &res_type_in,
const ValueType &input_type,
const GenericPeek::SpecMap &spec_in,
const ValueBuilderFactory &factory_in)
: res_type(res_type_in),
dense_plan(input_type, spec_in),
sparse_plan(input_type, spec_in),
num_children(count_children(spec_in)),
factory(factory_in)
{
assert(dense_plan.in_dense_size == input_type.dense_subspace_size());
assert(dense_plan.out_dense_size == res_type.dense_subspace_size());
}
};
template <typename ICT, typename OCT, typename Getter>
Value::UP
generic_mixed_peek(const ValueType &res_type,
const Value &input_value,
const SparsePlan &sparse_plan,
const DensePlan &dense_plan,
const ValueBuilderFactory &factory,
const Getter &get_child_value)
{
auto input_cells = input_value.cells().typify<ICT>();
size_t bad_guess = 1;
auto builder = factory.create_transient_value_builder<OCT>(res_type,
sparse_plan.out_mapped_dims,
dense_plan.out_dense_size,
bad_guess);
size_t filled_subspaces = 0;
size_t dense_offset = dense_plan.get_offset(get_child_value);
if (dense_offset != npos) {
SparseState state = sparse_plan.make_state(get_child_value);
auto view = input_value.index().create_view(sparse_plan.view_dims);
view->lookup(state.lookup_refs);
size_t input_subspace;
while (view->next_result(state.fetch_addr, input_subspace)) {
auto dst = builder->add_subspace(state.output_addr).begin();
auto input_offset = input_subspace * dense_plan.in_dense_size;
dense_plan.execute(dense_offset + input_offset,
[&](size_t idx) { *dst++ = input_cells[idx]; });
++filled_subspaces;
}
}
if ((sparse_plan.out_mapped_dims == 0) && (filled_subspaces == 0)) {
for (auto & v : builder->add_subspace()) {
v = OCT{};
}
}
return builder->build(std::move(builder));
}
template <typename ICT, typename OCT>
void my_generic_peek_op(State &state, uint64_t param_in) {
const auto ¶m = unwrap_param<PeekParam>(param_in);
// stack index for children are in range [0, num_children>
size_t last_valid_stack_idx = param.num_children - 1;
const Value & input_value = state.peek(last_valid_stack_idx);
auto get_child_value = [&] (size_t child_idx) {
size_t stack_idx = last_valid_stack_idx - child_idx;
return int64_t(state.peek(stack_idx).as_double());
};
auto up = generic_mixed_peek<ICT,OCT>(param.res_type, input_value,
param.sparse_plan, param.dense_plan,
param.factory, get_child_value);
const Value &result = *state.stash.create<Value::UP>(std::move(up));
// num_children includes the "input" param
state.pop_n_push(param.num_children, result);
}
struct SelectGenericPeekOp {
template <typename ICT, typename OCT> static auto invoke() {
return my_generic_peek_op<ICT,OCT>;
}
};
//-----------------------------------------------------------------------------
} // namespace <unnamed>
Instruction
GenericPeek::make_instruction(const ValueType &result_type,
const ValueType &input_type,
const SpecMap &spec,
const ValueBuilderFactory &factory,
Stash &stash)
{
const auto ¶m = stash.create<PeekParam>(result_type, input_type, spec, factory);
auto fun = typify_invoke<2,TypifyCellType,SelectGenericPeekOp>(input_type.cell_type(), result_type.cell_type());
return Instruction(fun, wrap_param<PeekParam>(param));
}
} // namespace
<commit_msg>use TypifyCellMeta in GenericPeek<commit_after>// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#include "generic_peek.h"
#include <vespa/eval/eval/nested_loop.h>
#include <vespa/eval/eval/wrap_param.h>
#include <vespa/vespalib/util/overload.h>
#include <vespa/vespalib/util/stash.h>
#include <vespa/vespalib/util/typify.h>
#include <vespa/vespalib/util/visit_ranges.h>
#include <vespa/vespalib/util/shared_string_repo.h>
#include <cassert>
#include <map>
using namespace vespalib::eval::tensor_function;
namespace vespalib::eval::instruction {
using State = InterpretedFunction::State;
using Instruction = InterpretedFunction::Instruction;
using Handle = SharedStringRepo::Handle;
namespace {
static constexpr size_t npos = -1;
using Spec = GenericPeek::SpecMap;
size_t count_children(const Spec &spec)
{
// accounts for "input" child:
size_t num_children = 1;
for (const auto & [dim_name, child_or_label] : spec) {
if (std::holds_alternative<size_t>(child_or_label)) {
++num_children;
}
}
return num_children;
}
struct DimSpec {
enum class DimType { CHILD_IDX, LABEL_IDX, LABEL_STR };
DimType dim_type;
Handle str;
size_t idx;
static DimSpec from_child(size_t child_idx) {
return {DimType::CHILD_IDX, Handle(), child_idx};
}
static DimSpec from_label(const TensorSpec::Label &label) {
if (label.is_mapped()) {
return {DimType::LABEL_STR, Handle(label.name), 0};
} else {
assert(label.is_indexed());
return {DimType::LABEL_IDX, Handle(), label.index};
}
}
~DimSpec();
bool has_child() const {
return (dim_type == DimType::CHILD_IDX);
}
bool has_label() const {
return (dim_type != DimType::CHILD_IDX);
}
size_t get_child_idx() const {
assert(dim_type == DimType::CHILD_IDX);
return idx;
}
string_id get_label_name() const {
assert(dim_type == DimType::LABEL_STR);
return str.id();
}
size_t get_label_index() const {
assert(dim_type == DimType::LABEL_IDX);
return idx;
}
};
DimSpec::~DimSpec() = default;
struct ExtractedSpecs {
using Dimension = ValueType::Dimension;
struct MyComp {
bool operator() (const Dimension &a, const Spec::value_type &b) { return a.name < b.first; }
bool operator() (const Spec::value_type &a, const Dimension &b) { return a.first < b.name; }
};
std::vector<Dimension> dimensions;
std::map<vespalib::string, DimSpec> specs;
ExtractedSpecs(bool indexed,
const std::vector<Dimension> &input_dims,
const Spec &spec)
{
auto visitor = overload
{
[&](visit_ranges_first, const auto &a) {
if (a.is_indexed() == indexed) dimensions.push_back(a);
},
[&](visit_ranges_second, const auto &) {
// spec has unknown dimension
abort();
},
[&](visit_ranges_both, const auto &a, const auto &b) {
if (a.is_indexed() == indexed) {
dimensions.push_back(a);
const auto & [spec_dim_name, child_or_label] = b;
assert(a.name == spec_dim_name);
if (std::holds_alternative<size_t>(child_or_label)) {
specs[a.name] = DimSpec::from_child(std::get<size_t>(child_or_label));
} else {
specs[a.name] = DimSpec::from_label(std::get<TensorSpec::Label>(child_or_label));
}
}
}
};
visit_ranges(visitor,
input_dims.begin(), input_dims.end(),
spec.begin(), spec.end(), MyComp());
}
~ExtractedSpecs();
};
ExtractedSpecs::~ExtractedSpecs() = default;
struct DenseSizes {
SmallVector<size_t> size;
SmallVector<size_t> stride;
size_t cur_size;
DenseSizes(const std::vector<ValueType::Dimension> &dims)
: size(), stride(dims.size()), cur_size(1)
{
for (const auto &dim : dims) {
assert(dim.is_indexed());
size.push_back(dim.size);
}
for (size_t i = size.size(); i-- > 0; ) {
stride[i] = cur_size;
cur_size *= size[i];
}
}
};
/** Compute input offsets for all output cells */
struct DensePlan {
size_t in_dense_size;
size_t out_dense_size;
SmallVector<size_t> loop_cnt;
SmallVector<size_t> in_stride;
size_t verbatim_offset = 0;
struct Child {
size_t idx;
size_t stride;
size_t limit;
};
SmallVector<Child,4> children;
DensePlan(const ValueType &input_type, const Spec &spec)
{
const ExtractedSpecs mine(true, input_type.dimensions(), spec);
DenseSizes sizes(mine.dimensions);
in_dense_size = sizes.cur_size;
out_dense_size = 1;
for (size_t i = 0; i < mine.dimensions.size(); ++i) {
const auto &dim = mine.dimensions[i];
auto pos = mine.specs.find(dim.name);
if (pos == mine.specs.end()) {
loop_cnt.push_back(sizes.size[i]);
in_stride.push_back(sizes.stride[i]);
out_dense_size *= sizes.size[i];
} else {
if (pos->second.has_child()) {
children.push_back(Child{pos->second.get_child_idx(), sizes.stride[i], sizes.size[i]});
} else {
assert(pos->second.has_label());
size_t label_index = pos->second.get_label_index();
assert(label_index < sizes.size[i]);
verbatim_offset += label_index * sizes.stride[i];
}
}
}
}
/** Get initial offset (from verbatim labels and child values) */
template <typename Getter>
size_t get_offset(const Getter &get_child_value) const {
size_t offset = verbatim_offset;
for (size_t i = 0; i < children.size(); ++i) {
size_t from_child = get_child_value(children[i].idx);
if (from_child < children[i].limit) {
offset += from_child * children[i].stride;
} else {
return npos;
}
}
return offset;
}
template<typename F> void execute(size_t offset, const F &f) const {
run_nested_loop<F>(offset, loop_cnt, in_stride, f);
}
};
struct SparseState {
SmallVector<Handle> handles;
SmallVector<string_id> view_addr;
SmallVector<const string_id *> lookup_refs;
SmallVector<string_id> output_addr;
SmallVector<string_id *> fetch_addr;
SparseState(SmallVector<Handle> handles_in, SmallVector<string_id> view_addr_in, size_t out_dims)
: handles(std::move(handles_in)),
view_addr(std::move(view_addr_in)),
lookup_refs(view_addr.size()),
output_addr(out_dims),
fetch_addr(out_dims)
{
for (size_t i = 0; i < view_addr.size(); ++i) {
lookup_refs[i] = &view_addr[i];
}
for (size_t i = 0; i < out_dims; ++i) {
fetch_addr[i] = &output_addr[i];
}
}
~SparseState();
};
SparseState::~SparseState() = default;
struct SparsePlan {
size_t out_mapped_dims;
SmallVector<DimSpec> lookup_specs;
SmallVector<size_t> view_dims;
SparsePlan(const ValueType &input_type,
const GenericPeek::SpecMap &spec)
: out_mapped_dims(0),
view_dims()
{
ExtractedSpecs mine(false, input_type.dimensions(), spec);
for (size_t dim_idx = 0; dim_idx < mine.dimensions.size(); ++dim_idx) {
const auto & dim = mine.dimensions[dim_idx];
auto pos = mine.specs.find(dim.name);
if (pos == mine.specs.end()) {
++out_mapped_dims;
} else {
view_dims.push_back(dim_idx);
lookup_specs.push_back(pos->second);
}
}
}
~SparsePlan();
template <typename Getter>
SparseState make_state(const Getter &get_child_value) const {
SmallVector<Handle> handles;
SmallVector<string_id> view_addr;
for (const auto & dim : lookup_specs) {
if (dim.has_child()) {
int64_t child_value = get_child_value(dim.get_child_idx());
handles.emplace_back(vespalib::make_string("%" PRId64, child_value));
view_addr.push_back(handles.back().id());
} else {
view_addr.push_back(dim.get_label_name());
}
}
assert(view_addr.size() == view_dims.size());
return SparseState(std::move(handles), std::move(view_addr), out_mapped_dims);
}
};
SparsePlan::~SparsePlan() = default;
struct PeekParam {
const ValueType res_type;
DensePlan dense_plan;
SparsePlan sparse_plan;
size_t num_children;
const ValueBuilderFactory &factory;
PeekParam(const ValueType &res_type_in,
const ValueType &input_type,
const GenericPeek::SpecMap &spec_in,
const ValueBuilderFactory &factory_in)
: res_type(res_type_in),
dense_plan(input_type, spec_in),
sparse_plan(input_type, spec_in),
num_children(count_children(spec_in)),
factory(factory_in)
{
assert(dense_plan.in_dense_size == input_type.dense_subspace_size());
assert(dense_plan.out_dense_size == res_type.dense_subspace_size());
}
};
template <typename ICT, typename OCT, typename Getter>
Value::UP
generic_mixed_peek(const ValueType &res_type,
const Value &input_value,
const SparsePlan &sparse_plan,
const DensePlan &dense_plan,
const ValueBuilderFactory &factory,
const Getter &get_child_value)
{
auto input_cells = input_value.cells().typify<ICT>();
size_t bad_guess = 1;
auto builder = factory.create_transient_value_builder<OCT>(res_type,
sparse_plan.out_mapped_dims,
dense_plan.out_dense_size,
bad_guess);
size_t filled_subspaces = 0;
size_t dense_offset = dense_plan.get_offset(get_child_value);
if (dense_offset != npos) {
SparseState state = sparse_plan.make_state(get_child_value);
auto view = input_value.index().create_view(sparse_plan.view_dims);
view->lookup(state.lookup_refs);
size_t input_subspace;
while (view->next_result(state.fetch_addr, input_subspace)) {
auto dst = builder->add_subspace(state.output_addr).begin();
auto input_offset = input_subspace * dense_plan.in_dense_size;
dense_plan.execute(dense_offset + input_offset,
[&](size_t idx) { *dst++ = input_cells[idx]; });
++filled_subspaces;
}
}
if ((sparse_plan.out_mapped_dims == 0) && (filled_subspaces == 0)) {
for (auto & v : builder->add_subspace()) {
v = OCT{};
}
}
return builder->build(std::move(builder));
}
template <typename ICT, typename OCT>
void my_generic_peek_op(State &state, uint64_t param_in) {
const auto ¶m = unwrap_param<PeekParam>(param_in);
// stack index for children are in range [0, num_children>
size_t last_valid_stack_idx = param.num_children - 1;
const Value & input_value = state.peek(last_valid_stack_idx);
auto get_child_value = [&] (size_t child_idx) {
size_t stack_idx = last_valid_stack_idx - child_idx;
return int64_t(state.peek(stack_idx).as_double());
};
auto up = generic_mixed_peek<ICT,OCT>(param.res_type, input_value,
param.sparse_plan, param.dense_plan,
param.factory, get_child_value);
const Value &result = *state.stash.create<Value::UP>(std::move(up));
// num_children includes the "input" param
state.pop_n_push(param.num_children, result);
}
struct SelectGenericPeekOp {
template <typename ICM, typename OutIsScalar> static auto invoke() {
using ICT = CellValueType<ICM::value.cell_type>;
constexpr CellMeta ocm = CellMeta::peek(ICM::value.cell_type, OutIsScalar::value);
using OCT = CellValueType<ocm.cell_type>;
return my_generic_peek_op<ICT,OCT>;
}
};
//-----------------------------------------------------------------------------
} // namespace <unnamed>
Instruction
GenericPeek::make_instruction(const ValueType &result_type,
const ValueType &input_type,
const SpecMap &spec,
const ValueBuilderFactory &factory,
Stash &stash)
{
using PeekTypify = TypifyValue<TypifyCellMeta,TypifyBool>;
const auto ¶m = stash.create<PeekParam>(result_type, input_type, spec, factory);
auto fun = typify_invoke<2,PeekTypify,SelectGenericPeekOp>(input_type.cell_meta(), result_type.is_double());
return Instruction(fun, wrap_param<PeekParam>(param));
}
} // namespace
<|endoftext|>
|
<commit_before>//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
#include "CartesianMeshGenerator.h"
#include "CastUniquePointer.h"
// libMesh includes
#include "libmesh/mesh_generation.h"
#include "libmesh/unstructured_mesh.h"
#include "libmesh/replicated_mesh.h"
#include "libmesh/point.h"
#include "libmesh/elem.h"
#include "libmesh/node.h"
registerMooseObject("MooseApp", CartesianMeshGenerator);
defineLegacyParams(CartesianMeshGenerator);
InputParameters
CartesianMeshGenerator::validParams()
{
InputParameters params = MeshGenerator::validParams();
MooseEnum dims("1=1 2 3");
params.addRequiredParam<MooseEnum>("dim", dims, "The dimension of the mesh to be generated");
params.addRequiredParam<std::vector<Real>>("dx", "Intervals in the X direction");
params.addParam<std::vector<unsigned int>>(
"ix", "Number of grids in all intervals in the X direction (default to all one)");
params.addParam<std::vector<Real>>(
"dy", "Intervals in the Y direction (required when dim>1 otherwise ignored)");
params.addParam<std::vector<unsigned int>>(
"iy", "Number of grids in all intervals in the Y direction (default to all one)");
params.addParam<std::vector<Real>>(
"dz", "Intervals in the Z direction (required when dim>2 otherwise ignored)");
params.addParam<std::vector<unsigned int>>(
"iz", "Number of grids in all intervals in the Z direction (default to all one)");
params.addParam<std::vector<unsigned int>>("subdomain_id", "Block IDs (default to all zero)");
params.addParamNamesToGroup("dim", "Main");
params.addClassDescription("This CartesianMeshGenerator creates a non-uniform Cartesian mesh.");
return params;
}
CartesianMeshGenerator::CartesianMeshGenerator(const InputParameters & parameters)
: MeshGenerator(parameters),
_dim(getParam<MooseEnum>("dim")),
_dx(getParam<std::vector<Real>>("dx"))
{
// get all other parameters if provided and check their sizes
if (isParamValid("ix"))
{
_ix = getParam<std::vector<unsigned int>>("ix");
if (_ix.size() != _dx.size())
mooseError("ix must be in the same size of dx");
for (unsigned int i = 0; i < _ix.size(); ++i)
if (_ix[i] == 0)
mooseError("ix cannot be zero");
}
else
_ix = std::vector<unsigned int>(_dx.size(), 1);
for (unsigned int i = 0; i < _dx.size(); ++i)
if (_dx[i] <= 0)
mooseError("dx must be greater than zero");
if (isParamValid("dy"))
{
_dy = getParam<std::vector<Real>>("dy");
for (unsigned int i = 0; i < _dy.size(); ++i)
if (_dy[i] <= 0)
mooseError("dy must be greater than zero");
}
if (isParamValid("iy"))
{
_iy = getParam<std::vector<unsigned int>>("iy");
if (_iy.size() != _dy.size())
mooseError("iy must be in the same size of dy");
for (unsigned int i = 0; i < _iy.size(); ++i)
if (_iy[i] == 0)
mooseError("iy cannot be zero");
}
else
_iy = std::vector<unsigned int>(_dy.size(), 1);
if (isParamValid("dz"))
{
_dz = getParam<std::vector<Real>>("dz");
for (unsigned int i = 0; i < _dz.size(); ++i)
if (_dz[i] <= 0)
mooseError("dz must be greater than zero");
}
if (isParamValid("iz"))
{
_iz = getParam<std::vector<unsigned int>>("iz");
if (_iz.size() != _dz.size())
mooseError("iz must be in the same size of dz");
for (unsigned int i = 0; i < _iz.size(); ++i)
if (_iz[i] == 0)
mooseError("iz cannot be zero");
}
else
_iz = std::vector<unsigned int>(_dz.size(), 1);
if (isParamValid("subdomain_id"))
{
_subdomain_id = getParam<std::vector<unsigned int>>("subdomain_id");
if (isParamValid("dz") && isParamValid("dy"))
{
if (_subdomain_id.size() != _dx.size() * _dy.size() * _dz.size())
mooseError("subdomain_id must be in the size of product of sizes of dx, dy and dz");
}
else if (isParamValid("dy"))
{
if (_subdomain_id.size() != _dx.size() * _dy.size())
mooseError("subdomain_id must be in the size of product of sizes of dx and dy");
}
else
{
if (_subdomain_id.size() != _dx.size())
mooseError("subdomain_id must be in the size of product of sizes of dx");
}
}
else
{
if (isParamValid("dz"))
_subdomain_id = std::vector<unsigned int>(_dx.size() * _dy.size() * _dz.size(), 0);
else if (isParamValid("dy"))
_subdomain_id = std::vector<unsigned int>(_dx.size() * _dy.size(), 0);
else
_subdomain_id = std::vector<unsigned int>(_dx.size(), 0);
}
// do dimension checks and expand block IDs for all sub-grids
switch (_dim)
{
case 1:
{
_nx = 0;
for (unsigned int i = 0; i < _dx.size(); ++i)
_nx += _ix[i];
_ny = 1;
_nz = 1;
std::vector<unsigned int> new_id;
for (unsigned int i = 0; i < _dx.size(); ++i)
for (unsigned int ii = 0; ii < _ix[i]; ++ii)
new_id.push_back(_subdomain_id[i]);
_subdomain_id = new_id;
if (isParamValid("dy"))
mooseWarning("dy provided for 1D");
if (isParamValid("iy"))
mooseWarning("iy provided for 1D");
if (isParamValid("dz"))
mooseWarning("dz provided for 1D");
if (isParamValid("iz"))
mooseWarning("iz provided for 1D");
break;
}
case 2:
{
_nx = 0;
for (unsigned int i = 0; i < _dx.size(); ++i)
_nx += _ix[i];
_ny = 0;
for (unsigned int i = 0; i < _dy.size(); ++i)
_ny += _iy[i];
_nz = 1;
std::vector<unsigned int> new_id;
for (unsigned int j = 0; j < _dy.size(); ++j)
for (unsigned int jj = 0; jj < _iy[j]; ++jj)
for (unsigned int i = 0; i < _dx.size(); ++i)
for (unsigned int ii = 0; ii < _ix[i]; ++ii)
new_id.push_back(_subdomain_id[j * _dx.size() + i]);
_subdomain_id = new_id;
if (!isParamValid("dy"))
mooseError("dy is not provided for 2D");
if (isParamValid("dz"))
mooseWarning("dz provided for 2D");
if (isParamValid("iz"))
mooseWarning("iz provided for 2D");
break;
}
case 3:
{
_nx = 0;
for (unsigned int i = 0; i < _dx.size(); ++i)
_nx += _ix[i];
_ny = 0;
for (unsigned int i = 0; i < _dy.size(); ++i)
_ny += _iy[i];
_nz = 0;
for (unsigned int i = 0; i < _dz.size(); ++i)
_nz += _iz[i];
std::vector<unsigned int> new_id;
for (unsigned int k = 0; k < _dz.size(); ++k)
for (unsigned int kk = 0; kk < _iz[k]; ++kk)
for (unsigned int j = 0; j < _dy.size(); ++j)
for (unsigned int jj = 0; jj < _iy[j]; ++jj)
for (unsigned int i = 0; i < _dx.size(); ++i)
for (unsigned int ii = 0; ii < _ix[i]; ++ii)
new_id.push_back(_subdomain_id[k * _dx.size() * _dy.size() + j * _dx.size() + i]);
_subdomain_id = new_id;
if (!isParamValid("dy"))
mooseError("dy is not provided for 3D");
if (!isParamValid("dz"))
mooseError("dz is not provided for 3D");
break;
}
}
}
std::unique_ptr<MeshBase>
CartesianMeshGenerator::generate()
{
auto mesh = buildReplicatedMesh(2);
// switching on MooseEnum to generate the reference mesh
// Note: element type is fixed
switch (_dim)
{
case 1:
MeshTools::Generation::build_line(static_cast<UnstructuredMesh &>(*mesh), _nx, 0, _nx, EDGE2);
break;
case 2:
MeshTools::Generation::build_square(
static_cast<UnstructuredMesh &>(*mesh), _nx, _ny, 0, _nx, 0, _ny, QUAD4);
break;
case 3:
MeshTools::Generation::build_cube(
static_cast<UnstructuredMesh &>(*mesh), _nx, _ny, _nz, 0, _nx, 0, _ny, 0, _nz, HEX8);
break;
}
// assign block IDs
MeshBase::element_iterator el = mesh->active_elements_begin();
MeshBase::element_iterator el_end = mesh->active_elements_end();
for (; el != el_end; ++el)
{
const Point p = (*el)->centroid();
unsigned int ix = std::floor(p(0));
unsigned int iy = std::floor(p(1));
unsigned int iz = std::floor(p(2));
unsigned int i = iz * _nx * _ny + iy * _nx + ix;
(*el)->subdomain_id() = _subdomain_id[i];
}
// adjust node coordinates
switch (_dim)
{
case 1:
{
Real base;
std::vector<Real> mapx;
// Note: the starting coordinate is zero
base = 0;
mapx.push_back(base);
for (unsigned int i = 0; i < _dx.size(); ++i)
{
for (unsigned int j = 1; j <= _ix[i]; ++j)
mapx.push_back(base + _dx[i] / _ix[i] * j);
base += _dx[i];
}
MeshBase::node_iterator node = mesh->active_nodes_begin();
MeshBase::node_iterator node_end = mesh->active_nodes_end();
for (; node != node_end; ++node)
{
unsigned int i = (*(*node))(0) + 0.5;
(*(*node))(0) = mapx.at(i);
}
break;
}
case 2:
{
Real base;
std::vector<Real> mapx;
base = 0;
mapx.push_back(base);
for (unsigned int i = 0; i < _dx.size(); ++i)
{
for (unsigned int j = 1; j <= _ix[i]; ++j)
mapx.push_back(base + _dx[i] / _ix[i] * j);
base += _dx[i];
}
std::vector<Real> mapy;
base = 0;
mapy.push_back(base);
for (unsigned int i = 0; i < _dy.size(); ++i)
{
for (unsigned int j = 1; j <= _iy[i]; ++j)
mapy.push_back(base + _dy[i] / _iy[i] * j);
base += _dy[i];
}
MeshBase::node_iterator node = mesh->active_nodes_begin();
MeshBase::node_iterator node_end = mesh->active_nodes_end();
for (; node != node_end; ++node)
{
unsigned int i = (*(*node))(0) + 0.5;
(*(*node))(0) = mapx.at(i);
unsigned int j = (*(*node))(1) + 0.5;
(*(*node))(1) = mapy.at(j);
}
break;
}
case 3:
{
Real base;
std::vector<Real> mapx;
base = 0;
mapx.push_back(base);
for (unsigned int i = 0; i < _dx.size(); ++i)
{
for (unsigned int j = 1; j <= _ix[i]; ++j)
mapx.push_back(base + _dx[i] / _ix[i] * j);
base += _dx[i];
}
std::vector<Real> mapy;
base = 0;
mapy.push_back(base);
for (unsigned int i = 0; i < _dy.size(); ++i)
{
for (unsigned int j = 1; j <= _iy[i]; ++j)
mapy.push_back(base + _dy[i] / _iy[i] * j);
base += _dy[i];
}
std::vector<Real> mapz;
base = 0;
mapz.push_back(base);
for (unsigned int i = 0; i < _dz.size(); ++i)
{
for (unsigned int j = 1; j <= _iz[i]; ++j)
mapz.push_back(base + _dz[i] / _iz[i] * j);
base += _dz[i];
}
MeshBase::node_iterator node = mesh->active_nodes_begin();
MeshBase::node_iterator node_end = mesh->active_nodes_end();
for (; node != node_end; ++node)
{
unsigned int i = (*(*node))(0) + 0.5;
(*(*node))(0) = mapx.at(i);
unsigned int j = (*(*node))(1) + 0.5;
(*(*node))(1) = mapy.at(j);
unsigned int k = (*(*node))(2) + 0.5;
(*(*node))(2) = mapz.at(k);
}
break;
}
}
return dynamic_pointer_cast<MeshBase>(mesh);
}
<commit_msg>Build mesh in CartesianMeshGenerator based on parallel type<commit_after>//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
#include "CartesianMeshGenerator.h"
#include "CastUniquePointer.h"
// libMesh includes
#include "libmesh/mesh_generation.h"
#include "libmesh/unstructured_mesh.h"
#include "libmesh/replicated_mesh.h"
#include "libmesh/point.h"
#include "libmesh/elem.h"
#include "libmesh/node.h"
registerMooseObject("MooseApp", CartesianMeshGenerator);
defineLegacyParams(CartesianMeshGenerator);
InputParameters
CartesianMeshGenerator::validParams()
{
InputParameters params = MeshGenerator::validParams();
MooseEnum dims("1=1 2 3");
params.addRequiredParam<MooseEnum>("dim", dims, "The dimension of the mesh to be generated");
params.addRequiredParam<std::vector<Real>>("dx", "Intervals in the X direction");
params.addParam<std::vector<unsigned int>>(
"ix", "Number of grids in all intervals in the X direction (default to all one)");
params.addParam<std::vector<Real>>(
"dy", "Intervals in the Y direction (required when dim>1 otherwise ignored)");
params.addParam<std::vector<unsigned int>>(
"iy", "Number of grids in all intervals in the Y direction (default to all one)");
params.addParam<std::vector<Real>>(
"dz", "Intervals in the Z direction (required when dim>2 otherwise ignored)");
params.addParam<std::vector<unsigned int>>(
"iz", "Number of grids in all intervals in the Z direction (default to all one)");
params.addParam<std::vector<unsigned int>>("subdomain_id", "Block IDs (default to all zero)");
params.addParamNamesToGroup("dim", "Main");
params.addClassDescription("This CartesianMeshGenerator creates a non-uniform Cartesian mesh.");
return params;
}
CartesianMeshGenerator::CartesianMeshGenerator(const InputParameters & parameters)
: MeshGenerator(parameters),
_dim(getParam<MooseEnum>("dim")),
_dx(getParam<std::vector<Real>>("dx"))
{
// get all other parameters if provided and check their sizes
if (isParamValid("ix"))
{
_ix = getParam<std::vector<unsigned int>>("ix");
if (_ix.size() != _dx.size())
mooseError("ix must be in the same size of dx");
for (unsigned int i = 0; i < _ix.size(); ++i)
if (_ix[i] == 0)
mooseError("ix cannot be zero");
}
else
_ix = std::vector<unsigned int>(_dx.size(), 1);
for (unsigned int i = 0; i < _dx.size(); ++i)
if (_dx[i] <= 0)
mooseError("dx must be greater than zero");
if (isParamValid("dy"))
{
_dy = getParam<std::vector<Real>>("dy");
for (unsigned int i = 0; i < _dy.size(); ++i)
if (_dy[i] <= 0)
mooseError("dy must be greater than zero");
}
if (isParamValid("iy"))
{
_iy = getParam<std::vector<unsigned int>>("iy");
if (_iy.size() != _dy.size())
mooseError("iy must be in the same size of dy");
for (unsigned int i = 0; i < _iy.size(); ++i)
if (_iy[i] == 0)
mooseError("iy cannot be zero");
}
else
_iy = std::vector<unsigned int>(_dy.size(), 1);
if (isParamValid("dz"))
{
_dz = getParam<std::vector<Real>>("dz");
for (unsigned int i = 0; i < _dz.size(); ++i)
if (_dz[i] <= 0)
mooseError("dz must be greater than zero");
}
if (isParamValid("iz"))
{
_iz = getParam<std::vector<unsigned int>>("iz");
if (_iz.size() != _dz.size())
mooseError("iz must be in the same size of dz");
for (unsigned int i = 0; i < _iz.size(); ++i)
if (_iz[i] == 0)
mooseError("iz cannot be zero");
}
else
_iz = std::vector<unsigned int>(_dz.size(), 1);
if (isParamValid("subdomain_id"))
{
_subdomain_id = getParam<std::vector<unsigned int>>("subdomain_id");
if (isParamValid("dz") && isParamValid("dy"))
{
if (_subdomain_id.size() != _dx.size() * _dy.size() * _dz.size())
mooseError("subdomain_id must be in the size of product of sizes of dx, dy and dz");
}
else if (isParamValid("dy"))
{
if (_subdomain_id.size() != _dx.size() * _dy.size())
mooseError("subdomain_id must be in the size of product of sizes of dx and dy");
}
else
{
if (_subdomain_id.size() != _dx.size())
mooseError("subdomain_id must be in the size of product of sizes of dx");
}
}
else
{
if (isParamValid("dz"))
_subdomain_id = std::vector<unsigned int>(_dx.size() * _dy.size() * _dz.size(), 0);
else if (isParamValid("dy"))
_subdomain_id = std::vector<unsigned int>(_dx.size() * _dy.size(), 0);
else
_subdomain_id = std::vector<unsigned int>(_dx.size(), 0);
}
// do dimension checks and expand block IDs for all sub-grids
switch (_dim)
{
case 1:
{
_nx = 0;
for (unsigned int i = 0; i < _dx.size(); ++i)
_nx += _ix[i];
_ny = 1;
_nz = 1;
std::vector<unsigned int> new_id;
for (unsigned int i = 0; i < _dx.size(); ++i)
for (unsigned int ii = 0; ii < _ix[i]; ++ii)
new_id.push_back(_subdomain_id[i]);
_subdomain_id = new_id;
if (isParamValid("dy"))
mooseWarning("dy provided for 1D");
if (isParamValid("iy"))
mooseWarning("iy provided for 1D");
if (isParamValid("dz"))
mooseWarning("dz provided for 1D");
if (isParamValid("iz"))
mooseWarning("iz provided for 1D");
break;
}
case 2:
{
_nx = 0;
for (unsigned int i = 0; i < _dx.size(); ++i)
_nx += _ix[i];
_ny = 0;
for (unsigned int i = 0; i < _dy.size(); ++i)
_ny += _iy[i];
_nz = 1;
std::vector<unsigned int> new_id;
for (unsigned int j = 0; j < _dy.size(); ++j)
for (unsigned int jj = 0; jj < _iy[j]; ++jj)
for (unsigned int i = 0; i < _dx.size(); ++i)
for (unsigned int ii = 0; ii < _ix[i]; ++ii)
new_id.push_back(_subdomain_id[j * _dx.size() + i]);
_subdomain_id = new_id;
if (!isParamValid("dy"))
mooseError("dy is not provided for 2D");
if (isParamValid("dz"))
mooseWarning("dz provided for 2D");
if (isParamValid("iz"))
mooseWarning("iz provided for 2D");
break;
}
case 3:
{
_nx = 0;
for (unsigned int i = 0; i < _dx.size(); ++i)
_nx += _ix[i];
_ny = 0;
for (unsigned int i = 0; i < _dy.size(); ++i)
_ny += _iy[i];
_nz = 0;
for (unsigned int i = 0; i < _dz.size(); ++i)
_nz += _iz[i];
std::vector<unsigned int> new_id;
for (unsigned int k = 0; k < _dz.size(); ++k)
for (unsigned int kk = 0; kk < _iz[k]; ++kk)
for (unsigned int j = 0; j < _dy.size(); ++j)
for (unsigned int jj = 0; jj < _iy[j]; ++jj)
for (unsigned int i = 0; i < _dx.size(); ++i)
for (unsigned int ii = 0; ii < _ix[i]; ++ii)
new_id.push_back(_subdomain_id[k * _dx.size() * _dy.size() + j * _dx.size() + i]);
_subdomain_id = new_id;
if (!isParamValid("dy"))
mooseError("dy is not provided for 3D");
if (!isParamValid("dz"))
mooseError("dz is not provided for 3D");
break;
}
}
}
std::unique_ptr<MeshBase>
CartesianMeshGenerator::generate()
{
auto mesh = buildMeshBaseObject();
// switching on MooseEnum to generate the reference mesh
// Note: element type is fixed
switch (_dim)
{
case 1:
MeshTools::Generation::build_line(static_cast<UnstructuredMesh &>(*mesh), _nx, 0, _nx, EDGE2);
break;
case 2:
MeshTools::Generation::build_square(
static_cast<UnstructuredMesh &>(*mesh), _nx, _ny, 0, _nx, 0, _ny, QUAD4);
break;
case 3:
MeshTools::Generation::build_cube(
static_cast<UnstructuredMesh &>(*mesh), _nx, _ny, _nz, 0, _nx, 0, _ny, 0, _nz, HEX8);
break;
}
// assign block IDs
MeshBase::element_iterator el = mesh->active_elements_begin();
MeshBase::element_iterator el_end = mesh->active_elements_end();
for (; el != el_end; ++el)
{
const Point p = (*el)->centroid();
unsigned int ix = std::floor(p(0));
unsigned int iy = std::floor(p(1));
unsigned int iz = std::floor(p(2));
unsigned int i = iz * _nx * _ny + iy * _nx + ix;
(*el)->subdomain_id() = _subdomain_id[i];
}
// adjust node coordinates
switch (_dim)
{
case 1:
{
Real base;
std::vector<Real> mapx;
// Note: the starting coordinate is zero
base = 0;
mapx.push_back(base);
for (unsigned int i = 0; i < _dx.size(); ++i)
{
for (unsigned int j = 1; j <= _ix[i]; ++j)
mapx.push_back(base + _dx[i] / _ix[i] * j);
base += _dx[i];
}
MeshBase::node_iterator node = mesh->active_nodes_begin();
MeshBase::node_iterator node_end = mesh->active_nodes_end();
for (; node != node_end; ++node)
{
unsigned int i = (*(*node))(0) + 0.5;
(*(*node))(0) = mapx.at(i);
}
break;
}
case 2:
{
Real base;
std::vector<Real> mapx;
base = 0;
mapx.push_back(base);
for (unsigned int i = 0; i < _dx.size(); ++i)
{
for (unsigned int j = 1; j <= _ix[i]; ++j)
mapx.push_back(base + _dx[i] / _ix[i] * j);
base += _dx[i];
}
std::vector<Real> mapy;
base = 0;
mapy.push_back(base);
for (unsigned int i = 0; i < _dy.size(); ++i)
{
for (unsigned int j = 1; j <= _iy[i]; ++j)
mapy.push_back(base + _dy[i] / _iy[i] * j);
base += _dy[i];
}
MeshBase::node_iterator node = mesh->active_nodes_begin();
MeshBase::node_iterator node_end = mesh->active_nodes_end();
for (; node != node_end; ++node)
{
unsigned int i = (*(*node))(0) + 0.5;
(*(*node))(0) = mapx.at(i);
unsigned int j = (*(*node))(1) + 0.5;
(*(*node))(1) = mapy.at(j);
}
break;
}
case 3:
{
Real base;
std::vector<Real> mapx;
base = 0;
mapx.push_back(base);
for (unsigned int i = 0; i < _dx.size(); ++i)
{
for (unsigned int j = 1; j <= _ix[i]; ++j)
mapx.push_back(base + _dx[i] / _ix[i] * j);
base += _dx[i];
}
std::vector<Real> mapy;
base = 0;
mapy.push_back(base);
for (unsigned int i = 0; i < _dy.size(); ++i)
{
for (unsigned int j = 1; j <= _iy[i]; ++j)
mapy.push_back(base + _dy[i] / _iy[i] * j);
base += _dy[i];
}
std::vector<Real> mapz;
base = 0;
mapz.push_back(base);
for (unsigned int i = 0; i < _dz.size(); ++i)
{
for (unsigned int j = 1; j <= _iz[i]; ++j)
mapz.push_back(base + _dz[i] / _iz[i] * j);
base += _dz[i];
}
MeshBase::node_iterator node = mesh->active_nodes_begin();
MeshBase::node_iterator node_end = mesh->active_nodes_end();
for (; node != node_end; ++node)
{
unsigned int i = (*(*node))(0) + 0.5;
(*(*node))(0) = mapx.at(i);
unsigned int j = (*(*node))(1) + 0.5;
(*(*node))(1) = mapy.at(j);
unsigned int k = (*(*node))(2) + 0.5;
(*(*node))(2) = mapz.at(k);
}
break;
}
}
return dynamic_pointer_cast<MeshBase>(mesh);
}
<|endoftext|>
|
<commit_before>/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: typedetectionimport.hxx,v $
*
* $Revision: 1.4 $
*
* last change: $Author: rt $ $Date: 2005-09-08 22:15:54 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _TYPEDETECTION_IMPORT_HXX
#define _TYPEDETECTION_IMPORT_HXX
#ifndef _COM_SUN_STAR_LANG_XMULTISERVICEFACTORY_HPP_
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#endif
#ifndef _COM_SUN_STAR_IO_XINPUTSTREAM_HPP_
#include <com/sun/star/io/XInputStream.hpp>
#endif
#ifndef _CPPUHELPER_IMPLBASE1_HXX_
#include <cppuhelper/implbase1.hxx> // helper for implementations
#endif
#ifndef _COM_SUN_STAR_XML_SAX_XDUCUMENTHANDLER_HPP_
#include <com/sun/star/xml/sax/XDocumentHandler.hpp>
#endif
#ifndef _COMPHELPER_STLTYPES_HXX_
#include <comphelper/stl_types.hxx>
#endif
#include "xmlfilterjar.hxx"
#include <vector>
#include <stack>
namespace com { namespace sun { namespace star {
namespace xml { namespace sax { class XAttributeList; } }
namespace beans { struct PropertyValue; }
} } }
enum ImportState
{
e_Root,
e_Filters,
e_Types,
e_Filter,
e_Type,
e_Property,
e_Value,
e_Unknown
};
DECLARE_STL_USTRINGACCESS_MAP( ::rtl::OUString, PropertyMap );
struct Node
{
::rtl::OUString maName;
PropertyMap maPropertyMap;
};
typedef std::vector< Node* > NodeVector;
class TypeDetectionImporter : public cppu::WeakImplHelper1 < com::sun::star::xml::sax::XDocumentHandler >
{
public:
TypeDetectionImporter( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& xMSF );
virtual ~TypeDetectionImporter( void );
static void doImport( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& xMSF, com::sun::star::uno::Reference < com::sun::star::io::XInputStream > xOS, XMLFilterVector& rFilters );
virtual void SAL_CALL startDocument( )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL endDocument( )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL startElement( const ::rtl::OUString& aName, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttribs )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL endElement( const ::rtl::OUString& aName )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL characters( const ::rtl::OUString& aChars )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL ignorableWhitespace( const ::rtl::OUString& aWhitespaces )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL processingInstruction( const ::rtl::OUString& aTarget, const ::rtl::OUString& aData )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setDocumentLocator( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XLocator >& xLocator )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
private:
void fillFilterVector( XMLFilterVector& rFilters );
filter_info_impl* createFilterForNode( Node * pNode );
Node* findTypeNode( const ::rtl::OUString& rType );
com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > mxMSF;
std::stack< ImportState > maStack;
PropertyMap maPropertyMap;
NodeVector maFilterNodes;
NodeVector maTypeNodes;
::rtl::OUString maValue;
::rtl::OUString maNodeName;
::rtl::OUString maPropertyName;
const ::rtl::OUString sRootNode;
const ::rtl::OUString sNode;
const ::rtl::OUString sName;
const ::rtl::OUString sProp;
const ::rtl::OUString sValue;
const ::rtl::OUString sUIName;
const ::rtl::OUString sData;
const ::rtl::OUString sFilters;
const ::rtl::OUString sTypes;
const ::rtl::OUString sFilterAdaptorService;
const ::rtl::OUString sXSLTFilterService;
const ::rtl::OUString sCdataAttribute;
const ::rtl::OUString sWhiteSpace;
};
#endif
<commit_msg>INTEGRATION: CWS changefileheader (1.4.430); FILE MERGED 2008/04/01 15:16:01 thb 1.4.430.3: #i85898# Stripping all external header guards 2008/04/01 10:56:20 thb 1.4.430.2: #i85898# Stripping all external header guards 2008/03/28 15:31:53 rt 1.4.430.1: #i87441# Change license header to LPGL v3.<commit_after>/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: typedetectionimport.hxx,v $
* $Revision: 1.5 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef _TYPEDETECTION_IMPORT_HXX
#define _TYPEDETECTION_IMPORT_HXX
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <cppuhelper/implbase1.hxx> // helper for implementations
#ifndef _COM_SUN_STAR_XML_SAX_XDUCUMENTHANDLER_HPP_
#include <com/sun/star/xml/sax/XDocumentHandler.hpp>
#endif
#include <comphelper/stl_types.hxx>
#include "xmlfilterjar.hxx"
#include <vector>
#include <stack>
namespace com { namespace sun { namespace star {
namespace xml { namespace sax { class XAttributeList; } }
namespace beans { struct PropertyValue; }
} } }
enum ImportState
{
e_Root,
e_Filters,
e_Types,
e_Filter,
e_Type,
e_Property,
e_Value,
e_Unknown
};
DECLARE_STL_USTRINGACCESS_MAP( ::rtl::OUString, PropertyMap );
struct Node
{
::rtl::OUString maName;
PropertyMap maPropertyMap;
};
typedef std::vector< Node* > NodeVector;
class TypeDetectionImporter : public cppu::WeakImplHelper1 < com::sun::star::xml::sax::XDocumentHandler >
{
public:
TypeDetectionImporter( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& xMSF );
virtual ~TypeDetectionImporter( void );
static void doImport( com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& xMSF, com::sun::star::uno::Reference < com::sun::star::io::XInputStream > xOS, XMLFilterVector& rFilters );
virtual void SAL_CALL startDocument( )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL endDocument( )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL startElement( const ::rtl::OUString& aName, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& xAttribs )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL endElement( const ::rtl::OUString& aName )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL characters( const ::rtl::OUString& aChars )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL ignorableWhitespace( const ::rtl::OUString& aWhitespaces )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL processingInstruction( const ::rtl::OUString& aTarget, const ::rtl::OUString& aData )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setDocumentLocator( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XLocator >& xLocator )
throw(::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException);
private:
void fillFilterVector( XMLFilterVector& rFilters );
filter_info_impl* createFilterForNode( Node * pNode );
Node* findTypeNode( const ::rtl::OUString& rType );
com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > mxMSF;
std::stack< ImportState > maStack;
PropertyMap maPropertyMap;
NodeVector maFilterNodes;
NodeVector maTypeNodes;
::rtl::OUString maValue;
::rtl::OUString maNodeName;
::rtl::OUString maPropertyName;
const ::rtl::OUString sRootNode;
const ::rtl::OUString sNode;
const ::rtl::OUString sName;
const ::rtl::OUString sProp;
const ::rtl::OUString sValue;
const ::rtl::OUString sUIName;
const ::rtl::OUString sData;
const ::rtl::OUString sFilters;
const ::rtl::OUString sTypes;
const ::rtl::OUString sFilterAdaptorService;
const ::rtl::OUString sXSLTFilterService;
const ::rtl::OUString sCdataAttribute;
const ::rtl::OUString sWhiteSpace;
};
#endif
<|endoftext|>
|
<commit_before><commit_msg>Fix i386 bug<commit_after><|endoftext|>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.