From f800dbc034e7a70a613bab8cd9d147be4f6e88b6 Mon Sep 17 00:00:00 2001 From: Clyne Sullivan Date: Tue, 10 Jan 2017 21:26:13 -0500 Subject: [PATCH] windows build --- Makefile | 16 +- entityx/3rdparty/catch.hpp | 8345 ++++++++++++++++++++++++++++ entityx/3rdparty/simplesignal.h | 580 ++ entityx/Entity.cc | 61 + entityx/Entity.h | 1104 ++++ entityx/Event.cc | 26 + entityx/Event.h | 216 + entityx/Makefile | 16 + entityx/System.cc | 34 + entityx/System.h | 180 + entityx/config.h | 11 + entityx/deps/Dependencies.h | 54 + entityx/entityx.h | 6 + entityx/help/NonCopyable.h | 20 + entityx/help/Pool.cc | 21 + entityx/help/Pool.h | 95 + entityx/help/Timer.cc | 32 + entityx/help/Timer.h | 29 + entityx/libentityx.a | Bin 0 -> 435972 bytes entityx/out/Entity.o | Bin 0 -> 317167 bytes entityx/out/Event.o | Bin 0 -> 23737 bytes entityx/out/Pool.o | Bin 0 -> 12428 bytes entityx/out/System.o | Bin 0 -> 21295 bytes entityx/out/Timer.o | Bin 0 -> 12317 bytes entityx/tags/TagsComponent.h | 55 + freetype6.dll | Bin 0 -> 522240 bytes glew32.dll | Bin 0 -> 568892 bytes include/common.hpp | 1 + include/mingw.condition_variable.h | 211 + include/mingw.mutex.h | 275 + include/mingw.thread.h | 167 + src/world.cpp | 4 - 32 files changed, 11552 insertions(+), 7 deletions(-) create mode 100644 entityx/3rdparty/catch.hpp create mode 100644 entityx/3rdparty/simplesignal.h create mode 100644 entityx/Entity.cc create mode 100644 entityx/Entity.h create mode 100644 entityx/Event.cc create mode 100644 entityx/Event.h create mode 100644 entityx/Makefile create mode 100644 entityx/System.cc create mode 100644 entityx/System.h create mode 100644 entityx/config.h create mode 100644 entityx/deps/Dependencies.h create mode 100644 entityx/entityx.h create mode 100644 entityx/help/NonCopyable.h create mode 100644 entityx/help/Pool.cc create mode 100644 entityx/help/Pool.h create mode 100644 entityx/help/Timer.cc create mode 100644 entityx/help/Timer.h create mode 100644 entityx/libentityx.a create mode 100644 entityx/out/Entity.o create mode 100644 entityx/out/Event.o create mode 100644 entityx/out/Pool.o create mode 100644 entityx/out/System.o create mode 100644 entityx/out/Timer.o create mode 100644 entityx/tags/TagsComponent.h create mode 100644 freetype6.dll create mode 100644 glew32.dll create mode 100644 include/mingw.condition_variable.h create mode 100644 include/mingw.mutex.h create mode 100644 include/mingw.thread.h diff --git a/Makefile b/Makefile index 26adce1..f8d7511 100644 --- a/Makefile +++ b/Makefile @@ -5,7 +5,7 @@ CXX = g++ ifeq ($(TARGET_OS),linux) LIBS = -lpthread -lGL -lGLEW -lfreetype \ - -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2main -lentityx + -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2main endif ifeq ($(TARGET_OS),win32) LIBS = -lopengl32 -lglew32 -lmingw32 \ @@ -13,8 +13,8 @@ ifeq ($(TARGET_OS),win32) endif CXXFLAGS = -ggdb -m$(TARGET_BITS) -std=c++14 -fext-numeric-literals -CXXINC = -Iinclude -Iinclude/freetype -CXXWARN = -Wall -Wextra -Werror -pedantic +CXXINC = -Iinclude -Iinclude/freetype -I. +CXXWARN = -Wall -Wextra #-Werror -pedantic CXXSRCDIR = src CXXOUTDIR = out @@ -39,6 +39,12 @@ cleandata: touch brice.dat $(EXEC): $(CXXOUTDIR)/$(CXXOBJ) main.cpp + g++ -I. -std=c++11 -c entityx/help/Pool.cc -o out/Pool.o + g++ -I. -std=c++11 -c entityx/help/Timer.cc -o out/Timer.o + g++ -I. -std=c++11 -c entityx/Event.cc -o out/Event.o + g++ -I. -std=c++11 -c entityx/Entity.cc -o out/Entity.o + g++ -I. -std=c++11 -c entityx/System.cc -o out/System.o + @echo " CXX/LD main" @$(CXX) $(CXXFLAGS) $(CXXINC) $(CXXWARN) -o $(EXEC) main.cpp out/*.o $(LIBS) @rm -rf xml/*.dat @@ -47,3 +53,7 @@ $(EXEC): $(CXXOUTDIR)/$(CXXOBJ) main.cpp $(CXXOUTDIR)/%.o: $(CXXSRCDIR)/%.cpp @echo " CXX " $< @$(CXX) $(CXXFLAGS) $(CXXINC) $(CXXWARN) $(LIBS) -c $< -o $@ + +$(CXXOUTDIR)/%.o: $(CXXSRCDIR)/%.cc + @echo " CXX " $< + @$(CXX) $(CXXFLAGS) $(CXXINC) $(CXXWARN) $(LIBS) -c $< -o $@ \ No newline at end of file diff --git a/entityx/3rdparty/catch.hpp b/entityx/3rdparty/catch.hpp new file mode 100644 index 0000000..e329620 --- /dev/null +++ b/entityx/3rdparty/catch.hpp @@ -0,0 +1,8345 @@ +/* + * CATCH v1.0 build 27 (master branch) + * Generated: 2014-03-01 10:36:25.999888 + * ---------------------------------------------------------- + * This file has been merged from multiple headers. Please don't edit it directly + * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. + * + * 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 TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED +#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED + +#define TWOBLUECUBES_CATCH_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic ignored "-Wglobal-constructors" +#pragma clang diagnostic ignored "-Wvariadic-macros" +#pragma clang diagnostic ignored "-Wc99-extensions" +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +// #included from: internal/catch_notimplemented_exception.h +#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED + +// #included from: catch_common.h +#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED + +#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line +#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) +#define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) + +#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr +#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) + +#include +#include +#include + +// #included from: catch_compiler_capabilities.h +#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED + +// Much of the following code is based on Boost (1.53) + +#ifdef __clang__ + +#if __has_feature(cxx_nullptr) + +#define CATCH_CONFIG_CPP11_NULLPTR + +#endif + +#endif // __clang__ + +//////////////////////////////////////////////////////////////////////////////// +// Borland +#ifdef __BORLANDC__ + +#if (__BORLANDC__ > 0x582 ) +//#define CATCH_CONFIG_SFINAE // Not confirmed +#endif + +#endif // __BORLANDC__ + +//////////////////////////////////////////////////////////////////////////////// +// EDG +#ifdef __EDG_VERSION__ + +#if (__EDG_VERSION__ > 238 ) +//#define CATCH_CONFIG_SFINAE // Not confirmed +#endif + +#endif // __EDG_VERSION__ + +//////////////////////////////////////////////////////////////////////////////// +// Digital Mars +#ifdef __DMC__ + +#if (__DMC__ > 0x840 ) +//#define CATCH_CONFIG_SFINAE // Not confirmed +#endif + +#endif // __DMC__ + +//////////////////////////////////////////////////////////////////////////////// +// GCC +#ifdef __GNUC__ + +#if __GNUC__ < 3 + +#if (__GNUC_MINOR__ >= 96 ) +//#define CATCH_CONFIG_SFINAE +#endif + +#elif __GNUC__ >= 3 + +// #define CATCH_CONFIG_SFINAE // Taking this out completely for now + +#endif // __GNUC__ < 3 + +#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) ) + +#define CATCH_CONFIG_CPP11_NULLPTR +#endif + +#endif // __GNUC__ + +//////////////////////////////////////////////////////////////////////////////// +// Visual C++ +#ifdef _MSC_VER + +#if (_MSC_VER >= 1310 ) // (VC++ 7.0+) +//#define CATCH_CONFIG_SFINAE // Not confirmed +#endif + +#endif // _MSC_VER + +// Use variadic macros if the compiler supports them +#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ + ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \ + ( defined __GNUC__ && __GNUC__ >= 3 ) || \ + ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L ) + +#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS +#define CATCH_CONFIG_VARIADIC_MACROS +#endif + +#endif + +namespace Catch { + + class NonCopyable { + NonCopyable( NonCopyable const& ); + void operator = ( NonCopyable const& ); + protected: + NonCopyable() {} + virtual ~NonCopyable(); + }; + + class SafeBool { + public: + typedef void (SafeBool::*type)() const; + + static type makeSafe( bool value ) { + return value ? &SafeBool::trueValue : 0; + } + private: + void trueValue() const {} + }; + + template + inline void deleteAll( ContainerT& container ) { + typename ContainerT::const_iterator it = container.begin(); + typename ContainerT::const_iterator itEnd = container.end(); + for(; it != itEnd; ++it ) + delete *it; + } + template + inline void deleteAllValues( AssociativeContainerT& container ) { + typename AssociativeContainerT::const_iterator it = container.begin(); + typename AssociativeContainerT::const_iterator itEnd = container.end(); + for(; it != itEnd; ++it ) + delete it->second; + } + + bool startsWith( std::string const& s, std::string const& prefix ); + bool endsWith( std::string const& s, std::string const& suffix ); + bool contains( std::string const& s, std::string const& infix ); + void toLowerInPlace( std::string& s ); + std::string toLower( std::string const& s ); + std::string trim( std::string const& str ); + + struct pluralise { + pluralise( std::size_t count, std::string const& label ); + + friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); + + std::size_t m_count; + std::string m_label; + }; + + struct SourceLineInfo { + + SourceLineInfo(); + SourceLineInfo( char const* _file, std::size_t _line ); + SourceLineInfo( SourceLineInfo const& other ); + bool empty() const; + bool operator == ( SourceLineInfo const& other ) const; + + std::string file; + std::size_t line; + }; + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); + + // This is just here to avoid compiler warnings with macro constants and boolean literals + inline bool isTrue( bool value ){ return value; } + + void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); + + // Use this in variadic streaming macros to allow + // >> +StreamEndStop + // as well as + // >> stuff +StreamEndStop + struct StreamEndStop { + std::string operator+() { + return std::string(); + } + }; + template + T const& operator + ( T const& value, StreamEndStop ) { + return value; + } +} + +#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) +#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); + +#include + +namespace Catch { + + class NotImplementedException : public std::exception + { + public: + NotImplementedException( SourceLineInfo const& lineInfo ); + + virtual ~NotImplementedException() throw() {} + + virtual const char* what() const throw(); + + private: + std::string m_what; + SourceLineInfo m_lineInfo; + }; + +} // end namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO ) + +// #included from: internal/catch_context.h +#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED + +// #included from: catch_interfaces_generators.h +#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED + +#include + +namespace Catch { + + struct IGeneratorInfo { + virtual ~IGeneratorInfo(); + virtual bool moveNext() = 0; + virtual std::size_t getCurrentIndex() const = 0; + }; + + struct IGeneratorsForTest { + virtual ~IGeneratorsForTest(); + + virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; + virtual bool moveNext() = 0; + }; + + IGeneratorsForTest* createGeneratorsForTest(); + +} // end namespace Catch + +// #included from: catch_ptr.hpp +#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + + // An intrusive reference counting smart pointer. + // T must implement addRef() and release() methods + // typically implementing the IShared interface + template + class Ptr { + public: + Ptr() : m_p( NULL ){} + Ptr( T* p ) : m_p( p ){ + if( m_p ) + m_p->addRef(); + } + Ptr( Ptr const& other ) : m_p( other.m_p ){ + if( m_p ) + m_p->addRef(); + } + ~Ptr(){ + if( m_p ) + m_p->release(); + } + void reset() { + if( m_p ) + m_p->release(); + m_p = NULL; + } + Ptr& operator = ( T* p ){ + Ptr temp( p ); + swap( temp ); + return *this; + } + Ptr& operator = ( Ptr const& other ){ + Ptr temp( other ); + swap( temp ); + return *this; + } + void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } + T* get() { return m_p; } + const T* get() const{ return m_p; } + T& operator*() const { return *m_p; } + T* operator->() const { return m_p; } + bool operator !() const { return m_p == NULL; } + operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); } + + private: + T* m_p; + }; + + struct IShared : NonCopyable { + virtual ~IShared(); + virtual void addRef() const = 0; + virtual void release() const = 0; + }; + + template + struct SharedImpl : T { + + SharedImpl() : m_rc( 0 ){} + + virtual void addRef() const { + ++m_rc; + } + virtual void release() const { + if( --m_rc == 0 ) + delete this; + } + + mutable unsigned int m_rc; + }; + +} // end namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#include +#include +#include + +namespace Catch { + + class TestCase; + class Stream; + struct IResultCapture; + struct IRunner; + struct IGeneratorsForTest; + struct IConfig; + + struct IContext + { + virtual ~IContext(); + + virtual IResultCapture& getResultCapture() = 0; + virtual IRunner& getRunner() = 0; + virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; + virtual bool advanceGeneratorsForCurrentTest() = 0; + virtual Ptr getConfig() const = 0; + }; + + struct IMutableContext : IContext + { + virtual ~IMutableContext(); + virtual void setResultCapture( IResultCapture* resultCapture ) = 0; + virtual void setRunner( IRunner* runner ) = 0; + virtual void setConfig( Ptr const& config ) = 0; + }; + + IContext& getCurrentContext(); + IMutableContext& getCurrentMutableContext(); + void cleanUpContext(); + Stream createStream( std::string const& streamName ); + +} + +// #included from: internal/catch_test_registry.hpp +#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED + +// #included from: catch_interfaces_testcase.h +#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED + +#include + +namespace Catch { + + class TestCaseFilters; + + struct ITestCase : IShared { + virtual void invoke () const = 0; + protected: + virtual ~ITestCase(); + }; + + class TestCase; + + struct ITestCaseRegistry { + virtual ~ITestCaseRegistry(); + virtual std::vector const& getAllTests() const = 0; + virtual std::vector getMatchingTestCases( std::string const& rawTestSpec ) const = 0; + }; +} + +namespace Catch { + +template +class MethodTestCase : public SharedImpl { + +public: + MethodTestCase( void (C::*method)() ) : m_method( method ) {} + + virtual void invoke() const { + C obj; + (obj.*m_method)(); + } + +private: + virtual ~MethodTestCase() {} + + void (C::*m_method)(); +}; + +typedef void(*TestFunction)(); + +struct NameAndDesc { + NameAndDesc( const char* _name = "", const char* _description= "" ) + : name( _name ), description( _description ) + {} + + const char* name; + const char* description; +}; + +struct AutoReg { + + AutoReg( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ); + + template + AutoReg( void (C::*method)(), + char const* className, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ) { + registerTestCase( new MethodTestCase( method ), + className, + nameAndDesc, + lineInfo ); + } + + void registerTestCase( ITestCase* testCase, + char const* className, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ); + + ~AutoReg(); + +private: + AutoReg( AutoReg const& ); + void operator= ( AutoReg const& ); +}; + +} // end namespace Catch + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TESTCASE( ... ) \ + static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\ + static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )() + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\ + namespace{ \ + struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \ + void test(); \ + }; \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \ + } \ + void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test() + +#else + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \ + static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\ + static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )() + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\ + namespace{ \ + struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \ + void test(); \ + }; \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \ + } \ + void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test() + +#endif + +// #included from: internal/catch_capture.hpp +#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED + +// #included from: catch_expression_decomposer.hpp +#define TWOBLUECUBES_CATCH_EXPRESSION_DECOMPOSER_HPP_INCLUDED + +// #included from: catch_expression_lhs.hpp +#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED + +// #included from: catch_expressionresult_builder.h +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_BUILDER_H_INCLUDED + +// #included from: catch_tostring.hpp +#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED + +// #included from: catch_sfinae.hpp +#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED + +// Try to detect if the current compiler supports SFINAE + +namespace Catch { + + struct TrueType { + static const bool value = true; + typedef void Enable; + char sizer[1]; + }; + struct FalseType { + static const bool value = false; + typedef void Disable; + char sizer[2]; + }; + +#ifdef CATCH_CONFIG_SFINAE + + template struct NotABooleanExpression; + + template struct If : NotABooleanExpression {}; + template<> struct If : TrueType {}; + template<> struct If : FalseType {}; + + template struct SizedIf; + template<> struct SizedIf : TrueType {}; + template<> struct SizedIf : FalseType {}; + +#endif // CATCH_CONFIG_SFINAE + +} // end namespace Catch + +#include +#include +#include +#include + +#ifdef __OBJC__ +// #included from: catch_objc_arc.hpp +#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED + +#import + +#ifdef __has_feature +#define CATCH_ARC_ENABLED __has_feature(objc_arc) +#else +#define CATCH_ARC_ENABLED 0 +#endif + +void arcSafeRelease( NSObject* obj ); +id performOptionalSelector( id obj, SEL sel ); + +#if !CATCH_ARC_ENABLED +inline void arcSafeRelease( NSObject* obj ) { + [obj release]; +} +inline id performOptionalSelector( id obj, SEL sel ) { + if( [obj respondsToSelector: sel] ) + return [obj performSelector: sel]; + return nil; +} +#define CATCH_UNSAFE_UNRETAINED +#define CATCH_ARC_STRONG +#else +inline void arcSafeRelease( NSObject* ){} +inline id performOptionalSelector( id obj, SEL sel ) { +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Warc-performSelector-leaks" +#endif + if( [obj respondsToSelector: sel] ) + return [obj performSelector: sel]; +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + return nil; +} +#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained +#define CATCH_ARC_STRONG __strong +#endif + +#endif + +namespace Catch { +namespace Detail { + +// SFINAE is currently disabled by default for all compilers. +// If the non SFINAE version of IsStreamInsertable is ambiguous for you +// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE +#ifdef CATCH_CONFIG_SFINAE + + template + class IsStreamInsertableHelper { + template struct TrueIfSizeable : TrueType {}; + + template + static TrueIfSizeable dummy(T2*); + static FalseType dummy(...); + + public: + typedef SizedIf type; + }; + + template + struct IsStreamInsertable : IsStreamInsertableHelper::type {}; + +#else + + struct BorgType { + template BorgType( T const& ); + }; + + TrueType& testStreamable( std::ostream& ); + FalseType testStreamable( FalseType ); + + FalseType operator<<( std::ostream const&, BorgType const& ); + + template + struct IsStreamInsertable { + static std::ostream &s; + static T const&t; + enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) }; + }; + +#endif + + template + struct StringMakerBase { + template + static std::string convert( T const& ) { return "{?}"; } + }; + + template<> + struct StringMakerBase { + template + static std::string convert( T const& _value ) { + std::ostringstream oss; + oss << _value; + return oss.str(); + } + }; + + // For display purposes only. + // Does not consider endian-ness + template + std::string rawMemoryToString( T value ) { + union { + T typedValue; + unsigned char bytes[sizeof(T)]; + }; + + typedValue = value; + + std::ostringstream oss; + oss << "0x"; + for( unsigned char* cp = bytes; cp < bytes+sizeof(T); ++cp ) + oss << std::hex << std::setw(2) << std::setfill('0') << (unsigned int)*cp; + return oss.str(); + } + +} // end namespace Detail + +template +std::string toString( T const& value ); + +template +struct StringMaker : + Detail::StringMakerBase::value> {}; + +template +struct StringMaker { + template + static std::string convert( U* p ) { + if( !p ) + return INTERNAL_CATCH_STRINGIFY( NULL ); + else + return Detail::rawMemoryToString( p ); + } +}; + +template +struct StringMaker { + static std::string convert( R C::* p ) { + if( !p ) + return INTERNAL_CATCH_STRINGIFY( NULL ); + else + return Detail::rawMemoryToString( p ); + } +}; + +namespace Detail { + template + std::string rangeToString( InputIterator first, InputIterator last ); +} + +template +struct StringMaker > { + static std::string convert( std::vector const& v ) { + return Detail::rangeToString( v.begin(), v.end() ); + } +}; + +namespace Detail { + template + inline std::string makeString( T const& value ) { + return StringMaker::convert( value ); + } +} // end namespace Detail + +/// \brief converts any type to a string +/// +/// The default template forwards on to ostringstream - except when an +/// ostringstream overload does not exist - in which case it attempts to detect +/// that and writes {?}. +/// Overload (not specialise) this template for custom typs that you don't want +/// to provide an ostream overload for. +template +std::string toString( T const& value ) { + return StringMaker::convert( value ); +} + +// Built in overloads + +inline std::string toString( std::string const& value ) { + return "\"" + value + "\""; +} + +inline std::string toString( std::wstring const& value ) { + std::ostringstream oss; + oss << "\""; + for(size_t i = 0; i < value.size(); ++i ) + oss << static_cast( value[i] <= 0xff ? value[i] : '?'); + oss << "\""; + return oss.str(); +} + +inline std::string toString( const char* const value ) { + return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" ); +} + +inline std::string toString( char* const value ) { + return Catch::toString( static_cast( value ) ); +} + +inline std::string toString( int value ) { + std::ostringstream oss; + oss << value; + return oss.str(); +} + +inline std::string toString( unsigned long value ) { + std::ostringstream oss; + if( value > 8192 ) + oss << "0x" << std::hex << value; + else + oss << value; + return oss.str(); +} + +inline std::string toString( unsigned int value ) { + return toString( static_cast( value ) ); +} + +inline std::string toString( const double value ) { + std::ostringstream oss; + oss << std::setprecision( 10 ) + << std::fixed + << value; + std::string d = oss.str(); + std::size_t i = d.find_last_not_of( '0' ); + if( i != std::string::npos && i != d.size()-1 ) { + if( d[i] == '.' ) + i++; + d = d.substr( 0, i+1 ); + } + return d; +} + +inline std::string toString( bool value ) { + return value ? "true" : "false"; +} + +inline std::string toString( char value ) { + return value < ' ' + ? toString( static_cast( value ) ) + : Detail::makeString( value ); +} + +inline std::string toString( signed char value ) { + return toString( static_cast( value ) ); +} + +inline std::string toString( unsigned char value ) { + return toString( static_cast( value ) ); +} + +#ifdef CATCH_CONFIG_CPP11_NULLPTR +inline std::string toString( std::nullptr_t ) { + return "nullptr"; +} +#endif + +#ifdef __OBJC__ + inline std::string toString( NSString const * const& nsstring ) { + if( !nsstring ) + return "nil"; + return std::string( "@\"" ) + [nsstring UTF8String] + "\""; + } + inline std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) { + if( !nsstring ) + return "nil"; + return std::string( "@\"" ) + [nsstring UTF8String] + "\""; + } + inline std::string toString( NSObject* const& nsObject ) { + return toString( [nsObject description] ); + } +#endif + + namespace Detail { + template + std::string rangeToString( InputIterator first, InputIterator last ) { + std::ostringstream oss; + oss << "{ "; + if( first != last ) { + oss << toString( *first ); + for( ++first ; first != last ; ++first ) { + oss << ", " << toString( *first ); + } + } + oss << " }"; + return oss.str(); + } +} + +} // end namespace Catch + +// #included from: catch_assertionresult.h +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED + +#include +// #included from: catch_result_type.h +#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED + +namespace Catch { + + // ResultWas::OfType enum + struct ResultWas { enum OfType { + Unknown = -1, + Ok = 0, + Info = 1, + Warning = 2, + + FailureBit = 0x10, + + ExpressionFailed = FailureBit | 1, + ExplicitFailure = FailureBit | 2, + + Exception = 0x100 | FailureBit, + + ThrewException = Exception | 1, + DidntThrowException = Exception | 2 + + }; }; + + inline bool isOk( ResultWas::OfType resultType ) { + return ( resultType & ResultWas::FailureBit ) == 0; + } + inline bool isJustInfo( int flags ) { + return flags == ResultWas::Info; + } + + // ResultAction::Value enum + struct ResultAction { enum Value { + None, + Failed = 1, // Failure - but no debug break if Debug bit not set + Debug = 2, // If this bit is set, invoke the debugger + Abort = 4 // Test run should abort + }; }; + + // ResultDisposition::Flags enum + struct ResultDisposition { enum Flags { + Normal = 0x00, + + ContinueOnFailure = 0x01, // Failures fail test, but execution continues + NegateResult = 0x02, // Prefix expressiom with ! + SuppressFail = 0x04 // Failures are reported but do not fail the test + }; }; + + inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) { + return static_cast( static_cast( lhs ) | static_cast( rhs ) ); + } + + inline bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; } + inline bool shouldNegate( int flags ) { return ( flags & ResultDisposition::NegateResult ) != 0; } + inline bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; } + +} // end namespace Catch + + +namespace Catch { + + struct AssertionInfo + { + AssertionInfo() {} + AssertionInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + std::string const& _capturedExpression, + ResultDisposition::Flags _resultDisposition ); + + std::string macroName; + SourceLineInfo lineInfo; + std::string capturedExpression; + ResultDisposition::Flags resultDisposition; + }; + + struct AssertionResultData + { + AssertionResultData() : resultType( ResultWas::Unknown ) {} + + std::string reconstructedExpression; + std::string message; + ResultWas::OfType resultType; + }; + + class AssertionResult { + public: + AssertionResult(); + AssertionResult( AssertionInfo const& info, AssertionResultData const& data ); + ~AssertionResult(); + + bool isOk() const; + bool succeeded() const; + ResultWas::OfType getResultType() const; + bool hasExpression() const; + bool hasMessage() const; + std::string getExpression() const; + std::string getExpressionInMacro() const; + bool hasExpandedExpression() const; + std::string getExpandedExpression() const; + std::string getMessage() const; + SourceLineInfo getSourceInfo() const; + std::string getTestMacroName() const; + + protected: + AssertionInfo m_info; + AssertionResultData m_resultData; + }; + +} // end namespace Catch + +// #included from: catch_evaluate.hpp +#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4389) // '==' : signed/unsigned mismatch +#endif + +namespace Catch { +namespace Internal { + + enum Operator { + IsEqualTo, + IsNotEqualTo, + IsLessThan, + IsGreaterThan, + IsLessThanOrEqualTo, + IsGreaterThanOrEqualTo + }; + + template struct OperatorTraits { static const char* getName(){ return "*error*"; } }; + template<> struct OperatorTraits { static const char* getName(){ return "=="; } }; + template<> struct OperatorTraits { static const char* getName(){ return "!="; } }; + template<> struct OperatorTraits { static const char* getName(){ return "<"; } }; + template<> struct OperatorTraits { static const char* getName(){ return ">"; } }; + template<> struct OperatorTraits { static const char* getName(){ return "<="; } }; + template<> struct OperatorTraits{ static const char* getName(){ return ">="; } }; + + template + inline T& opCast(T const& t) { return const_cast(t); } + +// nullptr_t support based on pull request #154 from Konstantin Baumann +#ifdef CATCH_CONFIG_CPP11_NULLPTR + inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; } +#endif // CATCH_CONFIG_CPP11_NULLPTR + + // So the compare overloads can be operator agnostic we convey the operator as a template + // enum, which is used to specialise an Evaluator for doing the comparison. + template + class Evaluator{}; + + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs) { + return opCast( lhs ) == opCast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return opCast( lhs ) != opCast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return opCast( lhs ) < opCast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return opCast( lhs ) > opCast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return opCast( lhs ) >= opCast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return opCast( lhs ) <= opCast( rhs ); + } + }; + + template + bool applyEvaluator( T1 const& lhs, T2 const& rhs ) { + return Evaluator::evaluate( lhs, rhs ); + } + + // This level of indirection allows us to specialise for integer types + // to avoid signed/ unsigned warnings + + // "base" overload + template + bool compare( T1 const& lhs, T2 const& rhs ) { + return Evaluator::evaluate( lhs, rhs ); + } + + // unsigned X to int + template bool compare( unsigned int lhs, int rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned long lhs, int rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned char lhs, int rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + + // unsigned X to long + template bool compare( unsigned int lhs, long rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned long lhs, long rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + template bool compare( unsigned char lhs, long rhs ) { + return applyEvaluator( lhs, static_cast( rhs ) ); + } + + // int to unsigned X + template bool compare( int lhs, unsigned int rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( int lhs, unsigned long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( int lhs, unsigned char rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + + // long to unsigned X + template bool compare( long lhs, unsigned int rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long lhs, unsigned long rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + template bool compare( long lhs, unsigned char rhs ) { + return applyEvaluator( static_cast( lhs ), rhs ); + } + + // pointer to long (when comparing against NULL) + template bool compare( long lhs, T* rhs ) { + return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); + } + template bool compare( T* lhs, long rhs ) { + return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); + } + + // pointer to int (when comparing against NULL) + template bool compare( int lhs, T* rhs ) { + return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); + } + template bool compare( T* lhs, int rhs ) { + return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); + } + +#ifdef CATCH_CONFIG_CPP11_NULLPTR + // pointer to nullptr_t (when comparing against nullptr) + template bool compare( std::nullptr_t, T* rhs ) { + return Evaluator::evaluate( NULL, rhs ); + } + template bool compare( T* lhs, std::nullptr_t ) { + return Evaluator::evaluate( lhs, NULL ); + } +#endif // CATCH_CONFIG_CPP11_NULLPTR + +} // end of namespace Internal +} // end of namespace Catch + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +namespace Catch { + +struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; + +// Wraps the (stringised versions of) the lhs, operator and rhs of an expression - as well as +// the result of evaluating it. This is used to build an AssertionResult object +class ExpressionResultBuilder { +public: + + ExpressionResultBuilder( ResultWas::OfType resultType = ResultWas::Unknown ); + ExpressionResultBuilder( ExpressionResultBuilder const& other ); + ExpressionResultBuilder& operator=(ExpressionResultBuilder const& other ); + + ExpressionResultBuilder& setResultType( ResultWas::OfType result ); + ExpressionResultBuilder& setResultType( bool result ); + ExpressionResultBuilder& setLhs( std::string const& lhs ); + ExpressionResultBuilder& setRhs( std::string const& rhs ); + ExpressionResultBuilder& setOp( std::string const& op ); + + ExpressionResultBuilder& endExpression( ResultDisposition::Flags resultDisposition ); + + template + ExpressionResultBuilder& operator << ( T const& value ) { + m_stream << value; + return *this; + } + + std::string reconstructExpression( AssertionInfo const& info ) const; + + AssertionResult buildResult( AssertionInfo const& info ) const; + + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); + +private: + AssertionResultData m_data; + struct ExprComponents { + ExprComponents() : shouldNegate( false ) {} + bool shouldNegate; + std::string lhs, rhs, op; + } m_exprComponents; + std::ostringstream m_stream; +}; + +} // end namespace Catch + +namespace Catch { + +// Wraps the LHS of an expression and captures the operator and RHS (if any) - wrapping them all +// in an ExpressionResultBuilder object +template +class ExpressionLhs { + void operator = ( ExpressionLhs const& ); + +public: + ExpressionLhs( T lhs ) : m_lhs( lhs ) {} + + template + ExpressionResultBuilder& operator == ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ExpressionResultBuilder& operator != ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ExpressionResultBuilder& operator < ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ExpressionResultBuilder& operator > ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ExpressionResultBuilder& operator <= ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + ExpressionResultBuilder& operator >= ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + ExpressionResultBuilder& operator == ( bool rhs ) { + return captureExpression( rhs ); + } + + ExpressionResultBuilder& operator != ( bool rhs ) { + return captureExpression( rhs ); + } + + ExpressionResultBuilder& endExpression( ResultDisposition::Flags resultDisposition ) { + bool value = m_lhs ? true : false; + return m_result + .setLhs( Catch::toString( value ) ) + .setResultType( value ) + .endExpression( resultDisposition ); + } + + // Only simple binary expressions are allowed on the LHS. + // If more complex compositions are required then place the sub expression in parentheses + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); + +private: + template + ExpressionResultBuilder& captureExpression( RhsT const& rhs ) { + return m_result + .setResultType( Internal::compare( m_lhs, rhs ) ) + .setLhs( Catch::toString( m_lhs ) ) + .setRhs( Catch::toString( rhs ) ) + .setOp( Internal::OperatorTraits::getName() ); + } + +private: + ExpressionResultBuilder m_result; + T m_lhs; +}; + +} // end namespace Catch + +namespace Catch { + +// Captures the LHS of the expression and wraps it in an Expression Lhs object +class ExpressionDecomposer { +public: + + template + ExpressionLhs operator->* ( T const& operand ) { + return ExpressionLhs( operand ); + } + + ExpressionLhs operator->* ( bool value ) { + return ExpressionLhs( value ); + } +}; + +} // end namespace Catch + +// #included from: catch_message.h +#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED + +#include + +namespace Catch { + + struct MessageInfo { + MessageInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ); + + std::string macroName; + SourceLineInfo lineInfo; + ResultWas::OfType type; + std::string message; + unsigned int sequence; + + bool operator == ( MessageInfo const& other ) const { + return sequence == other.sequence; + } + bool operator < ( MessageInfo const& other ) const { + return sequence < other.sequence; + } + private: + static unsigned int globalCount; + }; + + struct MessageBuilder { + MessageBuilder( std::string const& macroName, + SourceLineInfo const& lineInfo, + ResultWas::OfType type ) + : m_info( macroName, lineInfo, type ) + {} + + template + MessageBuilder& operator << ( T const& value ) { + m_stream << value; + return *this; + } + + MessageInfo m_info; + std::ostringstream m_stream; + }; + + class ScopedMessage { + public: + ScopedMessage( MessageBuilder const& builder ); + ~ScopedMessage(); + + MessageInfo m_info; + }; + +} // end namespace Catch + +// #included from: catch_interfaces_capture.h +#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED + +#include + +namespace Catch { + + class TestCase; + class ExpressionResultBuilder; + class AssertionResult; + struct AssertionInfo; + struct SectionInfo; + struct MessageInfo; + class ScopedMessageBuilder; + struct Counts; + + struct IResultCapture { + + virtual ~IResultCapture(); + + virtual void assertionEnded( AssertionResult const& result ) = 0; + virtual bool sectionStarted( SectionInfo const& sectionInfo, + Counts& assertions ) = 0; + virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0; + virtual void pushScopedMessage( MessageInfo const& message ) = 0; + virtual void popScopedMessage( MessageInfo const& message ) = 0; + + virtual bool shouldDebugBreak() const = 0; + + virtual ResultAction::Value acceptExpression( ExpressionResultBuilder const& assertionResult, AssertionInfo const& assertionInfo ) = 0; + + virtual std::string getCurrentTestName() const = 0; + virtual const AssertionResult* getLastResult() const = 0; + }; +} + +// #included from: catch_debugger.h +#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED + +// #included from: catch_platform.h +#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED + +#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) +#define CATCH_PLATFORM_MAC +#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) +#define CATCH_PLATFORM_IPHONE +#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) +#define CATCH_PLATFORM_WINDOWS +#endif + +#include + +namespace Catch{ + + bool isDebuggerActive(); + void writeToDebugConsole( std::string const& text ); +} + +#ifdef CATCH_PLATFORM_MAC + + // The following code snippet based on: + // http://cocoawithlove.com/2008/03/break-into-debugger.html + #ifdef DEBUG + #if defined(__ppc64__) || defined(__ppc__) + #define CATCH_BREAK_INTO_DEBUGGER() \ + if( Catch::isDebuggerActive() ) { \ + __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \ + : : : "memory","r0","r3","r4" ); \ + } + #else + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );} + #endif + #endif + +#elif defined(_MSC_VER) + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); } +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) void __stdcall DebugBreak(); + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); } +#endif + +#ifndef CATCH_BREAK_INTO_DEBUGGER +#define CATCH_BREAK_INTO_DEBUGGER() Catch::isTrue( true ); +#endif + +// #included from: catch_interfaces_registry_hub.h +#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED + +#include + +namespace Catch { + + class TestCase; + struct ITestCaseRegistry; + struct IExceptionTranslatorRegistry; + struct IExceptionTranslator; + struct IReporterRegistry; + struct IReporterFactory; + + struct IRegistryHub { + virtual ~IRegistryHub(); + + virtual IReporterRegistry const& getReporterRegistry() const = 0; + virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; + virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0; + }; + + struct IMutableRegistryHub { + virtual ~IMutableRegistryHub(); + virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0; + virtual void registerTest( TestCase const& testInfo ) = 0; + virtual void registerTranslator( const IExceptionTranslator* translator ) = 0; + }; + + IRegistryHub& getRegistryHub(); + IMutableRegistryHub& getMutableRegistryHub(); + void cleanUp(); + std::string translateActiveException(); + +} + +// #included from: catch_interfaces_config.h +#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED + +#include +#include + +namespace Catch { + + struct Verbosity { enum Level { + NoOutput = 0, + Quiet, + Normal + }; }; + + struct WarnAbout { enum What { + Nothing = 0x00, + NoAssertions = 0x01 + }; }; + + struct ShowDurations { enum OrNot { + DefaultForReporter, + Always, + Never + }; }; + + struct IConfig : IShared { + + virtual ~IConfig(); + + virtual bool allowThrows() const = 0; + virtual std::ostream& stream() const = 0; + virtual std::string name() const = 0; + virtual bool includeSuccessfulResults() const = 0; + virtual bool shouldDebugBreak() const = 0; + virtual bool warnAboutMissingAssertions() const = 0; + virtual int abortAfter() const = 0; + virtual ShowDurations::OrNot showDurations() const = 0; + }; +} + +#include + +namespace Catch { + + inline IResultCapture& getResultCapture() { + return getCurrentContext().getResultCapture(); + } + + template + ExpressionResultBuilder expressionResultBuilderFromMatcher( MatcherT const& matcher, + std::string const& matcherCallAsString ) { + std::string matcherAsString = matcher.toString(); + if( matcherAsString == "{?}" ) + matcherAsString = matcherCallAsString; + return ExpressionResultBuilder() + .setRhs( matcherAsString ) + .setOp( "matches" ); + } + + template + ExpressionResultBuilder expressionResultBuilderFromMatcher( MatcherT const& matcher, + ArgT const& arg, + std::string const& matcherCallAsString ) { + return expressionResultBuilderFromMatcher( matcher, matcherCallAsString ) + .setLhs( Catch::toString( arg ) ) + .setResultType( matcher.match( arg ) ); + } + + template + ExpressionResultBuilder expressionResultBuilderFromMatcher( MatcherT const& matcher, + ArgT* arg, + std::string const& matcherCallAsString ) { + return expressionResultBuilderFromMatcher( matcher, matcherCallAsString ) + .setLhs( Catch::toString( arg ) ) + .setResultType( matcher.match( arg ) ); + } + +struct TestFailureException{}; + +} // end namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ASSERTIONINFO_NAME INTERNAL_CATCH_UNIQUE_NAME( __assertionInfo ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ACCEPT_EXPR( evaluatedExpr, resultDisposition, originalExpr ) \ + if( Catch::ResultAction::Value internal_catch_action = Catch::getResultCapture().acceptExpression( evaluatedExpr, INTERNAL_CATCH_ASSERTIONINFO_NAME ) ) { \ + if( internal_catch_action & Catch::ResultAction::Debug ) CATCH_BREAK_INTO_DEBUGGER(); \ + if( internal_catch_action & Catch::ResultAction::Abort ) throw Catch::TestFailureException(); \ + if( !Catch::shouldContinueOnFailure( resultDisposition ) ) throw Catch::TestFailureException(); \ + Catch::isTrue( false && originalExpr ); \ + } + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ACCEPT_INFO( expr, macroName, resultDisposition ) \ + Catch::AssertionInfo INTERNAL_CATCH_ASSERTIONINFO_NAME( macroName, CATCH_INTERNAL_LINEINFO, expr, resultDisposition ); + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, resultDisposition ); \ + try { \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionDecomposer()->*expr ).endExpression( resultDisposition ), resultDisposition, expr ); \ + } catch( Catch::TestFailureException& ) { \ + throw; \ + } catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), \ + resultDisposition | Catch::ResultDisposition::ContinueOnFailure, expr ); \ + } \ + } while( Catch::isTrue( false ) ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \ + INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ + if( Catch::getResultCapture().getLastResult()->succeeded() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \ + INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ + if( !Catch::getResultCapture().getLastResult()->succeeded() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, resultDisposition ); \ + try { \ + expr; \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::Ok ), resultDisposition, false ); \ + } \ + catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), resultDisposition, false ); \ + } \ +} while( Catch::isTrue( false ) ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS_IMPL( expr, exceptionType, resultDisposition ) \ + try { \ + if( Catch::getCurrentContext().getConfig()->allowThrows() ) { \ + expr; \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::DidntThrowException ), resultDisposition, false ); \ + } \ + } \ + catch( Catch::TestFailureException& ) { \ + throw; \ + } \ + catch( exceptionType ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::Ok ), resultDisposition, false ); \ + } + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS( expr, exceptionType, resultDisposition, macroName ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, resultDisposition ); \ + INTERNAL_CATCH_THROWS_IMPL( expr, exceptionType, resultDisposition ) \ + } while( Catch::isTrue( false ) ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, resultDisposition ); \ + INTERNAL_CATCH_THROWS_IMPL( expr, exceptionType, resultDisposition ) \ + catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), \ + resultDisposition | Catch::ResultDisposition::ContinueOnFailure, false ); \ + } \ + } while( Catch::isTrue( false ) ) + +/////////////////////////////////////////////////////////////////////////////// +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( "", macroName, resultDisposition ); \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( messageType ) << __VA_ARGS__ +::Catch::StreamEndStop(), resultDisposition, true ) \ + } while( Catch::isTrue( false ) ) +#else + #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( "", macroName, resultDisposition ); \ + INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( messageType ) << log, resultDisposition, true ) \ + } while( Catch::isTrue( false ) ) +#endif + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_INFO( log, macroName ) \ + Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log; + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \ + do { \ + INTERNAL_CATCH_ACCEPT_INFO( #arg " " #matcher, macroName, resultDisposition ); \ + try { \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::expressionResultBuilderFromMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), resultDisposition, false ); \ + } catch( Catch::TestFailureException& ) { \ + throw; \ + } catch( ... ) { \ + INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), \ + resultDisposition | Catch::ResultDisposition::ContinueOnFailure, false ); \ + } \ + } while( Catch::isTrue( false ) ) + +// #included from: internal/catch_section.h +#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED + +// #included from: catch_section_info.h +#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED + +namespace Catch { + + struct SectionInfo { + SectionInfo( std::string const& _name, + std::string const& _description, + SourceLineInfo const& _lineInfo ) + : name( _name ), + description( _description ), + lineInfo( _lineInfo ) + {} + + std::string name; + std::string description; + SourceLineInfo lineInfo; + }; + +} // end namespace Catch + +// #included from: catch_totals.hpp +#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED + +#include + +namespace Catch { + + struct Counts { + Counts() : passed( 0 ), failed( 0 ) {} + + Counts operator - ( Counts const& other ) const { + Counts diff; + diff.passed = passed - other.passed; + diff.failed = failed - other.failed; + return diff; + } + Counts& operator += ( Counts const& other ) { + passed += other.passed; + failed += other.failed; + return *this; + } + + std::size_t total() const { + return passed + failed; + } + + std::size_t passed; + std::size_t failed; + }; + + struct Totals { + + Totals operator - ( Totals const& other ) const { + Totals diff; + diff.assertions = assertions - other.assertions; + diff.testCases = testCases - other.testCases; + return diff; + } + + Totals delta( Totals const& prevTotals ) const { + Totals diff = *this - prevTotals; + if( diff.assertions.failed > 0 ) + ++diff.testCases.failed; + else + ++diff.testCases.passed; + return diff; + } + + Totals& operator += ( Totals const& other ) { + assertions += other.assertions; + testCases += other.testCases; + return *this; + } + + Counts assertions; + Counts testCases; + }; +} + +// #included from: catch_timer.h +#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED + +#ifdef CATCH_PLATFORM_WINDOWS +typedef unsigned long long uint64_t; +#else +#include +#endif + +namespace Catch { + + class Timer { + public: + Timer() : m_ticks( 0 ) {} + void start(); + unsigned int getElapsedNanoseconds() const; + unsigned int getElapsedMilliseconds() const; + double getElapsedSeconds() const; + + private: + uint64_t m_ticks; + }; + +} // namespace Catch + +#include + +namespace Catch { + + class Section { + public: + Section( SourceLineInfo const& lineInfo, + std::string const& name, + std::string const& description = "" ); + ~Section(); + + // This indicates whether the section should be executed or not + operator bool(); + + private: + + SectionInfo m_info; + + std::string m_name; + Counts m_assertions; + bool m_sectionIncluded; + Timer m_timer; + }; + +} // end namespace Catch + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define INTERNAL_CATCH_SECTION( ... ) \ + if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) +#else + #define INTERNAL_CATCH_SECTION( name, desc ) \ + if( Catch::Section INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( CATCH_INTERNAL_LINEINFO, name, desc ) ) +#endif + +// #included from: internal/catch_generators.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + +template +struct IGenerator { + virtual ~IGenerator() {} + virtual T getValue( std::size_t index ) const = 0; + virtual std::size_t size () const = 0; +}; + +template +class BetweenGenerator : public IGenerator { +public: + BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} + + virtual T getValue( std::size_t index ) const { + return m_from+static_cast( index ); + } + + virtual std::size_t size() const { + return static_cast( 1+m_to-m_from ); + } + +private: + + T m_from; + T m_to; +}; + +template +class ValuesGenerator : public IGenerator { +public: + ValuesGenerator(){} + + void add( T value ) { + m_values.push_back( value ); + } + + virtual T getValue( std::size_t index ) const { + return m_values[index]; + } + + virtual std::size_t size() const { + return m_values.size(); + } + +private: + std::vector m_values; +}; + +template +class CompositeGenerator { +public: + CompositeGenerator() : m_totalSize( 0 ) {} + + // *** Move semantics, similar to auto_ptr *** + CompositeGenerator( CompositeGenerator& other ) + : m_fileInfo( other.m_fileInfo ), + m_totalSize( 0 ) + { + move( other ); + } + + CompositeGenerator& setFileInfo( const char* fileInfo ) { + m_fileInfo = fileInfo; + return *this; + } + + ~CompositeGenerator() { + deleteAll( m_composed ); + } + + operator T () const { + size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); + + typename std::vector*>::const_iterator it = m_composed.begin(); + typename std::vector*>::const_iterator itEnd = m_composed.end(); + for( size_t index = 0; it != itEnd; ++it ) + { + const IGenerator* generator = *it; + if( overallIndex >= index && overallIndex < index + generator->size() ) + { + return generator->getValue( overallIndex-index ); + } + index += generator->size(); + } + CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); + return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so + } + + void add( const IGenerator* generator ) { + m_totalSize += generator->size(); + m_composed.push_back( generator ); + } + + CompositeGenerator& then( CompositeGenerator& other ) { + move( other ); + return *this; + } + + CompositeGenerator& then( T value ) { + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( value ); + add( valuesGen ); + return *this; + } + +private: + + void move( CompositeGenerator& other ) { + std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); + m_totalSize += other.m_totalSize; + other.m_composed.clear(); + } + + std::vector*> m_composed; + std::string m_fileInfo; + size_t m_totalSize; +}; + +namespace Generators +{ + template + CompositeGenerator between( T from, T to ) { + CompositeGenerator generators; + generators.add( new BetweenGenerator( from, to ) ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3 ){ + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3, T val4 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + valuesGen->add( val4 ); + generators.add( valuesGen ); + return generators; + } + +} // end namespace Generators + +using namespace Generators; + +} // end namespace Catch + +#define INTERNAL_CATCH_LINESTR2( line ) #line +#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) + +#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) + +// #included from: internal/catch_interfaces_exception.h +#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED + +#include + +namespace Catch { + + typedef std::string(*exceptionTranslateFunction)(); + + struct IExceptionTranslator { + virtual ~IExceptionTranslator(); + virtual std::string translate() const = 0; + }; + + struct IExceptionTranslatorRegistry { + virtual ~IExceptionTranslatorRegistry(); + + virtual std::string translateActiveException() const = 0; + }; + + class ExceptionTranslatorRegistrar { + template + class ExceptionTranslator : public IExceptionTranslator { + public: + + ExceptionTranslator( std::string(*translateFunction)( T& ) ) + : m_translateFunction( translateFunction ) + {} + + virtual std::string translate() const { + try { + throw; + } + catch( T& ex ) { + return m_translateFunction( ex ); + } + } + + protected: + std::string(*m_translateFunction)( T& ); + }; + + public: + template + ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) { + getMutableRegistryHub().registerTranslator + ( new ExceptionTranslator( translateFunction ) ); + } + }; +} + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \ + static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \ + namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\ + static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ) + +// #included from: internal/catch_approx.hpp +#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED + +#include +#include + +namespace Catch { +namespace Detail { + + class Approx { + public: + explicit Approx ( double value ) + : m_epsilon( std::numeric_limits::epsilon()*100 ), + m_scale( 1.0 ), + m_value( value ) + {} + + Approx( Approx const& other ) + : m_epsilon( other.m_epsilon ), + m_scale( other.m_scale ), + m_value( other.m_value ) + {} + + static Approx custom() { + return Approx( 0 ); + } + + Approx operator()( double value ) { + Approx approx( value ); + approx.epsilon( m_epsilon ); + approx.scale( m_scale ); + return approx; + } + + friend bool operator == ( double lhs, Approx const& rhs ) { + // Thanks to Richard Harris for his help refining this formula + return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) ); + } + + friend bool operator == ( Approx const& lhs, double rhs ) { + return operator==( rhs, lhs ); + } + + friend bool operator != ( double lhs, Approx const& rhs ) { + return !operator==( lhs, rhs ); + } + + friend bool operator != ( Approx const& lhs, double rhs ) { + return !operator==( rhs, lhs ); + } + + Approx& epsilon( double newEpsilon ) { + m_epsilon = newEpsilon; + return *this; + } + + Approx& scale( double newScale ) { + m_scale = newScale; + return *this; + } + + std::string toString() const { + std::ostringstream oss; + oss << "Approx( " << Catch::toString( m_value ) << " )"; + return oss.str(); + } + + private: + double m_epsilon; + double m_scale; + double m_value; + }; +} + +template<> +inline std::string toString( Detail::Approx const& value ) { + return value.toString(); +} + +} // end namespace Catch + +// #included from: internal/catch_matchers.hpp +#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED + +namespace Catch { +namespace Matchers { + namespace Impl { + + template + struct Matcher : SharedImpl + { + typedef ExpressionT ExpressionType; + + virtual ~Matcher() {} + virtual Ptr clone() const = 0; + virtual bool match( ExpressionT const& expr ) const = 0; + virtual std::string toString() const = 0; + }; + + template + struct MatcherImpl : Matcher { + + virtual Ptr > clone() const { + return Ptr >( new DerivedT( static_cast( *this ) ) ); + } + }; + + namespace Generic { + + template + class AllOf : public MatcherImpl, ExpressionT> { + public: + + AllOf() {} + AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {} + + AllOf& add( Matcher const& matcher ) { + m_matchers.push_back( matcher.clone() ); + return *this; + } + virtual bool match( ExpressionT const& expr ) const + { + for( std::size_t i = 0; i < m_matchers.size(); ++i ) + if( !m_matchers[i]->match( expr ) ) + return false; + return true; + } + virtual std::string toString() const { + std::ostringstream oss; + oss << "( "; + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if( i != 0 ) + oss << " and "; + oss << m_matchers[i]->toString(); + } + oss << " )"; + return oss.str(); + } + + private: + std::vector > > m_matchers; + }; + + template + class AnyOf : public MatcherImpl, ExpressionT> { + public: + + AnyOf() {} + AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {} + + AnyOf& add( Matcher const& matcher ) { + m_matchers.push_back( matcher.clone() ); + return *this; + } + virtual bool match( ExpressionT const& expr ) const + { + for( std::size_t i = 0; i < m_matchers.size(); ++i ) + if( m_matchers[i]->match( expr ) ) + return true; + return false; + } + virtual std::string toString() const { + std::ostringstream oss; + oss << "( "; + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if( i != 0 ) + oss << " or "; + oss << m_matchers[i]->toString(); + } + oss << " )"; + return oss.str(); + } + + private: + std::vector > > m_matchers; + }; + + } + + namespace StdString { + + inline std::string makeString( std::string const& str ) { return str; } + inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); } + + struct Equals : MatcherImpl { + Equals( std::string const& str ) : m_str( str ){} + Equals( Equals const& other ) : m_str( other.m_str ){} + + virtual ~Equals(); + + virtual bool match( std::string const& expr ) const { + return m_str == expr; + } + virtual std::string toString() const { + return "equals: \"" + m_str + "\""; + } + + std::string m_str; + }; + + struct Contains : MatcherImpl { + Contains( std::string const& substr ) : m_substr( substr ){} + Contains( Contains const& other ) : m_substr( other.m_substr ){} + + virtual ~Contains(); + + virtual bool match( std::string const& expr ) const { + return expr.find( m_substr ) != std::string::npos; + } + virtual std::string toString() const { + return "contains: \"" + m_substr + "\""; + } + + std::string m_substr; + }; + + struct StartsWith : MatcherImpl { + StartsWith( std::string const& substr ) : m_substr( substr ){} + StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){} + + virtual ~StartsWith(); + + virtual bool match( std::string const& expr ) const { + return expr.find( m_substr ) == 0; + } + virtual std::string toString() const { + return "starts with: \"" + m_substr + "\""; + } + + std::string m_substr; + }; + + struct EndsWith : MatcherImpl { + EndsWith( std::string const& substr ) : m_substr( substr ){} + EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){} + + virtual ~EndsWith(); + + virtual bool match( std::string const& expr ) const { + return expr.find( m_substr ) == expr.size() - m_substr.size(); + } + virtual std::string toString() const { + return "ends with: \"" + m_substr + "\""; + } + + std::string m_substr; + }; + } // namespace StdString + } // namespace Impl + + // The following functions create the actual matcher objects. + // This allows the types to be inferred + template + inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, + Impl::Matcher const& m2 ) { + return Impl::Generic::AllOf().add( m1 ).add( m2 ); + } + template + inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, + Impl::Matcher const& m2, + Impl::Matcher const& m3 ) { + return Impl::Generic::AllOf().add( m1 ).add( m2 ).add( m3 ); + } + template + inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, + Impl::Matcher const& m2 ) { + return Impl::Generic::AnyOf().add( m1 ).add( m2 ); + } + template + inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, + Impl::Matcher const& m2, + Impl::Matcher const& m3 ) { + return Impl::Generic::AnyOf().add( m1 ).add( m2 ).add( m3 ); + } + + inline Impl::StdString::Equals Equals( std::string const& str ) { + return Impl::StdString::Equals( str ); + } + inline Impl::StdString::Equals Equals( const char* str ) { + return Impl::StdString::Equals( Impl::StdString::makeString( str ) ); + } + inline Impl::StdString::Contains Contains( std::string const& substr ) { + return Impl::StdString::Contains( substr ); + } + inline Impl::StdString::Contains Contains( const char* substr ) { + return Impl::StdString::Contains( Impl::StdString::makeString( substr ) ); + } + inline Impl::StdString::StartsWith StartsWith( std::string const& substr ) { + return Impl::StdString::StartsWith( substr ); + } + inline Impl::StdString::StartsWith StartsWith( const char* substr ) { + return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) ); + } + inline Impl::StdString::EndsWith EndsWith( std::string const& substr ) { + return Impl::StdString::EndsWith( substr ); + } + inline Impl::StdString::EndsWith EndsWith( const char* substr ) { + return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) ); + } + +} // namespace Matchers + +using namespace Matchers; + +} // namespace Catch + +// These files are included here so the single_include script doesn't put them +// in the conditionally compiled sections +// #included from: internal/catch_test_case_info.h +#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED + +#include +#include + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + + struct ITestCase; + + struct TestCaseInfo { + TestCaseInfo( std::string const& _name, + std::string const& _className, + std::string const& _description, + std::set const& _tags, + bool _isHidden, + SourceLineInfo const& _lineInfo ); + + TestCaseInfo( TestCaseInfo const& other ); + + std::string name; + std::string className; + std::string description; + std::set tags; + std::string tagsAsString; + SourceLineInfo lineInfo; + bool isHidden; + }; + + class TestCase : protected TestCaseInfo { + public: + + TestCase( ITestCase* testCase, TestCaseInfo const& info ); + TestCase( TestCase const& other ); + + TestCase withName( std::string const& _newName ) const; + + void invoke() const; + + TestCaseInfo const& getTestCaseInfo() const; + + bool isHidden() const; + bool hasTag( std::string const& tag ) const; + bool matchesTags( std::string const& tagPattern ) const; + std::set const& getTags() const; + + void swap( TestCase& other ); + bool operator == ( TestCase const& other ) const; + bool operator < ( TestCase const& other ) const; + TestCase& operator = ( TestCase const& other ); + + private: + Ptr test; + }; + + TestCase makeTestCase( ITestCase* testCase, + std::string const& className, + std::string const& name, + std::string const& description, + SourceLineInfo const& lineInfo ); +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +// #included from: internal/catch_interfaces_runner.h +#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED + +namespace Catch { + class TestCase; + + struct IRunner { + virtual ~IRunner(); + }; +} + + +#ifdef __OBJC__ +// #included from: internal/catch_objc.hpp +#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED + +#import + +#include + +// NB. Any general catch headers included here must be included +// in catch.hpp first to make sure they are included by the single +// header for non obj-usage + +/////////////////////////////////////////////////////////////////////////////// +// This protocol is really only here for (self) documenting purposes, since +// all its methods are optional. +@protocol OcFixture + +@optional + +-(void) setUp; +-(void) tearDown; + +@end + +namespace Catch { + + class OcMethod : public SharedImpl { + + public: + OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {} + + virtual void invoke() const { + id obj = [[m_cls alloc] init]; + + performOptionalSelector( obj, @selector(setUp) ); + performOptionalSelector( obj, m_sel ); + performOptionalSelector( obj, @selector(tearDown) ); + + arcSafeRelease( obj ); + } + private: + virtual ~OcMethod() {} + + Class m_cls; + SEL m_sel; + }; + + namespace Detail{ + + inline std::string getAnnotation( Class cls, + std::string const& annotationName, + std::string const& testCaseName ) { + NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()]; + SEL sel = NSSelectorFromString( selStr ); + arcSafeRelease( selStr ); + id value = performOptionalSelector( cls, sel ); + if( value ) + return [(NSString*)value UTF8String]; + return ""; + } + } + + inline size_t registerTestMethods() { + size_t noTestMethods = 0; + int noClasses = objc_getClassList( NULL, 0 ); + + Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses); + objc_getClassList( classes, noClasses ); + + for( int c = 0; c < noClasses; c++ ) { + Class cls = classes[c]; + { + u_int count; + Method* methods = class_copyMethodList( cls, &count ); + for( u_int m = 0; m < count ; m++ ) { + SEL selector = method_getName(methods[m]); + std::string methodName = sel_getName(selector); + if( startsWith( methodName, "Catch_TestCase_" ) ) { + std::string testCaseName = methodName.substr( 15 ); + std::string name = Detail::getAnnotation( cls, "Name", testCaseName ); + std::string desc = Detail::getAnnotation( cls, "Description", testCaseName ); + const char* className = class_getName( cls ); + + getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) ); + noTestMethods++; + } + } + free(methods); + } + } + return noTestMethods; + } + + namespace Matchers { + namespace Impl { + namespace NSStringMatchers { + + template + struct StringHolder : MatcherImpl{ + StringHolder( NSString* substr ) : m_substr( [substr copy] ){} + StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){} + StringHolder() { + arcSafeRelease( m_substr ); + } + + NSString* m_substr; + }; + + struct Equals : StringHolder { + Equals( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str isEqualToString:m_substr]; + } + + virtual std::string toString() const { + return "equals string: \"" + Catch::toString( m_substr ) + "\""; + } + }; + + struct Contains : StringHolder { + Contains( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location != NSNotFound; + } + + virtual std::string toString() const { + return "contains string: \"" + Catch::toString( m_substr ) + "\""; + } + }; + + struct StartsWith : StringHolder { + StartsWith( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location == 0; + } + + virtual std::string toString() const { + return "starts with: \"" + Catch::toString( m_substr ) + "\""; + } + }; + struct EndsWith : StringHolder { + EndsWith( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( ExpressionType const& str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location == [str length] - [m_substr length]; + } + + virtual std::string toString() const { + return "ends with: \"" + Catch::toString( m_substr ) + "\""; + } + }; + + } // namespace NSStringMatchers + } // namespace Impl + + inline Impl::NSStringMatchers::Equals + Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); } + + inline Impl::NSStringMatchers::Contains + Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); } + + inline Impl::NSStringMatchers::StartsWith + StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); } + + inline Impl::NSStringMatchers::EndsWith + EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); } + + } // namespace Matchers + + using namespace Matchers; + +} // namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define OC_TEST_CASE( name, desc )\ ++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \ +{\ +return @ name; \ +}\ ++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \ +{ \ +return @ desc; \ +} \ +-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test ) + +#endif + +#if defined( CATCH_CONFIG_MAIN ) || defined( CATCH_CONFIG_RUNNER ) +// #included from: internal/catch_impl.hpp +#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED + +// Collect all the implementation files together here +// These are the equivalent of what would usually be cpp files + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wweak-vtables" +#endif + +// #included from: catch_runner.hpp +#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED + +// #included from: internal/catch_commandline.hpp +#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED + +// #included from: catch_config.hpp +#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED + +// #included from: catch_test_spec.h +#define TWOBLUECUBES_CATCH_TEST_SPEC_H_INCLUDED + +// #included from: catch_tags.h +#define TWOBLUECUBES_CATCH_TAGS_H_INCLUDED + +#include +#include +#include +#include + +#ifdef __clang__ +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + class TagParser { + public: + virtual ~TagParser(); + + void parse( std::string const& str ); + + protected: + virtual void acceptTag( std::string const& tag ) = 0; + virtual void acceptChar( char c ) = 0; + virtual void endParse() {} + + private: + }; + + class TagExtracter : public TagParser { + public: + + TagExtracter( std::set& tags ); + virtual ~TagExtracter(); + + void parse( std::string& description ); + + private: + virtual void acceptTag( std::string const& tag ); + virtual void acceptChar( char c ); + + TagExtracter& operator=(TagExtracter const&); + + std::set& m_tags; + std::string m_remainder; + }; + + class Tag { + public: + Tag(); + Tag( std::string const& name, bool isNegated ); + std::string getName() const; + bool isNegated() const; + bool operator ! () const; + + private: + std::string m_name; + bool m_isNegated; + }; + + class TagSet { + typedef std::map TagMap; + public: + void add( Tag const& tag ); + bool empty() const; + bool matches( std::set const& tags ) const; + + private: + TagMap m_tags; + }; + + class TagExpression { + public: + bool matches( std::set const& tags ) const; + + private: + friend class TagExpressionParser; + + std::vector m_tagSets; + }; + + class TagExpressionParser : public TagParser { + public: + TagExpressionParser( TagExpression& exp ); + ~TagExpressionParser(); + + private: + virtual void acceptTag( std::string const& tag ); + virtual void acceptChar( char c ); + virtual void endParse(); + + TagExpressionParser& operator=(TagExpressionParser const&); + + bool m_isNegated; + TagSet m_currentTagSet; + TagExpression& m_exp; + }; + +} // end namespace Catch + +#include +#include + +namespace Catch { + + class TestCase; + + struct IfFilterMatches{ enum DoWhat { + AutoDetectBehaviour, + IncludeTests, + ExcludeTests + }; }; + + class TestCaseFilter { + enum WildcardPosition { + NoWildcard = 0, + WildcardAtStart = 1, + WildcardAtEnd = 2, + WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd + }; + + public: + TestCaseFilter( std::string const& testSpec, IfFilterMatches::DoWhat matchBehaviour = IfFilterMatches::AutoDetectBehaviour ); + + IfFilterMatches::DoWhat getFilterType() const; + bool shouldInclude( TestCase const& testCase ) const; + + private: + bool isMatch( TestCase const& testCase ) const; + + std::string m_stringToMatch; + IfFilterMatches::DoWhat m_filterType; + WildcardPosition m_wildcardPosition; + }; + + class TestCaseFilters { + public: + TestCaseFilters( std::string const& name ); + std::string getName() const; + void addFilter( TestCaseFilter const& filter ); + void addTags( std::string const& tagPattern ); + bool shouldInclude( TestCase const& testCase ) const; + + private: + std::vector m_tagExpressions; + std::vector m_inclusionFilters; + std::vector m_exclusionFilters; + std::string m_name; + }; + +} + +// #included from: catch_stream.h +#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED + +#include + +#ifdef __clang__ +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + + class Stream { + public: + Stream(); + Stream( std::streambuf* _streamBuf, bool _isOwned ); + void release(); + + std::streambuf* streamBuf; + + private: + bool isOwned; + }; +} + +#include +#include +#include +#include + +#ifndef CATCH_CONFIG_CONSOLE_WIDTH +#define CATCH_CONFIG_CONSOLE_WIDTH 80 +#endif + +namespace Catch { + + struct ConfigData { + + ConfigData() + : listTests( false ), + listTags( false ), + listReporters( false ), + listTestNamesOnly( false ), + showSuccessfulTests( false ), + shouldDebugBreak( false ), + noThrow( false ), + showHelp( false ), + abortAfter( -1 ), + verbosity( Verbosity::Normal ), + warnings( WarnAbout::Nothing ), + showDurations( ShowDurations::DefaultForReporter ) + {} + + bool listTests; + bool listTags; + bool listReporters; + bool listTestNamesOnly; + + bool showSuccessfulTests; + bool shouldDebugBreak; + bool noThrow; + bool showHelp; + + int abortAfter; + + Verbosity::Level verbosity; + WarnAbout::What warnings; + ShowDurations::OrNot showDurations; + + std::string reporterName; + std::string outputFilename; + std::string name; + std::string processName; + + std::vector testsOrTags; + }; + + class Config : public SharedImpl { + private: + Config( Config const& other ); + Config& operator = ( Config const& other ); + virtual void dummy(); + public: + + Config() + : m_os( std::cout.rdbuf() ) + {} + + Config( ConfigData const& data ) + : m_data( data ), + m_os( std::cout.rdbuf() ) + { + if( !data.testsOrTags.empty() ) { + std::string groupName; + for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) { + if( i != 0 ) + groupName += " "; + groupName += data.testsOrTags[i]; + } + TestCaseFilters filters( groupName ); + for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) { + std::string filter = data.testsOrTags[i]; + if( startsWith( filter, "[" ) || startsWith( filter, "~[" ) ) + filters.addTags( filter ); + else + filters.addFilter( TestCaseFilter( filter ) ); + } + m_filterSets.push_back( filters ); + } + } + + virtual ~Config() { + m_os.rdbuf( std::cout.rdbuf() ); + m_stream.release(); + } + + void setFilename( std::string const& filename ) { + m_data.outputFilename = filename; + } + + std::string const& getFilename() const { + return m_data.outputFilename ; + } + + bool listTests() const { return m_data.listTests; } + bool listTestNamesOnly() const { return m_data.listTestNamesOnly; } + bool listTags() const { return m_data.listTags; } + bool listReporters() const { return m_data.listReporters; } + + std::string getProcessName() const { + return m_data.processName; + } + + bool shouldDebugBreak() const { + return m_data.shouldDebugBreak; + } + + void setStreamBuf( std::streambuf* buf ) { + m_os.rdbuf( buf ? buf : std::cout.rdbuf() ); + } + + void useStream( std::string const& streamName ) { + Stream stream = createStream( streamName ); + setStreamBuf( stream.streamBuf ); + m_stream.release(); + m_stream = stream; + } + + std::string getReporterName() const { return m_data.reporterName; } + + void addTestSpec( std::string const& testSpec ) { + TestCaseFilters filters( testSpec ); + filters.addFilter( TestCaseFilter( testSpec ) ); + m_filterSets.push_back( filters ); + } + + int abortAfter() const { + return m_data.abortAfter; + } + + std::vector const& filters() const { + return m_filterSets; + } + + bool showHelp() const { return m_data.showHelp; } + + // IConfig interface + virtual bool allowThrows() const { return !m_data.noThrow; } + virtual std::ostream& stream() const { return m_os; } + virtual std::string name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } + virtual bool includeSuccessfulResults() const { return m_data.showSuccessfulTests; } + virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; } + virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; } + + private: + ConfigData m_data; + + Stream m_stream; + mutable std::ostream m_os; + std::vector m_filterSets; + }; + +} // end namespace Catch + +// #included from: catch_clara.h +#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED + +#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH + +// Declare Clara inside the Catch namespace +#define STITCH_CLARA_OUTER_NAMESPACE Catch +// #included from: clara.h + +// Only use header guard if we are not using an outer namespace +#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OUTER_NAMESPACE) +#ifndef STITCH_CLARA_OUTER_NAMESPACE +#define TWOBLUECUBES_CLARA_H_INCLUDED +#endif + +#define STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE Clara + +// ----------- #included from tbc_text_format.h ----------- + +// Only use header guard if we are not using an outer namespace +#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE) +#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +#define TBC_TEXT_FORMAT_H_INCLUDED +#endif + +#include +#include +#include + +// Use optional outer namespace +#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE { +#endif + +namespace Tbc { + +#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH + const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + struct TextAttributes { + TextAttributes() + : initialIndent( std::string::npos ), + indent( 0 ), + width( consoleWidth-1 ), + tabChar( '\t' ) + {} + + TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } + TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } + TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } + TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } + + std::size_t initialIndent; // indent of first line, or npos + std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos + std::size_t width; // maximum width of text, including indent. Longer text will wrap + char tabChar; // If this char is seen the indent is changed to current pos + }; + + class Text { + public: + Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) + : attr( _attr ) + { + std::string wrappableChars = " [({.,/|\\-"; + std::size_t indent = _attr.initialIndent != std::string::npos + ? _attr.initialIndent + : _attr.indent; + std::string remainder = _str; + + while( !remainder.empty() ) { + if( lines.size() >= 1000 ) { + lines.push_back( "... message truncated due to excessive size" ); + return; + } + std::size_t tabPos = std::string::npos; + std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); + std::size_t pos = remainder.find_first_of( '\n' ); + if( pos <= width ) { + width = pos; + } + pos = remainder.find_last_of( _attr.tabChar, width ); + if( pos != std::string::npos ) { + tabPos = pos; + if( remainder[width] == '\n' ) + width--; + remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); + } + + if( width == remainder.size() ) { + spliceLine( indent, remainder, width ); + } + else if( remainder[width] == '\n' ) { + spliceLine( indent, remainder, width ); + if( width <= 1 || remainder.size() != 1 ) + remainder = remainder.substr( 1 ); + indent = _attr.indent; + } + else { + pos = remainder.find_last_of( wrappableChars, width ); + if( pos != std::string::npos && pos > 0 ) { + spliceLine( indent, remainder, pos ); + if( remainder[0] == ' ' ) + remainder = remainder.substr( 1 ); + } + else { + spliceLine( indent, remainder, width-1 ); + lines.back() += "-"; + } + if( lines.size() == 1 ) + indent = _attr.indent; + if( tabPos != std::string::npos ) + indent += tabPos; + } + } + } + + void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { + lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); + _remainder = _remainder.substr( _pos ); + } + + typedef std::vector::const_iterator const_iterator; + + const_iterator begin() const { return lines.begin(); } + const_iterator end() const { return lines.end(); } + std::string const& last() const { return lines.back(); } + std::size_t size() const { return lines.size(); } + std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } + std::string toString() const { + std::ostringstream oss; + oss << *this; + return oss.str(); + } + + inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { + for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); + it != itEnd; ++it ) { + if( it != _text.begin() ) + _stream << "\n"; + _stream << *it; + } + return _stream; + } + + private: + std::string str; + TextAttributes attr; + std::vector lines; + }; + +} // end namespace Tbc + +#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TBC_TEXT_FORMAT_H_INCLUDED + +// ----------- end of #include from tbc_text_format.h ----------- +// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h + +#undef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE + +#include +#include +#include +#include + +// Use optional outer namespace +#ifdef STITCH_CLARA_OUTER_NAMESPACE +namespace STITCH_CLARA_OUTER_NAMESPACE { +#endif + +namespace Clara { + namespace Detail { + +#ifdef CLARA_CONSOLE_WIDTH + const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + using namespace ::Clara::Tbc; + + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + + template struct IsBool { static const bool value = false; }; + template<> struct IsBool { static const bool value = true; }; + + template + void convertInto( std::string const& _source, T& _dest ) { + std::stringstream ss; + ss << _source; + ss >> _dest; + if( ss.fail() ) + throw std::runtime_error( "Unable to convert " + _source + " to destination type" ); + } + inline void convertInto( std::string const& _source, std::string& _dest ) { + _dest = _source; + } + inline void convertInto( std::string const& _source, bool& _dest ) { + std::string sourceLC = _source; + std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower ); + if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ) + _dest = true; + else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" ) + _dest = false; + else + throw std::runtime_error( "Expected a boolean value but did not recognise:\n '" + _source + "'" ); + } + inline void convertInto( bool _source, bool& _dest ) { + _dest = _source; + } + template + inline void convertInto( bool, T& ) { + throw std::runtime_error( "Invalid conversion" ); + } + + template + struct IArgFunction { + virtual ~IArgFunction() {} + virtual void set( ConfigT& config, std::string const& value ) const = 0; + virtual void setFlag( ConfigT& config ) const = 0; + virtual bool takesArg() const = 0; + virtual IArgFunction* clone() const = 0; + }; + + template + class BoundArgFunction { + public: + BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {} + BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj->clone() ) {} + BoundArgFunction& operator = ( BoundArgFunction const& other ) { + IArgFunction* newFunctionObj = other.functionObj->clone(); + delete functionObj; + functionObj = newFunctionObj; + return *this; + } + ~BoundArgFunction() { delete functionObj; } + + void set( ConfigT& config, std::string const& value ) const { + functionObj->set( config, value ); + } + void setFlag( ConfigT& config ) const { + functionObj->setFlag( config ); + } + bool takesArg() const { return functionObj->takesArg(); } + private: + IArgFunction* functionObj; + }; + + template + struct NullBinder : IArgFunction{ + virtual void set( C&, std::string const& ) const {} + virtual void setFlag( C& ) const {} + virtual bool takesArg() const { return true; } + virtual IArgFunction* clone() const { return new NullBinder( *this ); } + }; + + template + struct BoundDataMember : IArgFunction{ + BoundDataMember( M C::* _member ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + convertInto( stringValue, p.*member ); + } + virtual void setFlag( C& p ) const { + convertInto( true, p.*member ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundDataMember( *this ); } + M C::* member; + }; + template + struct BoundUnaryMethod : IArgFunction{ + BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + typename RemoveConstRef::type value; + convertInto( stringValue, value ); + (p.*member)( value ); + } + virtual void setFlag( C& p ) const { + typename RemoveConstRef::type value; + convertInto( true, value ); + (p.*member)( value ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); } + void (C::*member)( M ); + }; + template + struct BoundNullaryMethod : IArgFunction{ + BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + bool value; + convertInto( stringValue, value ); + if( value ) + (p.*member)(); + } + virtual void setFlag( C& p ) const { + (p.*member)(); + } + virtual bool takesArg() const { return false; } + virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); } + void (C::*member)(); + }; + + template + struct BoundUnaryFunction : IArgFunction{ + BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {} + virtual void set( C& obj, std::string const& stringValue ) const { + bool value; + convertInto( stringValue, value ); + if( value ) + function( obj ); + } + virtual void setFlag( C& p ) const { + function( p ); + } + virtual bool takesArg() const { return false; } + virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); } + void (*function)( C& ); + }; + + template + struct BoundBinaryFunction : IArgFunction{ + BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {} + virtual void set( C& obj, std::string const& stringValue ) const { + typename RemoveConstRef::type value; + convertInto( stringValue, value ); + function( obj, value ); + } + virtual void setFlag( C& obj ) const { + typename RemoveConstRef::type value; + convertInto( true, value ); + function( obj, value ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); } + void (*function)( C&, T ); + }; + + template + BoundArgFunction makeBoundField( M C::* _member ) { + return BoundArgFunction( new BoundDataMember( _member ) ); + } + template + BoundArgFunction makeBoundField( void (C::*_member)( M ) ) { + return BoundArgFunction( new BoundUnaryMethod( _member ) ); + } + template + BoundArgFunction makeBoundField( void (C::*_member)() ) { + return BoundArgFunction( new BoundNullaryMethod( _member ) ); + } + template + BoundArgFunction makeBoundField( void (*_function)( C& ) ) { + return BoundArgFunction( new BoundUnaryFunction( _function ) ); + } + template + BoundArgFunction makeBoundField( void (*_function)( C&, T ) ) { + return BoundArgFunction( new BoundBinaryFunction( _function ) ); + } + } // namespace Detail + + struct Parser { + Parser() : separators( " \t=:" ) {} + + struct Token { + enum Type { Positional, ShortOpt, LongOpt }; + Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {} + Type type; + std::string data; + }; + + void parseIntoTokens( int argc, char const * const * argv, std::vector& tokens ) const { + const std::string doubleDash = "--"; + for( int i = 1; i < argc && argv[i] != doubleDash; ++i ) + parseIntoTokens( argv[i] , tokens); + } + void parseIntoTokens( std::string arg, std::vector& tokens ) const { + while( !arg.empty() ) { + Parser::Token token( Parser::Token::Positional, arg ); + arg = ""; + if( token.data[0] == '-' ) { + if( token.data.size() > 1 && token.data[1] == '-' ) { + token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) ); + } + else { + token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) ); + if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) { + arg = "-" + token.data.substr( 1 ); + token.data = token.data.substr( 0, 1 ); + } + } + } + if( token.type != Parser::Token::Positional ) { + std::size_t pos = token.data.find_first_of( separators ); + if( pos != std::string::npos ) { + arg = token.data.substr( pos+1 ); + token.data = token.data.substr( 0, pos ); + } + } + tokens.push_back( token ); + } + } + std::string separators; + }; + + template + class CommandLine { + + struct Arg { + Arg( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ), position( -1 ) {} + + bool hasShortName( std::string const& shortName ) const { + for( std::vector::const_iterator + it = shortNames.begin(), itEnd = shortNames.end(); + it != itEnd; + ++it ) + if( *it == shortName ) + return true; + return false; + } + bool hasLongName( std::string const& _longName ) const { + return _longName == longName; + } + bool takesArg() const { + return !hint.empty(); + } + bool isFixedPositional() const { + return position != -1; + } + bool isAnyPositional() const { + return position == -1 && shortNames.empty() && longName.empty(); + } + std::string dbgName() const { + if( !longName.empty() ) + return "--" + longName; + if( !shortNames.empty() ) + return "-" + shortNames[0]; + return "positional args"; + } + void validate() const { + if( boundField.takesArg() && !takesArg() ) + throw std::logic_error( "command line argument '" + dbgName() + "' must specify a hint" ); + } + std::string commands() const { + std::ostringstream oss; + bool first = true; + std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end(); + for(; it != itEnd; ++it ) { + if( first ) + first = false; + else + oss << ", "; + oss << "-" << *it; + } + if( !longName.empty() ) { + if( !first ) + oss << ", "; + oss << "--" << longName; + } + if( !hint.empty() ) + oss << " <" << hint << ">"; + return oss.str(); + } + + Detail::BoundArgFunction boundField; + std::vector shortNames; + std::string longName; + std::string description; + std::string hint; + int position; + }; + + // NOTE: std::auto_ptr is deprecated in c++11/c++0x +#if defined(__cplusplus) && __cplusplus > 199711L + typedef std::unique_ptr ArgAutoPtr; +#else + typedef std::auto_ptr ArgAutoPtr; +#endif + + class ArgBinder { + public: + template + ArgBinder( CommandLine* cl, F f ) + : m_cl( cl ), + m_arg( Detail::makeBoundField( f ) ) + {} + ArgBinder( ArgBinder& other ) + : m_cl( other.m_cl ), + m_arg( other.m_arg ) + { + other.m_cl = NULL; + } + // !TBD: Need to include workarounds to be able to declare this + // destructor as able to throw exceptions + ~ArgBinder() noexcept(false) { + if( m_cl && !std::uncaught_exception() ) { + m_arg.validate(); + if( m_arg.isFixedPositional() ) { + m_cl->m_positionalArgs.insert( std::make_pair( m_arg.position, m_arg ) ); + if( m_arg.position > m_cl->m_highestSpecifiedArgPosition ) + m_cl->m_highestSpecifiedArgPosition = m_arg.position; + } + else if( m_arg.isAnyPositional() ) { + if( m_cl->m_arg.get() ) + throw std::logic_error( "Only one unpositional argument can be added" ); + m_cl->m_arg = ArgAutoPtr( new Arg( m_arg ) ); + } + else + m_cl->m_options.push_back( m_arg ); + } + } + ArgBinder& shortOpt( std::string const& name ) { + m_arg.shortNames.push_back( name ); + return *this; + } + ArgBinder& longOpt( std::string const& name ) { + m_arg.longName = name; + return *this; + } + ArgBinder& describe( std::string const& description ) { + m_arg.description = description; + return *this; + } + ArgBinder& hint( std::string const& hint ) { + m_arg.hint = hint; + return *this; + } + ArgBinder& position( int position ) { + m_arg.position = position; + return *this; + } + private: + CommandLine* m_cl; + Arg m_arg; + }; + + public: + + CommandLine() + : m_boundProcessName( new Detail::NullBinder() ), + m_highestSpecifiedArgPosition( 0 ), + m_throwOnUnrecognisedTokens( false ) + {} + CommandLine( CommandLine const& other ) + : m_boundProcessName( other.m_boundProcessName ), + m_options ( other.m_options ), + m_positionalArgs( other.m_positionalArgs ), + m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ), + m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens ) + { + if( other.m_arg.get() ) + m_arg = ArgAutoPtr( new Arg( *other.m_arg ) ); + } + + CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) { + m_throwOnUnrecognisedTokens = shouldThrow; + return *this; + } + + template + ArgBinder bind( F f ) { + ArgBinder binder( this, f ); + return binder; + } + template + void bindProcessName( F f ) { + m_boundProcessName = Detail::makeBoundField( f ); + } + + void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const { + typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it; + std::size_t maxWidth = 0; + for( it = itBegin; it != itEnd; ++it ) + maxWidth = (std::max)( maxWidth, it->commands().size() ); + + for( it = itBegin; it != itEnd; ++it ) { + Detail::Text usage( it->commands(), Detail::TextAttributes() + .setWidth( maxWidth+indent ) + .setIndent( indent ) ); + // !TBD handle longer usage strings + Detail::Text desc( it->description, Detail::TextAttributes() + .setWidth( width - maxWidth -3 ) ); + + for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) { + std::string usageCol = i < usage.size() ? usage[i] : ""; + os << usageCol; + + if( i < desc.size() && !desc[i].empty() ) + os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' ) + << desc[i]; + os << "\n"; + } + } + } + std::string optUsage() const { + std::ostringstream oss; + optUsage( oss ); + return oss.str(); + } + + void argSynopsis( std::ostream& os ) const { + for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) { + if( i > 1 ) + os << " "; + typename std::map::const_iterator it = m_positionalArgs.find( i ); + if( it != m_positionalArgs.end() ) + os << "<" << it->second.hint << ">"; + else if( m_arg.get() ) + os << "<" << m_arg->hint << ">"; + else + throw std::logic_error( "non consecutive positional arguments with no floating args" ); + } + // !TBD No indication of mandatory args + if( m_arg.get() ) { + if( m_highestSpecifiedArgPosition > 1 ) + os << " "; + os << "[<" << m_arg->hint << "> ...]"; + } + } + std::string argSynopsis() const { + std::ostringstream oss; + argSynopsis( oss ); + return oss.str(); + } + + void usage( std::ostream& os, std::string const& procName ) const { + os << "usage:\n " << procName << " "; + argSynopsis( os ); + if( !m_options.empty() ) { + os << " [options]\n\nwhere options are: \n"; + optUsage( os, 2 ); + } + os << "\n"; + } + std::string usage( std::string const& procName ) const { + std::ostringstream oss; + usage( oss, procName ); + return oss.str(); + } + + ConfigT parseInto( int argc, char const * const * argv ) const { + ConfigT config; + parseInto( argc, argv, config ); + return config; + } + + std::vector parseInto( int argc, char const * const * argv, ConfigT& config ) const { + std::string processName = argv[0]; + std::size_t lastSlash = processName.find_last_of( "/\\" ); + if( lastSlash != std::string::npos ) + processName = processName.substr( lastSlash+1 ); + m_boundProcessName.set( config, processName ); + std::vector tokens; + Parser parser; + parser.parseIntoTokens( argc, argv, tokens ); + return populate( tokens, config ); + } + + std::vector populate( std::vector const& tokens, ConfigT& config ) const { + if( m_options.empty() && m_positionalArgs.empty() ) + throw std::logic_error( "No options or arguments specified" ); + + std::vector unusedTokens = populateOptions( tokens, config ); + unusedTokens = populateFixedArgs( unusedTokens, config ); + unusedTokens = populateFloatingArgs( unusedTokens, config ); + return unusedTokens; + } + + std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const { + std::vector unusedTokens; + std::vector errors; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); + for(; it != itEnd; ++it ) { + Arg const& arg = *it; + + try { + if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) || + ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) { + if( arg.takesArg() ) { + if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional ) + errors.push_back( "Expected argument to option: " + token.data ); + else + arg.boundField.set( config, tokens[++i].data ); + } + else { + arg.boundField.setFlag( config ); + } + break; + } + } + catch( std::exception& ex ) { + errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" ); + } + } + if( it == itEnd ) { + if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens ) + unusedTokens.push_back( token ); + else if( m_throwOnUnrecognisedTokens ) + errors.push_back( "unrecognised option: " + token.data ); + } + } + if( !errors.empty() ) { + std::ostringstream oss; + for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end(); + it != itEnd; + ++it ) { + if( it != errors.begin() ) + oss << "\n"; + oss << *it; + } + throw std::runtime_error( oss.str() ); + } + return unusedTokens; + } + std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const { + std::vector unusedTokens; + int position = 1; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + typename std::map::const_iterator it = m_positionalArgs.find( position ); + if( it != m_positionalArgs.end() ) + it->second.boundField.set( config, token.data ); + else + unusedTokens.push_back( token ); + if( token.type == Parser::Token::Positional ) + position++; + } + return unusedTokens; + } + std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const { + if( !m_arg.get() ) + return tokens; + std::vector unusedTokens; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + if( token.type == Parser::Token::Positional ) + m_arg->boundField.set( config, token.data ); + else + unusedTokens.push_back( token ); + } + return unusedTokens; + } + + private: + Detail::BoundArgFunction m_boundProcessName; + std::vector m_options; + std::map m_positionalArgs; + ArgAutoPtr m_arg; + int m_highestSpecifiedArgPosition; + bool m_throwOnUnrecognisedTokens; + }; + +} // end namespace Clara + +#ifdef STITCH_CLARA_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TWOBLUECUBES_CLARA_H_INCLUDED +#undef STITCH_CLARA_OUTER_NAMESPACE + +#include + +namespace Catch { + + inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; } + inline void abortAfterX( ConfigData& config, int x ) { + if( x < 1 ) + throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" ); + config.abortAfter = x; + } + inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); } + + inline void addWarning( ConfigData& config, std::string const& _warning ) { + if( _warning == "NoAssertions" ) + config.warnings = (WarnAbout::What)( config.warnings | WarnAbout::NoAssertions ); + else + throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" ); + + } + inline void setVerbosity( ConfigData& config, int level ) { + // !TBD: accept strings? + config.verbosity = (Verbosity::Level)level; + } + inline void setShowDurations( ConfigData& config, bool _showDurations ) { + config.showDurations = _showDurations + ? ShowDurations::Always + : ShowDurations::Never; + } + inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) { + std::ifstream f( _filename.c_str() ); + if( !f.is_open() ) + throw std::domain_error( "Unable to load input file: " + _filename ); + + std::string line; + while( std::getline( f, line ) ) { + line = trim(line); + if( !line.empty() && !startsWith( line, "#" ) ) + addTestOrTags( config, line ); + } + } + + inline Clara::CommandLine makeCommandLineParser() { + + Clara::CommandLine cli; + + cli.bindProcessName( &ConfigData::processName ); + + cli.bind( &ConfigData::showHelp ) + .describe( "display usage information" ) + .shortOpt( "?") + .shortOpt( "h") + .longOpt( "help" ); + + cli.bind( &ConfigData::listTests ) + .describe( "list all/matching test cases" ) + .shortOpt( "l") + .longOpt( "list-tests" ); + + cli.bind( &ConfigData::listTags ) + .describe( "list all/matching tags" ) + .shortOpt( "t") + .longOpt( "list-tags" ); + + cli.bind( &ConfigData::showSuccessfulTests ) + .describe( "include successful tests in output" ) + .shortOpt( "s") + .longOpt( "success" ); + + cli.bind( &ConfigData::shouldDebugBreak ) + .describe( "break into debugger on failure" ) + .shortOpt( "b") + .longOpt( "break" ); + + cli.bind( &ConfigData::noThrow ) + .describe( "skip exception tests" ) + .shortOpt( "e") + .longOpt( "nothrow" ); + + cli.bind( &ConfigData::outputFilename ) + .describe( "output filename" ) + .shortOpt( "o") + .longOpt( "out" ) + .hint( "filename" ); + + cli.bind( &ConfigData::reporterName ) + .describe( "reporter to use (defaults to console)" ) + .shortOpt( "r") + .longOpt( "reporter" ) +// .hint( "name[:filename]" ); + .hint( "name" ); + + cli.bind( &ConfigData::name ) + .describe( "suite name" ) + .shortOpt( "n") + .longOpt( "name" ) + .hint( "name" ); + + cli.bind( &abortAfterFirst ) + .describe( "abort at first failure" ) + .shortOpt( "a") + .longOpt( "abort" ); + + cli.bind( &abortAfterX ) + .describe( "abort after x failures" ) + .shortOpt( "x") + .longOpt( "abortx" ) + .hint( "number of failures" ); + + cli.bind( &addWarning ) + .describe( "enable warnings" ) + .shortOpt( "w") + .longOpt( "warn" ) + .hint( "warning name" ); + +// cli.bind( &setVerbosity ) +// .describe( "level of verbosity (0=no output)" ) +// .shortOpt( "v") +// .longOpt( "verbosity" ) +// .hint( "level" ); + + cli.bind( &addTestOrTags ) + .describe( "which test or tests to use" ) + .hint( "test name, pattern or tags" ); + + cli.bind( &setShowDurations ) + .describe( "show test durations" ) + .shortOpt( "d") + .longOpt( "durations" ) + .hint( "yes/no" ); + + cli.bind( &loadTestNamesFromFile ) + .describe( "load test names to run from a file" ) + .shortOpt( "f") + .longOpt( "input-file" ) + .hint( "filename" ); + + // Less common commands which don't have a short form + cli.bind( &ConfigData::listTestNamesOnly ) + .describe( "list all/matching test cases names only" ) + .longOpt( "list-test-names-only" ); + + cli.bind( &ConfigData::listReporters ) + .describe( "list all reporters" ) + .longOpt( "list-reporters" ); + + return cli; + } + +} // end namespace Catch + +// #included from: internal/catch_list.hpp +#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED + +// #included from: catch_text.h +#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED + +#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH + +#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch +// #included from: tbc_text_format.h +// Only use header guard if we are not using an outer namespace +#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED +# ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +# define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +# endif +# else +# define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED +# endif +#endif +#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +#include +#include +#include + +// Use optional outer namespace +#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE { +#endif + +namespace Tbc { + +#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH + const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + struct TextAttributes { + TextAttributes() + : initialIndent( std::string::npos ), + indent( 0 ), + width( consoleWidth-1 ), + tabChar( '\t' ) + {} + + TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } + TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } + TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } + TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } + + std::size_t initialIndent; // indent of first line, or npos + std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos + std::size_t width; // maximum width of text, including indent. Longer text will wrap + char tabChar; // If this char is seen the indent is changed to current pos + }; + + class Text { + public: + Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) + : attr( _attr ) + { + std::string wrappableChars = " [({.,/|\\-"; + std::size_t indent = _attr.initialIndent != std::string::npos + ? _attr.initialIndent + : _attr.indent; + std::string remainder = _str; + + while( !remainder.empty() ) { + if( lines.size() >= 1000 ) { + lines.push_back( "... message truncated due to excessive size" ); + return; + } + std::size_t tabPos = std::string::npos; + std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); + std::size_t pos = remainder.find_first_of( '\n' ); + if( pos <= width ) { + width = pos; + } + pos = remainder.find_last_of( _attr.tabChar, width ); + if( pos != std::string::npos ) { + tabPos = pos; + if( remainder[width] == '\n' ) + width--; + remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); + } + + if( width == remainder.size() ) { + spliceLine( indent, remainder, width ); + } + else if( remainder[width] == '\n' ) { + spliceLine( indent, remainder, width ); + if( width <= 1 || remainder.size() != 1 ) + remainder = remainder.substr( 1 ); + indent = _attr.indent; + } + else { + pos = remainder.find_last_of( wrappableChars, width ); + if( pos != std::string::npos && pos > 0 ) { + spliceLine( indent, remainder, pos ); + if( remainder[0] == ' ' ) + remainder = remainder.substr( 1 ); + } + else { + spliceLine( indent, remainder, width-1 ); + lines.back() += "-"; + } + if( lines.size() == 1 ) + indent = _attr.indent; + if( tabPos != std::string::npos ) + indent += tabPos; + } + } + } + + void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { + lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); + _remainder = _remainder.substr( _pos ); + } + + typedef std::vector::const_iterator const_iterator; + + const_iterator begin() const { return lines.begin(); } + const_iterator end() const { return lines.end(); } + std::string const& last() const { return lines.back(); } + std::size_t size() const { return lines.size(); } + std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } + std::string toString() const { + std::ostringstream oss; + oss << *this; + return oss.str(); + } + + inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { + for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); + it != itEnd; ++it ) { + if( it != _text.begin() ) + _stream << "\n"; + _stream << *it; + } + return _stream; + } + + private: + std::string str; + TextAttributes attr; + std::vector lines; + }; + +} // end namespace Tbc + +#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE + +namespace Catch { + using Tbc::Text; + using Tbc::TextAttributes; +} + +// #included from: catch_console_colour.hpp +#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED + +namespace Catch { + + namespace Detail { + struct IColourImpl; + } + + struct Colour { + enum Code { + None = 0, + + White, + Red, + Green, + Blue, + Cyan, + Yellow, + Grey, + + Bright = 0x10, + + BrightRed = Bright | Red, + BrightGreen = Bright | Green, + LightGrey = Bright | Grey, + BrightWhite = Bright | White, + + // By intention + FileName = LightGrey, + ResultError = BrightRed, + ResultSuccess = BrightGreen, + + Error = BrightRed, + Success = Green, + + OriginalExpression = Cyan, + ReconstructedExpression = Yellow, + + SecondaryText = LightGrey, + Headers = White + }; + + // Use constructed object for RAII guard + Colour( Code _colourCode ); + ~Colour(); + + // Use static method for one-shot changes + static void use( Code _colourCode ); + + private: + static Detail::IColourImpl* impl; + }; + +} // end namespace Catch + +// #included from: catch_interfaces_reporter.h +#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED + +// #included from: catch_option.hpp +#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED + +namespace Catch { + + // An optional type + template + class Option { + public: + Option() : nullableValue( NULL ) {} + Option( T const& _value ) + : nullableValue( new( storage ) T( _value ) ) + {} + Option( Option const& _other ) + : nullableValue( _other ? new( storage ) T( *_other ) : NULL ) + {} + + ~Option() { + reset(); + } + + Option& operator= ( Option const& _other ) { + if( &_other != this ) { + reset(); + if( _other ) + nullableValue = new( storage ) T( *_other ); + } + return *this; + } + Option& operator = ( T const& _value ) { + reset(); + nullableValue = new( storage ) T( _value ); + return *this; + } + + void reset() { + if( nullableValue ) + nullableValue->~T(); + nullableValue = NULL; + } + + T& operator*() { return *nullableValue; } + T const& operator*() const { return *nullableValue; } + T* operator->() { return nullableValue; } + const T* operator->() const { return nullableValue; } + + T valueOr( T const& defaultValue ) const { + return nullableValue ? *nullableValue : defaultValue; + } + + bool some() const { return nullableValue != NULL; } + bool none() const { return nullableValue == NULL; } + + bool operator !() const { return nullableValue == NULL; } + operator SafeBool::type() const { + return SafeBool::makeSafe( some() ); + } + + private: + T* nullableValue; + char storage[sizeof(T)]; + }; + +} // end namespace Catch + +#include +#include +#include +#include + +namespace Catch +{ + struct ReporterConfig { + explicit ReporterConfig( Ptr const& _fullConfig ) + : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} + + ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream ) + : m_stream( &_stream ), m_fullConfig( _fullConfig ) {} + + std::ostream& stream() const { return *m_stream; } + Ptr fullConfig() const { return m_fullConfig; } + + private: + std::ostream* m_stream; + Ptr m_fullConfig; + }; + + struct ReporterPreferences { + ReporterPreferences() + : shouldRedirectStdOut( false ) + {} + + bool shouldRedirectStdOut; + }; + + template + struct LazyStat : Option { + LazyStat() : used( false ) {} + LazyStat& operator=( T const& _value ) { + Option::operator=( _value ); + used = false; + return *this; + } + void reset() { + Option::reset(); + used = false; + } + bool used; + }; + + struct TestRunInfo { + TestRunInfo( std::string const& _name ) : name( _name ) {} + std::string name; + }; + struct GroupInfo { + GroupInfo( std::string const& _name, + std::size_t _groupIndex, + std::size_t _groupsCount ) + : name( _name ), + groupIndex( _groupIndex ), + groupsCounts( _groupsCount ) + {} + + std::string name; + std::size_t groupIndex; + std::size_t groupsCounts; + }; + + struct AssertionStats { + AssertionStats( AssertionResult const& _assertionResult, + std::vector const& _infoMessages, + Totals const& _totals ) + : assertionResult( _assertionResult ), + infoMessages( _infoMessages ), + totals( _totals ) + { + if( assertionResult.hasMessage() ) { + // Copy message into messages list. + // !TBD This should have been done earlier, somewhere + MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); + builder << assertionResult.getMessage(); + builder.m_info.message = builder.m_stream.str(); + + infoMessages.push_back( builder.m_info ); + } + } + virtual ~AssertionStats(); + + AssertionResult assertionResult; + std::vector infoMessages; + Totals totals; + }; + + struct SectionStats { + SectionStats( SectionInfo const& _sectionInfo, + Counts const& _assertions, + double _durationInSeconds, + bool _missingAssertions ) + : sectionInfo( _sectionInfo ), + assertions( _assertions ), + durationInSeconds( _durationInSeconds ), + missingAssertions( _missingAssertions ) + {} + virtual ~SectionStats(); + + SectionInfo sectionInfo; + Counts assertions; + double durationInSeconds; + bool missingAssertions; + }; + + struct TestCaseStats { + TestCaseStats( TestCaseInfo const& _testInfo, + Totals const& _totals, + std::string const& _stdOut, + std::string const& _stdErr, + bool _aborting ) + : testInfo( _testInfo ), + totals( _totals ), + stdOut( _stdOut ), + stdErr( _stdErr ), + aborting( _aborting ) + {} + virtual ~TestCaseStats(); + + TestCaseInfo testInfo; + Totals totals; + std::string stdOut; + std::string stdErr; + bool aborting; + }; + + struct TestGroupStats { + TestGroupStats( GroupInfo const& _groupInfo, + Totals const& _totals, + bool _aborting ) + : groupInfo( _groupInfo ), + totals( _totals ), + aborting( _aborting ) + {} + TestGroupStats( GroupInfo const& _groupInfo ) + : groupInfo( _groupInfo ), + aborting( false ) + {} + virtual ~TestGroupStats(); + + GroupInfo groupInfo; + Totals totals; + bool aborting; + }; + + struct TestRunStats { + TestRunStats( TestRunInfo const& _runInfo, + Totals const& _totals, + bool _aborting ) + : runInfo( _runInfo ), + totals( _totals ), + aborting( _aborting ) + {} + TestRunStats( TestRunStats const& _other ) + : runInfo( _other.runInfo ), + totals( _other.totals ), + aborting( _other.aborting ) + {} + virtual ~TestRunStats(); + + TestRunInfo runInfo; + Totals totals; + bool aborting; + }; + + struct IStreamingReporter : IShared { + virtual ~IStreamingReporter(); + + // Implementing class must also provide the following static method: + // static std::string getDescription(); + + virtual ReporterPreferences getPreferences() const = 0; + + virtual void noMatchingTestCases( std::string const& spec ) = 0; + + virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0; + virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0; + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0; + virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0; + + virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0; + + virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0; + virtual void sectionEnded( SectionStats const& sectionStats ) = 0; + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0; + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0; + virtual void testRunEnded( TestRunStats const& testRunStats ) = 0; + }; + + struct IReporterFactory { + virtual ~IReporterFactory(); + virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0; + virtual std::string getDescription() const = 0; + }; + + struct IReporterRegistry { + typedef std::map FactoryMap; + + virtual ~IReporterRegistry(); + virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0; + virtual FactoryMap const& getFactories() const = 0; + }; + +} + +#include +#include + +namespace Catch { + inline bool matchesFilters( std::vector const& filters, TestCase const& testCase ) { + std::vector::const_iterator it = filters.begin(); + std::vector::const_iterator itEnd = filters.end(); + for(; it != itEnd; ++it ) + if( !it->shouldInclude( testCase ) ) + return false; + return true; + } + + inline std::size_t listTests( Config const& config ) { + if( config.filters().empty() ) + std::cout << "All available test cases:\n"; + else + std::cout << "Matching test cases:\n"; + + std::size_t matchedTests = 0; + TextAttributes nameAttr, tagsAttr; + nameAttr.setInitialIndent( 2 ).setIndent( 4 ); + tagsAttr.setIndent( 6 ); + + std::vector const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests(); + for( std::vector::const_iterator it = allTests.begin(), itEnd = allTests.end(); + it != itEnd; + ++it ) + if( matchesFilters( config.filters(), *it ) ) { + matchedTests++; + TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); + Colour::Code colour = testCaseInfo.isHidden + ? Colour::SecondaryText + : Colour::None; + Colour colourGuard( colour ); + + std::cout << Text( testCaseInfo.name, nameAttr ) << std::endl; + if( !testCaseInfo.tags.empty() ) + std::cout << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl; + } + + if( config.filters().empty() ) + std::cout << pluralise( matchedTests, "test case" ) << "\n" << std::endl; + else + std::cout << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl; + return matchedTests; + } + + inline std::size_t listTestsNamesOnly( Config const& config ) { + std::size_t matchedTests = 0; + std::vector const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests(); + for( std::vector::const_iterator it = allTests.begin(), itEnd = allTests.end(); + it != itEnd; + ++it ) + if( matchesFilters( config.filters(), *it ) ) { + matchedTests++; + TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); + std::cout << testCaseInfo.name << std::endl; + } + return matchedTests; + } + + inline std::size_t listTags( Config const& config ) { + if( config.filters().empty() ) + std::cout << "All available tags:\n"; + else + std::cout << "Matching tags:\n"; + + std::map tagCounts; + + std::vector const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests(); + for( std::vector::const_iterator it = allTests.begin(), + itEnd = allTests.end(); + it != itEnd; + ++it ) { + if( matchesFilters( config.filters(), *it ) ) { + for( std::set::const_iterator tagIt = it->getTestCaseInfo().tags.begin(), + tagItEnd = it->getTestCaseInfo().tags.end(); + tagIt != tagItEnd; + ++tagIt ) { + std::string tagName = *tagIt; + std::map::iterator countIt = tagCounts.find( tagName ); + if( countIt == tagCounts.end() ) + tagCounts.insert( std::make_pair( tagName, 1 ) ); + else + countIt->second++; + } + } + } + + for( std::map::const_iterator countIt = tagCounts.begin(), + countItEnd = tagCounts.end(); + countIt != countItEnd; + ++countIt ) { + std::ostringstream oss; + oss << " " << countIt->second << " "; + Text wrapper( "[" + countIt->first + "]", TextAttributes() + .setInitialIndent( 0 ) + .setIndent( oss.str().size() ) + .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) ); + std::cout << oss.str() << wrapper << "\n"; + } + std::cout << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl; + return tagCounts.size(); + } + + inline std::size_t listReporters( Config const& /*config*/ ) { + std::cout << "Available reports:\n"; + IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories(); + IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it; + std::size_t maxNameLen = 0; + for(it = itBegin; it != itEnd; ++it ) + maxNameLen = (std::max)( maxNameLen, it->first.size() ); + + for(it = itBegin; it != itEnd; ++it ) { + Text wrapper( it->second->getDescription(), TextAttributes() + .setInitialIndent( 0 ) + .setIndent( 7+maxNameLen ) + .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) ); + std::cout << " " + << it->first + << ":" + << std::string( maxNameLen - it->first.size() + 2, ' ' ) + << wrapper << "\n"; + } + std::cout << std::endl; + return factories.size(); + } + + inline Option list( Config const& config ) { + Option listedCount; + if( config.listTests() ) + listedCount = listedCount.valueOr(0) + listTests( config ); + if( config.listTestNamesOnly() ) + listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config ); + if( config.listTags() ) + listedCount = listedCount.valueOr(0) + listTags( config ); + if( config.listReporters() ) + listedCount = listedCount.valueOr(0) + listReporters( config ); + return listedCount; + } + +} // end namespace Catch + +// #included from: internal/catch_runner_impl.hpp +#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED + +// #included from: catch_test_case_tracker.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { +namespace SectionTracking { + + class TrackedSection { + + typedef std::map TrackedSections; + + public: + enum RunState { + NotStarted, + Executing, + ExecutingChildren, + Completed + }; + + TrackedSection( std::string const& name, TrackedSection* parent ) + : m_name( name ), m_runState( NotStarted ), m_parent( parent ) + {} + + RunState runState() const { return m_runState; } + + void addChild( std::string const& childName ) { + m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) ); + } + TrackedSection* getChild( std::string const& childName ) { + return &m_children.find( childName )->second; + } + + void enter() { + if( m_runState == NotStarted ) + m_runState = Executing; + } + void leave() { + for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end(); + it != itEnd; + ++it ) + if( it->second.runState() != Completed ) { + m_runState = ExecutingChildren; + return; + } + m_runState = Completed; + } + TrackedSection* getParent() { + return m_parent; + } + bool hasChildren() const { + return !m_children.empty(); + } + + private: + std::string m_name; + RunState m_runState; + TrackedSections m_children; + TrackedSection* m_parent; + + }; + + class TestCaseTracker { + public: + TestCaseTracker( std::string const& testCaseName ) + : m_testCase( testCaseName, NULL ), + m_currentSection( &m_testCase ), + m_completedASectionThisRun( false ) + {} + + bool enterSection( std::string const& name ) { + if( m_completedASectionThisRun ) + return false; + if( m_currentSection->runState() == TrackedSection::Executing ) { + m_currentSection->addChild( name ); + return false; + } + else { + TrackedSection* child = m_currentSection->getChild( name ); + if( child->runState() != TrackedSection::Completed ) { + m_currentSection = child; + m_currentSection->enter(); + return true; + } + return false; + } + } + void leaveSection() { + m_currentSection->leave(); + m_currentSection = m_currentSection->getParent(); + assert( m_currentSection != NULL ); + m_completedASectionThisRun = true; + } + + bool currentSectionHasChildren() const { + return m_currentSection->hasChildren(); + } + bool isCompleted() const { + return m_testCase.runState() == TrackedSection::Completed; + } + + class Guard { + public: + Guard( TestCaseTracker& tracker ) + : m_tracker( tracker ) + { + m_tracker.enterTestCase(); + } + ~Guard() { + m_tracker.leaveTestCase(); + } + private: + Guard( Guard const& ); + void operator = ( Guard const& ); + TestCaseTracker& m_tracker; + }; + + private: + void enterTestCase() { + m_currentSection = &m_testCase; + m_completedASectionThisRun = false; + m_testCase.enter(); + } + void leaveTestCase() { + m_testCase.leave(); + } + + TrackedSection m_testCase; + TrackedSection* m_currentSection; + bool m_completedASectionThisRun; + }; + +} // namespace SectionTracking + +using SectionTracking::TestCaseTracker; + +} // namespace Catch + +#include +#include + +namespace Catch { + + class StreamRedirect { + + public: + StreamRedirect( std::ostream& stream, std::string& targetString ) + : m_stream( stream ), + m_prevBuf( stream.rdbuf() ), + m_targetString( targetString ) + { + stream.rdbuf( m_oss.rdbuf() ); + } + + ~StreamRedirect() { + m_targetString += m_oss.str(); + m_stream.rdbuf( m_prevBuf ); + } + + private: + std::ostream& m_stream; + std::streambuf* m_prevBuf; + std::ostringstream m_oss; + std::string& m_targetString; + }; + + /////////////////////////////////////////////////////////////////////////// + + class RunContext : public IResultCapture, public IRunner { + + RunContext( RunContext const& ); + void operator =( RunContext const& ); + + public: + + explicit RunContext( Ptr const& config, Ptr const& reporter ) + : m_runInfo( config->name() ), + m_context( getCurrentMutableContext() ), + m_activeTestCase( NULL ), + m_config( config ), + m_reporter( reporter ), + m_prevRunner( &m_context.getRunner() ), + m_prevResultCapture( &m_context.getResultCapture() ), + m_prevConfig( m_context.getConfig() ) + { + m_context.setRunner( this ); + m_context.setConfig( m_config ); + m_context.setResultCapture( this ); + m_reporter->testRunStarting( m_runInfo ); + } + + virtual ~RunContext() { + m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) ); + m_context.setRunner( m_prevRunner ); + m_context.setConfig( NULL ); + m_context.setResultCapture( m_prevResultCapture ); + m_context.setConfig( m_prevConfig ); + } + + void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { + m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) ); + } + void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) { + m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) ); + } + + Totals runMatching( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { + + std::vector matchingTests = getRegistryHub().getTestCaseRegistry().getMatchingTestCases( testSpec ); + + Totals totals; + + testGroupStarting( testSpec, groupIndex, groupsCount ); + + std::vector::const_iterator it = matchingTests.begin(); + std::vector::const_iterator itEnd = matchingTests.end(); + for(; it != itEnd; ++it ) + totals += runTest( *it ); + + testGroupEnded( testSpec, totals, groupIndex, groupsCount ); + return totals; + } + + Totals runTest( TestCase const& testCase ) { + Totals prevTotals = m_totals; + + std::string redirectedCout; + std::string redirectedCerr; + + TestCaseInfo testInfo = testCase.getTestCaseInfo(); + + m_reporter->testCaseStarting( testInfo ); + + m_activeTestCase = &testCase; + m_testCaseTracker = TestCaseTracker( testInfo.name ); + + do { + do { + runCurrentTest( redirectedCout, redirectedCerr ); + } + while( !m_testCaseTracker->isCompleted() && !aborting() ); + } + while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() ); + + Totals deltaTotals = m_totals.delta( prevTotals ); + m_totals.testCases += deltaTotals.testCases; + m_reporter->testCaseEnded( TestCaseStats( testInfo, + deltaTotals, + redirectedCout, + redirectedCerr, + aborting() ) ); + + m_activeTestCase = NULL; + m_testCaseTracker.reset(); + + return deltaTotals; + } + + Ptr config() const { + return m_config; + } + + private: // IResultCapture + + virtual ResultAction::Value acceptExpression( ExpressionResultBuilder const& assertionResult, AssertionInfo const& assertionInfo ) { + m_lastAssertionInfo = assertionInfo; + return actOnCurrentResult( assertionResult.buildResult( assertionInfo ) ); + } + + virtual void assertionEnded( AssertionResult const& result ) { + if( result.getResultType() == ResultWas::Ok ) { + m_totals.assertions.passed++; + } + else if( !result.isOk() ) { + m_totals.assertions.failed++; + } + + if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) ) + m_messages.clear(); + + // Reset working state + m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition ); + } + + virtual bool sectionStarted ( + SectionInfo const& sectionInfo, + Counts& assertions + ) + { + std::ostringstream oss; + oss << sectionInfo.name << "@" << sectionInfo.lineInfo; + + if( !m_testCaseTracker->enterSection( oss.str() ) ) + return false; + + m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; + + m_reporter->sectionStarting( sectionInfo ); + + assertions = m_totals.assertions; + + return true; + } + bool testForMissingAssertions( Counts& assertions ) { + if( assertions.total() != 0 || + !m_config->warnAboutMissingAssertions() || + m_testCaseTracker->currentSectionHasChildren() ) + return false; + m_totals.assertions.failed++; + assertions.failed++; + return true; + } + + virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) { + if( std::uncaught_exception() ) { + m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) ); + return; + } + + Counts assertions = m_totals.assertions - prevAssertions; + bool missingAssertions = testForMissingAssertions( assertions ); + + m_testCaseTracker->leaveSection(); + + m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) ); + m_messages.clear(); + } + + virtual void pushScopedMessage( MessageInfo const& message ) { + m_messages.push_back( message ); + } + + virtual void popScopedMessage( MessageInfo const& message ) { + m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() ); + } + + virtual bool shouldDebugBreak() const { + return m_config->shouldDebugBreak(); + } + + virtual std::string getCurrentTestName() const { + return m_activeTestCase + ? m_activeTestCase->getTestCaseInfo().name + : ""; + } + + virtual const AssertionResult* getLastResult() const { + return &m_lastResult; + } + + public: + // !TBD We need to do this another way! + bool aborting() const { + return m_totals.assertions.failed == static_cast( m_config->abortAfter() ); + } + + private: + + ResultAction::Value actOnCurrentResult( AssertionResult const& result ) { + m_lastResult = result; + assertionEnded( m_lastResult ); + + ResultAction::Value action = ResultAction::None; + + if( !m_lastResult.isOk() ) { + action = ResultAction::Failed; + if( shouldDebugBreak() ) + action = (ResultAction::Value)( action | ResultAction::Debug ); + if( aborting() ) + action = (ResultAction::Value)( action | ResultAction::Abort ); + } + return action; + } + + void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) { + TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection( testCaseInfo.name, testCaseInfo.description, testCaseInfo.lineInfo ); + m_reporter->sectionStarting( testCaseSection ); + Counts prevAssertions = m_totals.assertions; + double duration = 0; + try { + m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal ); + TestCaseTracker::Guard guard( *m_testCaseTracker ); + + Timer timer; + timer.start(); + if( m_reporter->getPreferences().shouldRedirectStdOut ) { + StreamRedirect coutRedir( std::cout, redirectedCout ); + StreamRedirect cerrRedir( std::cerr, redirectedCerr ); + m_activeTestCase->invoke(); + } + else { + m_activeTestCase->invoke(); + } + duration = timer.getElapsedSeconds(); + } + catch( TestFailureException& ) { + // This just means the test was aborted due to failure + } + catch(...) { + ExpressionResultBuilder exResult( ResultWas::ThrewException ); + exResult << translateActiveException(); + actOnCurrentResult( exResult.buildResult( m_lastAssertionInfo ) ); + } + // If sections ended prematurely due to an exception we stored their + // infos here so we can tear them down outside the unwind process. + for( std::vector::const_iterator it = m_unfinishedSections.begin(), + itEnd = m_unfinishedSections.end(); + it != itEnd; + ++it ) + sectionEnded( it->info, it->prevAssertions, it->durationInSeconds ); + m_unfinishedSections.clear(); + m_messages.clear(); + + Counts assertions = m_totals.assertions - prevAssertions; + bool missingAssertions = testForMissingAssertions( assertions ); + + SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions ); + m_reporter->sectionEnded( testCaseSectionStats ); + } + + private: + struct UnfinishedSections { + UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds ) + : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds ) + {} + + SectionInfo info; + Counts prevAssertions; + double durationInSeconds; + }; + + TestRunInfo m_runInfo; + IMutableContext& m_context; + TestCase const* m_activeTestCase; + Option m_testCaseTracker; + AssertionResult m_lastResult; + + Ptr m_config; + Totals m_totals; + Ptr m_reporter; + std::vector m_messages; + IRunner* m_prevRunner; + IResultCapture* m_prevResultCapture; + Ptr m_prevConfig; + AssertionInfo m_lastAssertionInfo; + std::vector m_unfinishedSections; + }; + +} // end namespace Catch + +// #included from: internal/catch_version.h +#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED + +namespace Catch { + + // Versioning information + struct Version { + Version( unsigned int _majorVersion, + unsigned int _minorVersion, + unsigned int _buildNumber, + std::string const& _branchName ) + : majorVersion( _majorVersion ), + minorVersion( _minorVersion ), + buildNumber( _buildNumber ), + branchName( _branchName ) + {} + + const unsigned int majorVersion; + const unsigned int minorVersion; + const unsigned int buildNumber; + const std::string branchName; + + private: + void operator=( Version const& ); + }; + + extern Version libraryVersion; +} + +#include +#include +#include + +namespace Catch { + + class Runner { + + public: + Runner( Ptr const& config ) + : m_config( config ) + { + openStream(); + makeReporter(); + } + + Totals runTests() { + + std::vector filterGroups = m_config->filters(); + if( filterGroups.empty() ) { + TestCaseFilters filterGroup( "" ); + filterGroups.push_back( filterGroup ); + } + + RunContext context( m_config.get(), m_reporter ); + + Totals totals; + + for( std::size_t i=0; i < filterGroups.size() && !context.aborting(); ++i ) { + context.testGroupStarting( filterGroups[i].getName(), i, filterGroups.size() ); + totals += runTestsForGroup( context, filterGroups[i] ); + context.testGroupEnded( filterGroups[i].getName(), totals, i, filterGroups.size() ); + } + return totals; + } + + Totals runTestsForGroup( RunContext& context, const TestCaseFilters& filterGroup ) { + Totals totals; + std::vector::const_iterator it = getRegistryHub().getTestCaseRegistry().getAllTests().begin(); + std::vector::const_iterator itEnd = getRegistryHub().getTestCaseRegistry().getAllTests().end(); + int testsRunForGroup = 0; + for(; it != itEnd; ++it ) { + if( filterGroup.shouldInclude( *it ) ) { + testsRunForGroup++; + if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) { + + if( context.aborting() ) + break; + + totals += context.runTest( *it ); + m_testsAlreadyRun.insert( *it ); + } + } + } + if( testsRunForGroup == 0 && !filterGroup.getName().empty() ) + m_reporter->noMatchingTestCases( filterGroup.getName() ); + return totals; + + } + + private: + void openStream() { + // Open output file, if specified + if( !m_config->getFilename().empty() ) { + m_ofs.open( m_config->getFilename().c_str() ); + if( m_ofs.fail() ) { + std::ostringstream oss; + oss << "Unable to open file: '" << m_config->getFilename() << "'"; + throw std::domain_error( oss.str() ); + } + m_config->setStreamBuf( m_ofs.rdbuf() ); + } + } + void makeReporter() { + std::string reporterName = m_config->getReporterName().empty() + ? "console" + : m_config->getReporterName(); + + m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() ); + if( !m_reporter ) { + std::ostringstream oss; + oss << "No reporter registered with name: '" << reporterName << "'"; + throw std::domain_error( oss.str() ); + } + } + + private: + Ptr m_config; + std::ofstream m_ofs; + Ptr m_reporter; + std::set m_testsAlreadyRun; + }; + + class Session { + static bool alreadyInstantiated; + + public: + + struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; }; + + Session() + : m_cli( makeCommandLineParser() ) { + if( alreadyInstantiated ) { + std::string msg = "Only one instance of Catch::Session can ever be used"; + std::cerr << msg << std::endl; + throw std::logic_error( msg ); + } + alreadyInstantiated = true; + } + ~Session() { + Catch::cleanUp(); + } + + void showHelp( std::string const& processName ) { + std::cout << "\nCatch v" << libraryVersion.majorVersion << "." + << libraryVersion.minorVersion << " build " + << libraryVersion.buildNumber; + if( libraryVersion.branchName != "master" ) + std::cout << " (" << libraryVersion.branchName << " branch)"; + std::cout << "\n"; + + m_cli.usage( std::cout, processName ); + std::cout << "For more detail usage please see the project docs\n" << std::endl; + } + + int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) { + try { + m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail ); + m_unusedTokens = m_cli.parseInto( argc, argv, m_configData ); + if( m_configData.showHelp ) + showHelp( m_configData.processName ); + m_config.reset(); + } + catch( std::exception& ex ) { + { + Colour colourGuard( Colour::Red ); + std::cerr << "\nError(s) in input:\n" + << Text( ex.what(), TextAttributes().setIndent(2) ) + << "\n\n"; + } + m_cli.usage( std::cout, m_configData.processName ); + return (std::numeric_limits::max)(); + } + return 0; + } + + void useConfigData( ConfigData const& _configData ) { + m_configData = _configData; + m_config.reset(); + } + + int run( int argc, char* const argv[] ) { + + int returnCode = applyCommandLine( argc, argv ); + if( returnCode == 0 ) + returnCode = run(); + return returnCode; + } + + int run() { + if( m_configData.showHelp ) + return 0; + + try + { + config(); // Force config to be constructed + Runner runner( m_config ); + + // Handle list request + if( Option listed = list( config() ) ) + return static_cast( *listed ); + + return static_cast( runner.runTests().assertions.failed ); + } + catch( std::exception& ex ) { + std::cerr << ex.what() << std::endl; + return (std::numeric_limits::max)(); + } + } + + Clara::CommandLine const& cli() const { + return m_cli; + } + std::vector const& unusedTokens() const { + return m_unusedTokens; + } + ConfigData& configData() { + return m_configData; + } + Config& config() { + if( !m_config ) + m_config = new Config( m_configData ); + return *m_config; + } + + private: + Clara::CommandLine m_cli; + std::vector m_unusedTokens; + ConfigData m_configData; + Ptr m_config; + }; + + bool Session::alreadyInstantiated = false; + +} // end namespace Catch + +// #included from: catch_registry_hub.hpp +#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED + +// #included from: catch_test_case_registry_impl.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + class TestRegistry : public ITestCaseRegistry { + public: + TestRegistry() : m_unnamedCount( 0 ) {} + virtual ~TestRegistry(); + + virtual void registerTest( TestCase const& testCase ) { + std::string name = testCase.getTestCaseInfo().name; + if( name == "" ) { + std::ostringstream oss; + oss << "Anonymous test case " << ++m_unnamedCount; + return registerTest( testCase.withName( oss.str() ) ); + } + + if( m_functions.find( testCase ) == m_functions.end() ) { + m_functions.insert( testCase ); + m_functionsInOrder.push_back( testCase ); + if( !testCase.isHidden() ) + m_nonHiddenFunctions.push_back( testCase ); + } + else { + TestCase const& prev = *m_functions.find( testCase ); + std::cerr << "error: TEST_CASE( \"" << name << "\" ) already defined.\n" + << "\tFirst seen at " << prev.getTestCaseInfo().lineInfo << "\n" + << "\tRedefined at " << testCase.getTestCaseInfo().lineInfo << std::endl; + exit(1); + } + } + + virtual std::vector const& getAllTests() const { + return m_functionsInOrder; + } + + virtual std::vector const& getAllNonHiddenTests() const { + return m_nonHiddenFunctions; + } + + // !TBD deprecated + virtual std::vector getMatchingTestCases( std::string const& rawTestSpec ) const { + std::vector matchingTests; + getMatchingTestCases( rawTestSpec, matchingTests ); + return matchingTests; + } + + // !TBD deprecated + virtual void getMatchingTestCases( std::string const& rawTestSpec, std::vector& matchingTestsOut ) const { + TestCaseFilter filter( rawTestSpec ); + + std::vector::const_iterator it = m_functionsInOrder.begin(); + std::vector::const_iterator itEnd = m_functionsInOrder.end(); + for(; it != itEnd; ++it ) { + if( filter.shouldInclude( *it ) ) { + matchingTestsOut.push_back( *it ); + } + } + } + virtual void getMatchingTestCases( TestCaseFilters const& filters, std::vector& matchingTestsOut ) const { + std::vector::const_iterator it = m_functionsInOrder.begin(); + std::vector::const_iterator itEnd = m_functionsInOrder.end(); + // !TBD: replace with algorithm + for(; it != itEnd; ++it ) + if( filters.shouldInclude( *it ) ) + matchingTestsOut.push_back( *it ); + } + + private: + + std::set m_functions; + std::vector m_functionsInOrder; + std::vector m_nonHiddenFunctions; + size_t m_unnamedCount; + }; + + /////////////////////////////////////////////////////////////////////////// + + class FreeFunctionTestCase : public SharedImpl { + public: + + FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {} + + virtual void invoke() const { + m_fun(); + } + + private: + virtual ~FreeFunctionTestCase(); + + TestFunction m_fun; + }; + + inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) { + std::string className = classOrQualifiedMethodName; + if( startsWith( className, "&" ) ) + { + std::size_t lastColons = className.rfind( "::" ); + std::size_t penultimateColons = className.rfind( "::", lastColons-1 ); + if( penultimateColons == std::string::npos ) + penultimateColons = 1; + className = className.substr( penultimateColons, lastColons-penultimateColons ); + } + return className; + } + + /////////////////////////////////////////////////////////////////////////// + + AutoReg::AutoReg( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ) { + registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo ); + } + + AutoReg::~AutoReg() {} + + void AutoReg::registerTestCase( ITestCase* testCase, + char const* classOrQualifiedMethodName, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ) { + + getMutableRegistryHub().registerTest + ( makeTestCase( testCase, + extractClassName( classOrQualifiedMethodName ), + nameAndDesc.name, + nameAndDesc.description, + lineInfo ) ); + } + +} // end namespace Catch + +// #included from: catch_reporter_registry.hpp +#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED + +#include + +namespace Catch { + + class ReporterRegistry : public IReporterRegistry { + + public: + + virtual ~ReporterRegistry() { + deleteAllValues( m_factories ); + } + + virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const { + FactoryMap::const_iterator it = m_factories.find( name ); + if( it == m_factories.end() ) + return NULL; + return it->second->create( ReporterConfig( config ) ); + } + + void registerReporter( std::string const& name, IReporterFactory* factory ) { + m_factories.insert( std::make_pair( name, factory ) ); + } + + FactoryMap const& getFactories() const { + return m_factories; + } + + private: + FactoryMap m_factories; + }; +} + +// #included from: catch_exception_translator_registry.hpp +#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED + +#ifdef __OBJC__ +#import "Foundation/Foundation.h" +#endif + +namespace Catch { + + class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry { + public: + ~ExceptionTranslatorRegistry() { + deleteAll( m_translators ); + } + + virtual void registerTranslator( const IExceptionTranslator* translator ) { + m_translators.push_back( translator ); + } + + virtual std::string translateActiveException() const { + try { +#ifdef __OBJC__ + // In Objective-C try objective-c exceptions first + @try { + throw; + } + @catch (NSException *exception) { + return toString( [exception description] ); + } +#else + throw; +#endif + } + catch( std::exception& ex ) { + return ex.what(); + } + catch( std::string& msg ) { + return msg; + } + catch( const char* msg ) { + return msg; + } + catch(...) { + return tryTranslators( m_translators.begin() ); + } + } + + std::string tryTranslators( std::vector::const_iterator it ) const { + if( it == m_translators.end() ) + return "Unknown exception"; + + try { + return (*it)->translate(); + } + catch(...) { + return tryTranslators( it+1 ); + } + } + + private: + std::vector m_translators; + }; +} + +namespace Catch { + + namespace { + + class RegistryHub : public IRegistryHub, public IMutableRegistryHub { + + RegistryHub( RegistryHub const& ); + void operator=( RegistryHub const& ); + + public: // IRegistryHub + RegistryHub() { + } + virtual IReporterRegistry const& getReporterRegistry() const { + return m_reporterRegistry; + } + virtual ITestCaseRegistry const& getTestCaseRegistry() const { + return m_testCaseRegistry; + } + virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() { + return m_exceptionTranslatorRegistry; + } + + public: // IMutableRegistryHub + virtual void registerReporter( std::string const& name, IReporterFactory* factory ) { + m_reporterRegistry.registerReporter( name, factory ); + } + virtual void registerTest( TestCase const& testInfo ) { + m_testCaseRegistry.registerTest( testInfo ); + } + virtual void registerTranslator( const IExceptionTranslator* translator ) { + m_exceptionTranslatorRegistry.registerTranslator( translator ); + } + + private: + TestRegistry m_testCaseRegistry; + ReporterRegistry m_reporterRegistry; + ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; + }; + + // Single, global, instance + inline RegistryHub*& getTheRegistryHub() { + static RegistryHub* theRegistryHub = NULL; + if( !theRegistryHub ) + theRegistryHub = new RegistryHub(); + return theRegistryHub; + } + } + + IRegistryHub& getRegistryHub() { + return *getTheRegistryHub(); + } + IMutableRegistryHub& getMutableRegistryHub() { + return *getTheRegistryHub(); + } + void cleanUp() { + delete getTheRegistryHub(); + getTheRegistryHub() = NULL; + cleanUpContext(); + } + std::string translateActiveException() { + return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); + } + +} // end namespace Catch + +// #included from: catch_notimplemented_exception.hpp +#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED + +#include + +namespace Catch { + + NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) + : m_lineInfo( lineInfo ) { + std::ostringstream oss; + oss << lineInfo << ": function "; + oss << "not implemented"; + m_what = oss.str(); + } + + const char* NotImplementedException::what() const throw() { + return m_what.c_str(); + } + +} // end namespace Catch + +// #included from: catch_context_impl.hpp +#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED + +// #included from: catch_stream.hpp +#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED + +// #included from: catch_streambuf.h +#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED + +#include + +namespace Catch { + + class StreamBufBase : public std::streambuf { + public: + virtual ~StreamBufBase() throw(); + }; +} + +#include +#include + +namespace Catch { + + template + class StreamBufImpl : public StreamBufBase { + char data[bufferSize]; + WriterF m_writer; + + public: + StreamBufImpl() { + setp( data, data + sizeof(data) ); + } + + ~StreamBufImpl() throw() { + sync(); + } + + private: + int overflow( int c ) { + sync(); + + if( c != EOF ) { + if( pbase() == epptr() ) + m_writer( std::string( 1, static_cast( c ) ) ); + else + sputc( static_cast( c ) ); + } + return 0; + } + + int sync() { + if( pbase() != pptr() ) { + m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); + setp( pbase(), epptr() ); + } + return 0; + } + }; + + /////////////////////////////////////////////////////////////////////////// + + struct OutputDebugWriter { + + void operator()( std::string const&str ) { + writeToDebugConsole( str ); + } + }; + + Stream::Stream() + : streamBuf( NULL ), isOwned( false ) + {} + + Stream::Stream( std::streambuf* _streamBuf, bool _isOwned ) + : streamBuf( _streamBuf ), isOwned( _isOwned ) + {} + + void Stream::release() { + if( isOwned ) { + delete streamBuf; + streamBuf = NULL; + isOwned = false; + } + } +} + +namespace Catch { + + class Context : public IMutableContext { + + Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {} + Context( Context const& ); + void operator=( Context const& ); + + public: // IContext + virtual IResultCapture& getResultCapture() { + return *m_resultCapture; + } + virtual IRunner& getRunner() { + return *m_runner; + } + virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) { + return getGeneratorsForCurrentTest() + .getGeneratorInfo( fileInfo, totalSize ) + .getCurrentIndex(); + } + virtual bool advanceGeneratorsForCurrentTest() { + IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); + return generators && generators->moveNext(); + } + + virtual Ptr getConfig() const { + return m_config; + } + + public: // IMutableContext + virtual void setResultCapture( IResultCapture* resultCapture ) { + m_resultCapture = resultCapture; + } + virtual void setRunner( IRunner* runner ) { + m_runner = runner; + } + virtual void setConfig( Ptr const& config ) { + m_config = config; + } + + friend IMutableContext& getCurrentMutableContext(); + + private: + IGeneratorsForTest* findGeneratorsForCurrentTest() { + std::string testName = getResultCapture().getCurrentTestName(); + + std::map::const_iterator it = + m_generatorsByTestName.find( testName ); + return it != m_generatorsByTestName.end() + ? it->second + : NULL; + } + + IGeneratorsForTest& getGeneratorsForCurrentTest() { + IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); + if( !generators ) { + std::string testName = getResultCapture().getCurrentTestName(); + generators = createGeneratorsForTest(); + m_generatorsByTestName.insert( std::make_pair( testName, generators ) ); + } + return *generators; + } + + private: + Ptr m_config; + IRunner* m_runner; + IResultCapture* m_resultCapture; + std::map m_generatorsByTestName; + }; + + namespace { + Context* currentContext = NULL; + } + IMutableContext& getCurrentMutableContext() { + if( !currentContext ) + currentContext = new Context(); + return *currentContext; + } + IContext& getCurrentContext() { + return getCurrentMutableContext(); + } + + Stream createStream( std::string const& streamName ) { + if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false ); + if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false ); + if( streamName == "debug" ) return Stream( new StreamBufImpl, true ); + + throw std::domain_error( "Unknown stream: " + streamName ); + } + + void cleanUpContext() { + delete currentContext; + currentContext = NULL; + } +} + +// #included from: catch_console_colour_impl.hpp +#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED + +namespace Catch { namespace Detail { + struct IColourImpl { + virtual ~IColourImpl() {} + virtual void use( Colour::Code _colourCode ) = 0; + }; +}} + +#if defined ( CATCH_PLATFORM_WINDOWS ) ///////////////////////////////////////// + +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#ifdef __AFXDLL +#include +#else +#include +#endif + +namespace Catch { +namespace { + + class Win32ColourImpl : public Detail::IColourImpl { + public: + Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) ) + { + CONSOLE_SCREEN_BUFFER_INFO csbiInfo; + GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo ); + originalAttributes = csbiInfo.wAttributes; + } + + virtual void use( Colour::Code _colourCode ) { + switch( _colourCode ) { + case Colour::None: return setTextAttribute( originalAttributes ); + case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + case Colour::Red: return setTextAttribute( FOREGROUND_RED ); + case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); + case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); + case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); + case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); + case Colour::Grey: return setTextAttribute( 0 ); + + case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); + case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); + case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); + case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + + case Colour::Bright: throw std::logic_error( "not a colour" ); + } + } + + private: + void setTextAttribute( WORD _textAttribute ) { + SetConsoleTextAttribute( stdoutHandle, _textAttribute ); + } + HANDLE stdoutHandle; + WORD originalAttributes; + }; + + inline bool shouldUseColourForPlatform() { + return true; + } + + Win32ColourImpl platformColourImpl; + +} // end anon namespace +} // end namespace Catch + +#else // Not Windows - assumed to be POSIX compatible ////////////////////////// + +#include + +namespace Catch { +namespace { + + // use POSIX/ ANSI console terminal codes + // Thanks to Adam Strzelecki for original contribution + // (http://github.com/nanoant) + // https://github.com/philsquared/Catch/pull/131 + class PosixColourImpl : public Detail::IColourImpl { + public: + virtual void use( Colour::Code _colourCode ) { + switch( _colourCode ) { + case Colour::None: + case Colour::White: return setColour( "[0m" ); + case Colour::Red: return setColour( "[0;31m" ); + case Colour::Green: return setColour( "[0;32m" ); + case Colour::Blue: return setColour( "[0:34m" ); + case Colour::Cyan: return setColour( "[0;36m" ); + case Colour::Yellow: return setColour( "[0;33m" ); + case Colour::Grey: return setColour( "[1;30m" ); + + case Colour::LightGrey: return setColour( "[0;37m" ); + case Colour::BrightRed: return setColour( "[1;31m" ); + case Colour::BrightGreen: return setColour( "[1;32m" ); + case Colour::BrightWhite: return setColour( "[1;37m" ); + + case Colour::Bright: throw std::logic_error( "not a colour" ); + } + } + private: + void setColour( const char* _escapeCode ) { + std::cout << '\033' << _escapeCode; + } + }; + + inline bool shouldUseColourForPlatform() { + return isatty(STDOUT_FILENO); + } + + PosixColourImpl platformColourImpl; + +} // end anon namespace +} // end namespace Catch + +#endif // not Windows + +namespace Catch { + + namespace { + struct NoColourImpl : Detail::IColourImpl { + void use( Colour::Code ) {} + }; + NoColourImpl noColourImpl; + static const bool shouldUseColour = shouldUseColourForPlatform() && + !isDebuggerActive(); + } + + Colour::Colour( Code _colourCode ){ use( _colourCode ); } + Colour::~Colour(){ use( None ); } + void Colour::use( Code _colourCode ) { + impl->use( _colourCode ); + } + + Detail::IColourImpl* Colour::impl = shouldUseColour + ? static_cast( &platformColourImpl ) + : static_cast( &noColourImpl ); + +} // end namespace Catch + +// #included from: catch_generators_impl.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + + struct GeneratorInfo : IGeneratorInfo { + + GeneratorInfo( std::size_t size ) + : m_size( size ), + m_currentIndex( 0 ) + {} + + bool moveNext() { + if( ++m_currentIndex == m_size ) { + m_currentIndex = 0; + return false; + } + return true; + } + + std::size_t getCurrentIndex() const { + return m_currentIndex; + } + + std::size_t m_size; + std::size_t m_currentIndex; + }; + + /////////////////////////////////////////////////////////////////////////// + + class GeneratorsForTest : public IGeneratorsForTest { + + public: + ~GeneratorsForTest() { + deleteAll( m_generatorsInOrder ); + } + + IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) { + std::map::const_iterator it = m_generatorsByName.find( fileInfo ); + if( it == m_generatorsByName.end() ) { + IGeneratorInfo* info = new GeneratorInfo( size ); + m_generatorsByName.insert( std::make_pair( fileInfo, info ) ); + m_generatorsInOrder.push_back( info ); + return *info; + } + return *it->second; + } + + bool moveNext() { + std::vector::const_iterator it = m_generatorsInOrder.begin(); + std::vector::const_iterator itEnd = m_generatorsInOrder.end(); + for(; it != itEnd; ++it ) { + if( (*it)->moveNext() ) + return true; + } + return false; + } + + private: + std::map m_generatorsByName; + std::vector m_generatorsInOrder; + }; + + IGeneratorsForTest* createGeneratorsForTest() + { + return new GeneratorsForTest(); + } + +} // end namespace Catch + +// #included from: catch_assertionresult.hpp +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED + +namespace Catch { + + AssertionInfo::AssertionInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + std::string const& _capturedExpression, + ResultDisposition::Flags _resultDisposition ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + capturedExpression( _capturedExpression ), + resultDisposition( _resultDisposition ) + {} + + AssertionResult::AssertionResult() {} + + AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data ) + : m_info( info ), + m_resultData( data ) + {} + + AssertionResult::~AssertionResult() {} + + // Result was a success + bool AssertionResult::succeeded() const { + return Catch::isOk( m_resultData.resultType ); + } + + // Result was a success, or failure is suppressed + bool AssertionResult::isOk() const { + return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); + } + + ResultWas::OfType AssertionResult::getResultType() const { + return m_resultData.resultType; + } + + bool AssertionResult::hasExpression() const { + return !m_info.capturedExpression.empty(); + } + + bool AssertionResult::hasMessage() const { + return !m_resultData.message.empty(); + } + + std::string AssertionResult::getExpression() const { + if( shouldNegate( m_info.resultDisposition ) ) + return "!" + m_info.capturedExpression; + else + return m_info.capturedExpression; + } + std::string AssertionResult::getExpressionInMacro() const { + if( m_info.macroName.empty() ) + return m_info.capturedExpression; + else + return m_info.macroName + "( " + m_info.capturedExpression + " )"; + } + + bool AssertionResult::hasExpandedExpression() const { + return hasExpression() && getExpandedExpression() != getExpression(); + } + + std::string AssertionResult::getExpandedExpression() const { + return m_resultData.reconstructedExpression; + } + + std::string AssertionResult::getMessage() const { + return m_resultData.message; + } + SourceLineInfo AssertionResult::getSourceInfo() const { + return m_info.lineInfo; + } + + std::string AssertionResult::getTestMacroName() const { + return m_info.macroName; + } + +} // end namespace Catch + +// #included from: catch_expressionresult_builder.hpp +#define TWOBLUECUBES_CATCH_EXPRESSIONRESULT_BUILDER_HPP_INCLUDED + +#include + +namespace Catch { + + ExpressionResultBuilder::ExpressionResultBuilder( ResultWas::OfType resultType ) { + m_data.resultType = resultType; + } + ExpressionResultBuilder::ExpressionResultBuilder( ExpressionResultBuilder const& other ) + : m_data( other.m_data ), + m_exprComponents( other.m_exprComponents ) + { + m_stream << other.m_stream.str(); + } + ExpressionResultBuilder& ExpressionResultBuilder::operator=(ExpressionResultBuilder const& other ) { + m_data = other.m_data; + m_exprComponents = other.m_exprComponents; + m_stream.str(""); + m_stream << other.m_stream.str(); + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setResultType( ResultWas::OfType result ) { + m_data.resultType = result; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setResultType( bool result ) { + m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::endExpression( ResultDisposition::Flags resultDisposition ) { + m_exprComponents.shouldNegate = shouldNegate( resultDisposition ); + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setLhs( std::string const& lhs ) { + m_exprComponents.lhs = lhs; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setRhs( std::string const& rhs ) { + m_exprComponents.rhs = rhs; + return *this; + } + ExpressionResultBuilder& ExpressionResultBuilder::setOp( std::string const& op ) { + m_exprComponents.op = op; + return *this; + } + AssertionResult ExpressionResultBuilder::buildResult( AssertionInfo const& info ) const + { + assert( m_data.resultType != ResultWas::Unknown ); + + AssertionResultData data = m_data; + + // Flip bool results if shouldNegate is set + if( m_exprComponents.shouldNegate && data.resultType == ResultWas::Ok ) + data.resultType = ResultWas::ExpressionFailed; + else if( m_exprComponents.shouldNegate && data.resultType == ResultWas::ExpressionFailed ) + data.resultType = ResultWas::Ok; + + data.message = m_stream.str(); + data.reconstructedExpression = reconstructExpression( info ); + if( m_exprComponents.shouldNegate ) { + if( m_exprComponents.op == "" ) + data.reconstructedExpression = "!" + data.reconstructedExpression; + else + data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; + } + return AssertionResult( info, data ); + } + std::string ExpressionResultBuilder::reconstructExpression( AssertionInfo const& info ) const { + if( m_exprComponents.op == "" ) + return m_exprComponents.lhs.empty() ? info.capturedExpression : m_exprComponents.op + m_exprComponents.lhs; + else if( m_exprComponents.op == "matches" ) + return m_exprComponents.lhs + " " + m_exprComponents.rhs; + else if( m_exprComponents.op != "!" ) { + if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 && + m_exprComponents.lhs.find("\n") == std::string::npos && + m_exprComponents.rhs.find("\n") == std::string::npos ) + return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs; + else + return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs; + } + else + return "{can't expand - use " + info.macroName + "_FALSE( " + info.capturedExpression.substr(1) + " ) instead of " + info.macroName + "( " + info.capturedExpression + " ) for better diagnostics}"; + } + +} // end namespace Catch + +// #included from: catch_test_case_info.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED + +namespace Catch { + + TestCase makeTestCase( ITestCase* _testCase, + std::string const& _className, + std::string const& _name, + std::string const& _descOrTags, + SourceLineInfo const& _lineInfo ) + { + std::string desc = _descOrTags; + bool isHidden( startsWith( _name, "./" ) ); // Legacy support + std::set tags; + TagExtracter( tags ).parse( desc ); + if( tags.find( "hide" ) != tags.end() || tags.find( "." ) != tags.end() ) + isHidden = true; + + if( isHidden ) { + tags.insert( "hide" ); + tags.insert( "." ); + } + TestCaseInfo info( _name, _className, desc, tags, isHidden, _lineInfo ); + return TestCase( _testCase, info ); + } + + TestCaseInfo::TestCaseInfo( std::string const& _name, + std::string const& _className, + std::string const& _description, + std::set const& _tags, + bool _isHidden, + SourceLineInfo const& _lineInfo ) + : name( _name ), + className( _className ), + description( _description ), + tags( _tags ), + lineInfo( _lineInfo ), + isHidden( _isHidden ) + { + std::ostringstream oss; + for( std::set::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) + oss << "[" << *it << "]"; + tagsAsString = oss.str(); + } + + TestCaseInfo::TestCaseInfo( TestCaseInfo const& other ) + : name( other.name ), + className( other.className ), + description( other.description ), + tags( other.tags ), + tagsAsString( other.tagsAsString ), + lineInfo( other.lineInfo ), + isHidden( other.isHidden ) + {} + + TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {} + + TestCase::TestCase( TestCase const& other ) + : TestCaseInfo( other ), + test( other.test ) + {} + + TestCase TestCase::withName( std::string const& _newName ) const { + TestCase other( *this ); + other.name = _newName; + return other; + } + + void TestCase::invoke() const { + test->invoke(); + } + + bool TestCase::isHidden() const { + return TestCaseInfo::isHidden; + } + + bool TestCase::hasTag( std::string const& tag ) const { + return tags.find( toLower( tag ) ) != tags.end(); + } + bool TestCase::matchesTags( std::string const& tagPattern ) const { + TagExpression exp; + TagExpressionParser( exp ).parse( tagPattern ); + return exp.matches( tags ); + } + std::set const& TestCase::getTags() const { + return tags; + } + + void TestCase::swap( TestCase& other ) { + test.swap( other.test ); + className.swap( other.className ); + name.swap( other.name ); + description.swap( other.description ); + std::swap( lineInfo, other.lineInfo ); + } + + bool TestCase::operator == ( TestCase const& other ) const { + return test.get() == other.test.get() && + name == other.name && + className == other.className; + } + + bool TestCase::operator < ( TestCase const& other ) const { + return name < other.name; + } + TestCase& TestCase::operator = ( TestCase const& other ) { + TestCase temp( other ); + swap( temp ); + return *this; + } + + TestCaseInfo const& TestCase::getTestCaseInfo() const + { + return *this; + } + +} // end namespace Catch + +// #included from: catch_tags.hpp +#define TWOBLUECUBES_CATCH_TAGS_HPP_INCLUDED + +namespace Catch { + TagParser::~TagParser() {} + + void TagParser::parse( std::string const& str ) { + std::size_t pos = 0; + while( pos < str.size() ) { + char c = str[pos]; + if( c == '[' ) { + std::size_t end = str.find_first_of( ']', pos ); + if( end != std::string::npos ) { + acceptTag( str.substr( pos+1, end-pos-1 ) ); + pos = end+1; + } + else { + acceptChar( c ); + pos++; + } + } + else { + acceptChar( c ); + pos++; + } + } + endParse(); + } + + TagExtracter::TagExtracter( std::set& tags ) + : m_tags( tags ) + {} + + TagExtracter::~TagExtracter() {} + + void TagExtracter::parse( std::string& description ) { + TagParser::parse( description ); + description = m_remainder; + } + + void TagExtracter::acceptTag( std::string const& tag ) { + m_tags.insert( toLower( tag ) ); + } + void TagExtracter::acceptChar( char c ) { + m_remainder += c; + } + + Tag::Tag() : m_isNegated( false ) {} + Tag::Tag( std::string const& name, bool isNegated ) + : m_name( name ), + m_isNegated( isNegated ) + {} + + std::string Tag::getName() const { + return m_name; + } + bool Tag::isNegated() const { + return m_isNegated; + } + + bool Tag::operator ! () const { + return m_name.empty(); + } + + void TagSet::add( Tag const& tag ) { + m_tags.insert( std::make_pair( toLower( tag.getName() ), tag ) ); + } + + bool TagSet::empty() const { + return m_tags.empty(); + } + + bool TagSet::matches( std::set const& tags ) const { + for( TagMap::const_iterator + it = m_tags.begin(), itEnd = m_tags.end(); + it != itEnd; + ++it ) { + bool found = tags.find( it->first ) != tags.end(); + if( found == it->second.isNegated() ) + return false; + } + return true; + } + + bool TagExpression::matches( std::set const& tags ) const { + for( std::vector::const_iterator + it = m_tagSets.begin(), itEnd = m_tagSets.end(); + it != itEnd; + ++it ) + if( it->matches( tags ) ) + return true; + return false; + } + + TagExpressionParser::TagExpressionParser( TagExpression& exp ) + : m_isNegated( false ), + m_exp( exp ) + {} + + TagExpressionParser::~TagExpressionParser() {} + + void TagExpressionParser::acceptTag( std::string const& tag ) { + m_currentTagSet.add( Tag( tag, m_isNegated ) ); + m_isNegated = false; + } + + void TagExpressionParser::acceptChar( char c ) { + switch( c ) { + case '~': + m_isNegated = true; + break; + case ',': + m_exp.m_tagSets.push_back( m_currentTagSet ); + m_currentTagSet = TagSet(); + break; + } + } + + void TagExpressionParser::endParse() { + if( !m_currentTagSet.empty() ) + m_exp.m_tagSets.push_back( m_currentTagSet ); + } + +} // end namespace Catch + +// #included from: catch_test_spec.hpp +#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED + +namespace Catch { + + TestCaseFilter::TestCaseFilter( std::string const& testSpec, IfFilterMatches::DoWhat matchBehaviour ) + : m_stringToMatch( toLower( testSpec ) ), + m_filterType( matchBehaviour ), + m_wildcardPosition( NoWildcard ) + { + if( m_filterType == IfFilterMatches::AutoDetectBehaviour ) { + if( startsWith( m_stringToMatch, "exclude:" ) ) { + m_stringToMatch = m_stringToMatch.substr( 8 ); + m_filterType = IfFilterMatches::ExcludeTests; + } + else if( startsWith( m_stringToMatch, "~" ) ) { + m_stringToMatch = m_stringToMatch.substr( 1 ); + m_filterType = IfFilterMatches::ExcludeTests; + } + else { + m_filterType = IfFilterMatches::IncludeTests; + } + } + + if( startsWith( m_stringToMatch, "*" ) ) { + m_stringToMatch = m_stringToMatch.substr( 1 ); + m_wildcardPosition = (WildcardPosition)( m_wildcardPosition | WildcardAtStart ); + } + if( endsWith( m_stringToMatch, "*" ) ) { + m_stringToMatch = m_stringToMatch.substr( 0, m_stringToMatch.size()-1 ); + m_wildcardPosition = (WildcardPosition)( m_wildcardPosition | WildcardAtEnd ); + } + } + + IfFilterMatches::DoWhat TestCaseFilter::getFilterType() const { + return m_filterType; + } + + bool TestCaseFilter::shouldInclude( TestCase const& testCase ) const { + return isMatch( testCase ) == (m_filterType == IfFilterMatches::IncludeTests); + } + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunreachable-code" +#endif + + bool TestCaseFilter::isMatch( TestCase const& testCase ) const { + std::string name = testCase.getTestCaseInfo().name; + toLowerInPlace( name ); + + switch( m_wildcardPosition ) { + case NoWildcard: + return m_stringToMatch == name; + case WildcardAtStart: + return endsWith( name, m_stringToMatch ); + case WildcardAtEnd: + return startsWith( name, m_stringToMatch ); + case WildcardAtBothEnds: + return contains( name, m_stringToMatch ); + } + throw std::logic_error( "Unhandled wildcard type" ); + } + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + + TestCaseFilters::TestCaseFilters( std::string const& name ) : m_name( name ) {} + + std::string TestCaseFilters::getName() const { + return m_name; + } + + void TestCaseFilters::addFilter( TestCaseFilter const& filter ) { + if( filter.getFilterType() == IfFilterMatches::ExcludeTests ) + m_exclusionFilters.push_back( filter ); + else + m_inclusionFilters.push_back( filter ); + } + + void TestCaseFilters::addTags( std::string const& tagPattern ) { + TagExpression exp; + TagExpressionParser( exp ).parse( tagPattern ); + + m_tagExpressions.push_back( exp ); + } + + bool TestCaseFilters::shouldInclude( TestCase const& testCase ) const { + if( !m_tagExpressions.empty() ) { + std::vector::const_iterator it = m_tagExpressions.begin(); + std::vector::const_iterator itEnd = m_tagExpressions.end(); + for(; it != itEnd; ++it ) + if( it->matches( testCase.getTags() ) ) + break; + if( it == itEnd ) + return false; + } + + if( !m_inclusionFilters.empty() ) { + std::vector::const_iterator it = m_inclusionFilters.begin(); + std::vector::const_iterator itEnd = m_inclusionFilters.end(); + for(; it != itEnd; ++it ) + if( it->shouldInclude( testCase ) ) + break; + if( it == itEnd ) + return false; + } + else if( m_exclusionFilters.empty() && m_tagExpressions.empty() ) { + return !testCase.isHidden(); + } + + std::vector::const_iterator it = m_exclusionFilters.begin(); + std::vector::const_iterator itEnd = m_exclusionFilters.end(); + for(; it != itEnd; ++it ) + if( !it->shouldInclude( testCase ) ) + return false; + return true; + } +} + +// #included from: catch_version.hpp +#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED + +namespace Catch { + + // These numbers are maintained by a script + Version libraryVersion( 1, 0, 27, "master" ); +} + +// #included from: catch_message.hpp +#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED + +namespace Catch { + + MessageInfo::MessageInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + type( _type ), + sequence( ++globalCount ) + {} + + // This may need protecting if threading support is added + unsigned int MessageInfo::globalCount = 0; + + //////////////////////////////////////////////////////////////////////////// + + ScopedMessage::ScopedMessage( MessageBuilder const& builder ) + : m_info( builder.m_info ) + { + m_info.message = builder.m_stream.str(); + getResultCapture().pushScopedMessage( m_info ); + } + ScopedMessage::~ScopedMessage() { + getResultCapture().popScopedMessage( m_info ); + } + +} // end namespace Catch + +// #included from: catch_legacy_reporter_adapter.hpp +#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED + +// #included from: catch_legacy_reporter_adapter.h +#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED + +namespace Catch +{ + // Deprecated + struct IReporter : IShared { + virtual ~IReporter(); + + virtual bool shouldRedirectStdout() const = 0; + + virtual void StartTesting() = 0; + virtual void EndTesting( Totals const& totals ) = 0; + virtual void StartGroup( std::string const& groupName ) = 0; + virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0; + virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0; + virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0; + virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0; + virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0; + virtual void NoAssertionsInSection( std::string const& sectionName ) = 0; + virtual void NoAssertionsInTestCase( std::string const& testName ) = 0; + virtual void Aborted() = 0; + virtual void Result( AssertionResult const& result ) = 0; + }; + + class LegacyReporterAdapter : public SharedImpl + { + public: + LegacyReporterAdapter( Ptr const& legacyReporter ); + virtual ~LegacyReporterAdapter(); + + virtual ReporterPreferences getPreferences() const; + virtual void noMatchingTestCases( std::string const& ); + virtual void testRunStarting( TestRunInfo const& ); + virtual void testGroupStarting( GroupInfo const& groupInfo ); + virtual void testCaseStarting( TestCaseInfo const& testInfo ); + virtual void sectionStarting( SectionInfo const& sectionInfo ); + virtual void assertionStarting( AssertionInfo const& ); + virtual bool assertionEnded( AssertionStats const& assertionStats ); + virtual void sectionEnded( SectionStats const& sectionStats ); + virtual void testCaseEnded( TestCaseStats const& testCaseStats ); + virtual void testGroupEnded( TestGroupStats const& testGroupStats ); + virtual void testRunEnded( TestRunStats const& testRunStats ); + + private: + Ptr m_legacyReporter; + }; +} + +namespace Catch +{ + LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter ) + : m_legacyReporter( legacyReporter ) + {} + LegacyReporterAdapter::~LegacyReporterAdapter() {} + + ReporterPreferences LegacyReporterAdapter::getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout(); + return prefs; + } + + void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {} + void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) { + m_legacyReporter->StartTesting(); + } + void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) { + m_legacyReporter->StartGroup( groupInfo.name ); + } + void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) { + m_legacyReporter->StartTestCase( testInfo ); + } + void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) { + m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description ); + } + void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) { + // Not on legacy interface + } + + bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) { + if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { + for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); + it != itEnd; + ++it ) { + if( it->type == ResultWas::Info ) { + ExpressionResultBuilder expressionBuilder( it->type ); + expressionBuilder << it->message; + AssertionInfo info( it->macroName, it->lineInfo, "", ResultDisposition::Normal ); + AssertionResult result = expressionBuilder.buildResult( info ); + m_legacyReporter->Result( result ); + } + } + } + m_legacyReporter->Result( assertionStats.assertionResult ); + return true; + } + void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) { + if( sectionStats.missingAssertions ) + m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name ); + m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions ); + } + void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) { + m_legacyReporter->EndTestCase + ( testCaseStats.testInfo, + testCaseStats.totals, + testCaseStats.stdOut, + testCaseStats.stdErr ); + } + void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) { + if( testGroupStats.aborting ) + m_legacyReporter->Aborted(); + m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals ); + } + void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) { + m_legacyReporter->EndTesting( testRunStats.totals ); + } +} + +// #included from: catch_timer.hpp + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc++11-long-long" +#endif + +#ifdef CATCH_PLATFORM_WINDOWS +#include +#else +#include +#endif + +namespace Catch { + + namespace { +#ifdef CATCH_PLATFORM_WINDOWS + uint64_t getCurrentTicks() { + static uint64_t hz=0, hzo=0; + if (!hz) { + QueryPerformanceFrequency((LARGE_INTEGER*)&hz); + QueryPerformanceCounter((LARGE_INTEGER*)&hzo); + } + uint64_t t; + QueryPerformanceCounter((LARGE_INTEGER*)&t); + return ((t-hzo)*1000000)/hz; + } +#else + uint64_t getCurrentTicks() { + timeval t; + gettimeofday(&t,NULL); + return (uint64_t)t.tv_sec * 1000000ull + (uint64_t)t.tv_usec; + } +#endif + } + + void Timer::start() { + m_ticks = getCurrentTicks(); + } + unsigned int Timer::getElapsedNanoseconds() const { + return (unsigned int)(getCurrentTicks() - m_ticks); + } + unsigned int Timer::getElapsedMilliseconds() const { + return (unsigned int)((getCurrentTicks() - m_ticks)/1000); + } + double Timer::getElapsedSeconds() const { + return (getCurrentTicks() - m_ticks)/1000000.0; + } + +} // namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +// #included from: catch_common.hpp +#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED + +namespace Catch { + + bool startsWith( std::string const& s, std::string const& prefix ) { + return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix; + } + bool endsWith( std::string const& s, std::string const& suffix ) { + return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix; + } + bool contains( std::string const& s, std::string const& infix ) { + return s.find( infix ) != std::string::npos; + } + void toLowerInPlace( std::string& s ) { + std::transform( s.begin(), s.end(), s.begin(), ::tolower ); + } + std::string toLower( std::string const& s ) { + std::string lc = s; + toLowerInPlace( lc ); + return lc; + } + std::string trim( std::string const& str ) { + static char const* whitespaceChars = "\n\r\t "; + std::string::size_type start = str.find_first_not_of( whitespaceChars ); + std::string::size_type end = str.find_last_not_of( whitespaceChars ); + + return start != std::string::npos ? str.substr( start, 1+end-start ) : ""; + } + + pluralise::pluralise( std::size_t count, std::string const& label ) + : m_count( count ), + m_label( label ) + {} + + std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { + os << pluraliser.m_count << " " << pluraliser.m_label; + if( pluraliser.m_count != 1 ) + os << "s"; + return os; + } + + SourceLineInfo::SourceLineInfo() : line( 0 ){} + SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) + : file( _file ), + line( _line ) + {} + SourceLineInfo::SourceLineInfo( SourceLineInfo const& other ) + : file( other.file ), + line( other.line ) + {} + bool SourceLineInfo::empty() const { + return file.empty(); + } + bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const { + return line == other.line && file == other.file; + } + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { +#ifndef __GNUG__ + os << info.file << "(" << info.line << ")"; +#else + os << info.file << ":" << info.line; +#endif + return os; + } + + void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) { + std::ostringstream oss; + oss << locationInfo << ": Internal Catch error: '" << message << "'"; + if( isTrue( true )) + throw std::logic_error( oss.str() ); + } +} + +// #included from: catch_section.hpp +#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED + +namespace Catch { + + Section::Section( SourceLineInfo const& lineInfo, + std::string const& name, + std::string const& description ) + : m_info( name, description, lineInfo ), + m_sectionIncluded( getCurrentContext().getResultCapture().sectionStarted( m_info, m_assertions ) ) + { + m_timer.start(); + } + + Section::~Section() { + if( m_sectionIncluded ) + getCurrentContext().getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() ); + } + + // This indicates whether the section should be executed or not + Section::operator bool() { + return m_sectionIncluded; + } + +} // end namespace Catch + +// #included from: catch_debugger.hpp +#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED + +#include + +#ifdef CATCH_PLATFORM_MAC + + #include + #include + #include + #include + #include + + namespace Catch{ + + // The following function is taken directly from the following technical note: + // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html + + // Returns true if the current process is being debugged (either + // running under the debugger or has a debugger attached post facto). + bool isDebuggerActive(){ + + int mib[4]; + struct kinfo_proc info; + size_t size; + + // Initialize the flags so that, if sysctl fails for some bizarre + // reason, we get a predictable result. + + info.kp_proc.p_flag = 0; + + // Initialize mib, which tells sysctl the info we want, in this case + // we're looking for information about a specific process ID. + + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PID; + mib[3] = getpid(); + + // Call sysctl. + + size = sizeof(info); + if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) { + std::cerr << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl; + return false; + } + + // We're being debugged if the P_TRACED flag is set. + + return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); + } + } // namespace Catch + +#elif defined(_MSC_VER) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#else + namespace Catch { + inline bool isDebuggerActive() { return false; } + } +#endif // Platform + +#ifdef CATCH_PLATFORM_WINDOWS + extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* ); + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + ::OutputDebugStringA( text.c_str() ); + } + } +#else + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + // !TBD: Need a version for Mac/ XCode and other IDEs + std::cout << text; + } + } +#endif // Platform + +// #included from: ../reporters/catch_reporter_xml.hpp +#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED + +// #included from: catch_reporter_bases.hpp +#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED + +namespace Catch { + + struct StreamingReporterBase : SharedImpl { + + StreamingReporterBase( ReporterConfig const& _config ) + : m_config( _config.fullConfig() ), + stream( _config.stream() ) + {} + + virtual ~StreamingReporterBase(); + + virtual void noMatchingTestCases( std::string const& ) {} + + virtual void testRunStarting( TestRunInfo const& _testRunInfo ) { + currentTestRunInfo = _testRunInfo; + } + virtual void testGroupStarting( GroupInfo const& _groupInfo ) { + currentGroupInfo = _groupInfo; + } + + virtual void testCaseStarting( TestCaseInfo const& _testInfo ) { + currentTestCaseInfo = _testInfo; + } + virtual void sectionStarting( SectionInfo const& _sectionInfo ) { + m_sectionStack.push_back( _sectionInfo ); + } + + virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) { + m_sectionStack.pop_back(); + } + virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) { + currentTestCaseInfo.reset(); + assert( m_sectionStack.empty() ); + } + virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) { + currentGroupInfo.reset(); + } + virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) { + currentTestCaseInfo.reset(); + currentGroupInfo.reset(); + currentTestRunInfo.reset(); + } + + Ptr m_config; + std::ostream& stream; + + LazyStat currentTestRunInfo; + LazyStat currentGroupInfo; + LazyStat currentTestCaseInfo; + + std::vector m_sectionStack; + }; + + struct CumulativeReporterBase : SharedImpl { + template + struct Node : SharedImpl<> { + explicit Node( T const& _value ) : value( _value ) {} + virtual ~Node() {} + + typedef std::vector > ChildNodes; + T value; + ChildNodes children; + }; + struct SectionNode : SharedImpl<> { + explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {} + virtual ~SectionNode(); + + bool operator == ( SectionNode const& other ) const { + return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo; + } + bool operator == ( Ptr const& other ) const { + return operator==( *other ); + } + + SectionStats stats; + typedef std::vector > ChildSections; + typedef std::vector Assertions; + ChildSections childSections; + Assertions assertions; + std::string stdOut; + std::string stdErr; + }; + + struct BySectionInfo { + BySectionInfo( SectionInfo const& other ) : m_other( other ) {} + bool operator() ( Ptr const& node ) const { + return node->stats.sectionInfo.lineInfo == m_other.lineInfo; + } + private: + BySectionInfo& operator=( BySectionInfo const& other ); // = delete; + + SectionInfo const& m_other; + }; + + typedef Node TestCaseNode; + typedef Node TestGroupNode; + typedef Node TestRunNode; + + CumulativeReporterBase( ReporterConfig const& _config ) + : m_config( _config.fullConfig() ), + stream( _config.stream() ) + {} + ~CumulativeReporterBase(); + + virtual void testRunStarting( TestRunInfo const& ) {} + virtual void testGroupStarting( GroupInfo const& ) {} + + virtual void testCaseStarting( TestCaseInfo const& ) {} + + virtual void sectionStarting( SectionInfo const& sectionInfo ) { + SectionStats incompleteStats( sectionInfo, Counts(), 0, false ); + Ptr node; + if( m_sectionStack.empty() ) { + if( !m_rootSection ) + m_rootSection = new SectionNode( incompleteStats ); + node = m_rootSection; + } + else { + SectionNode& parentNode = *m_sectionStack.back(); + SectionNode::ChildSections::const_iterator it = + std::find_if( parentNode.childSections.begin(), + parentNode.childSections.end(), + BySectionInfo( sectionInfo ) ); + if( it == parentNode.childSections.end() ) { + node = new SectionNode( incompleteStats ); + parentNode.childSections.push_back( node ); + } + else + node = *it; + } + m_sectionStack.push_back( node ); + m_deepestSection = node; + } + + virtual void assertionStarting( AssertionInfo const& ) {} + + virtual bool assertionEnded( AssertionStats const& assertionStats ) { + assert( !m_sectionStack.empty() ); + SectionNode& sectionNode = *m_sectionStack.back(); + sectionNode.assertions.push_back( assertionStats ); + return true; + } + virtual void sectionEnded( SectionStats const& sectionStats ) { + assert( !m_sectionStack.empty() ); + SectionNode& node = *m_sectionStack.back(); + node.stats = sectionStats; + m_sectionStack.pop_back(); + } + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { + Ptr node = new TestCaseNode( testCaseStats ); + assert( m_sectionStack.size() == 0 ); + node->children.push_back( m_rootSection ); + m_testCases.push_back( node ); + m_rootSection.reset(); + + assert( m_deepestSection ); + m_deepestSection->stdOut = testCaseStats.stdOut; + m_deepestSection->stdErr = testCaseStats.stdErr; + } + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { + Ptr node = new TestGroupNode( testGroupStats ); + node->children.swap( m_testCases ); + m_testGroups.push_back( node ); + } + virtual void testRunEnded( TestRunStats const& testRunStats ) { + Ptr node = new TestRunNode( testRunStats ); + node->children.swap( m_testGroups ); + m_testRuns.push_back( node ); + testRunEndedCumulative(); + } + virtual void testRunEndedCumulative() = 0; + + Ptr m_config; + std::ostream& stream; + std::vector m_assertions; + std::vector > > m_sections; + std::vector > m_testCases; + std::vector > m_testGroups; + + std::vector > m_testRuns; + + Ptr m_rootSection; + Ptr m_deepestSection; + std::vector > m_sectionStack; + + }; + +} // end namespace Catch + +// #included from: ../internal/catch_reporter_registrars.hpp +#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED + +namespace Catch { + + template + class LegacyReporterRegistrar { + + class ReporterFactory : public IReporterFactory { + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new LegacyReporterAdapter( new T( config ) ); + } + + virtual std::string getDescription() const { + return T::getDescription(); + } + }; + + public: + + LegacyReporterRegistrar( std::string const& name ) { + getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); + } + }; + + template + class ReporterRegistrar { + + class ReporterFactory : public IReporterFactory { + + // *** Please Note ***: + // - If you end up here looking at a compiler error because it's trying to register + // your custom reporter class be aware that the native reporter interface has changed + // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via + // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter. + // However please consider updating to the new interface as the old one is now + // deprecated and will probably be removed quite soon! + // Please contact me via github if you have any questions at all about this. + // In fact, ideally, please contact me anyway to let me know you've hit this - as I have + // no idea who is actually using custom reporters at all (possibly no-one!). + // The new interface is designed to minimise exposure to interface changes in the future. + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new T( config ); + } + + virtual std::string getDescription() const { + return T::getDescription(); + } + }; + + public: + + ReporterRegistrar( std::string const& name ) { + getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); + } + }; +} + +#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \ + namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } +#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \ + namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } + +// #included from: ../internal/catch_xmlwriter.hpp +#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + class XmlWriter { + public: + + class ScopedElement { + public: + ScopedElement( XmlWriter* writer ) + : m_writer( writer ) + {} + + ScopedElement( ScopedElement const& other ) + : m_writer( other.m_writer ){ + other.m_writer = NULL; + } + + ~ScopedElement() { + if( m_writer ) + m_writer->endElement(); + } + + ScopedElement& writeText( std::string const& text, bool indent = true ) { + m_writer->writeText( text, indent ); + return *this; + } + + template + ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { + m_writer->writeAttribute( name, attribute ); + return *this; + } + + private: + mutable XmlWriter* m_writer; + }; + + XmlWriter() + : m_tagIsOpen( false ), + m_needsNewline( false ), + m_os( &std::cout ) + {} + + XmlWriter( std::ostream& os ) + : m_tagIsOpen( false ), + m_needsNewline( false ), + m_os( &os ) + {} + + ~XmlWriter() { + while( !m_tags.empty() ) + endElement(); + } + + XmlWriter& operator = ( XmlWriter const& other ) { + XmlWriter temp( other ); + swap( temp ); + return *this; + } + + void swap( XmlWriter& other ) { + std::swap( m_tagIsOpen, other.m_tagIsOpen ); + std::swap( m_needsNewline, other.m_needsNewline ); + std::swap( m_tags, other.m_tags ); + std::swap( m_indent, other.m_indent ); + std::swap( m_os, other.m_os ); + } + + XmlWriter& startElement( std::string const& name ) { + ensureTagClosed(); + newlineIfNecessary(); + stream() << m_indent << "<" << name; + m_tags.push_back( name ); + m_indent += " "; + m_tagIsOpen = true; + return *this; + } + + ScopedElement scopedElement( std::string const& name ) { + ScopedElement scoped( this ); + startElement( name ); + return scoped; + } + + XmlWriter& endElement() { + newlineIfNecessary(); + m_indent = m_indent.substr( 0, m_indent.size()-2 ); + if( m_tagIsOpen ) { + stream() << "/>\n"; + m_tagIsOpen = false; + } + else { + stream() << m_indent << "\n"; + } + m_tags.pop_back(); + return *this; + } + + XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) { + if( !name.empty() && !attribute.empty() ) { + stream() << " " << name << "=\""; + writeEncodedText( attribute ); + stream() << "\""; + } + return *this; + } + + XmlWriter& writeAttribute( std::string const& name, bool attribute ) { + stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\""; + return *this; + } + + template + XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { + if( !name.empty() ) + stream() << " " << name << "=\"" << attribute << "\""; + return *this; + } + + XmlWriter& writeText( std::string const& text, bool indent = true ) { + if( !text.empty() ){ + bool tagWasOpen = m_tagIsOpen; + ensureTagClosed(); + if( tagWasOpen && indent ) + stream() << m_indent; + writeEncodedText( text ); + m_needsNewline = true; + } + return *this; + } + + XmlWriter& writeComment( std::string const& text ) { + ensureTagClosed(); + stream() << m_indent << ""; + m_needsNewline = true; + return *this; + } + + XmlWriter& writeBlankLine() { + ensureTagClosed(); + stream() << "\n"; + return *this; + } + + private: + + std::ostream& stream() { + return *m_os; + } + + void ensureTagClosed() { + if( m_tagIsOpen ) { + stream() << ">\n"; + m_tagIsOpen = false; + } + } + + void newlineIfNecessary() { + if( m_needsNewline ) { + stream() << "\n"; + m_needsNewline = false; + } + } + + void writeEncodedText( std::string const& text ) { + static const char* charsToEncode = "<&\""; + std::string mtext = text; + std::string::size_type pos = mtext.find_first_of( charsToEncode ); + while( pos != std::string::npos ) { + stream() << mtext.substr( 0, pos ); + + switch( mtext[pos] ) { + case '<': + stream() << "<"; + break; + case '&': + stream() << "&"; + break; + case '\"': + stream() << """; + break; + } + mtext = mtext.substr( pos+1 ); + pos = mtext.find_first_of( charsToEncode ); + } + stream() << mtext; + } + + bool m_tagIsOpen; + bool m_needsNewline; + std::vector m_tags; + std::string m_indent; + std::ostream* m_os; + }; + +} +namespace Catch { + class XmlReporter : public SharedImpl { + public: + XmlReporter( ReporterConfig const& config ) : m_config( config ), m_sectionDepth( 0 ) {} + + static std::string getDescription() { + return "Reports test results as an XML document"; + } + virtual ~XmlReporter(); + + private: // IReporter + + virtual bool shouldRedirectStdout() const { + return true; + } + + virtual void StartTesting() { + m_xml = XmlWriter( m_config.stream() ); + m_xml.startElement( "Catch" ); + if( !m_config.fullConfig()->name().empty() ) + m_xml.writeAttribute( "name", m_config.fullConfig()->name() ); + } + + virtual void EndTesting( const Totals& totals ) { + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", totals.assertions.passed ) + .writeAttribute( "failures", totals.assertions.failed ); + m_xml.endElement(); + } + + virtual void StartGroup( const std::string& groupName ) { + m_xml.startElement( "Group" ) + .writeAttribute( "name", groupName ); + } + + virtual void EndGroup( const std::string&, const Totals& totals ) { + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", totals.assertions.passed ) + .writeAttribute( "failures", totals.assertions.failed ); + m_xml.endElement(); + } + + virtual void StartSection( const std::string& sectionName, const std::string& description ) { + if( m_sectionDepth++ > 0 ) { + m_xml.startElement( "Section" ) + .writeAttribute( "name", trim( sectionName ) ) + .writeAttribute( "description", description ); + } + } + virtual void NoAssertionsInSection( const std::string& ) {} + virtual void NoAssertionsInTestCase( const std::string& ) {} + + virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) { + if( --m_sectionDepth > 0 ) { + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", assertions.passed ) + .writeAttribute( "failures", assertions.failed ); + m_xml.endElement(); + } + } + + virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) { + m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) ); + m_currentTestSuccess = true; + } + + virtual void Result( const Catch::AssertionResult& assertionResult ) { + if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok ) + return; + + if( assertionResult.hasExpression() ) { + m_xml.startElement( "Expression" ) + .writeAttribute( "success", assertionResult.succeeded() ) + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ); + + m_xml.scopedElement( "Original" ) + .writeText( assertionResult.getExpression() ); + m_xml.scopedElement( "Expanded" ) + .writeText( assertionResult.getExpandedExpression() ); + m_currentTestSuccess &= assertionResult.succeeded(); + } + + switch( assertionResult.getResultType() ) { + case ResultWas::ThrewException: + m_xml.scopedElement( "Exception" ) + .writeAttribute( "filename", assertionResult.getSourceInfo().file ) + .writeAttribute( "line", assertionResult.getSourceInfo().line ) + .writeText( assertionResult.getMessage() ); + m_currentTestSuccess = false; + break; + case ResultWas::Info: + m_xml.scopedElement( "Info" ) + .writeText( assertionResult.getMessage() ); + break; + case ResultWas::Warning: + m_xml.scopedElement( "Warning" ) + .writeText( assertionResult.getMessage() ); + break; + case ResultWas::ExplicitFailure: + m_xml.scopedElement( "Failure" ) + .writeText( assertionResult.getMessage() ); + m_currentTestSuccess = false; + break; + case ResultWas::Unknown: + case ResultWas::Ok: + case ResultWas::FailureBit: + case ResultWas::ExpressionFailed: + case ResultWas::Exception: + case ResultWas::DidntThrowException: + break; + } + if( assertionResult.hasExpression() ) + m_xml.endElement(); + } + + virtual void Aborted() { + // !TBD + } + + virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string&, const std::string& ) { + m_xml.scopedElement( "OverallResult" ).writeAttribute( "success", m_currentTestSuccess ); + m_xml.endElement(); + } + + private: + ReporterConfig m_config; + bool m_currentTestSuccess; + XmlWriter m_xml; + int m_sectionDepth; + }; + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_junit.hpp +#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED + +#include + +namespace Catch { + + class JunitReporter : public CumulativeReporterBase { + public: + JunitReporter( ReporterConfig const& _config ) + : CumulativeReporterBase( _config ), + xml( _config.stream() ) + {} + + ~JunitReporter(); + + static std::string getDescription() { + return "Reports test results in an XML format that looks like Ant's junitreport target"; + } + + virtual void noMatchingTestCases( std::string const& /*spec*/ ) {} + + virtual ReporterPreferences getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = true; + return prefs; + } + + virtual void testRunStarting( TestRunInfo const& runInfo ) { + CumulativeReporterBase::testRunStarting( runInfo ); + xml.startElement( "testsuites" ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) { + suiteTimer.start(); + stdOutForSuite.str(""); + stdErrForSuite.str(""); + unexpectedExceptions = 0; + CumulativeReporterBase::testGroupStarting( groupInfo ); + } + + virtual bool assertionEnded( AssertionStats const& assertionStats ) { + if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException ) + unexpectedExceptions++; + return CumulativeReporterBase::assertionEnded( assertionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) { + stdOutForSuite << testCaseStats.stdOut; + stdErrForSuite << testCaseStats.stdErr; + CumulativeReporterBase::testCaseEnded( testCaseStats ); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) { + double suiteTime = suiteTimer.getElapsedSeconds(); + CumulativeReporterBase::testGroupEnded( testGroupStats ); + writeGroup( *m_testGroups.back(), suiteTime ); + } + + virtual void testRunEndedCumulative() { + xml.endElement(); + } + + void writeGroup( TestGroupNode const& groupNode, double suiteTime ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); + TestGroupStats const& stats = groupNode.value; + xml.writeAttribute( "name", stats.groupInfo.name ); + xml.writeAttribute( "errors", unexpectedExceptions ); + xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions ); + xml.writeAttribute( "tests", stats.totals.assertions.total() ); + xml.writeAttribute( "hostname", "tbd" ); // !TBD + if( m_config->showDurations() == ShowDurations::Never ) + xml.writeAttribute( "time", "" ); + else + xml.writeAttribute( "time", suiteTime ); + xml.writeAttribute( "timestamp", "tbd" ); // !TBD + + // Write test cases + for( TestGroupNode::ChildNodes::const_iterator + it = groupNode.children.begin(), itEnd = groupNode.children.end(); + it != itEnd; + ++it ) + writeTestCase( **it ); + + xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false ); + xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false ); + } + + void writeTestCase( TestCaseNode const& testCaseNode ) { + TestCaseStats const& stats = testCaseNode.value; + + // All test cases have exactly one section - which represents the + // test case itself. That section may have 0-n nested sections + assert( testCaseNode.children.size() == 1 ); + SectionNode const& rootSection = *testCaseNode.children.front(); + + std::string className = stats.testInfo.className; + + if( className.empty() ) { + if( rootSection.childSections.empty() ) + className = "global"; + } + writeSection( className, "", rootSection ); + } + + void writeSection( std::string const& className, + std::string const& rootName, + SectionNode const& sectionNode ) { + std::string name = trim( sectionNode.stats.sectionInfo.name ); + if( !rootName.empty() ) + name = rootName + "/" + name; + + if( !sectionNode.assertions.empty() || + !sectionNode.stdOut.empty() || + !sectionNode.stdErr.empty() ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); + if( className.empty() ) { + xml.writeAttribute( "classname", name ); + xml.writeAttribute( "name", "root" ); + } + else { + xml.writeAttribute( "classname", className ); + xml.writeAttribute( "name", name ); + } + xml.writeAttribute( "time", toString( sectionNode.stats.durationInSeconds ) ); + + writeAssertions( sectionNode ); + + if( !sectionNode.stdOut.empty() ) + xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false ); + if( !sectionNode.stdErr.empty() ) + xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false ); + } + for( SectionNode::ChildSections::const_iterator + it = sectionNode.childSections.begin(), + itEnd = sectionNode.childSections.end(); + it != itEnd; + ++it ) + if( className.empty() ) + writeSection( name, "", **it ); + else + writeSection( className, name, **it ); + } + + void writeAssertions( SectionNode const& sectionNode ) { + for( SectionNode::Assertions::const_iterator + it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end(); + it != itEnd; + ++it ) + writeAssertion( *it ); + } + void writeAssertion( AssertionStats const& stats ) { + AssertionResult const& result = stats.assertionResult; + if( !result.isOk() ) { + std::string elementName; + switch( result.getResultType() ) { + case ResultWas::ThrewException: + elementName = "error"; + break; + case ResultWas::ExplicitFailure: + elementName = "failure"; + break; + case ResultWas::ExpressionFailed: + elementName = "failure"; + break; + case ResultWas::DidntThrowException: + elementName = "failure"; + break; + + // We should never see these here: + case ResultWas::Info: + case ResultWas::Warning: + case ResultWas::Ok: + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + elementName = "internalError"; + break; + } + + XmlWriter::ScopedElement e = xml.scopedElement( elementName ); + + xml.writeAttribute( "message", result.getExpandedExpression() ); + xml.writeAttribute( "type", result.getTestMacroName() ); + + std::ostringstream oss; + if( !result.getMessage().empty() ) + oss << result.getMessage() << "\n"; + for( std::vector::const_iterator + it = stats.infoMessages.begin(), + itEnd = stats.infoMessages.end(); + it != itEnd; + ++it ) + if( it->type == ResultWas::Info ) + oss << it->message << "\n"; + + oss << "at " << result.getSourceInfo(); + xml.writeText( oss.str(), false ); + } + } + + XmlWriter xml; + Timer suiteTimer; + std::ostringstream stdOutForSuite; + std::ostringstream stdErrForSuite; + unsigned int unexpectedExceptions; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_console.hpp +#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED + +namespace Catch { + + struct ConsoleReporter : StreamingReporterBase { + ConsoleReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ), + m_headerPrinted( false ), + m_atLeastOneTestCasePrinted( false ) + {} + + virtual ~ConsoleReporter(); + static std::string getDescription() { + return "Reports test results as plain lines of text"; + } + virtual ReporterPreferences getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = false; + return prefs; + } + + virtual void noMatchingTestCases( std::string const& spec ) { + stream << "No test cases matched '" << spec << "'" << std::endl; + } + + virtual void assertionStarting( AssertionInfo const& ) { + } + + virtual bool assertionEnded( AssertionStats const& _assertionStats ) { + AssertionResult const& result = _assertionStats.assertionResult; + + bool printInfoMessages = true; + + // Drop out if result was successful and we're not printing those + if( !m_config->includeSuccessfulResults() && result.isOk() ) { + if( result.getResultType() != ResultWas::Warning ) + return false; + printInfoMessages = false; + } + + lazyPrint(); + + AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); + printer.print(); + stream << std::endl; + return true; + } + + virtual void sectionStarting( SectionInfo const& _sectionInfo ) { + m_headerPrinted = false; + StreamingReporterBase::sectionStarting( _sectionInfo ); + } + virtual void sectionEnded( SectionStats const& _sectionStats ) { + if( _sectionStats.missingAssertions ) { + lazyPrint(); + Colour colour( Colour::ResultError ); + if( m_sectionStack.size() > 1 ) + stream << "\nNo assertions in section"; + else + stream << "\nNo assertions in test case"; + stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl; + } + if( m_headerPrinted ) { + if( m_config->showDurations() == ShowDurations::Always ) + stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl; + m_headerPrinted = false; + } + else { + if( m_config->showDurations() == ShowDurations::Always ) + stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl; + } + StreamingReporterBase::sectionEnded( _sectionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) { + StreamingReporterBase::testCaseEnded( _testCaseStats ); + m_headerPrinted = false; + } + virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) { + if( currentGroupInfo.used ) { + printSummaryDivider(); + stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n"; + printTotals( _testGroupStats.totals ); + stream << "\n" << std::endl; + } + StreamingReporterBase::testGroupEnded( _testGroupStats ); + } + virtual void testRunEnded( TestRunStats const& _testRunStats ) { + if( m_atLeastOneTestCasePrinted ) + printTotalsDivider(); + printTotals( _testRunStats.totals ); + stream << "\n" << std::endl; + StreamingReporterBase::testRunEnded( _testRunStats ); + } + + private: + + class AssertionPrinter { + void operator= ( AssertionPrinter const& ); + public: + AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) + : stream( _stream ), + stats( _stats ), + result( _stats.assertionResult ), + colour( Colour::None ), + message( result.getMessage() ), + messages( _stats.infoMessages ), + printInfoMessages( _printInfoMessages ) + { + switch( result.getResultType() ) { + case ResultWas::Ok: + colour = Colour::Success; + passOrFail = "PASSED"; + //if( result.hasMessage() ) + if( _stats.infoMessages.size() == 1 ) + messageLabel = "with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "with messages"; + break; + case ResultWas::ExpressionFailed: + if( result.isOk() ) { + colour = Colour::Success; + passOrFail = "FAILED - but was ok"; + } + else { + colour = Colour::Error; + passOrFail = "FAILED"; + } + if( _stats.infoMessages.size() == 1 ) + messageLabel = "with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "with messages"; + break; + case ResultWas::ThrewException: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "due to unexpected exception with message"; + break; + case ResultWas::DidntThrowException: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "because no exception was thrown where one was expected"; + break; + case ResultWas::Info: + messageLabel = "info"; + break; + case ResultWas::Warning: + messageLabel = "warning"; + break; + case ResultWas::ExplicitFailure: + passOrFail = "FAILED"; + colour = Colour::Error; + if( _stats.infoMessages.size() == 1 ) + messageLabel = "explicitly with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "explicitly with messages"; + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + passOrFail = "** internal error **"; + colour = Colour::Error; + break; + } + } + + void print() const { + printSourceInfo(); + if( stats.totals.assertions.total() > 0 ) { + if( result.isOk() ) + stream << "\n"; + printResultType(); + printOriginalExpression(); + printReconstructedExpression(); + } + else { + stream << "\n"; + } + printMessage(); + } + + private: + void printResultType() const { + if( !passOrFail.empty() ) { + Colour colourGuard( colour ); + stream << passOrFail << ":\n"; + } + } + void printOriginalExpression() const { + if( result.hasExpression() ) { + Colour colourGuard( Colour::OriginalExpression ); + stream << " "; + stream << result.getExpressionInMacro(); + stream << "\n"; + } + } + void printReconstructedExpression() const { + if( result.hasExpandedExpression() ) { + stream << "with expansion:\n"; + Colour colourGuard( Colour::ReconstructedExpression ); + stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n"; + } + } + void printMessage() const { + if( !messageLabel.empty() ) + stream << messageLabel << ":" << "\n"; + for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end(); + it != itEnd; + ++it ) { + // If this assertion is a warning ignore any INFO messages + if( printInfoMessages || it->type != ResultWas::Info ) + stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n"; + } + } + void printSourceInfo() const { + Colour colourGuard( Colour::FileName ); + stream << result.getSourceInfo() << ": "; + } + + std::ostream& stream; + AssertionStats const& stats; + AssertionResult const& result; + Colour::Code colour; + std::string passOrFail; + std::string messageLabel; + std::string message; + std::vector messages; + bool printInfoMessages; + }; + + void lazyPrint() { + + if( !currentTestRunInfo.used ) + lazyPrintRunInfo(); + if( !currentGroupInfo.used ) + lazyPrintGroupInfo(); + + if( !m_headerPrinted ) { + printTestCaseAndSectionHeader(); + m_headerPrinted = true; + } + m_atLeastOneTestCasePrinted = true; + } + void lazyPrintRunInfo() { + stream << "\n" << getTildes() << "\n"; + Colour colour( Colour::SecondaryText ); + stream << currentTestRunInfo->name + << " is a Catch v" << libraryVersion.majorVersion << "." + << libraryVersion.minorVersion << " b" + << libraryVersion.buildNumber; + if( libraryVersion.branchName != "master" ) + stream << " (" << libraryVersion.branchName << ")"; + stream << " host application.\n" + << "Run with -? for options\n\n"; + + currentTestRunInfo.used = true; + } + void lazyPrintGroupInfo() { + if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) { + printClosedHeader( "Group: " + currentGroupInfo->name ); + currentGroupInfo.used = true; + } + } + void printTestCaseAndSectionHeader() { + assert( !m_sectionStack.empty() ); + printOpenHeader( currentTestCaseInfo->name ); + + if( m_sectionStack.size() > 1 ) { + Colour colourGuard( Colour::Headers ); + + std::vector::const_iterator + it = m_sectionStack.begin()+1, // Skip first section (test case) + itEnd = m_sectionStack.end(); + for( ; it != itEnd; ++it ) + printHeaderString( it->name, 2 ); + } + + SourceLineInfo lineInfo = m_sectionStack.front().lineInfo; + + if( !lineInfo.empty() ){ + stream << getDashes() << "\n"; + Colour colourGuard( Colour::FileName ); + stream << lineInfo << "\n"; + } + stream << getDots() << "\n" << std::endl; + } + + void printClosedHeader( std::string const& _name ) { + printOpenHeader( _name ); + stream << getDots() << "\n"; + } + void printOpenHeader( std::string const& _name ) { + stream << getDashes() << "\n"; + { + Colour colourGuard( Colour::Headers ); + printHeaderString( _name ); + } + } + + // if string has a : in first line will set indent to follow it on + // subsequent lines + void printHeaderString( std::string const& _string, std::size_t indent = 0 ) { + std::size_t i = _string.find( ": " ); + if( i != std::string::npos ) + i+=2; + else + i = 0; + stream << Text( _string, TextAttributes() + .setIndent( indent+i) + .setInitialIndent( indent ) ) << "\n"; + } + + void printTotals( const Totals& totals ) { + if( totals.testCases.total() == 0 ) { + stream << "No tests ran"; + } + else if( totals.assertions.total() == 0 ) { + Colour colour( Colour::Yellow ); + printCounts( "test case", totals.testCases ); + stream << " (no assertions)"; + } + else if( totals.assertions.failed ) { + Colour colour( Colour::ResultError ); + printCounts( "test case", totals.testCases ); + if( totals.testCases.failed > 0 ) { + stream << " ("; + printCounts( "assertion", totals.assertions ); + stream << ")"; + } + } + else { + Colour colour( Colour::ResultSuccess ); + stream << "All tests passed (" + << pluralise( totals.assertions.passed, "assertion" ) << " in " + << pluralise( totals.testCases.passed, "test case" ) << ")"; + } + } + void printCounts( std::string const& label, Counts const& counts ) { + if( counts.total() == 1 ) { + stream << "1 " << label << " - "; + if( counts.failed ) + stream << "failed"; + else + stream << "passed"; + } + else { + stream << counts.total() << " " << label << "s "; + if( counts.passed ) { + if( counts.failed ) + stream << "- " << counts.failed << " failed"; + else if( counts.passed == 2 ) + stream << "- both passed"; + else + stream << "- all passed"; + } + else { + if( counts.failed == 2 ) + stream << "- both failed"; + else + stream << "- all failed"; + } + } + } + + void printTotalsDivider() { + stream << getDoubleDashes() << "\n"; + } + void printSummaryDivider() { + stream << getDashes() << "\n"; + } + static std::string const& getDashes() { + static const std::string dashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '-' ); + return dashes; + } + static std::string const& getDots() { + static const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '.' ); + return dots; + } + static std::string const& getDoubleDashes() { + static const std::string doubleDashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' ); + return doubleDashes; + } + static std::string const& getTildes() { + static const std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '~' ); + return dots; + } + + private: + bool m_headerPrinted; + bool m_atLeastOneTestCasePrinted; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter ) + +} // end namespace Catch + +namespace Catch { + NonCopyable::~NonCopyable() {} + IShared::~IShared() {} + StreamBufBase::~StreamBufBase() throw() {} + IContext::~IContext() {} + IResultCapture::~IResultCapture() {} + ITestCase::~ITestCase() {} + ITestCaseRegistry::~ITestCaseRegistry() {} + IRegistryHub::~IRegistryHub() {} + IMutableRegistryHub::~IMutableRegistryHub() {} + IExceptionTranslator::~IExceptionTranslator() {} + IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {} + IReporter::~IReporter() {} + IReporterFactory::~IReporterFactory() {} + IReporterRegistry::~IReporterRegistry() {} + IStreamingReporter::~IStreamingReporter() {} + AssertionStats::~AssertionStats() {} + SectionStats::~SectionStats() {} + TestCaseStats::~TestCaseStats() {} + TestGroupStats::~TestGroupStats() {} + TestRunStats::~TestRunStats() {} + CumulativeReporterBase::SectionNode::~SectionNode() {} + CumulativeReporterBase::~CumulativeReporterBase() {} + + StreamingReporterBase::~StreamingReporterBase() {} + ConsoleReporter::~ConsoleReporter() {} + IRunner::~IRunner() {} + IMutableContext::~IMutableContext() {} + IConfig::~IConfig() {} + XmlReporter::~XmlReporter() {} + JunitReporter::~JunitReporter() {} + TestRegistry::~TestRegistry() {} + FreeFunctionTestCase::~FreeFunctionTestCase() {} + IGeneratorInfo::~IGeneratorInfo() {} + IGeneratorsForTest::~IGeneratorsForTest() {} + + Matchers::Impl::StdString::Equals::~Equals() {} + Matchers::Impl::StdString::Contains::~Contains() {} + Matchers::Impl::StdString::StartsWith::~StartsWith() {} + Matchers::Impl::StdString::EndsWith::~EndsWith() {} + + void Config::dummy() {} + + INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "xml", XmlReporter ) +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif // CATCH_CONFIG_MAIN || CATCH_CONFIG_RUNNER + +#ifdef CATCH_CONFIG_MAIN +// #included from: internal/catch_default_main.hpp +#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED + +#ifndef __OBJC__ + +// Standard C/C++ main entry point +int main (int argc, char * const argv[]) { + return Catch::Session().run( argc, argv ); +} + +#else // __OBJC__ + +// Objective-C entry point +int main (int argc, char * const argv[]) { +#if !CATCH_ARC_ENABLED + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; +#endif + + Catch::registerTestMethods(); + int result = Catch::Session().run( argc, (char* const*)argv ); + +#if !CATCH_ARC_ENABLED + [pool drain]; +#endif + + return result; +} + +#endif // __OBJC__ + +#endif // CATCH_CONFIG_MAIN + +////// + +// If this config identifier is defined then all CATCH macros are prefixed with CATCH_ +#ifdef CATCH_CONFIG_PREFIX_ALL + +#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" ) +#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::NegateResult, "CATCH_REQUIRE_FALSE" ) + +#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, ..., Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" ) +#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" ) +#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" ) + +#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" ) +#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::NegateResult, "CATCH_CHECK_FALSE" ) +#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" ) +#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" ) +#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" ) + +#define CATCH_CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, ..., Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" ) +#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" ) +#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" ) + +#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" ) +#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" ) + +#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) +#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg ) +#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) +#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) +#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ ) + #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ ) +#else + #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) + #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) + #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) + #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) + #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg ) + #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg ) +#endif +#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) + +#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) +#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) + +#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) + +// "BDD-style" convenience wrappers +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) +#else +#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags ) +#endif +#define CATCH_GIVEN( desc ) CATCH_SECTION( "Given: " desc, "" ) +#define CATCH_WHEN( desc ) CATCH_SECTION( " When: " desc, "" ) +#define CATCH_AND_WHEN( desc ) CATCH_SECTION( " And: " desc, "" ) +#define CATCH_THEN( desc ) CATCH_SECTION( " Then: " desc, "" ) +#define CATCH_AND_THEN( desc ) CATCH_SECTION( " And: " desc, "" ) + +// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required +#else + +#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" ) +#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::NegateResult, "REQUIRE_FALSE" ) + +#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, ..., Catch::ResultDisposition::Normal, "REQUIRE_THROWS" ) +#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" ) +#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" ) + +#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" ) +#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::NegateResult, "CHECK_FALSE" ) +#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" ) +#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" ) +#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" ) + +#define CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, ..., Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" ) +#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" ) +#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" ) + +#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" ) +#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" ) + +#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) +#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg ) +#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) +#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) +#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ ) + #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ ) +#else + #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) + #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) + #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) + #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) + #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg ) + #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg ) +#endif +#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) + +#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) +#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) + +#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) + +#endif + +#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) + +// "BDD-style" convenience wrappers +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) +#else +#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags ) +#endif +#define GIVEN( desc ) SECTION( " Given: " desc, "" ) +#define WHEN( desc ) SECTION( " When: " desc, "" ) +#define AND_WHEN( desc ) SECTION( "And when: " desc, "" ) +#define THEN( desc ) SECTION( " Then: " desc, "" ) +#define AND_THEN( desc ) SECTION( " And: " desc, "" ) + +using Catch::Detail::Approx; + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED + diff --git a/entityx/3rdparty/simplesignal.h b/entityx/3rdparty/simplesignal.h new file mode 100644 index 0000000..3c60273 --- /dev/null +++ b/entityx/3rdparty/simplesignal.h @@ -0,0 +1,580 @@ +// CC0 Public Domain: http://creativecommons.org/publicdomain/zero/1.0/ +#ifndef SIMPLE_SIGNAL_H__ +#define SIMPLE_SIGNAL_H__ + +#include +#include +#include +#include + +namespace Simple { + +namespace Lib { + +/// ProtoSignal is the template implementation for callback list. +template +class ProtoSignal; // undefined + +/// CollectorInvocation invokes signal handlers differently depending on return +/// type. +template +struct CollectorInvocation; + +/// CollectorLast returns the result of the last signal handler from a signal +/// emission. +template +struct CollectorLast { + typedef Result CollectorResult; + explicit CollectorLast() : last_() {} + inline bool operator()(Result r) { + last_ = r; + return true; + } + CollectorResult result() { return last_; } + + private: + Result last_; +}; + +/// CollectorDefault implements the default signal handler collection behaviour. +template +struct CollectorDefault : CollectorLast {}; + +/// CollectorDefault specialisation for signals with void return type. +template <> +struct CollectorDefault { + typedef void CollectorResult; + void result() {} + inline bool operator()(void) { return true; } +}; + +/// CollectorInvocation specialisation for regular signals. +template +struct CollectorInvocation { + inline bool invoke(Collector &collector, const std::function &cbf, + Args... args) { + return collector(cbf(args...)); + } +}; + +/// CollectorInvocation specialisation for signals with void return type. +template +struct CollectorInvocation { + inline bool invoke(Collector &collector, + const std::function &cbf, Args... args) { + cbf(args...); + return collector(); + } +}; + +/// ProtoSignal template specialised for the callback signature and collector. +template +class ProtoSignal : private CollectorInvocation< + Collector, R(Args...)> { + protected: + typedef std::function CbFunction; + typedef typename CbFunction::result_type Result; + typedef typename Collector::CollectorResult CollectorResult; + + private: + /// SignalLink implements a doubly-linked ring with ref-counted nodes + /// containing the signal handlers. + struct SignalLink { + SignalLink *next, *prev; + CbFunction function; + int ref_count; + explicit SignalLink(const CbFunction &cbf) + : next(0), prev(0), function(cbf), ref_count(1) {} + /*dtor*/ ~SignalLink() { assert(ref_count == 0); } + void incref() { + ref_count += 1; + assert(ref_count > 0); + } + void decref() { + ref_count -= 1; + if (!ref_count) + delete this; + else + assert(ref_count > 0); + } + void unlink() { + function = nullptr; + if (next) next->prev = prev; + if (prev) prev->next = next; + decref(); + // leave intact ->next, ->prev for stale iterators + } + size_t add_before(const CbFunction &cb) { + SignalLink *link = new SignalLink(cb); + link->prev = prev; // link to last + link->next = this; + prev->next = link; // link from last + prev = link; + static_assert(sizeof(link) == sizeof(size_t), "sizeof size_t"); + return size_t(link); + } + bool deactivate(const CbFunction &cbf) { + if (cbf == function) { + function = 0; // deactivate static head + return true; + } + for (SignalLink *link = this->next ? this->next : this; link != this; + link = link->next) + if (cbf == link->function) { + link->unlink(); // deactivate and unlink sibling + return true; + } + return false; + } + bool remove_sibling(size_t id) { + for (SignalLink *link = this->next ? this->next : this; link != this; + link = link->next) + if (id == size_t(link)) { + link->unlink(); // deactivate and unlink sibling + return true; + } + return false; + } + }; + SignalLink *callback_ring_; // linked ring of callback nodes + /*copy-ctor*/ ProtoSignal(const ProtoSignal &) = delete; + ProtoSignal &operator=(const ProtoSignal &) = delete; + void ensure_ring() { + if (!callback_ring_) { + callback_ring_ = new SignalLink(CbFunction()); // ref_count = 1 + callback_ring_->incref(); // ref_count = 2, head of ring, can be + // deactivated but not removed + callback_ring_->next = callback_ring_; // ring head initialization + callback_ring_->prev = callback_ring_; // ring tail initialization + } + } + + public: + /// ProtoSignal constructor, connects default callback if non-0. + ProtoSignal(const CbFunction &method) : callback_ring_(0) { + if (method != 0) { + ensure_ring(); + callback_ring_->function = method; + } + } + /// ProtoSignal destructor releases all resources associated with this signal. + ~ProtoSignal() { + if (callback_ring_) { + while (callback_ring_->next != callback_ring_) + callback_ring_->next->unlink(); + assert(callback_ring_->ref_count >= 2); + callback_ring_->decref(); + callback_ring_->decref(); + } + } + /// Operator to add a new function or lambda as signal handler, returns a + /// handler connection ID. + size_t connect(const CbFunction &cb) { + ensure_ring(); + return callback_ring_->add_before(cb); + } + /// Operator to remove a signal handler through it connection ID, returns if a + /// handler was removed. + bool disconnect(size_t connection) { + return callback_ring_ ? callback_ring_->remove_sibling(connection) : false; + } + /// Emit a signal, i.e. invoke all its callbacks and collect return types with + /// the Collector. + CollectorResult emit(Args... args) { + Collector collector; + if (!callback_ring_) return collector.result(); + SignalLink *link = callback_ring_; + link->incref(); + do { + if (link->function != 0) { + const bool continue_emission = + this->invoke(collector, link->function, args...); + if (!continue_emission) break; + } + SignalLink *old = link; + link = old->next; + link->incref(); + old->decref(); + } while (link != callback_ring_); + link->decref(); + return collector.result(); + } + // Number of connected slots. + std::size_t size() { + std::size_t size = 0; + SignalLink *link = callback_ring_; + link->incref(); + do { + if (link->function != 0) { + size++; + } + SignalLink *old = link; + link = old->next; + link->incref(); + old->decref(); + } while (link != callback_ring_); + return size; + } +}; + +} // Lib + // namespace Simple + +/** + * Signal is a template type providing an interface for arbitrary callback + * lists. + * A signal type needs to be declared with the function signature of its + * callbacks, + * and optionally a return result collector class type. + * Signal callbacks can be added with operator+= to a signal and removed with + * operator-=, using + * a callback connection ID return by operator+= as argument. + * The callbacks of a signal are invoked with the emit() method and arguments + * according to the signature. + * The result returned by emit() depends on the signal collector class. By + * default, the result of + * the last callback is returned from emit(). Collectors can be implemented to + * accumulate callback + * results or to halt a running emissions in correspondance to callback results. + * The signal implementation is safe against recursion, so callbacks may be + * removed and + * added during a signal emission and recursive emit() calls are also safe. + * The overhead of an unused signal is intentionally kept very low, around the + * size of a single pointer. + * Note that the Signal template types is non-copyable. + */ +template ::result_type>> +struct Signal /*final*/ : Lib::ProtoSignal { + typedef Lib::ProtoSignal ProtoSignal; + typedef typename ProtoSignal::CbFunction CbFunction; + /// Signal constructor, supports a default callback as argument. + Signal(const CbFunction &method = CbFunction()) : ProtoSignal(method) {} +}; + +/// This function creates a std::function by binding @a object to the member +/// function pointer @a method. +template +std::function slot(Instance &object, R (Class::*method)(Args...)) { + return [&object, method](Args... args) { return (object.*method)(args...); }; +} + +/// This function creates a std::function by binding @a object to the member +/// function pointer @a method. +template +std::function slot(Class *object, R (Class::*method)(Args...)) { + return [object, method](Args... args) { return (object->*method)(args...); }; +} + +/// Keep signal emissions going while all handlers return !0 (true). +template +struct CollectorUntil0 { + typedef Result CollectorResult; + explicit CollectorUntil0() : result_() {} + const CollectorResult &result() { return result_; } + inline bool operator()(Result r) { + result_ = r; + return result_ ? true : false; + } + + private: + CollectorResult result_; +}; + +/// Keep signal emissions going while all handlers return 0 (false). +template +struct CollectorWhile0 { + typedef Result CollectorResult; + explicit CollectorWhile0() : result_() {} + const CollectorResult &result() { return result_; } + inline bool operator()(Result r) { + result_ = r; + return result_ ? false : true; + } + + private: + CollectorResult result_; +}; + +/// CollectorVector returns the result of the all signal handlers from a signal +/// emission in a std::vector. +template +struct CollectorVector { + typedef std::vector CollectorResult; + const CollectorResult &result() { return result_; } + inline bool operator()(Result r) { + result_.push_back(r); + return true; + } + + private: + CollectorResult result_; +}; + +} // Simple + +#endif // SIMPLE_SIGNAL_H__ + +#ifdef ENABLE_SIMPLE_SIGNAL_TESTS + +#include +#include +#include +#include + +#ifdef __MACH__ +#include +#include +#endif + +static std::string string_printf(const char *format, ...) + __attribute__((__format__(__printf__, 1, 2))); +static std::string string_printf(const char *format, ...) { + std::string result; + char *str = 0; + va_list args; + va_start(args, format); + if (vasprintf(&str, format, args) >= 0) result = str; + va_end(args); + if (str) free(str); + return result; +} + +static uint64_t timestamp_benchmark() { + struct timespec tp = {0, 0}; + +#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time + clock_serv_t cclock; + mach_timespec_t mts; + host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); + clock_get_time(cclock, &mts); + mach_port_deallocate(mach_task_self(), cclock); + tp.tv_sec = mts.tv_sec; + tp.tv_nsec = mts.tv_nsec; +#else + clock_gettime(CLOCK_REALTIME, &tp); +#endif + uint64_t stamp = tp.tv_sec * 1000000000ULL + tp.tv_nsec; + return stamp; +} + +struct TestCounter { + static uint64_t get(); + static void set(uint64_t); + static void add2(void *, uint64_t); +}; + +namespace { // Anon +void (*test_counter_add2)(void *, uint64_t) = + TestCounter::add2; // external symbol to prevent easy inlining +static uint64_t test_counter_var = 0; +} // Anon + +class BasicSignalTests { + static std::string accu; + struct Foo { + char foo_bool(float f, int i, std::string s) { + accu += string_printf("Foo: %.2f\n", f + i + s.size()); + return true; + } + }; + static char float_callback(float f, int, std::string) { + accu += string_printf("float: %.2f\n", f); + return 0; + } + + public: + static void run() { + accu = ""; + Simple::Signal sig1; + size_t id1 = sig1.connect(float_callback); + size_t id2 = sig1.connect([](float, int i, std::string) { + accu += string_printf("int: %d\n", i); + return 0; + }); + size_t id3 = sig1.connect([](float, int, const std::string &s) { + accu += string_printf("string: %s\n", s.c_str()); + return 0; + }); + sig1.emit(.3, 4, "huhu"); + bool success; + success = sig1.disconnect(id1); + assert(success == true); + success = sig1.disconnect(id1); + assert(success == false); + success = sig1.disconnect(id2); + assert(success == true); + success = sig1.disconnect(id3); + assert(success == true); + success = sig1.disconnect(id3); + assert(success == false); + success = sig1.disconnect(id2); + assert(success == false); + Foo foo; + sig1.connect(Simple::slot(foo, &Foo::foo_bool)); + sig1.connect(Simple::slot(&foo, &Foo::foo_bool)); + sig1.emit(.5, 1, "12"); + + Simple::Signal sig2; + sig2.connect([](std::string msg, + int) { accu += string_printf("msg: %s", msg.c_str()); }); + sig2.connect([](std::string, + int d) { accu += string_printf(" *%d*\n", d); }); + sig2.emit("in sig2", 17); + + accu += "DONE"; + + const char *expected = + "float: 0.30\n" + "int: 4\n" + "string: huhu\n" + "Foo: 3.50\n" + "Foo: 3.50\n" + "msg: in sig2 *17*\n" + "DONE"; + assert(accu == expected); + } +}; +std::string BasicSignalTests::accu; + +class TestCollectorVector { + static int handler1() { return 1; } + static int handler42() { return 42; } + static int handler777() { return 777; } + + public: + static void run() { + Simple::Signal> sig_vector; + sig_vector.connect(handler777); + sig_vector.connect(handler42); + sig_vector.connect(handler1); + sig_vector.connect(handler42); + sig_vector.connect(handler777); + std::vector results = sig_vector.emit(); + const std::vector reference = {777, 42, 1, 42, 777, }; + assert(results == reference); + } +}; + +class TestCollectorUntil0 { + bool check1, check2; + TestCollectorUntil0() : check1(0), check2(0) {} + bool handler_true() { + check1 = true; + return true; + } + bool handler_false() { + check2 = true; + return false; + } + bool handler_abort() { abort(); } + + public: + static void run() { + TestCollectorUntil0 self; + Simple::Signal> sig_until0; + sig_until0.connect(Simple::slot(self, &TestCollectorUntil0::handler_true)); + sig_until0.connect(Simple::slot(self, &TestCollectorUntil0::handler_false)); + sig_until0.connect(Simple::slot(self, &TestCollectorUntil0::handler_abort)); + assert(!self.check1 && !self.check2); + const bool result = sig_until0.emit(); + assert(!result && self.check1 && self.check2); + } +}; + +class TestCollectorWhile0 { + bool check1, check2; + TestCollectorWhile0() : check1(0), check2(0) {} + bool handler_0() { + check1 = true; + return false; + } + bool handler_1() { + check2 = true; + return true; + } + bool handler_abort() { abort(); } + + public: + static void run() { + TestCollectorWhile0 self; + Simple::Signal> sig_while0; + sig_while0.connect(Simple::slot(self, &TestCollectorWhile0::handler_0)); + sig_while0.connect(Simple::slot(self, &TestCollectorWhile0::handler_1)); + sig_while0.connect(Simple::slot(self, &TestCollectorWhile0::handler_abort)); + assert(!self.check1 && !self.check2); + const bool result = sig_while0.emit(); + assert(result == true && self.check1 && self.check2); + } +}; + +static void bench_simple_signal() { + Simple::Signal sig_increment; + sig_increment.connect(test_counter_add2); + const uint64_t start_counter = TestCounter::get(); + const uint64_t benchstart = timestamp_benchmark(); + uint64_t i; + for (i = 0; i < 999999; i++) { + sig_increment.emit(0, 1); + } + const uint64_t benchdone = timestamp_benchmark(); + const uint64_t end_counter = TestCounter::get(); + assert(end_counter - start_counter == i); + printf("OK\n Benchmark: Simple::Signal: %fns per emission (size=%zu): ", + size_t(benchdone - benchstart) * 1.0 / size_t(i), + sizeof(sig_increment)); +} + +static void bench_callback_loop() { + void (*counter_increment)(void *, uint64_t) = test_counter_add2; + const uint64_t start_counter = TestCounter::get(); + const uint64_t benchstart = timestamp_benchmark(); + uint64_t i; + for (i = 0; i < 999999; i++) { + counter_increment(0, 1); + } + const uint64_t benchdone = timestamp_benchmark(); + const uint64_t end_counter = TestCounter::get(); + assert(end_counter - start_counter == i); + printf("OK\n Benchmark: callback loop: %fns per round: ", + size_t(benchdone - benchstart) * 1.0 / size_t(i)); +} + +uint64_t TestCounter::get() { return test_counter_var; } + +void TestCounter::set(uint64_t v) { test_counter_var = v; } + +void TestCounter::add2(void *, uint64_t v) { test_counter_var += v; } + +int main(int argc, char *argv[]) { + printf("Signal/Basic Tests: "); + BasicSignalTests::run(); + printf("OK\n"); + + printf("Signal/CollectorVector: "); + TestCollectorVector::run(); + printf("OK\n"); + + printf("Signal/CollectorUntil0: "); + TestCollectorUntil0::run(); + printf("OK\n"); + + printf("Signal/CollectorWhile0: "); + TestCollectorWhile0::run(); + printf("OK\n"); + + printf("Signal/Benchmark: Simple::Signal: "); + bench_simple_signal(); + printf("OK\n"); + + printf("Signal/Benchmark: callback loop: "); + bench_callback_loop(); + printf("OK\n"); + + return 0; +} + +#endif // DISABLE_TESTS + +// g++ -Wall -O2 -std=gnu++0x -pthread simplesignal.cc -lrt && ./a.out diff --git a/entityx/Entity.cc b/entityx/Entity.cc new file mode 100644 index 0000000..ddb8df7 --- /dev/null +++ b/entityx/Entity.cc @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2012 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#include +#include "entityx/Entity.h" + +namespace entityx { + +const Entity::Id Entity::INVALID; +BaseComponent::Family BaseComponent::family_counter_ = 0; + +void Entity::invalidate() { + id_ = INVALID; + manager_ = nullptr; +} + +void Entity::destroy() { + assert(valid()); + manager_->destroy(id_); + invalidate(); +} + +std::bitset Entity::component_mask() const { + return manager_->component_mask(id_); +} + +EntityManager::EntityManager(EventManager &event_manager) : event_manager_(event_manager) { +} + +EntityManager::~EntityManager() { + reset(); +} + +void EntityManager::reset() { + for (Entity entity : entities_for_debugging()) entity.destroy(); + for (BasePool *pool : component_pools_) { + if (pool) delete pool; + } + for (BaseComponentHelper *helper : component_helpers_) { + if (helper) delete helper; + } + component_pools_.clear(); + component_helpers_.clear(); + entity_component_mask_.clear(); + entity_version_.clear(); + free_list_.clear(); + index_counter_ = 0; +} + +EntityCreatedEvent::~EntityCreatedEvent() {} +EntityDestroyedEvent::~EntityDestroyedEvent() {} + + +} // namespace entityx diff --git a/entityx/Entity.h b/entityx/Entity.h new file mode 100644 index 0000000..3217ae5 --- /dev/null +++ b/entityx/Entity.h @@ -0,0 +1,1104 @@ +/* + * Copyright (C) 2012 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#pragma once + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + #include + +#include "entityx/help/Pool.h" +#include "entityx/config.h" +#include "entityx/Event.h" +#include "entityx/help/NonCopyable.h" + +namespace entityx { + +typedef std::uint32_t uint32_t; +typedef std::uint64_t uint64_t; + +class EntityManager; + + +template +class ComponentHandle; + + + +/** A convenience handle around an Entity::Id. + * + * If an entity is destroyed, any copies will be invalidated. Use valid() to + * check for validity before using. + * + * Create entities with `EntityManager`: + * + * Entity entity = entity_manager->create(); + */ +class Entity { +public: + struct Id { + Id() : id_(0) {} + explicit Id(uint64_t id) : id_(id) {} + Id(uint32_t index, uint32_t version) : id_(uint64_t(index) | uint64_t(version) << 32UL) {} + + uint64_t id() const { return id_; } + + bool operator == (const Id &other) const { return id_ == other.id_; } + bool operator != (const Id &other) const { return id_ != other.id_; } + bool operator < (const Id &other) const { return id_ < other.id_; } + + uint32_t index() const { return id_ & 0xffffffffUL; } + uint32_t version() const { return id_ >> 32; } + + private: + friend class EntityManager; + + uint64_t id_; + }; + + + /** + * Id of an invalid Entity. + */ + static const Id INVALID; + + Entity() = default; + Entity(EntityManager *manager, Entity::Id id) : manager_(manager), id_(id) {} + Entity(const Entity &other) = default; + Entity &operator = (const Entity &other) = default; + + /** + * Check if Entity handle is invalid. + */ + operator bool() const { + return valid(); + } + + bool operator == (const Entity &other) const { + return other.manager_ == manager_ && other.id_ == id_; + } + + bool operator != (const Entity &other) const { + return !(other == *this); + } + + bool operator < (const Entity &other) const { + return other.id_ < id_; + } + + /** + * Is this Entity handle valid? + * + * In older versions of EntityX, there were no guarantees around entity + * validity if a previously allocated entity slot was reassigned. That is no + * longer the case: if a slot is reassigned, old Entity::Id's will be + * invalid. + */ + bool valid() const; + + /** + * Invalidate Entity handle, disassociating it from an EntityManager and invalidating its ID. + * + * Note that this does *not* affect the underlying entity and its + * components. Use destroy() to destroy the associated Entity and components. + */ + void invalidate(); + + Id id() const { return id_; } + + template + ComponentHandle assign(Args && ... args); + + template + ComponentHandle assign_from_copy(const C &component); + + template + ComponentHandle replace(Args && ... args); + + template + void remove(); + + template ::value>::type> + ComponentHandle component(); + + template ::value>::type> + const ComponentHandle component() const; + + template + std::tuple...> components(); + + template + std::tuple...> components() const; + + template + bool has_component() const; + + template + void unpack(ComponentHandle &a, ComponentHandle & ... args); + + /** + * Destroy and invalidate this Entity. + */ + void destroy(); + + std::bitset component_mask() const; + + private: + EntityManager *manager_ = nullptr; + Entity::Id id_ = INVALID; +}; + + +/** + * A ComponentHandle is a wrapper around an instance of a component. + * + * It provides safe access to components. The handle will be invalidated under + * the following conditions: + * + * - If a component is removed from its host entity. + * - If its host entity is destroyed. + */ +template +class ComponentHandle { +public: + typedef C ComponentType; + + ComponentHandle() : manager_(nullptr) {} + + bool valid() const; + operator bool() const; + + C *operator -> (); + const C *operator -> () const; + + C &operator * (); + const C &operator * () const; + + C *get(); + const C *get() const; + + /** + * Remove the component from its entity and destroy it. + */ + void remove(); + + /** + * Returns the Entity associated with the component + */ + Entity entity(); + + bool operator == (const ComponentHandle &other) const { + return manager_ == other.manager_ && id_ == other.id_; + } + + bool operator != (const ComponentHandle &other) const { + return !(*this == other); + } + +private: + friend class EntityManager; + + ComponentHandle(EM *manager, Entity::Id id) : + manager_(manager), id_(id) {} + + EM *manager_; + Entity::Id id_; +}; + + +/** + * Base component class, only used for insertion into collections. + * + * Family is used for registration. + */ +struct BaseComponent { + public: + typedef size_t Family; + + // NOTE: Component memory is *always* managed by the EntityManager. + // Use Entity::destroy() instead. + void operator delete(void *p) { (void)p; fail(); } + void operator delete[](void *p) { (void)p; fail(); } + + + protected: + static void fail() { +#if defined(_HAS_EXCEPTIONS) || defined(__EXCEPTIONS) + throw std::bad_alloc(); +#else + std::abort(); +#endif + } + + static Family family_counter_; +}; + + +/** + * Component implementations should inherit from this. + * + * Components MUST provide a no-argument constructor. + * Components SHOULD provide convenience constructors for initializing on assignment to an Entity::Id. + * + * This is a struct to imply that components should be data-only. + * + * Usage: + * + * struct Position : public Component { + * Position(float x = 0.0f, float y = 0.0f) : x(x), y(y) {} + * + * float x, y; + * }; + * + * family() is used for registration. + */ +template +struct Component : public BaseComponent { + public: + typedef ComponentHandle Handle; + typedef ComponentHandle ConstHandle; + +private: + friend class EntityManager; + /// Used internally for registration. + static Family family(); +}; + + +/** + * Emitted when an entity is added to the system. + */ +struct EntityCreatedEvent : public Event { + explicit EntityCreatedEvent(Entity entity) : entity(entity) {} + virtual ~EntityCreatedEvent(); + + Entity entity; +}; + + +/** + * Called just prior to an entity being destroyed. + */ +struct EntityDestroyedEvent : public Event { + explicit EntityDestroyedEvent(Entity entity) : entity(entity) {} + virtual ~EntityDestroyedEvent(); + + Entity entity; +}; + + +/** + * Emitted when any component is added to an entity. + */ +template +struct ComponentAddedEvent : public Event> { + ComponentAddedEvent(Entity entity, ComponentHandle component) : + entity(entity), component(component) {} + + Entity entity; + ComponentHandle component; +}; + +/** + * Emitted when any component is removed from an entity. + */ +template +struct ComponentRemovedEvent : public Event> { + ComponentRemovedEvent(Entity entity, ComponentHandle component) : + entity(entity), component(component) {} + + Entity entity; + ComponentHandle component; +}; + +/** + * Helper class to perform component operations in a typed manner. + */ +class BaseComponentHelper { +public: + virtual ~BaseComponentHelper() {} + virtual void remove_component(Entity e) = 0; + virtual void copy_component_to(Entity source, Entity target) = 0; +}; + +template +class ComponentHelper : public BaseComponentHelper { +public: + void remove_component(Entity e) override { + e.remove(); + } + void copy_component_to(Entity source, Entity target) override { + target.assign_from_copy(*(source.component().get())); + } +}; + +/** + * Manages Entity::Id creation and component assignment. + */ +class EntityManager : entityx::help::NonCopyable { + public: + typedef std::bitset ComponentMask; + + explicit EntityManager(EventManager &event_manager); + virtual ~EntityManager(); + + /// An iterator over a view of the entities in an EntityManager. + /// If All is true it will iterate over all valid entities and will ignore the entity mask. + template + class ViewIterator : public std::iterator { + public: + Delegate &operator ++() { + ++i_; + next(); + return *static_cast(this); + } + bool operator == (const Delegate& rhs) const { return i_ == rhs.i_; } + bool operator != (const Delegate& rhs) const { return i_ != rhs.i_; } + Entity operator * () { return Entity(manager_, manager_->create_id(i_)); } + const Entity operator * () const { return Entity(manager_, manager_->create_id(i_)); } + + protected: + ViewIterator(EntityManager *manager, uint32_t index) + : manager_(manager), i_(index), capacity_(manager_->capacity()), free_cursor_(~0UL) { + if (All) { + std::sort(manager_->free_list_.begin(), manager_->free_list_.end()); + free_cursor_ = 0; + } + } + ViewIterator(EntityManager *manager, const ComponentMask mask, uint32_t index) + : manager_(manager), mask_(mask), i_(index), capacity_(manager_->capacity()), free_cursor_(~0UL) { + if (All) { + std::sort(manager_->free_list_.begin(), manager_->free_list_.end()); + free_cursor_ = 0; + } + } + + void next() { + while (i_ < capacity_ && !predicate()) { + ++i_; + } + + if (i_ < capacity_) { + Entity entity = manager_->get(manager_->create_id(i_)); + static_cast(this)->next_entity(entity); + } + } + + inline bool predicate() { + return (All && valid_entity()) || (manager_->entity_component_mask_[i_] & mask_) == mask_; + } + + inline bool valid_entity() { + const std::vector &free_list = manager_->free_list_; + if (free_cursor_ < free_list.size() && free_list[free_cursor_] == i_) { + ++free_cursor_; + return false; + } + return true; + } + + EntityManager *manager_; + ComponentMask mask_; + uint32_t i_; + size_t capacity_; + size_t free_cursor_; + }; + + template + class BaseView { + public: + class Iterator : public ViewIterator { + public: + Iterator(EntityManager *manager, + const ComponentMask mask, + uint32_t index) : ViewIterator(manager, mask, index) { + ViewIterator::next(); + } + + void next_entity(Entity &entity) { (void)entity; } + }; + + Iterator begin() { return Iterator(manager_, mask_, 0); } + Iterator end() { return Iterator(manager_, mask_, uint32_t(manager_->capacity())); } + const Iterator begin() const { return Iterator(manager_, mask_, 0); } + const Iterator end() const { return Iterator(manager_, mask_, manager_->capacity()); } + + private: + friend class EntityManager; + + explicit BaseView(EntityManager *manager) : manager_(manager) { mask_.set(); } + BaseView(EntityManager *manager, ComponentMask mask) : + manager_(manager), mask_(mask) {} + + EntityManager *manager_; + ComponentMask mask_; + }; + + template + class TypedView: public BaseView { + public: + template struct identity { typedef T type; }; + + void each(typename identity>::type f) { + for (auto it : *this) + f(it, *(it.template component().get())...); + } + + private: + friend class EntityManager; + + explicit TypedView(EntityManager *manager) : BaseView(manager) {} + TypedView(EntityManager *manager, ComponentMask mask) : BaseView(manager, mask) {} + }; + + template using View = TypedView; + typedef BaseView DebugView; + + template + class UnpackingView { + public: + struct Unpacker { + explicit Unpacker(ComponentHandle & ... handles) : + handles(std::tuple & ...>(handles...)) {} + + void unpack(entityx::Entity &entity) const { + unpack_<0, Components...>(entity); + } + + + private: + template + void unpack_(entityx::Entity &entity) const { + std::get(handles) = entity.component(); + } + + template + void unpack_(entityx::Entity &entity) const { + std::get(handles) = entity.component(); + unpack_(entity); + } + + std::tuple & ...> handles; + }; + + + class Iterator : public ViewIterator { + public: + Iterator(EntityManager *manager, + const ComponentMask mask, + uint32_t index, + const Unpacker &unpacker) : ViewIterator(manager, mask, index), unpacker_(unpacker) { + ViewIterator::next(); + } + + void next_entity(Entity &entity) { + unpacker_.unpack(entity); + } + + private: + const Unpacker &unpacker_; + }; + + + Iterator begin() { return Iterator(manager_, mask_, 0, unpacker_); } + Iterator end() { return Iterator(manager_, mask_, static_cast(manager_->capacity()), unpacker_); } + const Iterator begin() const { return Iterator(manager_, mask_, 0, unpacker_); } + const Iterator end() const { return Iterator(manager_, mask_, static_cast(manager_->capacity()), unpacker_); } + + + private: + friend class EntityManager; + + UnpackingView(EntityManager *manager, ComponentMask mask, ComponentHandle & ... handles) : + manager_(manager), mask_(mask), unpacker_(handles...) {} + + EntityManager *manager_; + ComponentMask mask_; + Unpacker unpacker_; + }; + + /** + * Number of managed entities. + */ + size_t size() const { return entity_component_mask_.size() - free_list_.size(); } + + /** + * Current entity capacity. + */ + size_t capacity() const { return entity_component_mask_.size(); } + + /** + * Return true if the given entity ID is still valid. + */ + bool valid(Entity::Id id) const { + return id.index() < entity_version_.size() && entity_version_[id.index()] == id.version(); + } + + /** + * Create a new Entity::Id. + * + * Emits EntityCreatedEvent. + */ + Entity create() { + uint32_t index, version; + if (free_list_.empty()) { + index = index_counter_++; + accomodate_entity(index); + version = entity_version_[index] = 1; + } else { + index = free_list_.back(); + free_list_.pop_back(); + version = entity_version_[index]; + } + Entity entity(this, Entity::Id(index, version)); + event_manager_.emit(entity); + return entity; + } + + /** + * Create a new Entity by copying another. Copy-constructs each component. + * + * Emits EntityCreatedEvent. + */ + Entity create_from_copy(Entity original) { + assert(original.valid()); + auto clone = create(); + auto mask = original.component_mask(); + for (size_t i = 0; i < component_helpers_.size(); i++) { + BaseComponentHelper *helper = component_helpers_[i]; + if (helper && mask.test(i)) + helper->copy_component_to(original, clone); + } + return clone; + } + + + /** + * Destroy an existing Entity::Id and its associated Components. + * + * Emits EntityDestroyedEvent. + */ + void destroy(Entity::Id entity) { + assert_valid(entity); + uint32_t index = entity.index(); + auto mask = entity_component_mask_[index]; + for (size_t i = 0; i < component_helpers_.size(); i++) { + BaseComponentHelper *helper = component_helpers_[i]; + if (helper && mask.test(i)) + helper->remove_component(Entity(this, entity)); + } + event_manager_.emit(Entity(this, entity)); + entity_component_mask_[index].reset(); + entity_version_[index]++; + free_list_.push_back(index); + } + + Entity get(Entity::Id id) { + assert_valid(id); + return Entity(this, id); + } + + /** + * Create an Entity::Id for a slot. + * + * NOTE: Does *not* check for validity, but the Entity::Id constructor will + * fail if the ID is invalid. + */ + Entity::Id create_id(uint32_t index) const { + return Entity::Id(index, entity_version_[index]); + } + + /** + * Assign a Component to an Entity::Id, passing through Component constructor arguments. + * + * Position &position = em.assign(e, x, y); + * + * @returns Smart pointer to newly created component. + */ + template + ComponentHandle assign(Entity::Id id, Args && ... args) { + assert_valid(id); + const BaseComponent::Family family = component_family(); + assert(!entity_component_mask_[id.index()].test(family)); + + // Placement new into the component pool. + Pool *pool = accomodate_component(); + ::new(pool->get(id.index())) C(std::forward(args) ...); + + // Set the bit for this component. + entity_component_mask_[id.index()].set(family); + + // Create and return handle. + ComponentHandle component(this, id); + event_manager_.emit>(Entity(this, id), component); + return component; + } + + /** + * Remove a Component from an Entity::Id + * + * Emits a ComponentRemovedEvent event. + */ + template + void remove(Entity::Id id) { + assert_valid(id); + const BaseComponent::Family family = component_family(); + const uint32_t index = id.index(); + + // Find the pool for this component family. + BasePool *pool = component_pools_[family]; + ComponentHandle component(this, id); + event_manager_.emit>(Entity(this, id), component); + + // Remove component bit. + entity_component_mask_[id.index()].reset(family); + + // Call destructor. + pool->destroy(index); + } + + /** + * Check if an Entity has a component. + */ + template + bool has_component(Entity::Id id) const { + assert_valid(id); + size_t family = component_family(); + // We don't bother checking the component mask, as we return a nullptr anyway. + if (family >= component_pools_.size()) + return false; + BasePool *pool = component_pools_[family]; + if (!pool || !entity_component_mask_[id.index()][family]) + return false; + return true; + } + + /** + * Retrieve a Component assigned to an Entity::Id. + * + * @returns Pointer to an instance of C, or nullptr if the Entity::Id does not have that Component. + */ + template ::value>::type> + ComponentHandle component(Entity::Id id) { + assert_valid(id); + size_t family = component_family(); + // We don't bother checking the component mask, as we return a nullptr anyway. + if (family >= component_pools_.size()) + return ComponentHandle(); + BasePool *pool = component_pools_[family]; + if (!pool || !entity_component_mask_[id.index()][family]) + return ComponentHandle(); + return ComponentHandle(this, id); + } + + /** + * Retrieve a Component assigned to an Entity::Id. + * + * @returns Component instance, or nullptr if the Entity::Id does not have that Component. + */ + template ::value>::type> + const ComponentHandle component(Entity::Id id) const { + assert_valid(id); + size_t family = component_family(); + // We don't bother checking the component mask, as we return a nullptr anyway. + if (family >= component_pools_.size()) + return ComponentHandle(); + BasePool *pool = component_pools_[family]; + if (!pool || !entity_component_mask_[id.index()][family]) + return ComponentHandle(); + return ComponentHandle(this, id); + } + + template + std::tuple...> components(Entity::Id id) { + return std::make_tuple(component(id)...); + } + + template + std::tuple...> components(Entity::Id id) const { + return std::make_tuple(component(id)...); + } + + /** + * Find Entities that have all of the specified Components. + * + * @code + * for (Entity entity : entity_manager.entities_with_components()) { + * ComponentHandle position = entity.component(); + * ComponentHandle direction = entity.component(); + * + * ... + * } + * @endcode + */ + template + View entities_with_components() { + auto mask = component_mask(); + return View(this, mask); + } + + template struct identity { typedef T type; }; + + template + void each(typename identity>::type f) { + return entities_with_components().each(f); + } + + /** + * Find Entities that have all of the specified Components and assign them + * to the given parameters. + * + * @code + * ComponentHandle position; + * ComponentHandle direction; + * for (Entity entity : entity_manager.entities_with_components(position, direction)) { + * // Use position and component here. + * } + * @endcode + */ + template + UnpackingView entities_with_components(ComponentHandle & ... components) { + auto mask = component_mask(); + return UnpackingView(this, mask, components...); + } + + /** + * Iterate over all *valid* entities (ie. not in the free list). Not fast, + * so should only be used for debugging. + * + * @code + * for (Entity entity : entity_manager.entities_for_debugging()) {} + * + * @return An iterator view over all valid entities. + */ + DebugView entities_for_debugging() { + return DebugView(this); + } + + template + void unpack(Entity::Id id, ComponentHandle &a) { + assert_valid(id); + a = component(id); + } + + /** + * Unpack components directly into pointers. + * + * Components missing from the entity will be set to nullptr. + * + * Useful for fast bulk iterations. + * + * ComponentHandle p; + * ComponentHandle d; + * unpack(e, p, d); + */ + template + void unpack(Entity::Id id, ComponentHandle &a, ComponentHandle & ... args) { + assert_valid(id); + a = component(id); + unpack(id, args ...); + } + + /** + * Destroy all entities and reset the EntityManager. + */ + void reset(); + + // Retrieve the component family for a type. + template + static BaseComponent::Family component_family() { + return Component::type>::family(); + } + + private: + friend class Entity; + template + friend class ComponentHandle; + + + inline void assert_valid(Entity::Id id) const { + assert(id.index() < entity_component_mask_.size() && "Entity::Id ID outside entity vector range"); + assert(entity_version_[id.index()] == id.version() && "Attempt to access Entity via a stale Entity::Id"); + } + + template + C *get_component_ptr(Entity::Id id) { + assert(valid(id)); + BasePool *pool = component_pools_[component_family()]; + assert(pool); + return static_cast(pool->get(id.index())); + } + + template + const C *get_component_ptr(Entity::Id id) const { + assert_valid(id); + BasePool *pool = component_pools_[component_family()]; + assert(pool); + return static_cast(pool->get(id.index())); + } + + ComponentMask component_mask(Entity::Id id) { + assert_valid(id); + return entity_component_mask_.at(id.index()); + } + + template + ComponentMask component_mask() { + ComponentMask mask; + mask.set(component_family()); + return mask; + } + + template + ComponentMask component_mask() { + return component_mask() | component_mask(); + } + + template + ComponentMask component_mask(const ComponentHandle &c) { + return component_mask(); + } + + template + ComponentMask component_mask(const ComponentHandle &c1, const ComponentHandle &... args) { + return component_mask(); + } + + inline void accomodate_entity(uint32_t index) { + if (entity_component_mask_.size() <= index) { + entity_component_mask_.resize(index + 1); + entity_version_.resize(index + 1); + for (BasePool *pool : component_pools_) + if (pool) pool->expand(index + 1); + } + } + + template + Pool *accomodate_component() { + BaseComponent::Family family = component_family(); + if (component_pools_.size() <= family) { + component_pools_.resize(family + 1, nullptr); + } + if (!component_pools_[family]) { + Pool *pool = new Pool(); + pool->expand(index_counter_); + component_pools_[family] = pool; + } + if (component_helpers_.size() <= family) { + component_helpers_.resize(family + 1, nullptr); + } + if (!component_helpers_[family]) { + ComponentHelper *helper = new ComponentHelper(); + component_helpers_[family] = helper; + } + return static_cast*>(component_pools_[family]); + } + + + uint32_t index_counter_ = 0; + + EventManager &event_manager_; + // Each element in component_pools_ corresponds to a Pool for a Component. + // The index into the vector is the Component::family(). + std::vector component_pools_; + // Each element in component_helpers_ corresponds to a ComponentHelper for a Component type. + // The index into the vector is the Component::family(). + std::vector component_helpers_; + // Bitmask of components associated with each entity. Index into the vector is the Entity::Id. + std::vector entity_component_mask_; + // Vector of entity version numbers. Incremented each time an entity is destroyed + std::vector entity_version_; + // List of available entity slots. + std::vector free_list_; +}; + + +template +BaseComponent::Family Component::family() { + static Family family = family_counter_++; + assert(family < entityx::MAX_COMPONENTS); + return family; +} + + +template +ComponentHandle Entity::assign(Args && ... args) { + assert(valid()); + return manager_->assign(id_, std::forward(args) ...); +} + +template +ComponentHandle Entity::assign_from_copy(const C &component) { + assert(valid()); + return manager_->assign(id_, std::forward(component)); +} + +template +ComponentHandle Entity::replace(Args && ... args) { + assert(valid()); + auto handle = component(); + if (handle) { + *(handle.get()) = C(std::forward(args) ...); + } else { + handle = manager_->assign(id_, std::forward(args) ...); + } + return handle; +} + +template +void Entity::remove() { + assert(valid() && has_component()); + manager_->remove(id_); +} + +template +ComponentHandle Entity::component() { + assert(valid()); + return manager_->component(id_); +} + + template +const ComponentHandle Entity::component() const { + assert(valid()); + return const_cast(manager_)->component(id_); +} + +template +std::tuple...> Entity::components() { + assert(valid()); + return manager_->components(id_); +} + +template +std::tuple...> Entity::components() const { + assert(valid()); + return const_cast(manager_)->components(id_); +} + + +template +bool Entity::has_component() const { + assert(valid()); + return manager_->has_component(id_); +} + +template +void Entity::unpack(ComponentHandle &a, ComponentHandle & ... args) { + assert(valid()); + manager_->unpack(id_, a, args ...); +} + +inline bool Entity::valid() const { + return manager_ && manager_->valid(id_); +} + +inline std::ostream &operator << (std::ostream &out, const Entity::Id &id) { + out << "Entity::Id(" << id.index() << "." << id.version() << ")"; + return out; +} + + +inline std::ostream &operator << (std::ostream &out, const Entity &entity) { + out << "Entity(" << entity.id() << ")"; + return out; +} + + +template +inline ComponentHandle::operator bool() const { + return valid(); +} + +template +inline bool ComponentHandle::valid() const { + return manager_ && manager_->valid(id_) && manager_->template has_component(id_); +} + +template +inline C *ComponentHandle::operator -> () { + assert(valid()); + return manager_->template get_component_ptr(id_); +} + +template +inline const C *ComponentHandle::operator -> () const { + assert(valid()); + return manager_->template get_component_ptr(id_); +} + +template +inline C &ComponentHandle::operator * () { + assert(valid()); + return *manager_->template get_component_ptr(id_); +} + +template +inline const C &ComponentHandle::operator * () const { + assert(valid()); + return *manager_->template get_component_ptr(id_); +} + +template +inline C *ComponentHandle::get() { + assert(valid()); + return manager_->template get_component_ptr(id_); +} + +template +inline const C *ComponentHandle::get() const { + assert(valid()); + return manager_->template get_component_ptr(id_); +} + +template +inline void ComponentHandle::remove() { + assert(valid()); + manager_->template remove(id_); +} + +template +inline Entity ComponentHandle::entity() { + assert(valid()); + return manager_->get(id_); +} + + +} // namespace entityx + + +namespace std { +template <> struct hash { + std::size_t operator () (const entityx::Entity &entity) const { + return static_cast(entity.id().index() ^ entity.id().version()); + } +}; + +template <> struct hash { + std::size_t operator () (const entityx::Entity &entity) const { + return static_cast(entity.id().index() ^ entity.id().version()); + } +}; +} + diff --git a/entityx/Event.cc b/entityx/Event.cc new file mode 100644 index 0000000..b719c5d --- /dev/null +++ b/entityx/Event.cc @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2012 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#include "entityx/Event.h" + +namespace entityx { + +BaseEvent::Family BaseEvent::family_counter_ = 0; + +BaseEvent::~BaseEvent() { +} + +EventManager::EventManager() { +} + +EventManager::~EventManager() { +} + +} // namespace entityx diff --git a/entityx/Event.h b/entityx/Event.h new file mode 100644 index 0000000..cb7b3ab --- /dev/null +++ b/entityx/Event.h @@ -0,0 +1,216 @@ +/* + * Copyright (C) 2012 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include "entityx/config.h" +#include "entityx/3rdparty/simplesignal.h" +#include "entityx/help/NonCopyable.h" + + +namespace entityx { + + +/// Used internally by the EventManager. +class BaseEvent { + public: + typedef std::size_t Family; + + virtual ~BaseEvent(); + + protected: + static Family family_counter_; +}; + + +typedef Simple::Signal EventSignal; +typedef std::shared_ptr EventSignalPtr; +typedef std::weak_ptr EventSignalWeakPtr; + + +/** + * Event types should subclass from this. + * + * struct Explosion : public Event { + * Explosion(int damage) : damage(damage) {} + * int damage; + * }; + */ +template +class Event : public BaseEvent { + public: + /// Used internally for registration. + static Family family() { + static Family family = family_counter_++; + return family; + } +}; + + +class BaseReceiver { + public: + virtual ~BaseReceiver() { + for (auto connection : connections_) { + auto &ptr = connection.second.first; + if (!ptr.expired()) { + ptr.lock()->disconnect(connection.second.second); + } + } + } + + // Return number of signals connected to this receiver. + std::size_t connected_signals() const { + std::size_t size = 0; + for (auto connection : connections_) { + if (!connection.second.first.expired()) { + size++; + } + } + return size; + } + + private: + friend class EventManager; + std::unordered_map> connections_; +}; + + +template +class Receiver : public BaseReceiver { + public: + virtual ~Receiver() {} +}; + + +/** + * Handles event subscription and delivery. + * + * Subscriptions are automatically removed when receivers are destroyed.. + */ +class EventManager : entityx::help::NonCopyable { + public: + EventManager(); + virtual ~EventManager(); + + /** + * Subscribe an object to receive events of type E. + * + * Receivers must be subclasses of Receiver and must implement a receive() method accepting the given event type. + * + * eg. + * + * struct ExplosionReceiver : public Receiver { + * void receive(const Explosion &explosion) { + * } + * }; + * + * ExplosionReceiver receiver; + * em.subscribe(receiver); + */ + template + void subscribe(Receiver &receiver) { + void (Receiver::*receive)(const E &) = &Receiver::receive; + auto sig = signal_for(Event::family()); + auto wrapper = EventCallbackWrapper(std::bind(receive, &receiver, std::placeholders::_1)); + auto connection = sig->connect(wrapper); + BaseReceiver &base = receiver; + base.connections_.insert(std::make_pair(Event::family(), std::make_pair(EventSignalWeakPtr(sig), connection))); + } + + /** + * Unsubscribe an object in order to not receive events of type E anymore. + * + * Receivers must have subscribed for event E before unsubscribing from event E. + * + */ + template + void unsubscribe(Receiver &receiver) { + BaseReceiver &base = receiver; + // Assert that it has been subscribed before + assert(base.connections_.find(Event::family()) != base.connections_.end()); + auto pair = base.connections_[Event::family()]; + auto connection = pair.second; + auto &ptr = pair.first; + if (!ptr.expired()) { + ptr.lock()->disconnect(connection); + } + base.connections_.erase(Event::family()); + } + + template + void emit(const E &event) { + auto sig = signal_for(Event::family()); + sig->emit(&event); + } + + /** + * Emit an already constructed event. + */ + template + void emit(std::unique_ptr event) { + auto sig = signal_for(Event::family()); + sig->emit(event.get()); + } + + /** + * Emit an event to receivers. + * + * This method constructs a new event object of type E with the provided arguments, then delivers it to all receivers. + * + * eg. + * + * std::shared_ptr em = new EventManager(); + * em->emit(10); + * + */ + template + void emit(Args && ... args) { + // Using 'E event(std::forward...)' causes VS to fail with an internal error. Hack around it. + E event = E(std::forward(args) ...); + auto sig = signal_for(std::size_t(Event::family())); + sig->emit(&event); + } + + std::size_t connected_receivers() const { + std::size_t size = 0; + for (EventSignalPtr handler : handlers_) { + if (handler) size += handler->size(); + } + return size; + } + + private: + EventSignalPtr &signal_for(std::size_t id) { + if (id >= handlers_.size()) + handlers_.resize(id + 1); + if (!handlers_[id]) + handlers_[id] = std::make_shared(); + return handlers_[id]; + } + + // Functor used as an event signal callback that casts to E. + template + struct EventCallbackWrapper { + explicit EventCallbackWrapper(std::function callback) : callback(callback) {} + void operator()(const void *event) { callback(*(static_cast(event))); } + std::function callback; + }; + + std::vector handlers_; +}; + +} // namespace entityx diff --git a/entityx/Makefile b/entityx/Makefile new file mode 100644 index 0000000..5deb756 --- /dev/null +++ b/entityx/Makefile @@ -0,0 +1,16 @@ +INC = -I.. +FLG = -std=gnu++11 + +FILES = help/Pool.cc \ + help/Timer.cc \ + Event.cc \ + Entity.cc \ + System.cc +all: + g++ $(INC) $(FLG) -c help/Pool.cc -o out/Pool.o + g++ $(INC) $(FLG) -c help/Timer.cc -o out/Timer.o + g++ $(INC) $(FLG) -c Event.cc -o out/Event.o + g++ $(INC) $(FLG) -c Entity.cc -o out/Entity.o + g++ $(INC) $(FLG) -c System.cc -o out/System.o + ar rvs libentityx.a out/*.o +# g++ out/*.o -shared -o ../entityx.so \ No newline at end of file diff --git a/entityx/System.cc b/entityx/System.cc new file mode 100644 index 0000000..8e4b5a9 --- /dev/null +++ b/entityx/System.cc @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2012 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#include "entityx/System.h" + +namespace entityx { + +BaseSystem::Family BaseSystem::family_counter_; + +BaseSystem::~BaseSystem() { +} + +void SystemManager::update_all(TimeDelta dt) { + assert(initialized_ && "SystemManager::configure() not called"); + for (auto &pair : systems_) { + pair.second->update(entity_manager_, event_manager_, dt); + } +} + +void SystemManager::configure() { + for (auto &pair : systems_) { + pair.second->configure(entity_manager_, event_manager_); + } + initialized_ = true; +} + +} // namespace entityx diff --git a/entityx/System.h b/entityx/System.h new file mode 100644 index 0000000..3d2e4b2 --- /dev/null +++ b/entityx/System.h @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2012 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#pragma once + + +#include +#include +#include +#include +#include "entityx/config.h" +#include "entityx/Entity.h" +#include "entityx/Event.h" +#include "entityx/help/NonCopyable.h" + + +namespace entityx { + + +class SystemManager; + + +/** + * Base System class. Generally should not be directly used, instead see System. + */ +class BaseSystem : entityx::help::NonCopyable { + public: + typedef size_t Family; + + virtual ~BaseSystem(); + + /** + * Called once all Systems have been added to the SystemManager. + * + * Typically used to set up event handlers. + */ + virtual void configure(EntityManager &entities, EventManager &events) { + (void)entities; + configure(events); + } + + /** + * Legacy configure(). Called by default implementation of configure(EntityManager&, EventManager&). + */ + virtual void configure(EventManager &events) { (void)events; } + + /** + * Apply System behavior. + * + * Called every game step. + */ + virtual void update(EntityManager &entities, EventManager &events, TimeDelta dt) = 0; + + static Family family_counter_; + + protected: +}; + + +/** + * Use this class when implementing Systems. + * + * struct MovementSystem : public System { + * void update(EntityManager &entities, EventManager &events, TimeDelta dt) { + * // Do stuff to/with entities... + * } + * } + */ +template +class System : public BaseSystem { + public: + virtual ~System() {} + +private: + friend class SystemManager; + + static Family family() { + static Family family = family_counter_++; + return family; + } +}; + + +class SystemManager : entityx::help::NonCopyable { + public: + SystemManager(EntityManager &entity_manager, + EventManager &event_manager) : + entity_manager_(entity_manager), + event_manager_(event_manager) {} + + /** + * Add a System to the SystemManager. + * + * Must be called before Systems can be used. + * + * eg. + * std::shared_ptr movement = entityx::make_shared(); + * system.add(movement); + */ + template + void add(std::shared_ptr system) { + systems_.insert(std::make_pair(S::family(), system)); + } + + /** + * Add a System to the SystemManager. + * + * Must be called before Systems can be used. + * + * eg. + * auto movement = system.add(); + */ + template + std::shared_ptr add(Args && ... args) { + std::shared_ptr s(new S(std::forward(args) ...)); + add(s); + return s; + } + + /** + * Retrieve the registered System instance, if any. + * + * std::shared_ptr collisions = systems.system(); + * + * @return System instance or empty shared_std::shared_ptr. + */ + template + std::shared_ptr system() { + auto it = systems_.find(S::family()); + assert(it != systems_.end()); + return it == systems_.end() + ? std::shared_ptr() + : std::shared_ptr(std::static_pointer_cast(it->second)); + } + + /** + * Call the System::update() method for a registered system. + */ + template + void update(TimeDelta dt) { + assert(initialized_ && "SystemManager::configure() not called"); + std::shared_ptr s = system(); + s->update(entity_manager_, event_manager_, dt); + } + + /** + * Call System::update() on all registered systems. + * + * The order which the registered systems are updated is arbitrary but consistent, + * meaning the order which they will be updated cannot be specified, but that order + * will stay the same as long no systems are added or removed. + * + * If the order in which systems update is important, use SystemManager::update() + * to manually specify the update order. EntityX does not yet support a way of + * specifying priority for update_all(). + */ + void update_all(TimeDelta dt); + + /** + * Configure the system. Call after adding all Systems. + * + * This is typically used to set up event handlers. + */ + void configure(); + + private: + bool initialized_ = false; + EntityManager &entity_manager_; + EventManager &event_manager_; + std::unordered_map> systems_; +}; + +} // namespace entityx diff --git a/entityx/config.h b/entityx/config.h new file mode 100644 index 0000000..b42bbce --- /dev/null +++ b/entityx/config.h @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +namespace entityx { + +static const size_t MAX_COMPONENTS = 64; +typedef unsigned long TimeDelta; + +} // namespace entityx diff --git a/entityx/deps/Dependencies.h b/entityx/deps/Dependencies.h new file mode 100644 index 0000000..88c9f79 --- /dev/null +++ b/entityx/deps/Dependencies.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2013 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ +#pragma once + +#include "entityx/System.h" +#include "entityx/Event.h" +#include "entityx/Entity.h" + +namespace entityx { +namespace deps { + +/** + * An entityx::System for declaring component dependencies. + * + * eg. To declare that a `Physics` component must always be paired with `Position` + * and `Direction` components: + * + * system_manager->add>(); + */ +template +class Dependency : public System>, public Receiver> { +public: + void receive(const ComponentAddedEvent &event) { + assign(event.entity); + } + + void configure(EventManager &events) override { + events.subscribe>(*this); + } + + void update(EntityManager &entities, EventManager &events, TimeDelta dt) override {} + +private: + template + void assign(Entity entity) { + if (!entity.component()) entity.assign(); + } + + template + void assign(Entity entity) { + assign(entity); + assign(entity); + } +}; + +} // namespace deps +} // namespace entityx diff --git a/entityx/entityx.h b/entityx/entityx.h new file mode 100644 index 0000000..fcc187f --- /dev/null +++ b/entityx/entityx.h @@ -0,0 +1,6 @@ +#pragma once + +#include "entityx/config.h" +#include "entityx/Event.h" +#include "entityx/Entity.h" +#include "entityx/System.h" diff --git a/entityx/help/NonCopyable.h b/entityx/help/NonCopyable.h new file mode 100644 index 0000000..19c0ed1 --- /dev/null +++ b/entityx/help/NonCopyable.h @@ -0,0 +1,20 @@ +// Inspired heavily by boost::noncopyable + +#pragma once + +namespace entityx { +namespace help { + +class NonCopyable { +protected: + NonCopyable() = default; + ~NonCopyable() = default; + + + NonCopyable(const NonCopyable&) = delete; + NonCopyable& operator = (const NonCopyable &) = delete; +}; + + +} // namespace help +} // namespace entityx diff --git a/entityx/help/Pool.cc b/entityx/help/Pool.cc new file mode 100644 index 0000000..c710887 --- /dev/null +++ b/entityx/help/Pool.cc @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2012-2014 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#include "entityx/help/Pool.h" + +namespace entityx { + +BasePool::~BasePool() { + for (char *ptr : blocks_) { + delete[] ptr; + } +} + +} // namespace entityx diff --git a/entityx/help/Pool.h b/entityx/help/Pool.h new file mode 100644 index 0000000..f217ec2 --- /dev/null +++ b/entityx/help/Pool.h @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2012-2014 Alec Thomas + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#pragma once + +#include +#include +#include + +namespace entityx { + +/** + * Provides a resizable, semi-contiguous pool of memory for constructing + * objects in. Pointers into the pool will be invalided only when the pool is + * destroyed. + * + * The semi-contiguous nature aims to provide cache-friendly iteration. + * + * Lookups are O(1). + * Appends are amortized O(1). + */ +class BasePool { + public: + explicit BasePool(std::size_t element_size, std::size_t chunk_size = 8192) + : element_size_(element_size), chunk_size_(chunk_size), capacity_(0) {} + virtual ~BasePool(); + + std::size_t size() const { return size_; } + std::size_t capacity() const { return capacity_; } + std::size_t chunks() const { return blocks_.size(); } + + /// Ensure at least n elements will fit in the pool. + inline void expand(std::size_t n) { + if (n >= size_) { + if (n >= capacity_) reserve(n); + size_ = n; + } + } + + inline void reserve(std::size_t n) { + while (capacity_ < n) { + char *chunk = new char[element_size_ * chunk_size_]; + blocks_.push_back(chunk); + capacity_ += chunk_size_; + } + } + + inline void *get(std::size_t n) { + assert(n < size_); + return blocks_[n / chunk_size_] + (n % chunk_size_) * element_size_; + } + + inline const void *get(std::size_t n) const { + assert(n < size_); + return blocks_[n / chunk_size_] + (n % chunk_size_) * element_size_; + } + + virtual void destroy(std::size_t n) = 0; + + protected: + std::vector blocks_; + std::size_t element_size_; + std::size_t chunk_size_; + std::size_t size_ = 0; + std::size_t capacity_; +}; + + +/** + * Implementation of BasePool that provides type-"safe" deconstruction of + * elements in the pool. + */ +template +class Pool : public BasePool { + public: + Pool() : BasePool(sizeof(T), ChunkSize) {} + virtual ~Pool() { + // Component destructors *must* be called by owner. + } + + virtual void destroy(std::size_t n) override { + assert(n < size_); + T *ptr = static_cast(get(n)); + ptr->~T(); + } +}; + +} // namespace entityx diff --git a/entityx/help/Timer.cc b/entityx/help/Timer.cc new file mode 100644 index 0000000..43960a7 --- /dev/null +++ b/entityx/help/Timer.cc @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2013 Antony Woods + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Antony Woods + */ + +#include "entityx/help/Timer.h" + +namespace entityx { +namespace help { + +Timer::Timer() { + _start = std::chrono::system_clock::now(); +} + +Timer::~Timer() { +} + +void Timer::restart() { + _start = std::chrono::system_clock::now(); +} + +double Timer::elapsed() { + return std::chrono::duration(std::chrono::system_clock::now() - _start).count(); +} + +} // namespace help +} // namespace entityx diff --git a/entityx/help/Timer.h b/entityx/help/Timer.h new file mode 100644 index 0000000..4d22b08 --- /dev/null +++ b/entityx/help/Timer.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2013 Antony Woods + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Antony Woods + */ +#pragma once + +#include + +namespace entityx { +namespace help { + +class Timer { +public: + Timer(); + ~Timer(); + + void restart(); + double elapsed(); +private: + std::chrono::time_point _start; +}; + +} // namespace help +} // namespace entityx diff --git a/entityx/libentityx.a b/entityx/libentityx.a new file mode 100644 index 0000000000000000000000000000000000000000..643acc69d0e399960ddfa91424e318573e2e69f7 GIT binary patch literal 435972 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

P77y0xs*~9DaEL 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

olV|ms#%8cwI4; zwdTGO*Lloxm&R|blol=yGce6T_GlN@-2kSw`6m=(SzG3Xbq}-LDZEiJmbGDru>{3cuPM8(*+dX45$X1UwOb&9d9-y6+i%o;@#aNW6*p2x~8 zYnstK4q!$37M8&OwXD+=V_A0_%@fR8AHNnGNFON1vX+@Au|LTycfRTsV_9bz4b2v1 z-;RWWe`>7nD8{k|&KK0v%yQeq@rtpm8AkIAv)n1XQ!$qHAESAeS#Ha=#X*vuXUi;W zPosH`S?0F3*C$8Vy$+X?sI+~{&5E(C zvyJ90X01(8=w(aecEwoMGe+|VU@OYqc7Bu0Jwsf|E5wF_tySXx?Ggdia%4h;HM0LNS(AbBv(gW!AbO zY{0rwF_yL5vBLTjvj*We8P_q2v8;a?&3nvpr|`t%B&7GsENk`SMf1KVu3HpiS))!6 z)(6aTTiUA>V_D@V3hP5=4aBef8-kYMk&3abAB^TBpeo7_!*9?MY{_4El7#e8nPm+< zSv2S3Ke9?}vG_Mdh-<3B{26lEO7fG6u_14DiiG?zv$msO{K;kGI8-r~^{ml+0$@eC z+migK7|YuFREg^^%v#385{+w?Vl3-Qqxmbd#?h}bZ3>@OjAeanG@mld?J;h8nxyB` zGRvB7G@mic-NH{*jAh+sG=F2(ApAjgf&MbEeKR_{-b&b*domuX< zzEg~4jrokZpuS?3d%W01F_tyU zXuf8ad%U<_F_!hd(R{EpaQ?|GcfM*A zV_A(x^DVR7`MOatmi2|ve8;ST_)X?(=d(rko#yKjqxnB(1%3qnsqOG<#n`w;og?A= zi&^e`O;e0z9d0!LW|li&_bJA*J~x{GFw337A!Oum{YUfFVKm<}YY=_~K`7gL&s2vp60fm!a6`Uk~W*4XnT?Ef-rYy2kT$}7gQ&NiAKnKjVKx>qrl^}5mg#H@qyYjYDw z!_Sxae=4)AvyFxlmbM@JVZ~V1M@Cc5te-nmxYh*{S9!T*?P4@bFssU$!apg-vf3|{ za4MKZo|XI?g68lO#aPxp7YS-fX1UjY{-_ws+Vf&zEyb)F#E={vURI1{jk`ox1DHi^ zKDcZh+^QJMTJ2I{EzPWrL6LtG*Rn2FjAaeHOi;@(YqJnGU|pyf%UbDjVf~C*?)o}K zF_yLD6~bDUS?&?GS233Lk)%QNd?sX^%iCOM;c)wyS>#s($GPB(6aD!_l zu9Y>eJ&k4+X1Uwp$%?UYJzzAeGRxf#-&2fb{bV$&G0WW!$6hBXTuoDWl+jc&%iW@$ zQ;dykx$7mI)tMF4Fx8r^ubmZRSw|Sn8lJeGSBzz?a)ZRRrYEj_6k}PJ8qLo=aeb>8 z%i8HiiEAxSTt_IzvhFgPUofj1We~JQTN;CIl8}F)C4ZvPtj(+q!4d=nEyJ4>W8-?( zXx3rY7y|2Mnm%X(F|nPCZQODxIR*hjjQf931<+qRt8J{4M9`*f?_Od;_ZUkKv{&B z%jW9|#aPy`JA}0%vrYwkSxeHm-c*cb_54~`8);nfZ=%|`UQ>)^ZGESpHf9#BQ72hX zD#o&=+$E?@nB^|{cNJq2y1hVD{C}cC=1b<%a;5Zim`D$Y&2UkYY^}fE)gwj z?ca!Q%W})=Hkz%N<@PF{P>f}*_@IO{m|0tfVhG}ztr*LC$!NA_*2Q2YeVYjnNyuAk z3LiI`A7RPvaG!ym5_#(Th@a{Q^PFx__gt4!m3f$iAFPwS#Eo{%;UlurmUlk zrj}V$8p)FXN-;Ktdp{xJ3}=>mto&LrmUYaN!W!XWt@D({Sk`SuGm=?ue`EKjg*8(1 z^@Y)F!z_2}UHVyJZKJHUpA*ft%yO6fV~VjUoc3E`ZO5!_oMm{PVl3+!quHKWtAQn< zK+qPo-1DN_zTC2QF`6Bi<@VW5Q;cQ3U^F{2Yg8zPAg=Mhlel)&xE?T?QOvp*tflcM zmurMJbw)FmSv0#0 zR_JV8>%Sx+kJY%&G@5bDss}5%GFkbuu*NCt45P^~%RQPe@rtlA%E}wfcxI8E4=$U+ z6<-zB_;Q=C8;oWrW}N~`P$HJK|L=vhld_h7O*A_*%iW@y6l3GM+i2>TMXQd<()f#F zEUWT$iE9^T1*rpFYk8DnENh0*Okmcrz$U%Q_Y`AUli!fICNgU>SVy?wW?AkOmWgINO+mmnZ$8NQ>rSKDlUZ)B za?ST7hkVAgSnE7=D>SB#BozmFxHEVJCb>0-rL)|*CiAhW19+0rf3GTh=5 z3Hd-x;Xy{z$Sk*|{Yo)5uExJeIMbN5KjKPSzZVr_S+#!^Rui)}1xx-7K~s34Vl3<5 zM$^o!U{nmV_WM*qYA&~|2aG1itiWD|S>GwfvbOq6!kNx2+KFK;Wgz7hV_7#E%?xG@ z1WQ5*$2I(KqMK1}S&taaOlG+~w7SoQHB(tH8chqce&LL3-rt4QqO5hl5KSwy+;(i7 zVr&Yh8_g_c)j8vOTrrll)|V1j8?(;BZxEj?&2trFSu1`etafH?hq#ihcT>e!*7in| zXI9X+K-ZePNHLc6PowEzmb=Zjel6+gD7UOX8cip&+}39GZ-mvUtX+&|HnRpIU4nq1 zDg3o!Y+S4VLr`7Ja$EI76k}O`GMa8?t>upEpAvF+xn&*st!R3f^*vZgtNy)WEUWW7 zVa;LIO3t`mRE%Z)^8bX@%d9<|tTPp3S^qMcxy*9U6b}5CggjUC^@P#PW7d4cm9+EQ z{99P_ly$Sw%xBghX9`#TkFe$|tHWpxVwT(5oTC_m0^VnuE(?CL7H8 zj3F;2xGZL_!Q8_bYO4}1AuZ-IgSn6~gMvUpnCA`VBF2#48(cP=iUAV#m7cgZG?+^n zLv}T|Y&eq)<}$`?5da`r%+UsO1!Ksn2baZMWiVGUhE@WD%VIt>n7bI0ET3#P+tV~X zJA}?SE-xEs;$LU!CCcbT;y^PAn&pvwvcVE|8#MF{w?K0?G<03VaqS3+?#U&0@O>-# z&;_n*%56`%z-X>z)USlUZA{Y=3NvJjP(|X3V(Pd)0 z7kA}N_5`f#GZW7JjEU|@v{8O*Fb^vtZ^9tQJ*2Q%MbUStf_1q5?R4ERc>!Mx-N=NW@}*@OAUU|#WH2GfV4aJ}lmOg5O` zdoZUM%xfOZ(+2ap2UE75q~{F}W;=s<(}S63FmHJqT6Um>_?`!|ox!~C!5nNbA9&L9u)%!j31^8x zlAez|m`x4l&mPPagZY>-ZaX&DU_S9+E;N|Gc;b4@VE*dCEV+T?>r)Tr5QF*5gL%SW z{^r4Kx1q#E%e58d?s4!&gQ4ZxG|XBXNjS93nua;rU}#abqI_qx(&TvYwZYKRXIeO2 z8%tcY(3ysL!C+{~G7YoTCKAp+JebW4=ARzSM1%R(gE`w^XsIzRJ#QJz|9LRW{Zi6Q zi-u|8Y;Q3C_F!fk3@zKGg>$vR(Bhh$2n``-Ti!4jS|&>i=LdtKC9pKikWD3Dv~-n* zIm}>wVvM`}yk#(D2rez09}TA5gV|v-Ne?Z%q=hrfU})hZ4Re;k(1Jx8=5B+b1%fop zR|Ye{gV}g<+{CrC2h(UU%Xlys8O+ZZ;~rB6Y$0*cbT=){jRr%L+ceBW21AqEigLH@ z{nlV;Dw~GcYD?V2MHAOF%xr_9X=)ngZiAsoX&UBJgP|#C8fM+Ca1$3zO4Itz-UdUH z(lpFj217HZv@-n0U}(abhM71RH*wMQGA*ua4Th#hY2kcfFf@fo!_;goagocO7S~M% zL#}pOII9kkaLA2L!yIHV~1hLWTs(mHW(VB(lFl}44L~h%x*(* z6Bn7_G|bHgLnbc`^S;55sY=6aUn6mm`AG9O?lTzb(rM*fGfcvvZk86;;RZw9BMtLg zgQ2FMhFQH<;-co5hB?b%sQS||Lx)Q^R3&McTMUMZG7a;p!B8=!Vb&ZWaZ&ctF#8z{ zB|Qyufx%FeX_(IphW?X=S#uOUe+g(Vn=DGng?R%*O^Z)`O|0g26S;gPCnG8OFHt zb-Tfg_k^)yJeV;Cv$F?tk-^k?FrOIAE{t)fxr!EryI;f59W^sGs%P5 zh#Cd1T|Jnr!R*EucbYFWn0ik*e>IrhJ(!KC0pgnM!OS<92FAGk%r^{XiYJ`W)R1xQ z;lbQ&FjE=h&ii);v!@3$kvasfy*zOpV=#MrFc%rjJ|4_#2D7gR^PR!$=fPyCgW}rX zgE_%q4)9=>piYb{>%kmiFb8@te=wLv52lQa0j_Bt%*F=O0dKPdEd~Fyorz z2`6tby`FF`HJG^`%!>vy&x82|4Fb64doVK$<{%H|41+n?gZaQ<4)I{tpaBQhp&m?! z!5rqnTw^eYdoblRaN#<_gBfEmM|vsZFP+u@Z4 za~xwv0gXj4a|s)JA!xA0bv$F-Yq|Rx%n2S$m%*Iq!CY=ICwVaM8qCQa%o;TK<2uEI zsWq5WJ(zmmkgQ+9u5!clo zOt-;YD**J7e7K`4)q@!xPRs2J>qVrh*)KTz7inYB89*JmH*Y zFn4<}uNcfd9!v{O8gSj~!F*yc_jxe0Xkvlueh=oa2J?UiGnFPExPIfod}J^WdN7SN zLBaKq2lJu9JnX^jMUxm@k9aUI8_c7Oaj!?sqlpf##~9;oV{aPFcRZpV1Dnx zY%xp1dCh~l&|qHoU^ZxzaNh7>E-{!l8RPCdW7{R1w>;roXE1;8U`FL7oVPug7Yyc) z9?ZcV63#mwOukbv?|LvB&KAs{JecVQ^PUHDvBA9W!Ti@?K46U7{_Ng`o47voVD2-R zj~GL1ddW6FqFciGvj_8l!FGU@)J1FfDT>oWFZ8E6o$k7aq)(^9A#z2lIx(e8m`dzE(O&!ui@0 z&YlMIjR$j?!TiG$*E$DFT>oT@yNz9AFyDIO`pjUy^I$ePMB@5CPh3|T%)b~j%Gu^O zJygQ^H)Gsoc!|OMhcWIpKl(5U=X=J~Bd+9rt$!QL51w$Q94_Jfmoe@%pJXsUdct|Y zV18nZJ72X&NL-ZEw7mzn7)&{1+<6~%q=d7C2lE?)sqnL`Xo0P%pgxV<=G9?WK^Nn9IxFjpDOMjp%u z2D7mTGwF1RYZDLVK7;wC2lK06NjRG_#@)YGJVP*>dBW*5n9V(y_Y7tW4`#xd64#cD zagT9N8_ZUoa0Z_x;SBa*_A;2QJ(zP0W{3y#fWcIGFe{%e>8bW$nhj>C2lJT0)G)^V z+5Tp;0$WsJLR zY;>Vu#(Cm;)?hLo%mEikIO9E-R}E$-59aubC7hi-nEx}FIuGW-OC+3KJebEX70d(= zX6efWGtq;YXE2jIm<=wMaL&MRBhqA}`ITypF`83VbEDB9V8eO_nq^E6mTdJ% z1l7D@H216K@M{F~plXI*D;hdoT%`XR&6yfk?R9eJT-7uf%}2^w`+C8As+tpwW_e{z zy+JSoRr5Ea*;F-4-Xxe>)m&^e+o z)vS7_+@Vt-M4DhUXQ}2{qoETX1oN@coUfWC?~*(BsAdzRxllC|jpicN9A-3h4ukN| zHyS#1K{O8<&1I_j+-R;)&49ZFOXnwuw4>3`X$hj~HX3@{T{H*WBmbp0*+n|(Uit5x zs(ILG=#B3s%Cgz9lc!`SO+gdnOVIBdOj+4L6V7+4u_3Q~pI`~oQa%-39|6X$IT6gB zPR!F0%wA5+*AdL#PR#WCZF+19Pgf14a6c!j>;cOn%>GWy$Oz^DC+5xwChNqE_)R#j z1D%-PM=(uJOxuIuaGIT%8zY#U6I1t4IGpKD%xw|O3@7G-hr{8_bYhlxB#dcsV%B&x zjA?aZo{C`FoS6E@!r`<#G2ccoc_-${$HU=tI5D+PgfX2?OsisS%RD=w`AtIeiE5~2 z9^(x8$|u9IAM3=e81(F3u@JZtv*L1samB zjj%}bKtl8Th$h>JBQRRxDf~QwS?ZZ3%J`&=jk5dfIx?G`k)M-onm2D)HrvtJT~(XS zw)Et>vTeEUZk95=9yCadZt7_7%=R|6Wp-^ClC2t+t&0ZX4*|R^2S7m;3ZbE=CYx=W z(V{`3B++PWhNuNKWc8oBHuQ|lHZDVv+uldmj)>GG;sqM;jLn?*R)D}h~9o5-v_sqtw zTywUwr>kyP6D9sLBj4CoH@>%iLNAwoY9cb3%*0TOL4XrGnr3A?JK9>B=4Yxi87U1q zg@xMIqKUF9mdhavoX5<#c$f>n({H_pg)AuetP+36i!nbx5FT6ArOS=DvT2r=kxyE^Z;h60$7L=0=mH|OSsLvetH z_vX5~(F?<{SWrkw{jLq!s-coLlM`;jNM|OQiIHQ_qdC{nZf(OI#`o$d%n=gi*sdHb zYBTHO&AVupv%m_*HN=(kfK@$2QaCQx-P6@EU(;A9XKB1>*G=Xvl~*8lsXS-?+-OuZ z>ZDdO9I97sHnAo!qN%a7u?dYlT!d-hVHkc|nnMw|+fFQs;muO+rSgW($n~Uh(vmo` ziJM^-$qe-@TSu{!RafVztG492sV`@nbJOO`n9-7-QA}A>Rg1$#LwV_CQdL8vct;-b zXWJXQXBEz;sZvt~4zp4-GuPHxRkdqJer!kQd>UG#?Yp6;wwFiBy4Hrqy4Fl4YMm0d zqm~_mbBtco4L>1VQapUyVY8`YPQItEzz`Ve4>bHQ{K2C$;un;hWRw}ki0aT7v1pRr z)H^L))S=oy7K$1BsT<306h6F7G-ZxEC>L$mKY0hMU8p`ZOP9lnp0?l^irsukH z`KDYQBChF~-A@TibA{R(6bPD7m8%Jb zIL7isY6MBOP0V>aM6XvLs*3%SvDSv}4AY1C5GA47m4qOQVuOe$5vGYeqO4{aE__uL zrblyUwlvLzHq^$%n@_@r08YlfICQlQd~QcqWH3X4I8!qOlO+t94tTVpFz4JO-!wDV zGz-(49*oW5q*G~Y9;sSu;)tLu<51fIB4yXmGaO^<+{UivI;}nHo@92LlAY{s)>Mzu zu9LoL)E%$MwYT(;BkFdDGIUEL%w&3F-ISVNB*VjCnc#Q?BWx%KlP9#6nC76gOyeHe zIj4Ij=F3g9Fp@;9pQ}<6LwF>q(Gfhw$r(WnacWC$Zr#LbRXpm~W8onv)gXoOlCbqz z-56;i0U_v297%mgN1OJ+VbgMOr9#CR>gPV*&|DsKh#+~vs!KjsSMOx1{b(491&liU zV)mVxHhBWgPKIZ*`Hrr3teeo1Nh4MYU@~E+VX(sXGKj{-C?Vd?&T#4{^jo;iF<;Bt zOlOH0I~Z*r#noHX?Q?PbwzqJcetuf~X^k^2zBGI^{NnmdvMm?Ki?`*pNlR5V_fOkC zX<;zdYeAvN9%cjA1G+|Zg(FHT8N$stFZZ-0eaxbgZMMX~})Z_Ler-@Qjgy2(24hLLdQ|8&h&IrizSQ2ZoO5WS`nzS`m+I>d4~>(wwHAy4E^c z3czEoDNSu?s|^@_%&qC2+3B4_vfZ6cZMyJ5W5V=KS{%!mnn7=D7#1qhM9blUACJD< z8k?}_gw=v<|7l(m9@b-6Zp_cf*_sTOU_rLSc882j zXs9wB18Y!mV;>q~0@r*2C*v^vv3XLVF6f+22c;KUV5lKyC*&B2)e8HA&alkXJa7t& za4dZRjg9ZRi2AWUYHUO!qg!^QaDp^lbo2dda}=Cs8e zm?v6`jmHqOged`*ysT4`$3~;Du`1fcrnDTVNn8+fTS`0*(`!elpvfm!BpicI( zAgoc@m5qG1v97*ZqBN#f!u$8O`$P{g23g7+|A2W_ax= z{F+GAIgA^`D49Adt&CMAOj}jhv?UB{;G#PmeT|Z)q%n6BqmQmi2Gl|xw~Iqbr|o9R zq*sTM9&yB7!I*WBz+>>_wZL?w*nGQ#DZUKc`~@lxcaVk4Cf*peJ^9NbPK)L}QfCRM z%>KjmHA43mq3%Ys_w;2>fbKdGnL26V?YhvWOe0V!S;u<|&W3@mT#P?j zz=h6aM(8|={Jy|lM;n2|$)0Iqilp|WpJu4Y%TS5LZZbnsG8uLUwA@kKNKmx4Xx1yHSU*Mq5e8H#268IY#x4O z9@_OydwojVsUDfNm}w2(F@~e7oy{{@Z_PNKH1{HL@vZA2J85PLB^fvjTVdNYB-9>@ zvrU+qCd>-$tX>ea(n_V&YV1LcK4yt5sUcd&>lidync2dxKSU=WDIGgH521Zu5ig(` zT{JocNtrnm>yS8o|HQ!VOsta{Pw-GAI6Uzv!f|njOSUmQrH4x$08{+*(hDIapi&DY zC76CKoU}L`1(ldA6k9L}Vxl0bvtB1O5diz7-c2TnZPjFYJG$^TO~|b-a!pEH;NgLR zYv^gr+gHPM!C)^eCDE1)ygB9FQIwlasPOV!%5l?N@B=w?N8iJUD!iUUM{Z#KNj$LNK}FGy_E5jCCDRlb=U@<8*ltfS9-%tJV={)W zg}YK-V1r7yg~w_eDJ#bBFXY$;Lu+e%%`)bS7wbwFnrUF6D_q9N$B3jezi?goupb|3 zWpU$$rXHR_7g^>78o1b?OsIXQ_vs>IEL6)8r=cFjANcg@HBZ0*+DBiuh>f$Mx7b2H z>jK4@{#GVtYVo%+QIMrAM&JoeT4~gH4Hzx$jpaSgY0q`wBfB;`(}F^YiR3kHyiE%$ z+?K;4`6#8x*TSIdO?Dh?fpGaZcuwk_hHYqgV08^w*;(0)L8W0qP zuT#gI`dIgjxX01j#{sBh^@xSWyn;4Yr0 z_SK!F$AspbwZs`|?AeZ_?G{0!h^M7-*SH5My&>_83vcmH%A&94X3xQ)Y|$Qs=30ek zqs`6OCf?mKoyN{$T!TUbHJPdKNWG|5f5JP4ip)xZg`LQ=H3~92)^3FFr^3P;Ev}^x z#N{-HMP{o|4awOK)~?o(?~3=mS|?A*ro7IvkbFp+f@sZE53!R3yQztmY0U&;sJ+Lp z#4Uik=O2vm{(QzR^)&39ZP+R3i{bU!eyR^@0-?T63)0niiXFUphz%PUnE7>yRPVyy zmdU%o8&v+Wnzxq#MRo%3Scdm`5q~iyDzWD-rE8R4Wd43aSsq!i$U+XoWVD&UK~D8) z`cjVllG4z+D>jm$+ta42zP#jkKN zgYep0+~Il8AE_GF+%nyq;*{kRoM2N%M4nvGAcs?9^EkDT{HSbOM@MI$*5+D@^QNL3 zC+T6}^cI|ViWJb%!gS8-B6R1{miV#J2%FUsjvCczKMgkgT6er@!PbYzII>;w#@A2L z#}0H@co9Y3Ee)+5^iw`OkIa(G2oz`k`;KhCUG8JhcdHVfTj|Ewzeq%*B*u}6WDOF> z02jTTr7vURf}|_@_~C!2ygbXQ|65)U>N@mVa9zlsfbH~%~E zc^&^dRTptLqOJzkN^8`5q&w;ptCJ>EP}3+<7_>i68O%z3~gUSv9ouysC^TZI^vy^ zx23-5y`zSn-0Vf`?Sy;DVjeJ^6NmpDBbS&$(mp%a5|&smoLyYyWk*~#u zo}op*%rt&^GwfMNSEQ3yq_FcU|Jv986&%@?Er$8d2v#nnPo3%&DLb6 z!U+jJN#ojFov<@x0gCt*h<}X@X9csp2tN``fAH;n(o3@w5P@eg5on^ zMua?KHj!96&Q0skC$ud?=%wPc82l^8awcbV!qk`Pnm-nrMiyM3#-lRFIfbRqX!{{4 zc+8JyHyPLy+O`@k{_t>v+DHz2{E9^|0!6((j6k9Bt- zse59A(b35x?}A#0w8yFGmcLkw*WMml%*7;^ofh899V(Gx1Iy6co^S@DV=~S7LOxSp z!Y$6F3K_H{N9R;Vi!q$wm^Yth z0SlOZvDe|%aqf1L=HNVnVon8(Y#iW8VEEx4yQTgIbMXKci^&t~OIu#TF99#6p`aGq z8t_y!)FZiEUB?HeRl0u^zz#k=^^S%nvi5yA4{xM>R2F&#gg0y@M}?$+!P5dA40tG@ zp#w!;i^J@iu@9@UsmXqxkIv4ew=pxkzJ~Xj+Ub3GJgBRmfTu?ExF|Z0!Z_2|+&ZVb zr|)LB1wGZjkA>!AqqAfRB7>Z~0)qp6(RF>3wQyH1cBgi1dKcR2k4_t1QR_?a#jU|b z?JHu{TIAyn$?3*>XH=O5rmi()Df-uy6KfXk!y)eK z>tS4IaZx>{n(y8#>L zPs?G^g}@jvrr{BIm}buYjyoKoW5DHbt;p86v=P=fbwvP}1BcERr>zaagm}RZT8U;M z9A0S$ri-}@C$uIlp``^Jol^HbfmKzxeD|C#d^Rigaldfsn%6Y(0z67R{BqI)#2Y$E zK3SWQLUN=;7~zySK=weP5KNz^z|3by=jUge8+#gyc(f7?f~Ref5ZD!oIw`a|S~t0V z{4{*zEQkx`2d4%*z0sBUi>dfpGJU;-K2cgkIzrMf*w9n?fwp`6YKn{s~Z{nrmPcG_~dR_ zHb;^Jo-;w22n$WF)N?gLkv1&;s#;tdNTa3TJTWZ3%%%EJ{_tCo+ zq;pc6E4^la0eX3NTWLc9w^1+LT;Ta=!%l=$Z)Ze&;tD{M_8UH z;p|XZFp3nGGXsmQcB3UgHS8||?A5^_3o3UutYYb}I*|Z%XcI3z6 zB|SQK*X=hsab_O5fZtJ)k~rufyiT5*nVsI%*q+1WG_@1E1fpZ5qy5ni`)owtkw$zlJ$gw78LychQ^wn@c`rYIJHLNAyoSPR9%>f+V zo9pVPl}CTXNLf8?s)#LSkvXHodZX#Fi4LZ^Nh4q}g{J1o?oc!{wJ;0D$#cSR2`A%B zTMQ{Cr)k_`@|wymBDbmB)cm>`XbflzwbE>3b+1h<)>K9`HFh>O(b>hZhL%R4lk{7f zLlLF7vshHt+35>+C`}uJ%q8PYOYTT~eikP@XOZMs@3d_vmdfgCKFhf!*G;wo(}HPp zX3Q|pU&2ikmP6rMDaRwm}zd*t~8VAzY+ zgXQdaR;VU4-?cR;XBR3c=Q!N9mPEOR4hztSc-CDi@~G@^U$CQURb*dk)1P$_;(h*>i3I+NwSNFvL%GijlnEjrNISq>9zNyL~y` zhe*DcG(h(m{w%R1x#tV}|N5Igo_X%hruGbBCH#}ZViQD8LDi^DSxH~%&vw(gJyEzvR zySREuwx8m7Nk`GebDt|{+eC43`@`_111XC172Ak?@uqQ-@f6q3-0i+NuB+Xr&x@wE z+vJ(O?fdbpCfmfwzh}6RZ7B2K2JN@)cY&s;u^ZY(YPz6^akvz zprA)b4O2>r7P*lsB^}9H3~kCSU<^x%r?@(G3@S}+cty4t!PHp37GV!s3^uObp2dx3n-*zoZ*V5VoIY%_j)(QX}3? z;a5}mb3Hg)AZlI^Pyeh$%Lf%hsUQcv)U80g;iC%&7GNfjY(%98N1y%1=J{+_ZaVMb zkB1q4^itZE=g4=STk=?Rn;r|ip$F#1Y(nRg%0fHO>C8cFd&hfN`Dk_YQ-Ydvjs%6= z-y&R+V~c8V#YXM;usdzFh_u7>_r-nB>oasF zc5GP@Ikr#vN_q5;dd7^YpHh|Zdr+Cf?5E4jvRY~?{mT?op?G!Oxi}L!uRT<};T4+V z9;f-M*8fnlhy|SS@#`UEWEd@!N6GMtcjL$`q=D@Vm%PC%_Si zYlL_25yNXb_DKf4{Di$zL+Dk|XbSpnxOn*>!*6m#vJ@ZU>9IR6qL?qJhr!mB4IZea ztVLvMr#H5@v?U(?pbxngljz8CoMY))jNswTwWSV46ndSiwT_l5`t-srmolAAOWy_x z=QePQt%E|J3BZW@ z-5EJsGieD;4Z&f*>EmnRge0?@B*liCz~y&#hvF9}Fa$W}WQF={@!{*6($NgZyhLYs z##0WUMLMUxz>4r#eRRhtNBt`78vE!a`?k)&u=Ym|Z;gDP(&g}`rN}=e2{KZ0LHh$P zsnGpFl~e)#pcbGqQUWfuVp45})?bkokrq%91)oMOqM*~LB^PWWAUqhN7Ctnkh1_PH9=rC7T5`-KE5pV#cle=d@GSekTXB z#3OUG0JB3O2q`6bC50N8wD4j?pr!uhoCMi#c86OCyHH_MZ=I8&hecFvbKNCxQanmgSRL?)nLWYwu_ua*h zESAj4;~c$NaT5S4s&NE8pQ(7?~XOYavv_TJSUvr%L1<2{h$XTNSrdLt!_f zpK6qkwNKCHJ96`ya-BUm3#Xsz06pI>uwkhX<9#NJ2ceVs+Yh0th?vj*seM!V_=aEV znz6cIJaF_=v>3a1IWaz9KpU-y&>Io)&jQ%aA77p;& zOGhXT6+GqQP-wQD-GQOpYAe(MG2)&i6wy=4g}J7Jz5rX)w9? zk%5s;BXleWrDs3-Z3DX)Rj?HL_+bMo4m^6ol9gwxn{^9IHuRR*4;GpZ*@kgNgAmh- z?I_hr(@INxj#WWgY{R0UW63N&Q{(k9g4&mq;?Dr$t0VCMbfGO_68Vewpf zsY3EGZ4oZMi|%@i5zm5)N7wiE4gTu<)27nmmLIF>rq z2@>HBs4gUAm>-m~2vD2yP$cqI8GeQoTL=&nW;QPH6AV7p4+$`@s$(+) z9zXHQS0w2;4GtfvL+Z)Pfl0ytBljubQgXkt(W3T|sA%o;F_aif6JZpaIRC5r*l9bKzH4Zl zqVY84bWZ16tZ*;J&k!B)9o&!a4JgCEuhFU zDCBGhLwKueO*j5ojUr<$G!w!Sdc3?5@`&U_W8qFS!gGv>)o=}N=mOzYfFetxK*N`% zgiO?Cd7dm48Ec_hk2ojwsEVj#qTc)j49tD>uZ!3u9eblPJMiW@I)Ff zMdZ42`KDYQ%_`k*a-6gPxerGyQOB@ehF zZ5Yo_!qbyzgy{o+;KYbi6C2r+ZhCr9fs@>yQ;(Qw85%P!;r0`oVh8C-@qkNlc?t&B z_jD$zAdxO0-QVp$tJ*mLXvgC_U#bwDKY4TkyDyi() zj(m4d*BpHQxPJ-`Z$_mp>mUNBS?!;Q%~>ecKG%`Y+?&a?PM(tWyb2WS@rrv&e;a~##Lli8oV4^WPucNsi{ds z;-HViblSC37jMR?Hf=FgP{ebfI;uy`i>xR3w-`(5 zaHx4%IzbHuHl%bL3UAd05MMArLr61!RfxN=`GaRlC*sJKBs{Q=FXILNBpqboc&D?7 zqjcggM+afHx46Ufp3PG=tht50tw@u+EKP36?%+eYu@xN}9B~45zNf2$mKd{b9UYy0 za?o0e^U#u;Wa(k*bbKMM&3wKcC(UO2yxLh@B4U=8mb4Q7pV>=>PoO%TKdR?`8l?CL zg7{nt<3oIWbj`T>DG83lOAvB=de={pCEjlit#R~I6rM+o?&S`OxBq=ow)<&rY0$sp zJEi+FZuwn98f7sCO(ctvSfD8B$=ae$Tk_G%|4z9DPKk4w_J;&q&OyoVslVaY>|4tP~+?J%vf;Hc?8Igan3ibrU8a|7FZ?N)X5^Rto z`(2gYHPFGvR}Hn>m}HE`QdM+tD)d6T!`E=V@`$LhNZQ%h)zgB3c3}>$j)fT547^1! zCqH8jK1q#(HaQveEz4|YOK(Tt9&36BdOS?WS1BATLVYOB&bHW*9{L;r=UnpCBeA58 zdX*LR-Qv}WYG7}RPUT+Iehz8@aR;@~l3zTj$jx5#o>REq6H70p&zKfuuuYw${O=gW z#PpT+L8dLQiKS}~tQr(?#}N}eF@BQ*n9KOZPFNJ9#ak=+p;cpb>euW;%SaSc_@m|Z zt-Q!J9K#=3V%PHtOaST2>UeR4UJ2^c^v7$DXp@T5AR(z(MCOTCpFizhM9lG(ahL*( zPF$w#*vj6R&-Qd+4%XGZF!S!P$4CdVADAQ^82Y~oYz;V45qkPUw#hM~F3{}VdCrX^ z62}}YFbU@KQt{71mH1hA+Qv#Bc2Bkk(`D&|qPZBP`&9n)3Y@HvV3{GY<4AVQTNeN? zn&UJ|Gvn`5Y@udflbs5uCivtQZF!1kk)IRC?GjmvBEHq+UlYWc;A~goOYZ5L1iVkf zX*R|yHBmnhGq|*;>ji@2bCT#|-Z2|llWpkC=B9P%Q|y)@^ul{uECrtO@CzZy$r^h2 z;#g~!?`^u)wHHfrur&hDr!ufTbi#VFD#F7R+GM<$w#q5Q!3Y+cBoHObr)Y{zZ!Bh* zl%a=Ttyq*pPsrG|_4JdmrEZMLO-Cn>;tOg`;x<-xBRPlfP-cp?^6l-h#c52w*(u_E z`+W#7LuS`u@K7i;#s>~pU&1cVZHpNf?(?DMXa|+7@!$HA5FT5q$g0yCc5HA7AF^l$ z%Gi*Aak4dKwcI)0)6w^iF(ep|<4bmFRHuiw&vRa^Wgt*E7eohEQPm3?EF17EYtZxG7C- z(M7xIo!RM~L$ckSO>M*RK`?gI&?7R_JL!Woc$twu^-PZoW3L4{ouAeezlEnHI_ct} zga&sMe=QD_Y{uTV#-=9hd5OIFo8dLW&iUDPdUYR9-Rmddi5YrrLvl`sv8u7TbxwCr z-_3Okdh?KMic`!6n=HlXES@$^Neq_qiWFY2L>EuIO2lJHoi5w;#a6|po3YnA#4d+c z2Ky34achZ5yNnS*YnG2Ar8b0vaj1e}2+@|P#87ltEOwmbu@GEFv4HWu9x}98v%<>& zGxB7|=FkJpR1dX)tzASNIof6E%|YtSSd{Rrv5)Ta8oPY|o4R~rGYzdQ@JDp|?A}Fs zSxuIE1<$g2u_Mm-9PUmQUxVpO8|N8C;Pb}15n`Zc`pMQ@tig)9%+m^(t#AhVtwqvn z=(K?_KDLBfe{8WbZFDKn^ur5!Be^}MJ(LVBl&U8csrM3B955JQyL?IF<|F8Ehlo~!>n7KapEfy+M!CWh!0vr?zkK5iJjv|nq~l-c zQ_w}ECpM-dTk>jpDY0;R6K+h6O)tM%5fl==WWFE?a|P#00gXM2V^!;aW<6_M;%m^0 zsYI~ugJY{&x;r~uU!_?rl_W_@JKlEjB#Ax-P~;0wi>qzRyq~@#!L#c47!5Pz+)k6` z5EYtk>$w&DNCY3w;Hh(T1W${zFKylLpcT0ZI!N?5%=eLK-X5Gt^g@`WVIEHn2ulo( zwW@xt7<8WoJynV;2QAV+b%H-`j-j%TGIRq*CPN<~pOeezSQ1=?Cc0q%H5M*J;`SGY3P|)HL|lM*OZ&vf>+FR2VU9W9vuF* zQFfou)Y443P?fxFA3V|QrI3mPrU#4AIoPI-_RcK21=`e*EWUso%W_INou`<@w z)6$#EcE-wNB5jGpsnRp~13Oq0rD=SoergNH7pkX;^b7{4Beu6Rr9$Yzcswk;29cl9 zmdn&TLPUcPLi7M>&s`#1@|7BUnr6B}ro9-UkmFEl$U}oA@5ZhfQn(XqVJ|wma$2Bd zs&IxYmN@BMj)|>wOa{gzKAF`Xx7yAnS}YJzqrh7_S`cP98U#DuEFbVg4xTYnPr=ab zx@D`}ai8a~ZmLXgZEvO5MPp%;*Me_6_0YGgD2M_OO+|Q?>awqRS-%^W)`VI-y66aS zmX@TrP}mIAU{L~S)6WDFHb#>D!nHdg}nFt{?pco28P)}PHhDxEBvSy!+j#YN$un;8?)yOf8v~Gf` z)REJsB6cf54Zi1CH9}H279JCJ8*p%#8PKkTa4i%?7~DmRop6e$Ow~42h=_G}TcI}b zg(y62DJgLg>sfR(v`kh~G`y~so}08!XC`VdC;%_TU)*U_Z-J+gJng|t@ziZ9FK#>v zmxjz^OD}j{2zA$RYU-SI>_($Q!vxey|B80`q6n_~brVB%s#Y&%dPX!gb~ZM_KF7_P z2dA}{7AP&xwETa2?*nD&Rn>{!N;RR0Ed(qvC^|)GH9+Xxd+XLe4BDOUn^5WMPTAER z@*v^M?W$Ydw^DuUQgy4+37}|@MNbonipV%DMU6fe@@CXw9MmjV2p}*j;~&Ns-vVVE zo-a?bTr4L#d6;G1Z=e5vzx#c+zI&_2@Fi9K)%o_>XP@za^7M9%gxFCFK-AlV#B{q@Pl% z>o6lTX)uMT>gXw3Y(b=DCCR+?C97XFalhjrNEvHJxD zlP(aWA{2~N^E5lUCmB(YA4HTprGtlx5W^&=;qE=(S~`zZ#nG}r_Cic1 zCbaA8iPr|~g_Z*BFnZY?DRMap66}I1)Lc;T+k))epjR+3XM;2m+v6Vx|7Y6lI%jxR zbYZV1H3{fV)eUq*LRj*fYpkm=0qg3r$z03BfWMU{vh0fx@0X=1$j|SL}nz zHqBIT_g!=p3(nP%$U_%hT89eRa;SoId%4{yr(Crmc|lg#0CK&E=s4$90-G2~q?_!-th zgD4?Tkq}KeYS!t92Gvbd1V%-u;exb7yvs`6Qy8fXr6N_&kKn)%lA6f@gchtPc+MgM zTCubu?BlLbEy9-#$O)WUqYPP7YnPrswWb-e28xdH!9XojL35xE)FOu3?yGFegvDTU zW>K}smd{|YxiY9?)G>*(j^(~Jtj!`E!`+-#mEy4~f+N+;O|Rmkg(57ROvOZtBC|IO zO`pcr;LgvxRCd);`EeM7zVFPcc)d2+>wlyb1|)41Us|AoJ=XI)G^p95o3Ci>ssh<1 zk~}p~6KjCzRTVA&L_cbRVb!zKEXUz~4^oJhcJ&UmSvjH019c{R1bzsc4 z#Q`+@uv=PH#h@yYOUn3Q2p1j8BdZQ?>qOkniWp-E^}-^(u-lFi{86DD$HoVUR6? zaWE;I{p7``eID)8JVV^!;0eEZt1EhQ_=W1~>f`rp##iawCEZjkgH-@r)LDbXi}?*4`J?j9fX+S>)_9{?X|7B$*AT^`oCsHW8c|c)!??TAfH}Y%_(v>{s%ihi7dwHa+uc}` z7lB6+MMfRg=9Bz{*@=4{w<$02KJEc?NccnDa=Uh_>+Q}mwbHoIT7#oTUA(2aNJWmG zWmX~HO6^~c!b_6)f=Fll#y5>XbU1P?H!ZNUL8^{Q8FohGywy26obD?wD;wbyq!IT9 zGNC0t&WkV5sHVfn*e)85>uU{M5l9E-Nn`8coTw(VHIU@?kzqE1N4ybU1UM zc&QZfGq_unG)RRwv$E9C4F(m?P(Q#RTO76&k5v)eYY7XUat0}umo#KqS@UC61T)rS z>cWD!gyK^xx6*ZeIdSwyOk69NR(uatVOmzbbs|ABYnwUSr94?9{u;%`N^k(i%8ntC zoc=`7eo9ak!6@BkXU%g#xkAdL{x(B9UG4xuDjAV_^+!@)$PDtdFcd#z$3T=8#hJl% z5v0x1JX-yw0bGezZtNyV&(V}Rd0f{acYqNh0`RgBi>u1haoW3vKgeuMKbP}jA$B?} z!n5jT>+7UiV=)QJ=W1>CT^~8kf(Nhrh6Hfi;xKjJvcMr%lZ+#VT1`=)s%HOcU&|g~ ztBq?d?-8TCXq<{zsJ09ffNd7^-tsh$d{qbn`3*B8FSl)gTuil8c?F^~>gRAo=w!0^ zqNbndDew1~$QqG*hf%bwIwBski`FSlD(-oQSNpQEY-r<}r-fo#VwLPB_?3f9eE~6? zFCM#Ax@-Unv>@e_V(LozUS=gym4`RDXtr%1;0VcT@CB-BqA0bgWr9kaD=N3 zQsIO%%!=@gLpj}m1;%J(q#%r(D2@rjpLY;p;2vo?m2?~DVCuwfe-_@myHm1R@xkw3 z#8=P2xOv2iX+~=X|2rN zvAF?}27&o;$-o@K0aWtd^a0xgT*E33rgxbL)f}eSKdWvQnQL#aFR}Z@P*Ge>5sHal z7x%uw_T^g2FgVcx!K1@(7fDl1XNc`m-PK#(PJvX2(I>W`EHh=1 za3io1c~;Ss?$yQmfT_)8N<;~$=9VerNF+I2YVz!($h!vSQKr!inj{^}KxtdQFl!sa zChzf(iqM{521=(#+yfL^N-2&LE@-tCo=A;KX?FSPDB`4~>c-VLqEkdukElMdomfsB zniy=))e)37zp-@1aR80R9q^$%)IJnL%5UOotcmlZktA6<i>RFN>U?ZA&j#3xJb_@3-!lHl;va` z6FKs0A~5G1dtj^2!yjdKtKmFQehBVOpctG)iiVk?o4DvS8^l#+TJ6qOmtD?9NwjNG z9BGONv8HI|tp#@CjxaZBe_043MONhSJomXY$jf~~UtA%DS7)}f(OhmpK$gy$MYWTK zxEI+m6NXBKEDPXPMpwA7_}pU1I8mCRrWQv`yGtr|m6{iOhmjhmxSF^*t+0x5K9 z@_pGjnPnag`gArbc!%^SGarGd6mTzas!3p?czM?8F48D@d9nu9ydnZdZn z)rp~a@E9Zo9u}GfscO+64!JoMQ*^yPqmFJ);Xp&}nTA@XtSp!b6pc(5>K)rC*`uIy zNwnVtFGLA7H({5v~^&2?Q^6QedkgtoP(V86SGTcYxzS{76TwWH8_o7o6FO!Q1^G5` z3(h)+QIH%kxV@RgE-1u=0zYT1wogHx<)=ui;#IkacohJbMP!qV;Aig%H5BnDr%;oQMw66B9$BTKu_^?KnsUR?)?hgV zi47vdgw*McuBRQkIi?2LX%>4UPN^r z?&&mOg+5E~MG)m00ckiCF}+7a1kKJyMoy$AxtY5-Rz{yArUyDrV&MG194#KpVjorZ z_~`I5W*80OJgP9psZ*7g9s;%*)8R3C^hPwhL4vdc7N__s?k~5~j(wE~NN!x;z}*~1 z!(}uc;(FO>DL3yJjV7tl#??4)P;MDi znX0mwr=Ceo5!ECs0p|LU5}-5Dj)FU@Qn-h2 z6UEas#_?bak<~$MW_;cEU^U;S+MBPIyG(;@48FUyWhSt33^jG&n{hz*VBTChsY~7s z&N0kFRdokGhwSwegPWg&?MAt>(vT@h&x!zRV6AbATcl^MS^ z4#!r(%lQUgoU9_v(tIWa@C}LebS+iNqSf~(3!5ABD1q|SiJ!Zd$x}^8B16751US3> z60C5oiKAWGqjYDx_jTYQ(Oy}X+UbI^N`kqbR(NFaOOBJ3jr9vj_k3$p8s(=4vE3$u zJ@VMr?S8%r(ZTfKijY;I@e!0!Nlk5vv`Vzk46cgsB|>RNpG%DFkx3O7=jW@2q8{;9 z`JOTdxGDmT<_bixJA=TaTPgZoA_0z!vJTUPn@aV3Vv3(#l3;2woZYUw(YKXwS~VMQ zy(}0q5E9hIX4r|x^YvS(BR)*@6d!^l1hC{HD54z9)goy)iXbLXM^drH$BJ&L2x$R~ z83^@;V1`x-=aGfsYm)S>z9SblSm~{IHgSV81r0;sfXz*2UCm|i*+i&NhEk5K6xIM+ ztJgSb==`D|Rd&wbJ^!H!IaFaiY`%4?v1TC50WOOGudKk~ad{aboj2E4XhT?p(uTw( zWfU;b5@bbaxgCaiiH@r@q|(d^X6c$9MkuB;RZ-|9i8OeUqwB(lvY@eqyDV(eg&~w8 zD-@OC3YsQ$OpQetY;yb9IZ|(K*XygNPAB|U0u&PzA%{@BY63GXpC`&>VirBMezF0? z+!}6)s-n=Xm!%$G2J|5VQK93Xkl)y4Sv%02rEf)X-c*++CyQ@L7H^TtqdiKTY(CgC zN##~S6Q50cE|3ofwIux{ZU4JfxC(dBw_EKlA~|)s8`$r%X#G*0LOQ1%R0OkK>?k`jTbwcHA4ciN1ytqPp2Nu4exCyW=;em6M~Kv8 zE4t3@5~YUyBw|uwVWzXW`mxhXYY;Mx=n^ZPWTjJ1HakmeN*{}jMt!A2UiENgs?&Wt z6dYns^6}V;{x7Mfd$(h)?Jnyc^zR;>E)iOLHZBy5u3TBpCRe8CR0XF9Xix-Zm*#9> zg+4_PgIgxzC`e-qCY^y5`x-&m=g0^k@Ss$tPEi@EZ@h|Vt%9MO#RE5X)p4Qd$;Bje zarS9aPC)Pz7ep3>DnQzWR+zL@x+;^)trg*{kkCN@2`e+w=HJjg6^&h1fEL>X(pYz6 zofJgL+WLB@FI%xzHZ_roKsfwjb(P6De5KWHtfAtY&5dqry*(WD*lrXotId@-p1wSdGGt{8&!U35BgHu>c3?lul6A!gp$TMC_%M`#Zb7nI z#$x9>r1hgfNLP%}&JWv;d0L#S$^1I54D770wU+LySFyFobl{SIPqAZ?_Fz+Gvaug- zQ!$eEU{mEZz#ML)ImD^v1A~ib$@9~fz8q#$#@IT7IYWbhg*qkP=*{_(%vOQ z5K5>S7U!9s;lv)*GwgDksKKH)SG&!@t?m7SQbX)%0%bG8x-w<+4c!+uv~cQUj;dUR zp95YOfxS1~=i`Q+PKDJD$F?OA`9I7d+36Qvp4J z%q~elg<-+hXYjJL?v9V0YFjQ@}_wBT{*ZcDjOWpKi zkRs@VQSn_YUp7KNgRZmI|3&sJuPj{IO|NFKewGtWm|ADdqKo1RmZ7RQhFherY85K1 zt+pK3!`A8SQsKJ#&9`QDh)Wm2>ZC^nPjplSrt)P-Wy#7})77(($S;EKWDAx<`9ACo zt4W$_y1gUpcqe`o&CIbp+C$s_p5)3V##Dh6bU_PD{@kJHmRznnp}|6O6~BVMV2lQ# zkaJi>HWnbMQH9|Ru6?Co>~*N*A(}w269IBSLq=eUo+?=8rlCTXWUjl@IL)QMO#|~@ zU=k&@WP(jvql1X=Yq;^VuS1Dc@r2?W*z(D6i!`bVGf{T>LiHU~MYZ@jtkQG^>D+@2 zybB2Y+h`}V4$-QPZHyH*V@M5_RTXWV^+ycsm)3BDOz>PgL|C1S;_7GFkvHwqP3ful z0%SFaRkO)`wy|{2z1Um!HKysd8?M;E@wbdQG6=+)Y#s_&ZX0mrX|q9wiL_P2$EPdK_t<^0JnK|UFyB(TV=WkHr8<@Se~q;(f(Ow@e3D(2~~bsoMn|o@J2- zj;vH*C+2Jsu+v-3v(+PAy&7(VM6aq~%rHk2ACn?`oHlUz+cV5|Z3lLWT~z=)6wcjS z-R4DpmuUrDVi;Qx;aVyP~Z^AC6tK(y@!**+9~C&ja+z-Z(1{Y<-52&F%Q#1CI<~vHZ7c?{BpY38TYL3`KAU-&DR~;!X#*`# zSCh`E)Z~DW!1dX<#VYNzG;bzZ91Vs6=*_rPrIy}-7NM$Q$c8Y7K?v+~ZCIF{-6G$% zsFJaVc&Jw^;+umlK~)5OQs`2HiDS4l%QX>QpJJ+fq;FGYES!rsGgD<1+TveKbz~Qz zhoFV(Y;B$|XqBlML9MnC^GR&u-9=`|h05v{vt+;rS8E!JTryn52HE5g>@(A>B8RQV zJR6l~23?A(&>$EPU8+j)!F(N7VO-QGB2<-PcJijwKg*iMq%FlYes0a@Hdq?a#LQ~Q7({^-Ks`RAqv=jr!ZtL zc@y)kvz6JS>uY42hFj;`+v~W{9FF9$*C;2IDfQ)8bEUC`BLFn)&D(bS3gUK(Do9#o zVPn0!?%kmnCQO`!n+;gA8<5dh1kM78Rp-uT`{kp}b`k6!Po>gqZ*FZglZ{sUoM7U` zVN-2o4s9`raE~^IJijRiB7z?J?stV`2XvMBIGS&@@A0SF&PPh6Cw^6lKutMC@s?2E z(~z(YJ3mx{VB;9rAu7;n|Ttw?P0?G*}pzB0{Q0xFRC> z-9W;F`7hjj_LK>U@dZ^2;yq*CXgAKmQEa`_++a+uo}rd}2ddhrc6>b|&ZmM|N{3=bx6It>yccRyoET*Bd6oT|m1vn0t`6+fBy}Ot3A%K@--4-5pjw zF-G$gd-yUfZ_s0IKHH~YUxOold9GjRu~np~o>l8-#HJqul9_&n7|ojCV{m~&+pyrk zsco~@Xf+#m0O!KkMI`5%T_`z(#T|saK^J3IsnGF>^>$HRD9NTn&m&cwsEGL^ePG~* z&2QnW*C(N@-@?i*64=zjNowl&>DT&bShV+S{9T&>b_>viP47L#?#kDD6te4hdhh*< zue|Dhq4>o==MeICjw^_vv|u{@;6X)QZEX6@s|wfKxPr`jHKWI>psukf{(v!1PKHYL zGpcqHlSEU=mOUvB#9Mt25U90yq#DYjXE1Uq#Z5>Vlq9#z-*(fHd8j0|&L(qYJ|wjb zQ(Uh%J$LfK)e!c0p+n(I9XZWsIP`|2o_bHTLxxlY)h;b%&LRvxDPeiYA-i0y4V7M)7#CB zO_(vbpbkn+^@*coF2lAYNp$E!nSwc4a}%vN)gcmuYo zXSdFs<5nfs@QD>zsWvt#atVnQ{k2mCVPr3K*4v;1PTrgMWUII6cF{c%cI69cJ_o>! zt=rs|N?e)kb3YHnALS4f95l5}NGt9rW8#Edy4k&Sb3K+}k9&|vGWg}c_RWT_9=S8KhL2PIx!0Dfg9n?(W0z)9O#$|tVfS!upT;Q6M(HprlHb9RD;#r zZRC||){R0U=`mtoDNRF*E}IJuEhC@cSY9uIY>7GwVxZ}Dp*WFKjgg~^%8DjLE?62_ zG{82vyV>kwlZX2-ut#4^?mgdHI*(Lm98$-GvXFk37Ln{Z$WewBa_{^DpJ^|hZ!X;f*Q72E0^O=mPpEoN)zIxBDBaF3xEw8ByBb&3xQYl^(!rpd zS`i$DMN!*miu=G=UvmYuJz$jtVQnpHO+;!)F-D?KQbwcbtAS}w!_{hlNpLv`K=!I` z)aKN2gr&|+zivS>DQ1~B54qc6rSdpxsN;j;gGIV8J*Z~0H!U+X-fwR;?`57TxHPuD zfL)B;;+kT&g=C*s8{Tlzne>EYg)OYFud!8&=JMp(Cd53ai4DGymUp6wTf6MeF|<^4 zS6(o;;z{Hi43P6&Nk4~2TizB@(WCe|j&LrkU3BJNDh7%UeOz=!jceoJ};~(}S249s# zSfwMD9D+fdrU>h&z~r&La@1rfC(BN_$My#N+uz=hXi338nU;f`@~Oh<$_|{*pGYwoZS~HJR8~V7KW=7-5yST zQ9stUxqU$dEjI%M8M0l*UhlD+CaHn+AK*K%K^1n=jZTMzLr<8NqEEp^Qx9Vi#m2GG zO{m}nvNE!#XFS?$nkfSOQ9acgY8=x%q@xN<@V-&GRG~#DnLQ$0ON3@IN@e;yrVd49 z+Msgg)Nu@0+PWdsjM==Vh9;X1x=^%q*W7Rst)A4ozgeAsFfzUT5JgMuNz#IelGKP?LSXIxBuP$vgS3!$eI zp<{QZM5(VX9AC15r6}9`XlrVvaiO*59saOE64F0`v8`kI@RboXuBODa!?8(sqXEU$ z9A*%j$cRd?I!CICzJiglR>q8@o9?Zq(c+X8P)I0%Ny1uV2?{i5Gm^&E#W_(j)3^8- zES<$fpnisWFeYumG6KtWqkXO^dnQI`6hnZ2I}FBHwq$kvOwMwnMgAT#u_3_*<$f#y zIKpuEWWA=FmbrW3mjT+G{&l3pAU>fk(4ZNG(==p9q1bb~P#3@ixU}qnRgRdiDH^9` z&n?>qkwLdb0&guY@Wv>LY>;-|(CLVCHF`R#Tpf^(Y6qPWL7cZ^qC7+OU&aw1LzJQ6 zV_7pabS!J`hV>BPV2DQeL}Y}^#n3tDk13zP;z;l8mf~>K2-4hYs9L*u(bel4s^cE) zIx?~b!n*U66=CC2{0s6a$yWTu%sVni-v|o@jVVH2F02l3mdmR(zk-{f)p~{rAkj@g zNLX&l9SZJ#vxk%x@3us*=dmkKs$Ua;QR6I>^M%GbXb%HDzo zB=7viqY(jP&|Tmz7#NK9l3@xA#YFYp|>NeD!58? z_+>d_iR(7bL3_uPcfNhW5LOcz!OC6Aj3y2p;|DZfSeLLJ_Z0+DO^oI62R#gw2`TY! zD|y}hprS#HbDK4qt51J%`f#4Gy?zf)gGt1<7Dl>GB%lt8SKkf-ER|6`TY*J$ZzFaB zLZ@h_)j4r!5%pcA<^VT>$|}XwO^SuN8NJL{0EedQhqYeJ6PwHc5tG)Ip^@saM2{)!t%9M1lG}scB7P`)7O6j! zkE%f?M}9S`PBpB}KnRu4?buT;rS3hpNqO2Kj4EH7gmLV+eZpw7wN-S?^==zCtKSw@ ze|q3ti{bX=47nCEn;G=$Osn15>N0ObN`j~4IoFbrd?Q*5OdSG)GJhp6N_7FuLsXQ^ zb~bQjHA1_32jP+W#PmCr3aMOhHcG+j>ah4!#+XjS)6s?Bdd4E{$UzY$KVl52D|MO1c-e+j2UqJ#57+P>5$7WG%kXAl5)Uk0{WBOrUOA~EuYqa zPQ@t>BGz%&2O_YI#R;Ng3;>U5xb5284Yk)RY^Nu-c~*nkmgz-q?`F_ZNyINEIB>uM zvdG9iw%GOhjM6`y!p6#8J28HsQejRF-gZv$qJnnTs1LuhS|J8Gb$$W0)d%Q(5M}p1 z3u=$G)WeaLxO9(y_+%VSh#W2y-Ar4~;P&6)>V@Ac+}msx^Z7K%pkgQDS%nP{iB( zUIEq)OGL4T&%L+JOj`*9C;rAo1SYvAZxuV5+)NS6pvlk5eepAFuRT^oCTVQ)J1v}t z6|GXstqLAeQ^!=E3Xx4L&*XwOSLa*It;XLhMVNuT>B2U{mNcrE*8X-0dO9UY>J3sZ z0Vs$dC^!TO4`z3Xp8)ahCMkoU6vjT(v@1cPs`-nVJVNYcJG*E=D!W%1APNdhlaEtXF#CdjmqUW`1hHUj8kR~EpE454dxPuk2`;EaHb zZO}{D)=T(mNT=&;6S9i>!Sp}Xyk`poznjlpg+%sqxT@?55eDPU>=GPZw@fzNqX z-5K}sd7rV=UcGJ!CkyBbcP}a~=Qxgqxlj2zgORl3QEAA~J1RHsk&9hr$fFpInop^M z)2>*n)KVE8=~$04+xFNQ88#L%BX<(oa}vsQ|L_n8$6jkvtTZ~wneE=!X(CSj%DOe? zxdNiurYLaIv}0uhH|=)Mw>IVZOS%C%yFkMuk*&5)G&$5H$k}OAVKQZRMev!jJdnxY zl9a+tSBpqm|V_`STpf%-i+)>Z#L7iYw573)2jXS=LXX{MU8=Db-;gZgLSj?@X6mjB>KhsoRv9Nr z*w~%>K$tlYeE5i$z~9%k+uKFLg7%b=DU<&Klk{y5RXam0f4w6+g)w9c<|#YkU82^| zIm0jzEP;G+>&H$ntzq+Q-2J`MNme@LWV5rhHjM~>_ck_`nIrg0hfGUwI>~M zL5ma%LE!GCus*o!Bk?(R$5jvsf#4;BE6nq6Hgp^X)hFesF|6*Oa*LNq8Q+hIrFwq5 z*C6yGprk9eXqCkpG*29(n#>y)<{_3}u9LN4)8-$&?45SgLP=0fytgDMTk@DQXlQdg4J@x%Xa}i<2`FOFsW`3NYM z8<@1U8*&bM0cGo6*d1wWvD@Fgd+-#yh!{vFd!7Tf41W$&zO-u9L3AY5^pHco6}ED%sVHgB4(P zVr_Z>rtFP&(p|?MY-4kfbr0}k(1Ge}mZTPj;u}KtK!6HE93kEmSW$Phdk<~VLxlwP zV45X}>!sXlp_bMtgmcys>g0-8Kg;w3t`dMxS&C4^v`|KyWXBE{IIbaqn!&R;;uiB# z1c0MCqEU(+|4w_mmfQ}ZMqjxVGo1JM5^;(QcQvJJFcA}+@fG`!gA~oNLAWpa3r5#8gIhdG4!n>EaEc<|{+lQ_IWr?YTa zeU?O9Sq$U!Gk1OiZ%D7bE9Ag50_Rh8@E!`&=XZsVYMOARR)miThbP-KoIkIxe3l|*aG&bK%C}MW|M(bon zSSQb82pIkvPdiXUF6#$(HnGiNE^N*l!%;3OiICs=A%rR^BtCy}IcbRZVxe@F1gw** zc@|0veeXA^Nw~9%h;hvxO9$umuI8Uj%@bSQ=EW?Lc|Ai5wkb84E>l3HGt3Z@U161+ zbCVg7>!`jK(J~#vzE1SD8^)LAoN&1&A^mc-e|SxI-4~AI#0;}`(cjZy zt!gZJLHo@L=kN!UklBI@7_+v*x|m10Fk&H>%It~WlUFM~6{xi*C<-=YJ} zsNC3t*A8hSyLxs$nZYkobnHj^*0E#8<4$^-@}4mbiFfQ0oxa68YnIixN`>vRwqX$` zWRCD8Blc(twf&57N9J{=5lSGFCVw<%WmvYze6|PMGAmHnh$J_3G9Yx<7Gv}mBW9Qi zy;-)n#117xk`z;=$$rnNalm2#eZwhNIHmDX+iEv9?n_q0P0({NFy0OvMZy9bmY9wE z&NiVaq6`Q%aTewRW>yi)KP1F>q3b+z#Mp|Rwo3;R?9q+5cw`=8Z`gMpY{;*Ui8J4& z2%OED1lQ6C&WGIJ_V-U{rP6F~Zf!J^jle~xW{V4VU<7ACPq-nAw6HLd#}|l56Fhfn;pVfa zOlY(#1)s(7uehl?S;vi34LZ2P6?HU){rl;Rqc3MoCm%+H+?dN%3ZvH(V}u{h!p+RJ zLN^jQneT+K5V{ZrwD#EI*F5nt0Xtp19uth z4oP$wKt_kB-5T3`-%mG5uwAt)5)rd0a=WeKRl?@Tby9O!YwP}sRQTRS4|>cHW`tn(UA(}4dT%F|9hy=$J<0VX zN#1n&b`{J--+@z^sk5MOM>m=XBZmuH5d#j*8HKNwIlPEC5zP^SBfN@=DUND-?&R%9 z=I4&FLe$Jo~1+gHXHXG0!`qs1>9JE zD@C!e4stR7>7cEgP$9J~77Gt)xje1^nUAEkgF~b(Qk1m?)xU(UI~h zH5N4@NHzlhBq9wv(t!fy5)8~MD;|84CuPLEK0u75Z@UBJpy72 zKa?4UCS~>3BJPjM-bN;U^3n;@&)d6YO3=q|nd+|`YgWY+B|VNdbQElimzamYj)L7M zp~3YV9cHbh_&a4C#T4!{%yiK-TTWtga-j7jJ#43aYo6H9*=vINcKUXjDLGFX*&0VK zrlDZy1{($hPAf84=cEt6UdNs?y5GRYW?Vj54RI5#n9bf5CTAcs?_Bq%M2}O_eR*li zf}kBK%?A0WueCtc1|y(&pBxap<0cOBntr6sLUx75k_7*STMKbE?PKf>rnksz>0erh zxhI6W)6zM7)Dx#Chc`WO`si9ig5GUcHE*yxrs>&hC)TfBQOH@#+^$dnp^UL^VUd`< z*%WuiSS?m1XLjvOLe%Zd0%kAN$(`!FUg^_3Y7EeGnw!P|{nS1#s>DS9^aae6Z=m0# zF5T(co8c^&Z=LDzG<*MSNukX)FMZe~su)O(Z7wK<_2!QzGf zie&q~HU*3Qh*0U$er^Ty*V{)CNQZ*P@ix>5 z(z;hesd{oS6aV)PJ;#J9a(K%t%bAL<;PMK^g4Ke zssL;{pURzc=j=SG_e$H(d`ain84sfDw(4;_fwt=Ncp`gSvC*7!DA_Y0JadzC7cV9- zde~gYi3l!fNw&*uc4?iyGZTmg=2OA<;L*)>I@`iZ2}GuAlG12X@p@_(prR&(8FkJa zbjV6%tHQdq!zU9_p>%Zss#``Gq8f?|fV1mjMMkTGV-i;SKryZuB5kapsfl`w)>x~j?;@;5clAD^0dpyGC=cvt zutFqD7cVx>wzeze{IS_emev~ZL{qWbrTvKsNshD`z$g;M_JuIUs8|_mpB_@1EoTjG zvza3*4s1-*dR%dxxPgc>P}~5LuwhJdY-`Q-x$gO-xv{an0ZigE%$NA*vyEltHv@9k*0wnW4RsB{ z>}BZ-t6PVhDz;l2U4%0yXpHHZ*7_#%Fs{uZQW>-53w>Z7GxWi_CV^i8l$5SwN~c5X zH;jv?Qk$t&%H`Tjd3+rI@&hG$zJ5)q^l|pKZ{!gC zp1bUw|2j5ODn0pvQtAEQ%K!c*{4-uE-+hSuA`H0D>)}%Q(L-l9H_dPR%s<5YI|**X zMtA_<%2b%~0N>#oYDNNHL3-&%z+LfDo(^(L<5!pOzM)c?0MhOb();Kl)W5pXYc@lBMcOng-C2LU(k!qv(%CLERf>rT1UemB&r7QPz+_Xyx# zE%1%vZ${r_)xy_7`qO}WgMhn2!cE!rCHl^z@H<`lrtNYG?wx>Jap7hrChd3#bE)*>9^8c0&_qNH za3A#GY7-TsT-Gjt`$Z3K(i&Jq-#Y>KQ4emaVs^+l;64Pn-}2z5Yg10Sj{xpb4{m0{ zY(Q$dF96Pbc>B%P%nqS;`7+@Cv%sguLA5+JZDgkU9(ZA?^p|eA)yk~d&Q$I}z?l!9 z9~0KV+7Ezo5UyrT5E=(FfP2C#cd~4jOK@)h+}{g08uy2g0sk&IES{;I95Q zyx=k5rpr8u{bv0OxI-2k_)B%lqL1}2;LPXn)eNp?(nt0E5a8woK5AzHH*NMCmHTiI z-?UZkIN%-$!&&2n%KakX?)J)^o|(co`HbP^D=t3br`74%X$gdXXTU(823%L*1M4p_ zzFVCsTX0A(qp?3P;E3OfctA7Zj!#qhu$9t+>;($ zrD~3Q;zL)zxK#Q_0msJy>N`=j<~hNg2He;+yaWw5F)_`P*l#NLgMh0FI91V;A9Zsob{%?z0};>_ipcD1Kgjw zaFgXJx7;TI_eBq`GHs3n!gugnOQpZ@;HondvQYd>aCZXkYYyC*OaJ#T5ZGOx#M|XF z2QJt5f9*w|xcbr`vxEnpyc!9YOPA`;(7*WOz{q2GyM(uAK1W#|cyj*}AAk1QXMgO` z7yb03?|QU529Qg~4(=nMeFvZT-|^|IFR{}eM%w2-`4G!|-K7&xU9La%nG*4_~yYz`CK8@V|_iH#Fe5XtbBVHbObe~8KmT5tR39u*yuK(mxKt&$L z5Ak+ZD?yD}w3)8yd5GiQcj*LLlfR3+m#HDp8&9F}d8I^4*fmA2haP(N*^!d`Fw~0AQ zeFHc>MQC(?L%er21I5W*`+amMbn!S&|-E5=Vv*)8dv!Zh)dp;)r zNjlrv^M%?rOJDX|zj3pEIp%i1boM((UuDwS%-)_B4?2}SU%zy+wMzE;vFznx8>`3J zJkLk$;6LE!%F=uA``6gphw%G9;b*M$h;jFo6qy;`M})f??b#!56dXn!?UqQ7Z59V>kY zey_2&dG$v4ZenTlMtbJ46773#WN+V(->+qFG|p*3A7hlifxS_Vo{CyouqqoWwxZoYKSU?WlUYS-s7vw|Vt;n|eE?-p;7EJJj2o z+1sI&)>;#9^!)R)rP8?(evY!V#M9*O=QEbaS9;RCluEA@DI;j*QM7&NnFb8?1cPA! zcO!*niB5SRQmDQ<d`^=3oF6mmQd2pAeiqa!r-Ih}Y>Z@=W_`aPulA|N!L zzYusxyc!*0T$fO=N7jN>4k^!9r5{9fA47`9bCfaqQt7*p8l&f&m+Rd~`8x~GFMBDU zLJI9|CoZ2?fgn&!FZ@;Mn{Na z>UNf8T~aVI*WZei11uNGhZ0u5P0}F5b3jq}HjzU7B1YjqDi~ST+RGUlwiAlw`U?dk za~=6ko{M<#=*Thr_9^^#3P$F7DRnO%Hr_^F$o~+(W&RH+7@6zEG)VEh7(b&U)HHs7 z{jh?Oxt zYk4l>ioC9G6Dc%{WA*w=1tW9a_)3n47(s0GKB8b`uIYn37fsg~h3``^GS^>=6q+!x z+5LmGu;95y)$4af3QdO55t96PeF;jwO@0skRVuwq<@$(7q5h5W!|x^W2hX>wTt6>T zXjsQ6d?77!c)mmBx+qd;SdWenAJC7a@UIk%Y>gvKh%J?9SaTjVqO!?czo1}bu4hEb zILpOaQst7oV4Q?BJlEof(4&HN0aB=)bjtq_cxZ@>j)=nYaJfIqfR$R2iFM(j=8nOBkUlK4kq`+KD2=J8g6T|aU0*2(z7|r{r5In@IV|d;pU}%pMgZa9EA-OgN z^L8Q@&m?|gF#jZArcz+uNEN~}jh`5v-xDx2a$+zyQKj+B;wJ|4a{}gdDKIalhQafF z_=(|ppMYU9Ok_M?O^t`=_4tY5c|gE?e+tas378*9fjLE;K;QAh=hNFn3N8FR<)=jo zi4;8LKZulZmGUPdhx=0~@cm?djjv^@jiPQLl zJv`Sr0aGfC3q0>oDH8LqS}Cv=TV7k(7Fa0Pf5CUgTMshRGg!RJFeSKLp-(rd^w=&u zDlr+8i6TvZsy+=jdAvJ`QyLfg2LR-KY*ja(=Y?I2b}@3C!eW(3x6-6bo|qj!v+Fx_ zZfPlLUR-K+x=EKDR!y>{Yg4i1y0y#gEez}46N#{#blSO^+|Gg&@{3c7r5j^bAa7mh zta-IiU)gml#TM<2r$H9xO`Jg%28T5soAz{vM}BP}#H7)wuu@G#)Wf2#4W+?PH!>bg zPGKq_N+2S)%PEa+8)$7OP}}9Eh-BNWFMyWS;gzncMgy2ne^qfX1>5B`#$9^Zwp+tz z0Np40&T6%YPgf=n%O2d4oFa`LJGFQdLZ{ljR#?;7(>%?IC{xYS{e}=<#a*SUa;hbb zt&6xwqYSTE6iiZ$WumC+lu9c4qnRa=xrF&bV7gEaWmpL zbj*o3jK&i#N8{-A-IwId`si{};O@WwejT7#zYSUJZJtk7HX0Y2MT@>B-d^Ib35!A4 zj|gm|7>qc|*TG?w#6?ECq#X;t4m!2O4?qglqLCJWhgdvkq(dx_ua844Fe(fiG?=V? zp%~sC5{Qiw$@_7j!zwHk50e5_JuMhp#TO>wc|&Rd-Khj*s|t~5eZ`ERxR7koP*^ki ztYF|`oY!-FT8O>ra0F(vF$Z4ZkkC9-0=!PfSRJVFY}C%2mIX}_CO|_my4ans%ywGM zrRKe@%_eSEXydM+t)(tG>cZ(4H$vb>&ZTZ^yP0&Dqpt4hdECWC%DVH+%NUoj(oUkj zaC@ue0#@NG>;l4HzI_f6=@tUua2)o)>0Tvrg_aqJ@CkhhPh;a8m5S6UTo|$r&t|ou zV++Pm^tw9(kZE_GNHR(y@EK!ZDY;@nSa zO9xz-VuZseXIMQI+gOVUrUvdHlqP%PfD08hMcM%>4u&*Laea5-ByAY|87z2c16d7K zrKuQ3o&8dEg$vu%YtB{@?ip2F+Xd|L-&!e|`6s>y`Y zxXiL>5=t%6e5H2c$Q{Yi+fFRpcCvo*^di?W>A^csfkT)1oyf`B`qDi~XML@;bYHlb zAUVDXCf9U*!<1mH$tSU)neSIeW}_IS8fzFOeZ!Pskv2e0_puZSEP`b$Y&#JWS>4{Bg|Tyzwi$%u4~%qWwEJ4FvBG zxN2d2ea#4ZK3)+~&!=Z)ymLG1d8Jyb&WzJTQO~)v<dFgN<>N)vSo(A0GfPFW_i@04+8EV1wQgRX82}>QzibUhx`;DA$(WUU)(#H!Br-N2P;p%4*z@^a90U9 z@?>OiRV&CWi?+Alaf9Y?GgiTb=3oeJV$y;mPx%_)zRRVrRwj2>^&G?7Jm9W#>8nka z6%bzN^FyI>Co2{l#RT{;;BFN7RQpX%3Qt;&mFRmUgm20UUd+nEJKyb$ZH|4=imtA~s2i##F&bp0&@O=z$w|a0hUb#;Kjv|oLqw70kjX%Oi zQTN~C!P(LN3GPn7o%i8p%2a@O2=4uW+i>Bk<*M6ne+am@`*2>r?ZevfZV#?fbKChw zz&+%^v8c5(mri`;a{VhjMl@b1tTICJs-V7?>Q9<~Jn_|6KUjZK#^6Qh>aRWUj<1y{ zsPxxllw1A%!TJ*vNS6{s!0C5Ay7j0igvSj2IJFIrO8pfH)UUq5rlL+7a zz^C@TSw!&_5t1*LfDMt7MZ9kvtr}^UWo+(P1Y;3N+KtqF#h@ZJbDCL{auEEv$M%&h zdR0W{GNQXtIuPOfQqllV!5yPv#R5KeLqgtwfN_ z*GHsbS}(0g!+SXTE=3!2>zbvFuuSQEIiduI+BQph*PG?#h!RY(%2fSwL?wnert|GE z(sh>lJ#UqVH1Q+>f6tOEk;ruQ3)2io}317Ws!-WvsM_-#^UW z?!s>x31g*o_M6_`i8pG6vC{kToBkSOkxcm;ZCxp{4v$ewk+^t_+Hv+qz5FWnM)dJF z!bQC}#!BLEgyja7R>5!Dyp5G8>JY^$8^eD*j?);6CreTkk6TMIkoZ@E<@k=UH=6P9 zWN-WM`)&BSlI`w(guUSxi}rpc<4A93Y2)~PGk(Uf^OtYmg12|zhsSKiMh;(zzLP9% z9KRt9BaPmu2K?Wym8)2R0Rjd&Q32CFes%p(^w^%&1_P`yzMGoJQp_4ZozMv^A~ zN_!OkMgfZW8_9$G?MC%RF`F za#5RVG9?{S)1YIX{)Wg!WQ~qc`}?{6tAdebJtb1;pV5))@LQIk-{!)(hJ z`e$^6t#EkbkIes<3P$GoF2UAR71Vfmi2KCiY`#{($Xtse<)tjwIDY$M{(TBY=K6h+LTx@e!qzUl@kh4& zGYUrLdaW3+#1&)lLst}x%=NP(h1RTC#LV9oFf@-ix8bzVZ{jx0phzT9{YFQA2fxMi z66yU#x)hm>f4Bt@PhdQAM7O8`#_m<4zpuoP8{t&K{jI1MNwl#@m;WGOXw4iQxdXpt z4@fMf(z61FR-9Or#_y&Hfrn!A#UcaVCSb->VD1$#uV65=>gf7Q%IMBEdalJ!tgM&O zRKxR1{KR0E1Pt-&7|hQJ7>W!StNR}a7#>lSBn_YDZ=y+zM?@6Gn-4Q9U}zPH(erKr z^Qsh>KNB#oPJ#KVfO$;{%&Uln;JF?@F?!|&%xhC%-X>rUrNI2IfVm+B<{t!1IR&Q5 zwg?n=SdQf5B84~rA3@6^h2}d?d51_TmBvNNPpK4w!9m+{!-~>KDR$gOAS?Zj%0+lS zkH4fbBCIK-CDpm^GmYXIP92YBd66Ttu8(DwQu~>8i>#t5WZZwhsFls*}@|vgGR2wuS#nh_?V(RtT z6mZx*bsPxwVC%P0Yt#r? zhMFq=MTu*(M|vJA4~qp+2e^O`1xaW42MDN(X$f4XvR5tPKZ(pY{2^ z|2fs{)n^?cQ%E05GZ@1(BgnoalQH3RGZnyS!iaOR3C?UxME%YU&TvdjIhjtzte&-+ zZ-{41xR}qRQJ6FBLJY`&?w6};CS)S(x3Lu?GLd1OQq0IoPhtLHhGgV+T1PP@1H^2S z7-KTQF)ng5CnvvaSSu~wx7lr8(4Gtx;m0sj4f`=vE7jS_aeBy)p-SrE z(!o%k_`<8fA+{1x(JSir|Gi&JO`7xH7EQ-HF4 z=*9g6Z1aD1o_c2pu40)ZGyCv0zQ}aG!VKCZ_4AMLl#l z@S#w-wb^L}gcrg`_Ti7a_$Gb0&jRkRUAQURuAdIaz8ord+A=d{rzl?o+>-(yojkDm zR>~8m-7TF)y`0X|#R-jS7mTMGlI1gwm&1U&%7d$wD-sC*Qho0R+?WS9S)MT9sQoTd zxyHlko3;%5$MOBWfcq{F-^`3z4{8^(UpF6)Z+6D)IHKTF_&5f*8wEZ(m1X`3)tcp>K=joBw=Cf3bDudeHm~c@!+N{ z`}%z#=o(l~d`!TR^$jm~ddloK!uN96FMQp@H{;p4p9b7Mst_JlU!rfKY}JGCy%%sV z^x!HJHI|eABDhZh?ivrSYI$-I+%tf?)`OdEin$;BIx{YGsS@Qn_Q8#HT&D$`pN*553O=?kyf%ZNjbZy8w6IgPZiq zeFShD9^BN_q%0KwQn^n7?(H7jwB;y8aO6|+ZVzs@Y|cx9TL#=iF5G0fOyA@~?;ir( z&pL31&G=K?FXH2rg?lMH74=g1wCkk+Jh#Ispv*liUi4cfct5=SGsh0@r?X}JyN?*l zXZ9UL)k{y{r^GxX4y3zZ%xm`wIA6f+f*dx4qrue=Ja+Zv>g6+ExqRz>`h9BO<-7J@ zy7S=vOY;Z!G1rD?|NMa`4`>WQ2aTV5u=(_x-*T6*@J9t|yaEqA+Jm&ZMjRq-|K)Et zNz*j_*#l4R*I9!!{W6;7_e&#}?|Mc!hwT4t;)1NzM9MYrE*RPRS3mNO1J6ENDs8<~ z1E7h29z4SWrsgL&d?R-9#BZbX$cF*%LOkRKkgayB+k((}e{(q*|DNv|zm|VJ(P%f$ zH8)=OI)pM`X`O>~dEKkV+w0x&B?Jp^E?*0N$1M`LU&z5rC&;DdatUont|3odK68Ng z2kMSadggPF?Kk`>n0JNnU5NQpgwrqAnTN)K%ca@J;BzAUO>9`^*22cPNWWYX0|*Vk z(v^RTXxbS*0Hlx2V?hrXK`+7LJK7a3AQ4j~xid|$+)Iz)E1XKu{^oa0l}ML#9o|o% zrf&xtbid`hLroa0i>R}nHKL9ZH}G)pmTa_$F++8YKD4gOhX$K`)Y(d9#`2>E{_xig>AJ})r$3A)F_nDRaI6l1#KQBa^ z{51YmaH!iA5Aw=US-*;(Ujhsh-DMq4YFa*v@Bb0s$qGv0XzA}yAo;KHop7n|cVzcP zA=a<*37?WIZQgG_hFjKiAv>Mdm~@`bo{w4I%JLSo=c6@HwMz~komZRra`=N>Yvy}P zb~?#&QqlRQ?D_ibKZqx~yc5~W8#nXiptIk8=y$wW?Q&c8`dRsM%p-{Nx;=%z5~W?j z&y~y$l|+EC(oOiy-&%Nk6Z_gxZ(Df#3H*$e-hc-gw?0z#Gqd8{T-{`|-x}z87yi@2}wP4q&;m^lNzg zDTePeD(w&P_I{T3XLvi!;2y`@PqQ>^8JHg)_otzifWIALZ#3d6Dy_!eXw;MHWsK3w z-w5t?ERFEJp1o189AS z_I>K@`_&QC`5rx%NDCPL{7-A3xMpF1@nhbaj;AeD%=B$1sh5uf`$Xx#{QmDsAM`%Ttu=?#;;TrYL zio$ISBzpUR>Ff!LQv@GGF(au|g{mFjGdVN5_$XqWX28f3yL#z$o zs$gWU&x;fq`Y|u93b|t7`8L%W?-MCBKzY4J83g^3Z@(d6Xz;mSV-n`i1Pl$ekk1iL zm%2+UNtx6O#1nYFe?qR`uu`rEV~rUZg#5CA zp^3-+JvAOV#%i>X;u*(J%&VmyxGqW2^gAqF+5KTm{+F2bcl7~p$QYi z^Hl*u(<276D3(wf`Z1VC1Pl$(7|a-n7kH>CV=ym!Edyb`*)f=xlVFI4NRPo>7BECs z4CWsM43QOs`DYS@@DN!sm>(`P5a!DsgZUc)L+D~KXGqM&L!dF3|5L!wKQWlslgNgL z{)xdnEMSO3@bUX!L<-GUp7K?ZLR^cdJYT5YiAV92SBezkNIa!3QnU}$IgtVo0rQhq z3XaYlk0)HuzPZ`l=u!@vPaN}at6VbWkGzz>u~L!-OsrZ04a4&+zAJ+$X)$c-yJnRJ zwSI~`mL}@$E{^zxf|aMax2;P%t}OUsd0`4Mu?63#<>m%dyB8Xrxm6@tq2)v9;W*W; zoo{TOpIgP-O!KWUC`h{N^cRI^t#ul$jk)8iixcF96*5O2e5tPeGTEUZT6?$AT7volfpxE@kz_qlTM}Q7oac=WoePYM&9&xIx3bxF$EF&yCl_ZD+^BkDeL2}+H>%QD#vQ4^G?P@z$uSYtpM6|T z=&Ss+u+h5EOg5U7CIkL6bkn*fNq3{s>Tb?aU-2LKJ47bJbEyGR<|M4Nt;xaXRPF)6 zX2&!x2y3;MHteCMMhGIn(wKuwDCY2XV{NP1XJPdk3feYHp-J*w>QGFfB;dcRnz}%i z2m8kbS{Zrsvd)`ZoK9GW~v$Jw#W&B zpx9a3(y(@%f^4*g%bp=5oZVVkX>R0Syy{b^qEo+uOQ4C5d$Cy)27J0qfy=z4MH^zq zAhbnhZ-~%wWyn4~1p2LmMW3CpthMGdA-QtQh z6ek@hLDMYhIW26O4KWx_)kEMk2|!P%PPYZr9SfaiF-9rH4J}*nj1*Vo#OWb?niLc) z9vTAZ08251P^cKw!V%E730O+5FHuOMq_J_1{CSW%1xb5-qbdHv&}yxd1*YERWRcx6 zs1Q+FVWOqnfMp@g5i7Hjkuh5|rh_fJ$4XVv8A3HVM!_AdoD-HQY^A)_S%&(TV*S)F zq(K_u`?l`bVFqh=oE?1)h!tx$ImIvuv%oEtDSEzKhLE@ zfs~c7$bE#d0e9Dl|CP^@oVpaZ(Nj7EDWN=<^#^i=doIn(J#$#+4DkZRx*j?kW8`a@ zwa`OCF|G!L-B?Ri3B@r8OB3Yu(SS+`Rj9}{B3;+y)NyzPt7;ES!9`UY81g}pZ)?tq zrr*FGI*zrKLmHy@(XT!}4jt*DCu$XJ%eswjYYAp4!jT$(t+$g#dl@!qo867ACH8l@ z)v|O(^Of3(BX=Z6Z#%JY+sXRL(~B%}kkK;pn3%w@(%4$-CQu~aBTbTwc+I*7Vft>F zzwM?Y^B{5SY%)g!C#3ia+%7HJ=o^RCrY(eH@o4Iqhp6;&j_1{4F$}$sU1e2tfvfyC z4y(KOU9|WW>~a4WwS=@s%X3OaBKOI56X*#upj~XFxZ)%{wb3+7dM%eQHy|T^&aN3|0tvdkb z2hOC1!s%XXeUsUZ*XAJ8t3zY=119En>8jK48Q9RFHpeR>*5>qVIM!yRI#HP(r-x!~ zj*~l5=}!-oN_Vk0Ki1~MNFRf{;ygJj<00?9@lyG2)9;ae2>e1!x6sZ^(U68la4u@)+~VmI{lfO|XOC|)EzvOoCNkEhY^{rLG+2jAh+;lnpns#fee z>bGC_;1I*GQk|J5MB<_L`xM}=GwN}eVjWf{tO^s{Gk~jlaJ7or!30+WkvIBq)3c&X z`iJ1w0C%$oH#zCzdl+yF9^8~Q@^1vbF9PmO9^AB5F3sO-UZCS+lE*OSCF(nE#UMS5 z^hW?kaWCni{^jj5YsL6v?E<(DxNz076}ywQ%TA_XJ`ciD$k9cs^S#zcnzJ~$# zF%Pab<-&ataKGolO;#tVV&WluV;J+Fb>I-w3=#Rpcsw~7_wTN!o}g@(MlUVyd*D-J zZ^q5{D)t$V=_d1pA@TLtr4wJceAgE^p8D4=op}mz1NS|Mw|xgi;uDw7Jo#Y#%MYG; z!iuzpBt-|J^U1hu`!Ah%hN96e?7LjLeBzl)BbR<~pN?zyaiaHk=$EAR8d1vAm(Dzc zVjn#7v{ecM9bP{3lnnmIa6iLv^ZFrzpqGYP9iVoy>wJJ(hsAcI*o@an5--(x^`4MH z?ml_x&o9>xup$u55bZ&2!Q(8x>XR?~^GlCk`uj_$`56Sed;GyOUv`Ln{PLME@-T`j zrX8?J+zj946Z`EdUqVR22kTGE2Dj?E|4RrC`OKHDVJ*n|_Bx%PsQ9Z3U;ffvPkgEV z#FyA&^OyhMm+pEx(2QTIe@)^=&2>?HyofgZQc1v!Upn!m0me{1EjzpZq#)-Z>c-|D z{n3#;vFONunSN-#vsec*X4o6E$AEef@~T)|$Ft|V-pqGCd%kZm^W}(Dl_%dg$_Ta# z;@F-3B)<@z))IQ$`{2isCi8wT0mwE*-nWRn^!+e?s14YXDq%z%zj37BjUVDaR=*hK zkK^0B@N+wUZo`jR&K0-tSbH%V4+31$xN7F*@%$1Q&o7pr^2+=~qbj?by&qW^9a--j zvBM6V<-I+7d3pNZtRKlLs($^(#1nBA2^Y2L7>f^bCwsdIzxmtU>TL^eJl5D{yivf0 zvC;?e`!(#11epEojm8Ge-7&=0;Uj5`^$Yzq#zqf+qcOtaXd!zs`%2La_#26sRO2yr z2Q$w>rIW;VWvPbW*Rrn^8R)y&8`a}F_C^$Ns>bnl1xuqh5_)<3EQkT(jmqX}#54HY zOVnGLy&c1E{yi_)SqjdiEO7-?V>g`qPjpo}}$&bv%_eV=h_-s6{ zhlD^6wcO|kn}_Ug`b9OR=SLL`qBD><6nGvJFtjF&jxc_ypd=oOWKYlYO2EV3Ud9*$ zZ%KYzxrEiFze&N!TptiAG)6{8*qCS7=$Fj@7Yat^`ZnqsJT$6exqe*1$Xx6)dgP!U z=Ix^!K$azMeAkh%K10I@4@J-6Q2*Uac@`-&zBJ5tU|8BIbO$_*O%3zE(a^<1O*uNU zO26q(_DFjET*1iFPl^tqM&WTo{9J#pU}UbJpecZd8pVxUB+L3E1tW9qqX~zHDm*%J zn117jKQh<*6pYOEtu#sS5b3;k{C56b1tW9aDLS7>kHw;rvFmk=tv?XCi1b(#uJVBUxnALidu!?1_u=_l})vSz?lnoH+5*4yhd%Uif49Ov_M7Z~(JbVx^9svV0KE<7j2>;&vTZRiC!vy$B?gNr{EWnAn`VSg+mR+*mi`MdU5gLx5wI zd_+$!t#7rha0VJhrQD_1CLK5%b>|RkVIsL5m;P+BdxD@Eg>?afpd=Yv2lrM_F?5>< z#nDWfo%N;j!KxQrDpR=neR`pl+L;$|-FThi$W$sz>lZG-G=p@-bJPmDzT(dKlekBF z?sO$NOVcWHJbxCGjRGzq>;$1h z*G+eSA1EN~)4*JvvBRMUeh)Gq!c4NUV;Mq)|SK0dc%op%!Vmg=?(+;PZbD&*rR z78^8=suazstT32EH%}@DR_xG35^CgBEV{MBXsr3P<9Qrmi)PWf;fiI*oHfdl+!!9B z*N4d{B`Mah+k?z9NT(j7k(sC&W-$NmG0h-3dy;XQl!oSYsO7`cShjdmRo_$b{pSu4FpNdO zCVChps*0*1TyUvu$+5=5pbC&i%giohk|`8n{ck(#o8QPTg9r=cV*vzW-%|2TZ!}@% zy>3sR zFy4!@k=0gvkwDdqp>;SkD0?p6shL!9isSa20+}T}tF4Pg8(4m(n`@2EW^?^B@}?3|u+Rj-1<{JXaX1Z5eh%g`;8aZf8 z!x*_{tdUVsOGRbH8o6X6QewGAMlKn(R8%NzvPQ)gtKZM(Ip;m^bKdg~+?oFT+WqaT z_s-{@^EuD?_nhZE=g+;2&WN$o7q}PRFNItF@0eNp?%s1WimsSWHOsaWF_P+ zc+Y2QCk>xAxnpuf>f>)~rnYzZlzH=XbhZ9q@#0Kt@9??4z+71-GpoxdLtg7S1wV|% zUfk`6<*REaozqzB1(LTkjaOIKq>1D$PvsTsHE#$$tVrdxv}hjXtxMz8*EJ-08&Y}o z#UyW2DzDjVnZZc(bQ-Ur)~hcQ?M&r0c=@)X`v))6CCOyizvnbGdh(d>_#U4p{n60k z@v1ihDDeE0Vmr+B)5F>%gl4Z-V8$2A`!Kb+t`eqp5$}z|)WA zwP-~h4Z^-uUR`~oN}L03{h$f}H1g`2v^=)o*i>G9ZJkQavd&89HR=XrzAM3dBxslV zq8>ygEx42CUd~@U~a6uLZhw+c}4K5Ta8}D zyhcwEnD2P-YAi1H0F?UhpOb`8GA{ej5wk4)8hxUUR*c$9^k( z2sY62-1w+#_6)~D@J54opXI^)+jc2>^43DYCh#^{-jOk{m@MC%f5>Dmz989tEe*Oq zMk4(t@U9MdMcsZi;8otA$;`GqSC9JIg4Wa3;0*(Bq2;|cDqnqFtuEhqgl_@wSC;4c zt-h{Fw;#(l^urj#7n*v+`PSF!^3kr%0#84pr}g!op0Ym{f_GFX&+Cs7;4KGlu;s<& zYw+rk2k+_Bd>ab2h>M;)z#j0Lf_w{JJ*vU0dLT+={+fC;dU`qxQA5CM4dgWzwE<*( zN2SVZ_VUexHz}1@tkwNNJzWgmr8Zxur}Zt~gibrTKTTdkZCw#@(bEo)`v~Tmq`Zc@ z`a(p)U(V;#z|)VkOGAA@myc~e3%oB{dCqP$G&D4+#ChPAsqz|%x_qq1hE!gmUiYue z3+cSTuI)?Z`Ta|IxfOU*kEw5?H!i97wW++O23@{9cq72unADesre@tPls6$&UbEL9 zls5ysrvrJ-&DxF^!CMO6b3uO;>zWZ4JtF{m!F$p2+<0p!dhN${IRKu1OuH042ax(Q z_#ZXP+S7)XW^Fe%fszNW@*-njSbvdMsBP4GH5lPL!CP#3&JGo7J%@<-9!Sf#P}ivQ zodjORgPF_+tURZug}N54_d~&(2A+OQ`Rcv?W%-tY_fSy2de48MPOJuRO^|OxU8Bl` zW!MVdhLG2!%O~@~M`6o@eEso3-Z1c<4|$&5WqsSh+Zp8B*sS%1daw{Y{g`%X^2%2Y z!u_ed=0-hlvHezqw?8Ofu~yfYdb$C;vXMq#oSqhnoXq=H z19>e)oiF8$25(eSUSn;8t_S5!1MiBYyvEw1wg;`?tpaaOAg|7|lcT}g0p9JF=kyfj zO3TZGH|%40Q;+mVV|`KE1NQG|@a_%rg&|UDM*(+$w<5^5;Ef~d)duj^2J#x~b-v{7 z0Pm5ISJe5kd=(GD76th>*Xnj20^Tt2^keE<^!#z^->6hxi^t1@Hy*sLLHSxdzn#2= z;QchoYpV6u738e|Z&%3k#u0hz!FxI2)z#_xQvbGrcOc|>JcuOtM z`C(1Iz1o8g*bCmHmX||1(|#>peMcaC`zJG*yDm2U=K7<#Ht?SZe=3uC!17%GHrILU zY3e~Oc&kF5w@x8%6nLKtc=et=&4V`yymbMu!E5JA@D_uoAE|G1V}rJ*v};Sjd(6tK zz-Pm2^5zBh?^f`B73ACG)q{P#AH2N*ui4uXWB=B!#+!OfzD2Kpsn4z8{V|YNY}Vs) zGk6ogt9YB~H`d?CYw`SImapd1*h8?qxPMzbJI?eIz|&7_b!+cA#aeGaq8)^3;LWh| z+3*H9HtH5Vzzha@F{UMHz!W#G`fxN~#JJEcYeUDYt-YHyk+2x3V8M2Jji;i z2JebwJzDC$jZxNP7kK(H^=RFys}r!Jh!$3h=H9c`e$ZWc%#{ z?}o6xEy;GS`XX#X3QsR+S|P6nygMz=>0cc-@Ri}9UQGi}Kc@Za>huOa`=bNA&jk6_ zHR$@T25&id4_n@A@Y%{M6x4tlhVa6dGMOVTOX^i!W0T^I1aA^}Im;`Lcob)C2ph%3zVVKb?n$iBk^+taupv&q2Ph&r0uU zLxzFZZh5i()i>z=rM^r9Pd~PN1#O7fE{njM7Ut`1jIw+yz?&WB+obIQdA;D>74nLW z%5G2(c7gYR<;8kX-=Y^j?2lz%hR+d}uSIWkQ4iLG_eaZ%^`OC9=uzGQ@bqKa1qY6* zo%0|J{R;NPMjQQ$+qt1mI|!6F3cO*K=lqDehC1!=a!7T6*A(*V^+d>iTLWHe3QteK z%(oZ3OG93Rc1+m6d%znT@(Oyv&+=7%HIun6*Z$=7FFF;tnvEa=Oc})dn zUs%4y;4KPyo;_ufmEhfz!qXdKEZ-LJmWRBeK4E3PyTE%eg{L=6s=%vQhd1?DeeoQ- z<%q8aZ?%;-2%ilP=M~BxEJgS#@Sd~0ikJtD!3XcR$jecII_M)@Lmb( zf%SPqoSyY)??awGsLO*l0ldmFNxNHU(DtelyhZ8qumg=q`>>str1J`T9MNv90`C}` zZ#>>`&|ZwBp-licr^{>93!2g3?d^l7HwyFMjd&!JIU}sEw}D081n_FZ@?iysNc+^_ z?;`LWTW59hV2zLeJs-uRH`ZD_NdcY-%1u^%T=@BZZiUdaw#S{TMxMY}N~l5g@Dq?;$HMw$F`4?Ke^Hcc#lL>Uog) z?n~#jXg_fzcn84S5a!#W=OZ?G>w4_BTVAYx*eF!}n+I*Xll@QBai4Dc==GCcc3>IyaIS< zg}j2kIYRp~Iz8Wl_Me&Wc<>6LyvC-4UM)!c|~nssDGQ%<+bRIGnVgZ@U95uwKNqGX&;tvXR17yp+vjv?SrQe)~GN0!J81| z+gzt_YSEq!c@*n&%Zv5C88;Pd;qa#xuaV&09?GlN>yJEm9pEiV;pqkXBJl19@7^$9 z&yQuhRR0U!)MNCyxuC}-+j$6hpA7RY=mT3;sQ}*EFkkGX$C=Qc&H%4Bl-H~`x@fPK zq?fO#{Su14AH45ad9nR#ZqfcT>#;diUJ*C25NRLw+Yaz{1?9u?Qt8z&@G3W89Us)U z*r4^E`4+%C?CnW=g?)>J{*4AtKc+umo?GHjj*qeFJa1#Z7rY7JRoi^s{g=98v02G$ z1#ieV@TMM{Z;Q5n%y&X6uccP^#}M$Qfp=$6Uo5+u;!N1Ti__)RX+MJfyBxfwR$kn{ zI5$x8*v^~M<<;whcJ}Xf@IDikuR*VqDX-!&tfxa>LHi{fM?=8Vk7++_A1FVO@`i%< zXeh5yuNx_^HCx!9-AS=K5Uoez1Z6ed3AbUitW4xyvIUbgPwnB|DFbK zv*pF@SJ$ZZJ`di0@V1BYyaOrLcktsl-wJu&!2x+g!PAdvzq(>lUy9)E4du1y^)&Th z0(gH6>On<_b76g#fOph8vJx2A7u&naj;}=Q!{D82dCp$d`}<8Rz#F|0W8Lx&!)H?u zOfyPeE5dhzrytA1!Z8lb1J*o&HIkLbQd(YPLDhryc_euHvAibjhf!Z9fpW!zlC*eSUzu`fqJkF zJpEXC1#M3=sNfFp7Fc;lB7x;K>UCK=!gqWdw!`u&VqUXehqB*lpM;DnP5Y_(7WKXg z?Z$ZU^keh&^lupmGr%iYd90V=HP-3jSc!> zlKG4VPd_%_2EA{#6oj$hJ!0j#dAh#Q^EbwVw;jA)mRF9?R$ik%$R2`%*FFXRbgXGV z=O@-Q)^X5z1m!;s{74n+&yh`3G@Ro%GUhULZj*X*rpsaJc!(~r%!pyv;&MAi4uHdbD&FSw7X>cMe70=(xe zPt~_c&#RNbYX@(K<;CN&*_$tig7+|Z$GkIWKkpoe{jm)^{n&c6=nDu{AnZ!z;r<_u zw|xlrfj7kF8@DsQ(4^+KJa|L5V9W*OE7og!K>Zs9-nk*KLC})18=p>A41954n zZ)?EQkCoS=_j9N(4}*8y_+^SX9?GG`(y(`fl`2L6HaU6{WPd}0`zbB&n zY_{_x@Tx<3-i6UTcniTh!SdXA!?CHhb9NWUy4r5Ef;ZydpsSYW#!*9Uv%UvF z-XidhxH{+$?~53V!P@{{&hnf+ZKy43`_~TMh;2CEw>*_^QSaNb+{?hzk8KxkKZ5e^ z2X9&^uSH+<7FrN8*Z@wN=SKPq_b>IV+F$AmV91g7VgY_hOK5eXX`b zL%{1z&$mv`)3h7g!K<90`%TK{?fbNXw=0l0iSKJ(oH-jp!kM!mnw{@4@9 zlYASsKgs^B*p4z+OnIBY>rKcTKDFcK zx$_WdAL{SZ;B8g)XqDfYD75JDM&6b%-(LJ4g}3g>fwwiue+M_@dHy7M(zF2Xc4>7!qf8+d7HrdRmf}7`_$we0B>&!FR53B zUGUpOp7(`f%9{mV#iZo;ZSwXB$y*KHQ7Jrq4}iSw;0+FW-uX8F-^Qf9-v-{skOzYmOGj#L!NiOz;+o0-g7Cu7Ug%6w-~$~A2YKtk zdokb@y?r?H_JX%BUovC!N0+NY{+X$`Z?|3jZER`dzO^96uiq*czS<`yk79ehrH(G zx?(?gQ$ijtOhJf!D6jS<*sK(u-p3?w26ziXp7%vB@>YSjIEAOr8_C-S-Uk96+*qa0 zv2oH^8x7t=A6 z58;Ua#CkB4=Y7$TybkbohP;Aa_mH<1yx*kol77if@b-tiM!jC8ydf{+p6`_8yoF<{ z#5fuYURB6z(&spow+y`FQh3_WA#W3S`H3XgALhFfykf`;^kpk}7pCy^eiQSp z`U7lHz{5UuW0b3zr$>QzRmiJL`p=8On-uZ_zkNM;H>B{Ae*0eVIznC{*)Bu(<6dbB zFKKrtfwwf|HR|tcu$@)+c?LZEZb~yE?L*!) z@O~fiy!~hLR)UwAmK>M$-hCSKwt{y=$g9`qB%I%>{)DxK<;Crcdvg?GANI#s@ajXJ zx4+9IE5K_H^KDG}8(YA;I^;Da^||r@svGi}wf$qht>DcLdEPxn@)m-(FyLXhH6YSH zsAdG-3-g}m|LtqOVGK0kTO!TVeaFFF5i25()+ zDx-ccd1Mej#Y?^l2~*z#1q-Vb?^w;jBufQRo@Cgz2F zCYu=>@4ArZ{SXFu%fXuw@`CweGk9}Tc-kJY9+_-5v&iz|`W6aF z|8FFC4~Fs@^*s-kZxMK_Q+Ubs{yOl!81kC*y(P-q1K#?Ohl@)rym?rUnzC$Wqvff3 zc=w-~WCnOULV5Tih82cCjyDZJ#ozYV;v1Uzi#B-*9=uxw^S3NPuejRNo6A`-R}074Vwz11o;M>%c37JnsiVDQ^#W z=Z8G+2f3x4Uz5#@3VGi5qNSa|yCUQTe%K1|CWO2u{R2sqw*|a+hrDL(-?JW-M`SZ| zLZ0_S!jv}>yxRjFe&;UHZ;QZN67mAQUkBd3A+KKF`(nO(z*`aW8j|~KHLuNPJ{j^F z_4xwpI|014DZJ#oumZeCLSB>JucN#z;Pr+)@7@jTQB{@Ad?$sM^y@}~w>9K>_c1AN z5qLjM;U)E89eBG!UP~}fgZFa4!w-lh{Gpm7vzY@aJgrwO-vsaun~}5!Ep>X{C+~jn zszY9Va=rC5cqgRrl6IrwsBEStcLaFDLtY_Sz7Ft;AR>;c**mg z{OhurheMus|DO4d2k+64*Pzco$XgEHrWBt3!B_G&gZE6x^X?&&mpLYz*%tDe^zWRI zR|N0pAkhccB-v_)p?}tdq+W}r?W@4OUbm)71ixn z)ocHc`rHm)F60&TIRxb`1Mj4e*O=U&+yvgxkk^zP=Lf*6PvIrcdkVR1W<<#Ie(!mdd7HqyD}|SwR}X-`l&kePj$Z_NXQC$J9saq@bvj0>$?=ZeIc)2 z-{&W<7ra+ec**s`e()-9Opae1Pg96}2y0KuW{wGY-uLp!n*rXC6kbxFSAlm%$n*Ze z3Ci0BUTw$=&Lyi)#(r4H^Y*DJZxnbVL!NgZxD~v`;9VZ_ynA1i*9+eG6kgKa?+0&6 zz-y{a`gOJWY-U!-3(lElfVUvzdG~WzzE$8Y4tWhp{o4lK2SQ%3KB_(?o4G&aH755v zM}hZH$ZOL3i5!=U!CPZ_@wmkHMq>T88N6?Y@`7=hITibB0S~{!+=R^R!*(fx_k761 zH^C#8*=L;t-p-I$NZQ>s;Qc1#H6`0+2YCBKp7(uNmT&NB*k7BK9GAFmo7e|#2d^rH zmz*z`f_GfN!}noTJJbI4f|n0@_@R@yUC28C-dQ2f`-gA1zgw)q{#wWj&My~%cYerg zOy0Nc1#eUeFX`{@2k(lI=lz}=+qw31?5~Bq=Hz{W8Q{G;i|xz5bAP25)P~^S+-#JdES03c?ZC|A>V#a z4)(7?p66e&9^=6q5%Rp>!(+b7!Mix*6_f4qG|X^um|YgiKFoI{ zc+*0j_wNEQ$zt$khrIgaJiQ*gg(0sYxbFzwT_G>HM=`Vx`&S_^SjSHS?}3o#{VoLS zu>!nRA+MNR=WPM+b0N>O_mo#zkNvBFhwuBTcBbC9g7;X+^ZYs{Sqk3f6kgI^^@8_o z$g5AD3+)GQd&ny!?{CyLVE-zGm$bVxz}p-0f_396@ctO`n)L6Xu)f>CtGGEi&Kq$M zhDiHRPpb>qzY2KxUFXEQVl;SzL!S2!t1{mu;GG)s>XY}8Hh?!QGOLS9qy9?ClKW~A`6{bPOifHybfH7EBIYnrg%l)_8y z%TECBo{$%O&+vZmmWMp=A0(w8_B418T3+0KxYnZlrqSS4H{*U&$n*XIN7i=&c+Um- zHsfEQMx=enyC1wAA+KKh&m6x`gZE;XulMhwP+qQx{hT>TeQs_@>cMF6jtO~%2n;Q%&c%L?<;D6^#DPl0!rTTp7QDqF58phFc@(_@yobVk868 zo)3B6KNv`P`4QNE33*N0&n9m?c)tmG-tX~{w;a6v3EsG_Uw#5nnQNZ_>K<3s-B!8x z=*O$Ow&;LtwS4N_Q;q2EOjp|h{>6u?>_(t2paV~d06*BKs@(O!tFOL#ckj_3?p@N` zkwdbsku?=eSW&auU&lz)Sqpp_-hFvoF~UG2=G zv$x6?Rz3{YA8Pc6TK!>!{qWSrij1_6Et|^;@e55(oxKrRGVsKB8F*Pog<8+@-rd{r zS|ny4^W#%bm_CWy`ZhF@M?jh0w`T>oU1OH?v~BAix1=iZ&p0-oa*Y{uD5_5anmQ(#1V4DURu9FN0 zceU;6ZrkNDT&6!PWroXChC4g&*eMy}9U1O)8SXS0M%+1!o(%ZI4l zozFu3!M%Iy3z z-*-pVtGFgVKOYk?=3m6f6Y|%Yua}ILfhoYE$Fb{6#_j+PAAZjC*&Q=GZd-UxoBSO< z1J_2T4WBuC+Vq7(&&-d=o9KyCZ@y{H&9m`g;!Tt1-8gahyqUL8NBkLQmIy={8+{!F2wZN`CI-+1F1$6&YG_3#QMVH}mG%6R(N$x;Foox8(8B zMp@w(baYI=X--GJ3Ng*KlXe zoHq2#%#@iO^QL#4dv3?{c^$gK4Rfc>nLM}SwsYpqylKv?>GNh@KYQ{l)PL^uccZ%V zXLsb!&(~&51EBXdMzd~Dk?GwwF z)BYv@KAJ~7X2PSt(c8KA|>kMkK_wXV@M6)<+MZegNVU(IF`uga4Kos(%DlwtVMmks)KHgnsck6`yY zYl4z=_c`-w=Jf0dm%j^}IN71y<=HQl;Vk%z}I${5_V?=JIOh_1PmY z8T8KVtRog=?usLjw(`>9HZ6G>dI^Prgz&}lnfglBD}PK+SQRUD!3i-}~Tn5m?5 zZx)H)(t}CV&UJmzHyTQp6Tr{Wbd;8XtCRS6kw51qB=*5Oue!2xPp)gsp6>bPU#RFF zQ}r+CgiP0W#hiETea+^swjEvjUjx5lXE%6lJG#g1?8Mg&$ZYD5 z|I%h)KaFc_<*+$DM)_SlJZDo%Km9=R97q~hj$}FEKXX+g9u!(0or#u*`<659@6y@w zOPB1THx2&`j{La2UG3HEnfBaM8>=&B3|pVPvo{({(l^km8gbU+%z9#{?Fkuxk;l~X z#5{Oy&ZC20iP2f>jn3}DF`?y&`G8A}$F1w!SVNKA|4hOgrwHvd=mJuEk3JLSGF0uxld#YqW zY(a~3kK4*BbdTF6q;cEv2ma}+KftoHvuz)2&$`auXt{A-+rFbe0>gCl-Iu}d>KU`+ z;90DLdF~mv!*BQ0W^sCA+N{=ZhU(6ZSsGfj(TJY5r~OFXSJ7OIPJ%}dO@uz~qNK;>REv3xQCdxIBtc%$r(meZUCX7B>``puBOC|7nvzi7|ny*sV5{*rJLu=`eSK1@r zj2jZhd@1@J4TzQ}=E_?6QaBg%i0Na%BOZ)DQo&fYyAG}U9U|&7UsOjV${Pz&`^H0% zevWS9sC|PH)cExld+x?qBzIpo*RMk{4*FiWC)J))e>nGB8)Ee;=EUn@R4~)^IJ1)3 z8*9nYHI?j3^sv-|qtVQTc5blqMR#ijTlGM9hK}Ro`^%#F$L1+@zyL#K($hzCjp4_B zgsHusGTJkU@<#h$KPRqF6rLzkc~mC9zH}_^qhoP;TshXI^2{xwC|)1!u8T=b$boO% zTdb}tAOCqdccJ_(0a188e{mr$)Gcl-P|thX{@_MDEW{slv&V6}kL!9O{?xTC?wHEX zO*Pjzf4$Ofc$vDoVI0;7#Wlr<^@aV|SKCExYwA#zjq4Emp9hOe$aQ+sw_Nl@=Z=$6 zG1G>|+=wzhNr;E*bKPy($Ms}vPvSnk(*=#stcg9E!^$1{GYlT@G12*Aw)2m#&VPx4ml0mU96uHJ3x3echP|xS$ZO-+ys=Y&|3W>DOHGKSO5hbD%ZHaJz#0ble%~hKmmSWu2q0A!bUH zqlkU6eNgG6xlX1Nkp`8+1cJ?-#Iv1s62X}ia0lF^YG zvre#rGM+(z`g9+Ux`tJgiPsKn(Tl%losGsIyyCCSYhkG}uq?3ow{i0r=Qw0-Ow>k~qw831YiaW%e{|eloEmzmG~qBb)5nYjC9N zTpf0|4!*nhz2dK513Gi(8WOJm8z4p|McY39p| z$73n-wRWH3XFH|OY-w9z4+=2!*xSz>z2ti+684?224w5wZ-w!f%i&DUJs%;FVYRWa z7uXg^xZq5NK@F`S<6u2u z{=}ZQ=l58higG~i^jp}Crd8bNV+1<3UA9Ec9Nd?k=x;dIigK*I6gwGeb>CJgdXMg~ z{y_x7OQbSCIQ zBf1aY#MUp(#<@K1?wx;hPup*7N4&5~)PZ_TJye6*8Z4?yqyeyP1#o&s8Qr3C(jTqp z8TT7q%&MhrFCG0z+e>C=xor0^%H=*Ewwn^Us5a})V8dwsJ#iW0Lh3qGk6<$1y5Lld z>8e&KJyi%rlD>s`Yjx($>>02Me2o7ln|4P(lEH~?0c1vq;zoBLPW}XgU`V@OPw*+e zX`V#K_L=2*v=ST^9PL3%!z59gfobyP7Ly%Gs94 zs}GB3`di#eHJ)tyKur>UN5pXlIj6*9z?4f&B$Qw|v_J}`?8~2HSO1)}W?w?~qp)C- z0!h8?eub;!V6PqGano10Et7Qw{`$UOU*+g4{C{Zq#8KEsM`2%zqY$a!Kz(QK>*k=V zSQX)zrW(keA~-u_7K3&S$mxx&d#5*>npn1 zZ0!)ZyJ=6xml0BIR6I6W4!Y$$Qid~D#d$5^Z1cz~n%DGIK~6B<*q7x(w7|i+tX&Z~ zj5$P&&t47M=X*<}Oq7~&`as9g6I72;~s zyG8hs4Ckt3U-vPb$l{Ua?_)#~_h#)F^!wBA8A4KN0S6t@Zq8% zm)O^H?cevh*pAJ3=yCfu8irlZp9vQpyOZXK0JjLM)U0VU^%7w5VOBtNrlScqljVKE zSS(z?TWJfd0DPRsacMv9E@z!K6|OOd{-S?QS95F?e?@3dXgN87i~4}$is@};bJ1xH z7_C=j*92Ki$z;oW2GRYV&OLp%mpPXzb=*+z(FszA7^93eX2LYXu43ts8e4g8a&Sdu z$DQc5xhJB08gz--3g(E>mdv(6bQTfL+fuIzwJxei>YP}1Ei+m}xjPb&p?zEo4z_kg zLj^>)|4*;%{-~!{yae-P+X33o-7uGXy2l-OvVxbaU+ru=knOzVKz6|kk-iwa7MT(( zs_bym@uljaZ)Y%u{!Zo%l*B6j|GqLE%!Z`dg18}Q;BZ9=7E?y!1r=TIz`_@HFK70* zp$pLg78?-PWjO!ms79n=k1@I$O!Mal(BwsSSyE9KJ9&1B%Qmo6ysA};osq{F9vfw> zqp!fHp7C4+_RQfsJUMKSbRUzv&(hTqXMrVb*SLL;ab3#^L7BMps>Paa)Sr7QZyzCPnrg_LCkSHe%s*4g%nmgKZ&`j~#dBPL%8; zU=H>#(2G5n3vG~u-45J$+Cz!#HW}1))m4he1>|&GPl|51q6>Zxv+PFw*Ah*wqEi7uFHwmcqtl0l}D<)A4o6kYY zXwx5Z-iS<;xpc@XyKNWFm(l$xdJfz-Px@@ecjPD&hi znmAZ-@k+*Lv- z?Y%)7SlOwrN{E%~X4moTsR(ED9- zGV5QMglZorF*!M{+J)9aWk6{~om^sub&UEKubM9V9trY`8m7(ct6>PL!Q1lhtFHtmConY_zN}!cJ7> z+x-UC$`1JGZ)aO2y1w$fwyOC*i@9d(I^4=e#?Ct-Cb-GGaLUl z%25oZ_UP$ra4;fy#GwVHC1sFtJ$7Fl#X)4HbZL-EERo$mHTPzs)QNjDxK_!2i0z}S zwy|>y--Rk!&6^#>c3R?9)Czqw*W5!~m-5nY>NMY%b*heiH>qD}Z_tS{Qlx%*EriW*u7$d* zmP3~bDwelA4*!s@(C(w%+UQ5-yBpEoPo($Jde?rJ)J!f`PvbFU$7>MI;YM|b2T`e} z&%+f_%9}htr@ZxWxlfMPyESsZc;D``d+f2Jc;8W*%4UNd>=A)xE3I$le*-PGyEaOS z4`y<7qg0Qqcr10=E09KilI2azp=?B{S0dcbMV|c(CgsRi#IST_N>`S+{e^pwIX+q5 zsD0lW?UflH0o|46{#yG{(p@kNiI|sRFU7aU&U~V48!qs6M)$_#yDP(X&+NRTIy3*2 zuKi2R{&#w1cTefOsXE)W7o?P8;=3&vI`CKhsbMF(`94{@?d)n3Cs2&98W z`?&PM-!pxm6e`k-LyYZHaD2$|-c_|c9@}~jg{~w!8Ak%KE=6-MPH@rC{$0LG<6r6x z6SP%iE714h{$M!zkM!26##^zz0`rb+w8qA!NBbFRK7?C&yLlure)?Dw_2n0()+O>M zu-7SimbS@h#y#zxW$XIHei7vxefKriB}-QZvy~d@C%&E`>P9=~%J%q+Cug^Oe?J1W zYGP-htqQtGZ^Bw%n)WAbkfv^wkywq&$<8sxn;hWAHA+pxfeAj#6OGSEvz-Q;w&9o6 zprZ6R9{)M+d1H;=)3(0{DyzLIILOg_7U`F<7imVlW6%pfK*drD*0$q?k8_l^;d@V} z9{x9EDluD6Fqe)&a~pwNlx|0G*kV$>9f?66H6QOUZ;!eHGRk+q5sevj4VwsRxFaIO z*}6KpIGUul!6fOnqrU;ijh7d8p9ULZ+b#E*+x)b80x;Sh#J=wV_PiF#s0ddY& zYfFvWz4zPOy=q)?K0aFJ3+aaua+6%?T~FJuy$~T~Epum%RYn^`|&4o{DXgMEm#{=WfuLu_k_*o;|-!lNa>@rX6m-?6m2ITG;O{*|v#F8WhZh-|1zxS>JU9Ov(P4}ki#=_Fxs1VP2#-tD_+#Pk zl-Qh!_0~F!#R^Nxtm^Z^H)W_nq)ilvL?WINL0?@Tyzl`e3g@KV3v}**Aem@nPK2gyc2`EjTDsV_lDBz>c9{Qs+$p<{h_R&M!7o}iS(f?R+|YE* zV2264voC|PH%WOpW`3A3{ zY~MbCgUL?1Y8Ys44<(%6qhWQ3Ig#Ti$|zEC8rgl+1fFb0Mr(JiqrsR)p(+XXllOMv zl+MMW)b^55;p%Q47Nnf5j`3k{D;0GGO|!pX>VA9Sg^{m5rj# z1>6XT+QsaV_u;ZQy+nP|P0&NU-96}qWnv}**F|nPcJ3uuE_)H8(Iw{d9l(ApN{vh9jm>xGiwO+E` zri{+M+0H-%MBli_Plw2U9E13;3aWcGC63>Cti1o>%#mA!n7MiPVRE&j+ z2J?AsJCFY0C`?}r-;u>F>iNQmhdUVaCyR-SYDKRt(p(w)TYK;wL{*@$)@_(uqc0Td zfoGctGn{kCF-0qe8F^wd=-#KfYtc$v`WsWBGbSAR7=X^nJop(F654z6q3>Gy9(Rd4 zY+EbRCG0(!az=Iz%^JmVjz*;JG zevdy6jqNe+B#snqWsK5#N8DU5jTPkzbVfNBT%YMaw@v{1Gpb!Tek9P0=k)PA)Qn&3 z*kkS5_5DBm2;N=xJ8C#bi(bR~!!}-wQe)ZKD{D90S}NAso;$Y13nzE#*!4up!YNX8 ze2+F*I7M;sNp~n+)%M(S zoh*BwCS@*!;X0KXWAqS+-#^8;<*A zT_JZB)asbF6plhf#zz>NsK&r@PsE(VTa528*K~b5x|iGaTXQ@V3DD|bZiHA}D58YO zC+TlWQ1Y8Pkua1d=@Um+3)HRIlukjDJ=r=~=49hj)Ao4IF&I%bt?PpB9z$P&S3Gc# zAwT!UUmmm9vH2xI9NfaX;Mxw}fyM2^H?;7}2C=xf0c20#?bVBJq~8am9Nq*qcLr>q zS9@4_*Rnk`TriQtbiVJpl{N@J?xaBDC6kUPNn z$17XuGSKKHJ^YIQcjU`FhJG>dLiKq+6kry+@Xvg%?5J;;c;y`P<9pMmO`Ov)cjC<1 z@*{bdT;6o0{7N7G@Mroixp+bQWeeIazp{2>!|0h)>Y6UPdDblXslk!vNBS;V(1z#A z$(LMNoY*${@|KAcub(}C;?#u;>*^|V;r~JJ<6+UY6W)nz5ZF91h1p95$(VQ- zAzJUF+?bo#4$5DIAr>oZTEM>}9-XJqkK4s`)^1t9)8DZxAuhIeefzBk^Jx+1wLP;m zeIns@YSBJIN;veXZsM5v9n%-$H#hsIN^AnBPi_npW=x+or>^eun`d8i^PJlzPnk7c z#%-i`4TB_E=4}^UbZ&m=+b$n>X1*}IWw`tcCOH$8$=-fNCcCII`^Kt@ils0l^dI=5 zd6ncB994OD*@Z_Ay5L)2;CJKy4%3~$GDYRQs`PS7J4NY6mY!~)?Q(=J=fx&Jw)F_S zj>7A8I(|$XKLOz*Dy82!1n3L1oQN(ulNIqBWEaHF8#DPJ^l&I47X4w==ienLKuQD{M3485?+0!pMW^(W`~!4 zwoA|8?CtHNMUxNbr%Wc&=R7bC&jF;LhriTeSH`lNos3?@&w&q-N3@Hd5Z7S`;+G>{ zey=BL!}3S6WUvnW@!CrvTYj!TiZ?}+@svmWBE;v(jpCL3R>ZG7Ncu^Lf94?R7bE^R zh(AWlzdSDgD#UX@%Reg-F9>X?`Bc1QWWBQ6iCai~5;b)~)e z*R`o_^HS{8aXQ@1TWWr7r(#!o{G*vw?A>gw=a0o zOpc}GeXN%8_Jilme51VIpwnGhdb)x3iPR%&l%*A#M4`vy!;4 zw0c|&w4N90@-8ZUJe{V~U3>6!x{jaF>DWFWIe7c%I*!w6%Z$+|rEMFzjqS#^GC z^Bd#&lrkrC{-~gH9odfo%5XtH?5sYsoy};{jJNHW=~3~-$3W+f##Rj{eB3afL!V_^|XkW(--LI zY-8H{ocowAN_(D8JHK>Y8))CBjfwt@$&DzlEO_;pTwnTJ)*t^uw^LfVOVOcgb^DeX zXTOwmXXtcOO7E9}+U9d~elttYuR*7~sq}QG=yZqhV{|{zHalIPbnyK0phkK=RHwrj znP|*-Nn@lx>or~0w0W8Fd`k9X*fEi=57dugCq**UzFNP^!Ht_p#z4zKV-v|3XgS`h zWDK+%7bzKs@ayuRMmp3A?8*-vT5t$En+H8gdubwVS!?Mw%bSPBA6)0P{=G@(IrZS_ zbXnh~)1jVs9HO2&&;P%U>r!kw+t}$(Km7auDd`3}_oStxPVp(lPL2exf=V0N77VU~ zt^KvW^4!Cvvu7Hm^rh$j^yAFuES;Y{qbMc6n{>J|GeMV|F%{w3{Kf7)mynx|s5YNNm7dH?^@ zHd^z4ZB%(U+5k`TUPcANM32@2M0V!ySdZSqN<`(n)!5X&#&#Z5jwjafpYU?&;2V{F zy!7?wU(%lRXMBqteOQ%ypmua!D5I}7WBH;s8|Ycupejh z7o%;R4)$Y=4K&@=UVdhgR!YAQbdPwT{eHeK=j{g{(^@|VI$!rkU-BqhG#);w%SjvZ zkvsJcoD~mrZ2WJZOaHHa>38@CIwua)b`R8+ zF4yCTbKBhqpWAA{kLJbq>$Gk6ly_E?E#kFITDemEjU#pXe%$9BXxsLujr9DM*X8WT zzTrT>ukc2l-y!bF>T>qS_Um-sKG)>Z=cvncIm_B4VJZFYo$DRqzK1U7i8{Y`m0r$) zo&^lFoCD2opkqI;+vO1YNiN%zYvVida_bU~{f^St#+6>$()(hBPIrhiXx;Y%wH5s- zXC7sX+J<{0x@~Sdg#WG6dOjxF^`=9l)%E<}uH$LnwJODCuzg*B974x+d;V{qEB>#3 z>HgP1=lX%p+5NHk+E#dTHf%+I?q_*-*KRD`276=a5c97t>w7Q+-5BJ2F|YLbVxaxu z?Me0HyJB^^to^v3H&EYepnFmUUCw@dht3=K{rEo9={moD_or-NE%d4?6Q;dS27hY3KK2Z)%{n=l^szeGV9? z?)|N8)!%b|92b#p&(peX*84O1v)=E|cewPJPP>;-itS0W1*N3x&s?s{>DlCd+&>uT zo%ey>+eu5udhjX5M)rVLu?=t9MlLz{zL9RHwERoymx1oV542wfss{s|EAwbl*QWhg z;|#Pt2b!)w?ZP^-?>RU2*Vol)z5RF0$x{!premS{w=jw8zO>a5Gc+q(ttJC&lZPA}KkS=Sh&JSh1^$=y%2fN8fdsUrj6X%ZDzr_Ql$@4C9O88@dNSd&whBH0C^?18sioA=+H) zN7}r>cs_mk547JbKj(pE{JR%#k^d0&+Z~5)16_{(=&5eIk;vNREp3P0UDI?W-Iwl9 zzvq!v)aG~Ve9`7*_6tUR%|ANr70I-hm=5bJt!}3ivPc}Yb@_2w?i7`h?h`uCvX99I zQ(x(HS-tyJ7j%|S=!b6gXU@`jo~_G@ww-c_JayXs+De`F!9>1g_Z@t%K=(`9IO?l? zbvown`tuO`cYld=1NEQN(y=^z`mz%or+ii5MW3tU0Nx_q<(TRI>$h)z_Q>)m9_z&N zejP8btY1EOS@WPrY5O~7*hW#>dw^ZOW-fS7WY9{{r@z#gn|6pX$MQyH9;ofUHmvIv zhpKB{<;!{4wN*doy@8%V4%F8i=-nFD*VVBf_QCTt`{DNw^xS%&_Rsr0utVHCpx+Vc z+&}1f(E1$Z_he(I1Kd)^%Lv`R{W!z!kKZuRv7*!U$ByZAd0oGL=ueuxFQq;Eb4QY8 zV_9i$|Ad#*bIuLFJ-EHqbv#<9y{z=JvvE3Inc3tkrH*N9BbJ9xUvr`MnQsHH;x$m< zXfBL=<{M)5Eu|c%FvCbjKYpWWpf+rvIx*1S%E{~c^+R_DTEBPc{L0J^1RkniSw_y^ z)ZzL3`+C){_II8RC4=)=B;ym5alDdYe1HcIH81M%&1&&}BfTqkS?S;H9H=e6+{@2=alVvsH_-e>==}Z$bIm~W^UgirQ@Z}- zb^Yv~cYpM!5$P+Mef^nb{m?_nVcwA*PNJOil$`iD(BHuwsJ}JP zbOY7h{>iacpa8G4e!rN*iazDI~$1K z2h7PYjX#_~^k!*=a+%Zd{)ixICr?&PiVcFeqWq?yQFz}dh&zj47c>p;-x72y-c4*5 z(03*50lc3p=(Bh?vGi&`fRY|2zoY+lL0mAN%9NCM;<$FsWvCm6BUMgpZd^-KbI#?)Hc{gYVttKm zVy~DK*8>^J3xG@;d;rL#_>e=?9FsOKAJ1Hj6qfV|Da%lx+wjU|j>h{n5=O+@=Q6{9 zrU_~Sx=s-L@&-XQKsO0u3Zw0(ImCXuO=3s6uvtKhB#iqy?-g`15dX!4T;@!my9G5n zbO8|lWi`Zd=VCKnIr;Y??iC)T{6xYS`wKzG;r&;FSo0l%7;9SSM4(lYmiqUC#J&#i zFAHkK`z?Yvia#wpw%A1yb{*bZ1yQTND(H5+e@uAq2Rc{6*bB5OIr*0)Oc-_9gnbRj z)QGM2IZ0aw^aVlGpN9o8HYo55kc(1m+&$g_DuhX=3zz@>&t)pDwkp13}W5>Bw?&uj9zhJ*)pbJ?AKiw z=WnC!hf6Hmph6IP;Rr$J1C1A64(Lb;^Y!mI31dl3uTo14io=E@%xE3;${=ck8J9;e zOr(%^x*)cOvBl#U3mrO4{v{EECL_$GrL7w(Dc%nBWDDYa@@dzv0ya(M!o?CIFo)=z~B{$hiDR$NQ4wecSP#u!{xJo;KrU^yLx>ul{uxBQzed7nhfInKfi_Eux4GC;fS!^tT0-v4!OO+_6;kHc z0hzMU#*ULPYT|f7)L4^ZJP_?uE^{l9)NLt{nFH1WT_Y)2OB41ykeL?_1KW(55kN*G z==&LY*8@F>S5Df~r0v3Ila_Yaq+J7Kw1hfjw1guz){^U_1jn-kf~XtM;AQG-kUz>y z+mmN35;e?NB!-!?FwB&NVK+F**9&5Q+$4zh;9Dq94*!{dJI7d%1un%rm*O^;VyjEB z$noxS=)Eq*G?#*_2b0I$5;hdMbqiwMjCEwG?v=2cfbPO8C;rEK1$`9nACg#UA(6*g z8r#k=W5*e0>^Q^jcPTz1h%@_xf>_^=38HUytRRlEHGPJ$k3KK4V}Z>0U>)ZYiST``3nhSZ~aOT`|=dLOnqN)v3nePNf7nrWkGDA-?`ZR4*kjTUU9r^IVCf< z3Wp9CL@7rIVrwjw6eEC)&u}f!heWey105;6+kvVD9S3y0AdcFX@XBS_R>w-%bfDt| zG2bDA*l#BbV!KR+HXSDazL=SbIYXT4QVew|P8Y=3Hw&UqGh7hcv`!G~Q4qvDngtC9 zY8AxtO_AI<<6IxGoa2ob#J0M|guCcCg{F6??i)OIu1qGvp@%c?JP~JS@u{9RCwC@$f^4%qfc|0wxL67!d1#xWM?RZ8C z+hD1Lu_a9&dT?BNlpmzb?FX%>~dj-u0GIQPsfw)tWll>wymwgmrW-jCE z-K3z;U}iPe=s`)r(tk`)U!`9qv2jV$5cU33!eh-pBd7pG={fPDKPzD~@OiBumf%Z* z*yqN!lfA&j8qLWg>^2EI0?4%Uu|Vr3jIpLoneSr~#(e)-(4|0M5p)fZX{(!nj1`>= zWZLRBAk$WzK&FM5+qrld-F;l7uzZ^YQFosd#F6qAL8k$IM-cn>UjG^iCIc3(zhJ>vFNQ47(+a zZM+$;ob2cPi-etq&!+9`fapb;Hu#OirfEss2GnBi#p%&QyS7il*ail%%zuzDrv0O! zJkWm&q6f;2VY7NNwWPfgGNn+0fGQD*f(3>P|JdoMT;CSOm%gMj# zXu|HqXQSh6`(cuTn*9T*FXw%OxFcdv3(z^jqjuH{qMbCYHUX$8VebYq^;ihh=p>&f zi27`J=L4Bur9300*`aoz^CiVB7k0M`Tj|h0yVz%3*som}*OEp`&LOtDDc@<1M{8lq z*Xj^Qk15q0AXATffsDKdfQ*z%ATw4uq70(88{MF9W)QZbO2VcCy-Uynpc+Aofj(8nJUA|6%Q`_~X)PuS zV)=|lG&%GxAT#o20+|}ImZnDUb7(ct6p?c9{y5I1;K(!bIPwgl{u#-B>zY#0zL-2X zW=sl>OM|FQ)1?HAogs*=d!rzZD1$hn3~B+IEwOA#W1H9pMjq3Skyy?%#wTR#EfU7j z-XVxucdH<3@iVA?PX3)v(`s!9Gw2#1qt6{KYzdIb?S2=w+J&tJGOaNP8e*ip9>}EN zX_E;ny0BItlj5B~uR(g)Qy2DrpxdRSY$3y=FJ%yW!63%oAw25FVnM9=8wIglIt5Wr z?-9hlG-YW7GUbbFKF)>FZ#Q{-(4|-d)Fo2B@4|itWTgBC$fV#NiW%LlK&GA93p^Xj zWrhM73rw5%VF_ai%nFhvU=4Da$u8_hpx6SN+*r3|l9uR$f;a|QKQn4S>S9+2dNX3o zP7$@~6B2eg&}u;^0S%Fn$9ci5aIbKP7S617rvjOE^34u0t*P7DK*o<{9{(hgDbLi6 zQp~Q^A|T_(E_1OD0GV2{{-2YyY^yH_YIHo-!^E;zP0eXLP0cyenVm{n0j9@(4&IGq zj=`^rymNrQE{Ho+-xNe`;#r;9r!k20r9q5+L}ICl22qMZjNRa34PvZ8h{)VhN$ZHW z%pQC^OlI|$1hF133*rdW(!STlnp*m47rWRvZCuj#rO3O>rRWsIS=`KsoW;%j zMjbWt8^?zk0Y?K-BlPJe>uY97+O=Yog3gkSPg>K|B?LcOA$JySj zbK2x4rtL&pkYnIDp}Q16eFFd|bA0M)DaNWOm9 z`(2pP;yj|^PNGyqw4VkY;Si;pFqX$4`acGl(~MSpHfWMViyd0!P_IKf9HRec(&ioF z9A)J>#9jO@Dg7!J_F14)&<2NPHo35!4)MIkNU3pXq(jpjTH?@Zhc-EsM@gv*roQwb zav9d&lw~LocTaM%S7*wS$7gyFCdDv^Xq8M@y+gFFCX92EL9~1Z(UUaj0*6LAMEhxC zFLh{)L)1nSd!<8HIYdvx#9rsnWQVvuFtN1d2F-HlW`{Z)y49iE9lFDz#SV2kbdN(_ z4slL0x!otoZ|6@-SRLL?JNvO~60v!F{=9?{ebJ#WJG9QBuQ~LnL*HY3WLqBwAn?pZ#=%)_-%%PnQ{o0`y9r_Q4_6qXL{96h0%lvzn z;=dd^;LxiMm0?two}r&CxlIo_Nq$T8zHao_5gK zGY%SiW+FC^mKY{sMCUkE?@*&d^tDY3o#)W`4qf2TNQd6$(4`KIaj4y)D;>JZp?3-L zTa72Mx?Nc2i7o}beN(>a4$W}rMu%oQbc;hBg8bZWm9SW^{Mg$Qu`J6SPTpdNIvu*l zA)W%7k}h-TgAU#2(1#sb;m}7NddQ(qImEL>Bl+`!{4#%0!r~gS%wKjX)}^HQS|Wun z@6kjo<$c4+>viY}hj=!goM)brFuzn!yAWX_G4d7#IhyJFjt$t9OO`?L$7t{D2HC> zP|l$@ICO$TCpwgO=ro7UaOg~jhBCjaUz008q4o!4uibK;Kn&Hrm4$XGx7Kb_+MyR6`VWWpI`mtIe(%tKImBDPX3V_mP#G2ib{siW>CkH( zI?AEfIh1qg4Gx{)(1{M^9XidSGaNe8p*T;NiS zbm(mkUFy&nhuR&w(xIyydY3~J9Gd9R6o;leG{d1A9h&XXEe>@!bgM(RJ9LLbiv{^L z@02jV=J&W1T@EdC=z|X3=g@~8TH(+~9eT*2PdK#Np?`Ada}IsMp@$v%szZ-B^mT_e zIP^`2Hahezhc-L(U5B1===%lN_4r(7PR) z>Ch~PZgyy{L-QS4=+Ju{y3?We3G!QViG=wr`F@w;0}k~#wA`V8aOeSt{!x&h$4Uu{ z^YCLoo`|JhebUMMbc(z+DJeehQhd>&FFUl(p|3ggs6*dy=tYPALy%w6y%N?}J${>r zWj%iHT(O zsZ&j$eSf7I&M6*bn87f{a{?E^cpxTI&P_t~VA_>ul;h+xTxF*{w^+_$i0n(wR~-j( zM95wn!d<<-Qq>=0vOGK!rMlUMV5<$OxW6AiQJEJzPLyhy4S5a793qLykQ*E4y-W$b|^G z%;VgMkcnQ%N`!pW3waVDY_qtRe}WL!F%H>{5I(QPtFL+;pNlwAy)HyZ6;s$3?pj%n zgl2g<6F*U3%ypbdPLB=Y&TV;?dyVlErTT*7M5#905biLSXOD}M07a?xI!=`8SROXw z;ofk0mi3LFDAmP|6Q$~~A+H0uJj=B46Q%m3<3y>xYeS9!xjf5r8k0BEMybv}&V(J4 ziBhe#A+$1mr8=1#Q+SSbsd{V(_vOo_p&U2h7 z)m1j+c#zApm&8ecqExp!PL%2&YzS>gd6w-TKT)dnjuWNYWMjLyfYA~el%c;3*L>rdsGYQF%UZLuw>d z9`9i-e&IM#s^d;Jxt}hnu1rle+Hs;(ci51ggVg=AmUD(kPPb9dIZh<`6&vybMHaQb3QnJs;LO!N-CDK6d}AZ6Nh{$2zd@6-|;yA zjSxPZZTp(3hw!jRI8m!M*$}QX%CjT*PJ%p9zmIdADAmn2L~L4?Ryuy7RQEYfl>dZG8RspQOe58*#PL!&OSHAExN-B<^Ft4{ePL!(0hBQek zdN1)4)vN4GBdIA9rJ8F)nn5n_qcyfWPL%3`vy7agq`DRFp{-l%I8mx&-fU9w_C{Z; zl7)^FrTUQ#Iag9$o|@N1Jl4Z=uB+D?8*&~()7CO%pMJJUb)HN0F&iSfl%*AlS}sQW z949K_#lwx9w@6;;8g;wlM5#V&L(Z2}>1(v794AV((}ukDAgRiEw29}fu3jhFkXD5D z)ytC|C(3J;4Y@#4rI&Dr<3y?6SZi{>P*TNKA0J(7Ug|hesty}+k))z0W2ER*pLCok z)pu>kNJ*8R*Pk3GN_9q^k=-V#@^}yP8s|7ss`uKEizO8`Kh%vcI8K!6IUB-z9_3ll zMj-P<>GwNMl}#a7IZl*njt!x2-NruVS8d3pl4>K~xl%PxRKjr$ zraYHsqEw%;A(w&J*NSYj<3y=`X+uU!s&I#axt>xmd5v~?jkh6VB-OQekIEIJ_c_l0 z~x;_Sw4&Hf)$lve^xauLC18+Te?!e?-4Z+io-*k`(e4S9U$dN%dlb(Xu`wDLa^o zeAKLlk6fcgWZTBi3`SEu z`00vw#8hPGtY;gHrn*Q{Mw!apziu-aP4$o?l&mqPa`&%u4MtP_T~f+SMKPB6qjPxj zk&1J9g{Jzbq>KaX^F<%EPEm~;sxu{Jf~i*FuR`F9Da{WXjF$BaN!bOI&s%=VQHs+p zBWp@hDgmlD8;q9qMM;?qQ2o(hG}V39E9twL%H5YY7>uTxm6WLf)f)^(Q(Y%1(@aIa zims*j+Yb#!Q*~`n8djO=Uice-H2q-)qp7NrQUh3d4vGuWYN`tjMpJ!6QtC`a@d1sE zzul{-IMr8Zs#7H8RHmZbWvSj{Fq-NQk}|_o2jOp4!*v@~+KiEPuB6N|)sgfU|5qO^ z^>%~NvIdS;d>R0%HlLMMF&IsCfuzha6}9~A?B+KHqp8*%qj=9VmD)#zul&&(USlwt z>WPDjisn$tKh)S2rZg`z7)|wnV-?k2rgFF5lMF^vy-`y31*mQ}7)|x~O-j~j0jjFO zXsRnE<#eW6g};gmzL_S;sGe)6u9cKC0rYu9-!T}i;T@9lJf>QWzltwO)3VlVQ)$mLvSuaa`9S$>?}rRV z%lf^fynv}_{*{&Wgdvso0we2WNqHeteFlGHKU-^fxxr{zf0UFLF%{)YW8-fRd!~~0 zA|vYvNjZzDVmbJy>7OqV%-M_~AO7z2Gk>&<8x2P5^G`{+1|nC|HVW&bd;U?|l|C=V zZ$7W!RD;o+FP4;-Fcn2mwHEQW{~lJHUt)6lLPy$8jP0pUP*a5Q_)OQW8-hXGZ;qHW)4I&L=897Y3*{8;quUrKG%;sobUUb%W7V4|=we^*W|< zm&U0Eqp5C^l-DzryEN`~lH&Y&QyR~dls5$O^;(0`vc4fH7X_&9d9spqk&$(Tq+HBY z?$Vey7%l5vl5z=Cxl7}Z2BWFgJV!~tl&RdMQ8O4#b(y5Rk*N;H-)!sslfh`JBO)d1 zO-%Jp{LNaM*Bgwc`n9CInW@|sVE7cp`OT&bua=azFqOMB9$r#ZZ!uJ7O3GzS<+f}$ z8jRNP&LfJ?TLV^xy*K0s+UR1`-Rjw#LS22~_Zv5O}G}ZW|qWS<+Q7_ASXtx=RrrNSwQGJl9+^zRB2BWFg zPARGnG1WTyi~p;SZY7^J7)^EDw4%BiKwq1`!C*AildFpA!%XGY@N$FERFAGHs*f<$ zfl4*`t2KO~!Dy=6B;}d_)zj*V^EE3p)rFFBEmIwWzY0O(w5zHb- zg^j81I-{trGgPNb%14>XZLvRLFj~WZOUlQX>LK{6_~MJv@SItd_Aw*to(+}qai*et z>D&KFEeSqqPbBgozM%E+dRmvxr>N5Pzw%*MKqh-xY$|sr1-8SB7Fq-PC zlJY60T1S8JfA!Hhe8e85&!<*ssu4-~G=M9+o}>x*znbcm2BWF2mXsTq>QVTsvGKPb z8H}d7+g>I8My7J-Ysg?U)%lV_vqiOUM{&VFjnvx=MpLcYr%*RBmD?U}G#E`aAt^UA zm0QCP8jPm;yQJL0RBp@mq|=l>x2(`q$4km*naVwyUtuts>YtMGxj?=SJzdHAoRRfx zN%?#zUk0OP-Q^6$=YInET5m9#>U2r@LLgtCG#E|AM>aumD^t1a>)_`qeQq`RIzm#u z7|?LaV6?0YB;`v?<+h?fHW*Fyq%)QDFEbU*-R_M4tB-E|7aEMF`n#lj1;CYEG_TK& zuqQlEasG#EQ8Th|0gLwU@EtUFMYA%^n(?e>H#lNDL)LzdauD~sw2-)R6k-Wx21in!DyiqlV4XsX_qtCZK`KPpPB zvG_L$#Al~q{ukeUk>ncuSm>eWitZ<*@9@i+eHGOQYmrn*p4eh2W%u2uM(&DReMMpHfJJcar_Q@O{BV+}@A z?Us~3FqM0}c$dLwsvkVWeVpFcB| zJ70YUqp3=g@)xFZ=j(EV(Nw>clslMe75--Pb<71S?GBT#OC{y6OcnbP_@`-ye=ry= z>&OcgpZ{YjcfLjpMpHdcQvSwN?tEQiFq-PulJa+^a%69n|#$I*qgjlpPHS4zr1naVv<|I=VJ)%w>d-v45%r{Zr`R@GoM)diCBZ>C!1r22@#XsWME z%72*Zbo|x1iNCFRy^{Z*6`JY-Ng>62`?0S#7)|vPN$Fy$2Rk)<$QzWbt}ab=tfU;k zR0XGo-!~XdHGPrdvy!REvr_-Y7n8%E8jPko@nVI#6H~e4Ki@SNO?CVwit5fx)dvaL z(cw!5qp3Drs;KV5RMh6# zdob1Y$X9FybZJb!RZ-o;P~H7)D&?L`bp)v5kER+k7%l5MNx2tOx$VZmZ&#e})upM< zmXv!lmAf5YYcQJX=aOsod@GBEQB39b9G>t#MfE5{wO3MBG1cQN z39+o77>t%R_?kY$1~MIPFV+jSYtHRm6CD@Q@O{lH+@7=9nz(#UV4p6c>+_da>_dFT8+_E zKb4dxGL^fQAA6mmdZLjPNy?K96~xI$m;8AKqh(z$DNkmqgMe3jiBMBL?4v5}$z7Ui zR#KkARBo^G27}R5_xhOPb0||i*^&^;I@Mq_)fXk@sZ4bVsItDzrjIMmPc<5TT2i{1 z>OxT61^-tcov$OWS5)0yTGq9aQedjXH39!uQ~knVG}Zk-q4@ML70s8`zlls!ooz6h z>JO6A%TzQj#~)4gtWPRVyW0KOxRPOQXv7b^@eTM3#lCqkq-1hKppH@_>4b=-J zrJt#&G_ocCdxOy$KI;a>XAM)i$I3q#jHWv4Mn$zYK=ts?XpE+MzoZN>mD}HV=1q!f zz~t+m=n! zruqn|?u!4bk8Zt3d_hqi*`;NDLQ>W-RWINQL3EmmpR2^b*L7*Cr{AhjM=_PV^)?Jf zQ@vAC)-x5&F5?KDmi4GFD$eVTtk+1&2BsPURW>qt|1T-34TkDGNhvawdo(}b%ZjRK zsH&2(k*Ube#~-cXy}qKTHg@TJy<1X_W~y^R5|@akI{B-L>S#lCkFTkeW0=a_qDBoy z%eq=p2APVYj@i=qnZanP`+r@@I+m$o?Lcm7`ACD&R1=c2iK)&8HtSXXz+g1h_HQUz zo0)1msIoTdGX|rndcUctwlLL0@i(?px(q*JFq*3WTZ(EcQ@sVU;=F09YYawHt^T&6 z+Qw7|TV=4ql*ZWxqp7|mDML)<9v$xU9mRR5OH*x2JJB{pU-Iu~!0lxH*5W1UoA zG#E|w4@o(RsjdZ8b}Xp=M9Dv?OHlCq1b z+#cHCuNBoULv^d9RG8|aPFZ_@qo^u|>Jh(HDU(d)wqqL%Mr$}ODZ80!&?)QF2BWDS z@;fDKimA@W-&me5&DR=?rn=Yf71cCTJsq;Lt@jXv(Nu>^N|mYNz6Ekqa~B(oruws_ z)R@ZM<|qH4^r>}es_#llovGZ`<^g|HRCPmjtfZXERI8wuLg0(h@B;>;Wj)|e3N^!2 zZmWKV!Dy=QOUf)$J;W{R&x-SGm!^8bUsOtisr~_~tX2Pq!Dy=b9g1p>sqXERb*sT> zs>lCTQOz^eaZak&7>uU+KS|lcRPLF=DgUQ9?=kthK~nZI)jr6|+WEu&rl|HBsw*UA zA5$IV)bKukS5*59RZUV(V=A|`xzJ#AzCJ7|r!$qimVak3n(ER2P}0v}sz*UX-K*kn z8w^HMogyjEWvW%qe0{)RG}V73=WE+Pl|E;h(zr-cp2t+rf~>3`{wIUcvX1_j z;`4l_ngdnrC+Hl$%3w6rS0v>HO!XE}#a2L5J@(&<^9ziIvy$>craBT-S!?rpgVD0C zk(3u1D#aJ%rVbwQAC>l^E=~1ZNjZzDo(F7pth~%%G}Wgir!=aPM4;7jikJksoZw{n+Bt) z9z+-K-_8=u8v>Xs1#@Wt^Buvw zjxpo|XbJJR{|M%i0G~B?QaZmmfSDG|+X9#?1am%P_EM3XkJjv|^z;Ef7cz!)jz1c+ zT`;d_40$Q>M`QK~=EIDkwyO9NQe)mEn2Q*5P|U=_d|ogYGlu-$_@nu(yo=&}SwPmK z1@lJ6kX?;Gn$H%&yooVSiUIhhF)tF#TNp!DJ^pCSTLtr0#!w_M{%FjP1@j@sWXmUt zqQ>ZW)J=CBcdb|@@*jTJ16I(D#Bs_Nq}&79CmXDIPa%cgaEnteKni`{&a#fcH~LL| z)Gv77iXOVa=j~m(r@TQ@-oaF>@SDcQ-yV5)mG%xp^+ri~CsVBkmCkWY^_2foRPQuY zACZ)IG1V!c%39Hl^Z*Aw@9NSTeo0c^%~bA)Yn=)QpLZLo1MjI)E@!F-;x~MekNO2K zI2(+X^+bB~1E2RWmD@AF$Y3LU`V0zIQRgXKg zQQq4S9Eh;nXB&PyJVANrSgBEx6w+ZO0aKqtM`mYr5=lz$*reYMorxK7U+$6u)r9ij zZ%Ho5b6(kXL`K@7qm9~(Nc#wWRVUdquob@)KG!lPxg$}F{EJ|&W6WA4$9zj_Sg86s=bBkcE4`99{m`?;SzY)wQ8FL#lKGv=F0)hq4ZD`K3@r7whQK~0nE9A`C0&TlVH9cz^r(r(&rli%+m$)%>ZVvV7?W= zd`K|g4q$#SnC}EIPo&3#@%e55^K8M~#u%EX;EQ~8y}wp4-wR;ABAD+7Wc}AF#qkFL z%+m$)!vN-V!Tczo&-H@&ae&VO2Pu7i62KfHnEwr6b_nKn#<=a+9>M%HfVoI8KMTnE zlwf`yz})Fzm9Jj}FlPwnmjTQTg85Yd^Ylk6Sro2a+2tMwFBc4jYkio9JVx=MFsl#q zBEe8lb!FEvXr!TdRZ*({j9 z1TYr}hC+=#eZD1_zXmV|K3?feK|>#(!v*uV0OnM|P}t7L=WT+a;F`J-8edYjFkJ!6GoGOIp|FdO&u+m` z;KPSGUoaG~@L{eN3(4^FdIbSd|WAc^Z9|c1bP9J9Tq4*IWnqK;3y+bfGHS+QK ztzc*h;luPjRmmck-6!ikf+1Ji$LGG?iVwNbKFn!?A(zyL`LJNfP4r>@Ef{jke3H@F#iw?nR_2*TQ7dZhfJ^!bA@2YL4Fw~`e<=nSg z@u6%zFhxMd`zQMKDxM zKFovGDp{00ALb;%km^3n8w5ileVAVghW_KjJZJzv;zR%OVNMXtVFAp`1@p83=FY?b zpQkg%?UNiWn8O2nb_?bi0nGaZa|C1DW96R(b7TPXc*+ny>jJV~ESRGLnA-)jK7i?= zg287)0CTEfii~mR>q^0F4DdOC3K*ZG1DK-(b4&npv0w%Rn4b#fSjM<@E>LCSvnjym zRf5?ZztPamKjY>H%bU@RFuG48w%ks-vV8sa0ES^)C^GM4z%1DLl8=F|Y@{$x<`nF(O75zH)O-1+*I zU>X5FtH?0pGZ)}f70i5q&l?4^CxE$CFna@-hteQ`&%OX=LNKQVFy{&8^Z@2Zf;l6A zc_0lq_&hg&sR`!H0Osw2d0qh1MFST;&ktaZ63hz%n3oIYg#pY}f_YH@^JBrB6~Oe- zK#I@VjB&Ta%LMac#vBPWf?)Dd)YuC_gDpNUVT?PL`)t9S6Tr*}=A{A5n+5Z-0Oosw zd3gZyKpOnN9nBNNKwE@fwIX?Kjjxp|bcz<$y@OgcJ&x-}~h5+U}g1IPw zxj#8j_*@*o>=4W)jB)FHhF~rYU~Ul18w0X_E0{M0FpndL4xcv%F!O?WO91nE!CV%= z{6jEr4PXYzdBo>!0nDsm-X6ewNHFgRVD3UrC_e8DV73e9T>;EFf_ZlU^L4>o9>DaH z!;8;*0+^Qz=86F3D#5%rfcdRp-WS01lXH#F`vaJh1#=~1-0k_jg1IWd=QhE7Ab?p( zjyyge49Kbo=0gEKuM^DG0nC>L^WgxdLX!r3J`%wER4~^BFuQ4DfzP!8%+CdLT>!I_ zCLj2GG=TYuU_KVWlxTv2&&LCp9}DLC0Okam#NhLZ0Om`A`6Of9@uj&n**2;!Q2wSyjL)v4PbsN zn9l_;hws9V_ajB)p!_0x*aw*q|L zDVT2uFh^DupYH@PUl7c91DMlmiqCBUOtr2s-wR+KeX7EIKY$q*%nt&XO9b=70OntU z`4MB>_UD;1_z|BU2Qb$N<|mAym|nKcubowV{x^WRPB6DK#yxNPtzdo{z>GGOte*ui zUlh#G1DL1JDL%glU_K$3UoysBhJ|^>=T`wfUl7c%1DMJl#pgEx%)R$2%x?pjC+}03 z-vuz=5X|oxGV~%vT`9q$o`23AA?lQboFn?!^yUnjVQ}Ou+V}>9ryI<>Xg865F z&yMFQKL28jTj!Sv=HCH6*9qo7jB)3y|M^N5sp{K%@Ls`mF~*(u)h|$d4hUdADwvf4 zS@(XS;&Z0}pJBn=Il$-Rg1Jio^QadoS$7R!-Yl5A1@yVkS&Gly1DHrK{}sTzPcR1t zFb_Oi$+|}X^LD}9lQHgbdEmv0&%FYC&JfJK1DLA>b05aI+t?v5QL_F!fH^}j_hpQ` z&HqI(_Y3GVaE_97|A4IX1oMCZp95d2_&hM6&l!SwP(arI3g*E9S({#_WIZH+dAVR7 z8o+!>Fb@l0N-tNk9v;B_PB4!MU@kpZ@p)tbbBkae6~G+w3dLs?W2miWeUf(z=AZzd zn+0=l0P}=bDp`*XVBRX2#{@7x63k-*m@ThTvK|+}TqBsr2QaUGwc>LKW8D4gUgs&y z69Rndf_Y*9^8>*=DS+AZ8YSz=jB$@~Hwoq`0X~PGulO7qz?>kMrv@+=3Z^@NxlS;J z0OmdyD1CYYm@&ch1~8uzOdn(1>*n{oP{~@&n9WWpQ%$fk^4#BKtjC(A2 z)N7SK0|7qA3g)l?<~+eXEr7XBFi#I)4tkx^=kNe#QZUa5V6GF)5dqAv1#@HoGxvI> z&$v*L3eh8y*5yQI9@q?{!w zuP`Z>O9~hZ)y+t`oAhAC=P!bJm7%)-ThuSFG%0H(rBd(l0r8{D9n!~<;^DLz8_S-&@B+^+a^gl z-=y3kDRjew!rU$?uQw@o`jGnN!zSf%l5&wr*(@m+o0Kyph3;Wc^sko`x^+RNd`wc_ zWKw=DDQ__;cez?&>HY-u?FdPs+Y(gDtfbIsca`#-53B#uNp|(^Wgk)h{h&#?UQ+19 z_W>)SX#Msb(Uu)(g8WhF9|~s0idDkr4wIre-{%^IB}}DjC%Qfurap5C%<)dlO$p2i zPRt(?m}faLAG7(4IWdnfKD(Tl13qD6Do)G;KWSqootV!g zFjG#<(5GxZ(@xA^5}2wJbK|FNJ~bz%{{|aVcVZ?DMz_ohGASR;r2N#RP|G~a$@#Jy zZRuw_F>m@zjG_L1;@H&Cy!2D*-BDDUoh{GEl@63bpX(A-l=8Vu%J(uUzs{umE0c22 zO}0M7xj&H-O_!%<%ld{1tez?jNp9*Qd(8n=2!Q z{`Iw~sWROQvY|X)nwx42&KLV<%Cq>^3d!h{jfNgQQ8c@&G*cdn>W!Jfts)ZtnW&bg z1~<+RZJOuO_bO2=7B^ch1`IdXMt4W`+Eit9U$LiHRHZ?;uu$7t8j*!mF1r_;$Kr-G z&&4k}w6pD-hL1|L+(HMkvc5ok2Q0p8%GE}tv2SkyEf-(6l&YnP@(g5gGl<4(GsVfc z{c3c7k*RtH$G|b}Zd;wdPg)E%Wf7|@)v@wkn~MXqX1+W#i(Y8MQmmlK(AMFo(5rNl zoNyC{p2ch?2983H=3FPcwdT8;e;Xv8YZcG+Gi6xRF-}i6@7z?*0&6O(+m-W}s;66N zxS>4Tn5peEIyTFhk1pADvw8EeV!xR1;V`TB?^u(a7y0 z^nq7n_^FIp0^DsUC1TB(D)(0DdMC;aFO5&dfl+RT5!AGLmae0eW<5P+>Z+CUEcNAR ztUNL|F;S^b+fAI&8dcrSgS!I+N#)uwkj941AN9RZEqPA)SS;#Z?6{3)m#PTF+1gh#L=KR?rA2L2vf&G*9+J+tj(}(#GsnFw6 zAr_IBMOsCeCh~|PlV!N@g#xBWdv;YucOlhkW6GP)!n*+{W1kP*qnYoi%_Igh6o^xs zZcLUiWIEuA{IcupQ?yQve3~nAN z@Tfn8z(ZWBv4-iA(Dm6cvr) zYI$(TNonlIa4!NFgZPWtcX4FG%^OeAQ*jj z^7NQv*?Nu~r&7#0X*<{rbI_#6?3l+0Mqfv{QMLi`@HpI9 z8%bDeaA86}RH!FnSoSJGVQ8k-sAYop&ea3B_1y}&xl-NTU#TLXG;S$6 z+<>{5AEX5UaxqW=dD=nPD3--Jd<)1E?HoOW~~U(_w!dcvJPNAO}}tQ*Y;^XU{0Uxany z*hX>{NjGd6Cej{5v$1tD9^iySak^5BmtVKG!5}^I7W&OF5H)5>2*3=Y>JiP=QFi)1 zza1Xr&t%OYT5pvlb1}*W2Z2OV;N$!KE3NA>Bojh zQzIG~-Q4Q8;+HygKzxs!)jqeg>eIwCX<1mIhMDFr;4quqg&k(o(u5!`cn{N7D#2?x zOkL$@$v!4c3fV{2q)>fiEfr#h3G6tv++Ih^)dN*(o!J-6fq9}>Y+8b42|Wy34(s$) zvC+sjR=G{Ar{y?J;zG=AD{>sBSC3F}lg~yZ9D`0`DHru1qh!p*qn0)}*D!nl+nVa$?GQ22n%=z>M0-$bbX}%&+X`v@>(pdpVLbckDBitz>!D z{Zsi}3TGeoWm|g7*y2wykkO>n_TBJAP-3n+h1i7Mos)40-kw-Y?HNc!Dik6a&+3eF zNuKO{+btIfdDf-FlTEW-p}8UN!TQf!wL-gEu}|kT#He&+qZ*Y4hdQIqB*jfICcw|< z&>KdGxThtY?~Z1^2fd%CUD$zKm8n-^L+K(GJWZdB-Lb7sFKj`wzP+1P*5m z_gk?DdlVTkyYmOD^R#w>P0EmgV-K!<`$e^_zKEFnd~G*YILXCM3~UfoOodJS*-k`d zOu(jT?$<_fEGN$Ypak~SmK0Ahz|tVBqgg(k|48hI0XDf~hGR$eF_ENmm^O$>V(P3E87pK=TfsJM8N(X8=nhBUh@>fL z%H721W1^BVX)}-8MMJ97cC)PNJ(lVTN8H6m;vlid5Xftj=}6vuyV>L~12_GG%EQgF zdD)~JqiIj!vPhF9^PZ@)3{=hj?fP14_7f+ZxrW(pMB|NVaQ$jyKJA;Y3~>kn zo0XEIY^SFD;JQS?g@HN_N>yOq6X8%#K76r|LV-dQSofn7H%06UG@JIUf+ic5EG=vB zO!*{^NwhDpU+A_b(LAJC6KQ1{Ws#ku@Vo^Fg7u&}L`yCl5i+U{H+rW_d!a3P8ZZ*+ zs6eYr-5F1*wHY_9=!)lI?_GCH39%|>EnW{ddT?wp>CT(^Q^#gcGIcVAw{_8`Olwgo zk>lKgvtghs=kZ6IxX{JoS~E`~zb|&z(MI5KvS*r^A{l$qp&2Uj(yN5%O=eJ~SY&s= zlsjr03MFfswpC!FoTbmJSWkFyzKCfQsiGW{jWmVJOrcZOxFfYf{dK+NwjzUz+6Yo6 z=BS7^H^gm08JWeNeXQ?kZ*F8Z3k><@kxeFL&Cf1abpdH)tKg=|Tmt`T;n*!!zfrfI z307u|NGzM%OXk+DZ`$kA+D`SvtVO0ZIAaV)*L1ePWPP&eSZSVza_Oz>mYtNDLQ4h? z!XmMte#RmpTS|{Pflf z!NaK40`aivXyN!|I0`B=S;$*38Ny6K^h7}?G{b;>(%>eO%(iMWy|o#frm@`WoG~fo z0SI0VDUmlZb!Q}>}#oM3XF3+2rahT6OTuzPJ2wo z(6zXc@+KQp>=vG?ZD^Lq?{DVV#zX65I%b)2#q+w-&1M=1blGK$e5}nn^NZ`s+kSka zm8Fdrnz}uM&ROP78o07SMXP=L`*co;&1yN}Gz_8mW1rr5&6_ZQw&}~}*f?vQVzYeK z1S~+=nEP!3hk}uJ-9?5fP_^@H$6jF55Q+o7TW+E^W#jHFYXzMz87`3Ng#^p@tgI}?p+O9iE%Y<^z zTIP;4_G|}eyG7h6(z=wkraeg28!~HLIK{suLSHSPI)_Wyl068`wScwJu`z5DpRJA4 z*qO&QXf{xjnX*UfrHcO8JBD&*rAc5Xv9?AmqxE_te1{4PCt6&g56E(w!<^Y_RzvD; z2W?je$#=zhugUE@BF}M-Me-rF2FaT1>DH43y{U=9v@(I{)xYtPxCOX-;lUW^=ZiYj zGki=me01Cw?Rag6>Vukq)z>K?-Gf!^_~aorY+zvK;}Tx)BHWhAyTA#m@L0{;OMoIf zfisr&J};tQCZ#fa?mS(i^&$)R6Uy>H(;~ARhV5uGv4iaOY1%2rj%aGdU9pi2-JUjG zwR6a)NXM^eH^`vfY`r#XnJOkR>QmheA=f$T2Rhfj=S?LyPSRrFcm?;JLIb*5nC^L9LU+y= z;>SiKY*x!SYE-8k8f^Gjce-i8*4two*{*cs>yY@=g$|1+C~>ybiXC()AAu#aY#4!L zcHVbn`|WZcnvt^v-you!>IaUpsomml_@@(P4i_b;yp zb!{CB9<=-k*p9#s+>N+Vx4k{6G=6VpuVahlb?iS?mvA?dt_EVIfgv4>ziNL7uLqlX z0Bi<^C>-s;9qhc>9viX9E*GM$aT@G)p;vFGQR8f4Ggh+$!45wmef$g}5dp22FhpXo zT+AU7-nJd|fKA}zEfaINUXSi7Clz>{u2<%3?JeU4Jq0WbV>^9PiFR%^s83nfBA7Ti z?$+ZeLFkT4Yx^3CoxP)__DxXgkULk^rM~pu(Qu=D>e6~Ub}w1x0n<5g*nf;%W(rCB z>|7x%Wxa5BrM6y3NPCo+XeooXC5E{SnspPLGDf^@k2n04didT)%y+Oe2M#{$2kc*B zClW}y)iV@gMR_H94TdlJcRGHLN!YG(sg6Sd^zcGk(~+Q!p-mMTBLfu?h~-HT312L! zDdS4pGwHV7X>4yURij1?^P!p9#msZcw!+jP+p(!J2EOwJpi4cafwek8HpejJ71~NS9V+%o2uF_9ot()DQ#;eOuoRj` zHjPhXsmyUtVe2#64yb}q}c+ z>_foIG!*n>TLV@_tscqc>bgGASLxwV06X~1t#>puk+pB*KD+_FRAwCk;SF2aQ6cMJ z@U*}T20Rqd(19ZF$7Ob7*oRdb9o5hC(cQUp8nejpHJodjrt|Pvs2kdZRU=w1O3tG& z&XmR`=Vlx2o81a}YIq+D&BxY7WC{|4oH_!73w_abLz6YTE9c#*otoZRTm8{#lM%Ic z*yoGECG9Junp))R4$0}pxihNFCR5iwvJ{^HxBld$0wqJa%k}kC5#| zWbSN7vz@k_@{n(y8%o4 zM#>1f5Eui-2$sNYGP(OZ?QmGvfUC>35?kYZBW!5u3I>=1Tlb68)`oaOyzq-wl3B3% zwRT~;GMBcZeLh87W1O5)x36HKP_E9-&EVOr)Z>13>B=!p9Dqlu+lP}DAlJG{K3kiK zLUL%LC~Qp}Abp{b1vBd@F!Ry6>b_{K)F|axT1m3tXyU2<<3fzhW)-&N=$U|&H8+ogJtSDdN-+ax< zsgR46kvv01jvKId>|7@2f5oA(3g+^W9``$_POS4)S2r^CrmPdx{N`?0HiybFol~J= zf(lKp)q6E8p~K5xRm-)3G+7GH8`CTZZ7FtLs%Aq>n@in|{jIT*tzzvUtaYql59J$0x6yk_m@rXt^!N*@jr*4Om8o z!o2f8q3|LEs9*}|saIT)nF_ggv@+05;+sRcLeK)kkt2jBTDUt@1&k7f<;=jc)o!u` zsD{HOfW4col>lwo++?kd%3KrwN!)l83KJwpnU05W;s%c1!26iu`tl2Fr^XhtTRGN} zyCI(zGt&w3JrLH(yB1~nV&rzTM;ZG|eRPR#p|G`9U5`V0bnmX)Z*t;f9=X7GlvGKa zb{dY8mv=?uGo|S=CZ|?dQNnI$yS!u@?;gS67^DCpQ;gyz?g)`O^bg$bn^|FQ&IPoH zhJp#P%fkhsfhd}qz;R4V!RnsLp`^-VQ$zE^=wKQYf1?thsKs!JE{8v@jJs;+{uNkj zzVcR5i_>WeAU4X2f4s7(qG+1G;+n>&K$eYBNB$FxXn@6wPq_UunFSp??A=@$abBE^ zN8xAZrucaeTZA3Aa^1I#3&~P~(Au#OlVc-LcwsQSQkyM{r4h^T?%Cx7v3WK#~TSgmb7ck+$DcsU3p*<8K4^=Vq*UXn^W-0O*77WdXXj4Thm__D{F6&L|qm_=Q zx>+NjG0mpt+3t{=(p#8KW%8WRF5#?9Uoa$3PJOg_^6I6{ky|gVH@|KQGzPSVe${MK zb#Izjs;R6UE!9h-ba!#8q4@~tCjH8oCCJ~-Qlhl8(++JfO&j9OWo7!*9l-OmxZyd1 z%BkL|+fGW$o*ur-xl*1b+kk1o$lSz)tiRYz&nK|ZQ<|lt9pqNDS55_-DVna=s?Y=1 z?9T4amv5bz#1wQRq@jU@7%l-#}EJd~GwGC&}vgpKOWoij(>*nW$SZtbIU`6WC3mQ&!Vo`b7xYUJ7 zJF0{?#Z58v$mJD#c2!1qAvM(wsbX9t6bqw4BtHe6|79V3C2?xdRMsl183oEQM0-e* zm5F)waaDc*413WU2xq6WLN#IX-QS0DcA?^OPQ!I;$&{;gS%6u@)9zBvtFrCBphwk0 zVrs!JPt#Ezx06<+pNvq1rX1aznror}R-5;pE%{b%=vC*yy#;8i`uanQKHDh{M^n-^ITq!jYC(3r zo|y%7jQ3bM%{yPcWZO?Zx~!wL12zE!Q9=}%qs1Bx8%j7Q8)^@vFc@%5;KJ9E%?-b{J4L#gw z+?CRL19nwV+@q6*$)nMd8>v?G$kw8@DYuC+Y(-AKI&};xqf{5O4UH!G#5w31k~l>+I;+Z)~2AX3FEd zhd<5JUV3S5%X8wL=SmepxA7G7;Rei&Y(nRo%B-E|bmt(pz2h8KHCY`UQfRE~P{?wB zbJlv3*))yb{Ms#@QP9tgmFo2}u6@fm)3G0$tHI?J?ReOowpt|Gq5r&iXuZBjcVef) zipa5EAN7nGQ-`$5_&uo1)%xi&39EUv42LPGLUDB68JtPn*KQTB9ihp$oEEOy z@SKRAIQz%eIl)@SqcHz%c&8BTeLPJZGk$IzV4X^2@4k2OT@ z80Dy6*{*Sjyk+0k$qcbSa(MgH`;;z+*QZf zRAxS`XXv~SxBaM2mT#toBOy=lEIi>g+eq>a457Cv@&0RPRGOr?j=Iw;e&yS4g^9^Q zM+>0`)`F*bxK*O+nCdNdCD4@5*s8Rp>V@4%KGmomYafrQwesH4a=n4Oa5_{6==nOp zhEO5K`(lKJ(Cz&8gH;s?^Vyl&m&(T*e%_d|alv@t=#W^9T^vqK4;V;IR)lpTBK<6Y z?)>TST$4VSbpNq+_4-B=AK7e6sD(rtu}aF9Ry$+r!3Fsf-OwE3_B6$h4{5V8tv zb<=KP%Z6SPcECc@CEGBrXb{S@VmnGt*0fTH&k+@*U>kyhj*wY;rpECxg6cy`={10K zbR^Bd1llqtkzc&Gh5@Ck?S98oh3qnI4j11=?pnr3XTe2B*`V!%xJoNI6+mjzvL{9} z7b}VFB)c5flRNKCrb%WT^G1;%0h{GY+P?jCZI~BSB=Oql34Af_En>~h% z%tE*)Kfd@*p+F&*h!1(}D{i+oW2Oq8>|wU_tU)^E2YG@3{hmdU#H%vAhLj2fC=(_d z7kCAOZ}o!$a#S6g8L<4sk*|d6xD5`E)Iodla$r*Mzr^pvxYeBqPH(NXr~$2t)2&z- z$FmA$Cc9WcOl=0h*=!u!O-?uTDton4vkcxH!Z+~QgUO;z?-GxK*b=FVTnz{5d3@w1 z?mgb#Hgh_9(KkKl^uh_|Lk*efoUuinn$=})QHMI>h9nv-Y9C4^YoD*7#8{f)kyp9! z(S7W+T~F^Cic_?arku{{f6A(Nq=u+p)6K$5*(g#b=_t6bnW-iUd+}#T>w5;t2WV>! zXEtCA`R2Y&CXmf9)=Sk3B&yr~+7!sw?*%4vv+lO+8TN#vA9TR1XyK-4l1gsUehAKK zLjselT@^l7lbtMiMu_B|a!fP2t>p$9e1}M*lxabn&N!0s1gRwl$jQLzI5-t|lBbpL zh4Sf1QVvJS&6{j&I$Qy}6N5eTh*rG9rp($YAdg-hFD#!NPr+p-G_4d=hS*s!JyFmh z&M;yBxao!==XQHC>v+Amt!GPEEIplMS-Rmysfx>5=sa7j<_UNfjkeSjqUJlk%BK=C z9kTRHe_CFNF7(XPfptAGN?Dtbv2Uf8CzEY7z4(c)99qyR;F5B>>;~~TGB5Wwb_Zr;!ZQ{IYz>2xCS?L0Xqtivm}}{d=*M4 zCT&(=WhtlBX0@JhPKHnwNyo%^^P4a*x9MN!*d(1gQEBIJHK<&TJ(ow|72svaGZti zN~4vWfyTZ%u4bu@*Ai_W0W8ch%T>B`PA|rd&)`v<#;(e&dHT+7o0<2?`I_@gS@LL` zx=oJi#}#RzNri2c)8lT|DC-58g;~={Yc4a18C;@ds5PYxA)=J9VJY>1%W1=Seqv8g zk^=n$f9%94rzSPBXWeu^tJq2ISeLXW(kkJbW z_5N&IZfvthps=p#@RXAC&(c3Fjsm56c}`WDc`)%Pk+IeE(vriIRFfFI zqa>3UieoRpy$lcZm~9qy7;E^LXqeu(O3X^*!?8IFq?t=iO(G$K9>K-LZaMA%=j}j< zBazUUuZG&}rAsV7eK5ZQ3$bP{MPdIvPUGbJi35Ta2Z2In>^WZcsykb+>Lq;jL;0 z>3{(mg3tUFAiKHwgJ()N;;1c2Sg=lq@nV0HF0yc(>CADJPWo_k%yYWp<{7-3r?7gg zLT@Y5Brl@L4cQ$$l$(m^(BOz0sH=^c8ig36sambxmV;Kw=b>dc$Je9G91Xb9#E$ zAz_*G%~p(~Lm~o8jqY#<$?d#P%68x9md5=%y;HiKaVzW^(kP2DXfs)iOn{=Lm9?eT zExYux|CC$olsLo0`&PQSBS=~=%`_?)Xcu#Mbp&EyGjNJvt~xP?C#iAKCaXbjSw{8Be677@&EP}Qb)b2i2Am4b)p*B+oD^!m)g%kEkJf$3zh2fXi+|O z={+aA-ZP<>)@Mu$8En0il>NsjW~Q&S57HN2Q#hPjMi>V`#S zw0LVJFIts)ysz0?VI-1dKUzLC$w96)82-o-yVfT#0i>7Jad3o=1hqB&3ECstq~bJ4 zP!&OBo_MwWw0jQ8>Bu-t0Y)b-(`jsFFIA&P4Rf%W*~QGe!yZEqWIr}ZW?<-i73dmp zXko3skZp2|s0*6CJMX!12yx88Vv``xOQoNMYVlcj+Qv!`yJy>jbXmHgXb%SIw#uK5 zz^Moc!VH-mM{38sb^&nE9Jf)*jK3{uR4S;ek&(}8!N zlqRb@d>|w{SwjzBj##^TZ_^dmUKVw*H3I8XMc5v?VLe+F_HczZnQo?&>K5X71WQd4 zh$P}$G?h&+F4ugk6p)o#oxZ2^J&uvQ?7w+>`bJT-MB>r1FityM{AgfL> z?9||5U$Q6zWok&kI63KwmOICLy87NRhQ#A>I%MawnoWidW$V+Cf9{&OAKL_v^w2}I zOc?jk+FZ4P`8Ee2T3`HM7E`G#H*F(IA5>qap`;%hQnBU2RmQG0M_)r|GJM(>Q=)~_ zXt80(=u|RjH(rm%>)p|8eROIK9t2}Y4LzbbUZ)3XaF~&wdZy*V)UhC^^E2u3TX;%h zCS5#~(BO{Z@5hCbW7zvv8Xd)+m&D26BF6~p`=V(&x{p=&p-osZL$4jq&gn2#mBuFL zW*hCB>k4{vcjR%3*IEDYYS7j6)R+Lx{FSC5ECyu-I{z$0E3l$^xeQx@Bk)v%+D3 zi7MH#Ia<*4dZsESMPsQm(Ogbp~wP1qSLl}m*{1E z5%&t7WzAzpocJ8>PL__rwA03UMiKkGscr-bw5FeJ&3O%0(q$fLVz%rIbgV_vF?8BM zm>yfK)}IPi`bL)~P2Uda4RCw(ElOH}QsYS_>b=E?0|o=c8@9uwWapoA)zZwqXk1=` z9>fOYdB;*Dc3|ULnbN+IG6F?JfR`{wuwB3=mAm|1o>1mAKU|BHyCl~FrSGK*O{>8K zb9C!oJlY8_H(K=GofydCJV%3ipK+ZjE_%+TXsSg+jSHJ2z8~W*iTl+9fW> zfpIwlYN9vQycQt8dzfEi-i(_Nv$dQlG>1ltDy@+Ns4w42LCyLShKy)kbzej;*ymVk z%Cg}pWr7R4JXwc`BEf^(hc=FEx6vq9cmmkHkM373O<*OnR;TM<=qczN`lQBmWJ?`Q zZ$%30n{i|Mw7z__A}%C4WWEr^T|^sM?V+cqVf_4#X~3x0Mc1di{f(;Yw_?lqiAZPqG~|C z>mRFoCWkNwl=2^&8k!&GsxsfAiN>y(atV>K(MDyy9Mw~0vYEC-;#TQh{J;)^qBM;! z4(+V4Jgc5I(;5tJN1U#VdLgthp5}#P5Y>sPa&gGP5e+`(7y#0qy9{6Ql}e4#T`tbF z7sKM5hEhZBjYHn0nF&?6oBLreYBOb1pk%6Whbuyybe3cDBwdq%F^O+x)z_^~bBX2! zLNp4zQmcTcEe32iO89^mIe5lQJq1Iz>nC01j^B9>>n2sxTisjfxM+$uc`bP3sX=d7 z5sM}eqlG<7b=g-O)}Mu?6|VWwxdq@ZEv0cY-V8KsQ37bzIW|s&y|D0#lwBc9ByEW^ zNP#G6aZ8Xv4twcFj2g_d@g-b;YV?;Jbc)^5)`1F(;Yiey)q{~}XS4%_r=m`Xxpb~R z3`?V`x!?&)&bYN!!a`_D>@h}Ilf>(yq(ClUhHZbb+Nd=4;nrY?R((S=O8pcj#qG7W z5(!$m*;e-g^FDZtSY4@(mG_G9(C;B8Yv#){vlJzh;UJp{3t24T*7+h7DHjOmc(#e&7T|J)0vstiwht~5-x5Z zX|TY3M1l4YBni~5mo9BQnwN%}$F^SZ90+ySuva^09lO!!&@ci0s(&TBd@cf4{kjRQ zIyF`=WqQ_*mg=QZ*ypra3*b!c`Iu68rZQ&b(%81vD2yQ8H&aUKxw%VHizLlN^-`cL zt~Qe)j~Ex+i0~D{03H#Cv5io4YOKozG;BSp^z>jPz^tu2OG7z=Y9n(K6KWaGZsVz< z4Nw_@KJ^McrCB4gtewb0VZ&!J$UMOs>RoCMR7`pB(GpOW% zq?!g;(5nW8gu4h+;~3>rlu2Wk`VnT)#nvvE6h&tAN&lW6GSa`NNAlF~tMxn72^}1c z5i8=%zXO~q1P3DH$he%b%pm0+0y1Uffu)Pe14|5Zxcf_<$&{PvP=%_kx_>d9DD$() zvHKT8h!{*tWFK8EqQ@@puZ97Kd32D2chU|v30TBgLV&1cN+Xz}M~fd1sOzxO5{fff zY`JWy$8Vy;wA8=ar#1>KO{Uc=nWXYk%Cj@6y8wzTPmCeFN@t6gCc`11-Lg zI6JbtD5Z{Xqd}7{lVdv)F8t*jE`wa1X)>vK>_fN?i`a|D?+c2N?jT2_C=6+A(~`G) z(k2Qz2jR6&VYo|#I4h<@S<>yF3~8*K{j(|#t+xG(A+#7byQ7t|NiX(!ve_!RQ6bhn zFAGyFZIW7|;qXu>5*vFPc)Ss7hCOm6+@4*P(OpP27A+658DrXFLbJZ6e3QUtZ0Uj> z)|cN%(Zh*T;WX5+R*pipENGt_;tCe$d`O#dvi)P>|F|kY=ZupT4eVFbkp$GHsRnu> z!UgoR?F+HeKN|A5<)o$R-t1^(L8xYJ-6>|~xH4PD9#Q{o=;&H<8#)_hbIz(wCR!as zo}3H!m2p55&(22fNmP-3GFoHzOFSZWmZ4EIUABpdt@lSwZWa3WO}HMX^09 zBSAwCT_zS4@=+K;ae1YyQ+K(ZlC}kTu@2_(AQIoBu7@u3#!Yf$%tg|osNOQ}Z%juT zLV|?Ah>5qC(T$HzO49)8#3M#$x+#*4 z7_&^08pm3GHLS`v9OJk-jVhhzY83Wlvt@ma9qlN?j;m>mXs6U{ZbHM|IMKLUw_S$Z zlvL|HtVZ89u@N7SP08`!QwodZZFF9mBZE!G^Hy{)y(ccdPIEUI$nTM~k^|GR7LmQl zf~%Q29P`mB+{)IHzr0$L1VwquMI0oLq$__W+7RUt`{8EH=Ij3W*<;M9>aa%V9tL z@M)V%`_#{H@33=)-+t8dM;&fa0vT_TjOB(TRAUiGo zcHVh`RyI?HjAzj}xIR_F6M?i~9+l?y4oWt8uYp##4MJONq8IdHhmV=pB|C`xWJs-T zQR#l713B1gy(PlEv=g{mV^pW4kJ1RX=Nd^Bja-LkiyKo_?dsz4D(xnAh}S`( zEJ1pT5<(irxr3!vY|t5SM)(06vSqQQ^IVO>&4w`NDyLIp{YXQek+pTMMqxHRb}Y=v zO9G#9a4Q_^YmrBL%J`##A@NN@g(1>->O_uY-ZD!~ms%n9MGeIy=hwlo?m`TQ&*QSs+X!3cw{Ru%G|sSExf^PjO`b-ZgTum0 z#McI!H0H2wKBih-Ps8>wZKaXtW}#KdHhAx7YdUtgfww^4x)S~d>=WCh!TQMj4Kzs6 zdX9W;#n}LTvVBanI*A6CVS?@cWJP=ZRx}5R78UQPO3u1mu;Su=2fXfI}3 zg7VAsbSbr|rDa~tlxum{NnaJW&ZXvbDJ9$HX_U?F5PEvO(}8Qxc!5Ge~}#xQST_u4Ua`o zG%L2z=3g-&?a}IqT`$Es$~q>G=Q{KZ(4&L{uZ1M6s$LzZxvTpJO~&!L79SSk)nU1w zH7>TcR;ptzwnD8PwYKZ74N6<^;>W(>0c;yy%GkFSxWw6{%@IqQO%Z6a*?!nJu^(Wr zif1i%ODpd*PopeCThHY{G}`+VlsKo zqJ~%W%;|TZ%j)ramqN78I&M7Xht}zyRJ`+!Q|)7BXG0awJPmcGBqnL!gnDw2!xwPF z)!?yg(scpQMGM+b=}cZJ-pjj0di3HA9-6Ht7jVS0T6}>fn-FCtwd|;LST?Px7*E6F zXDqHromD*lgK>JUYBy! zW`fjl#hJ5FJZDo5Z(zY@G}@#fo1Ew#6I_2@#|;C!_0FlNQJTP3Cw~1|PVX*{WIN-F zKY!5=TrH(I9zMUjXW-J{Vtza_Fo^2_3a!5MfxQQKhE*1(mstr@9Jbp(U|tp(tj^a)`F$~D6i-vQ z?!+(3yKmThJzv|6BYzbAO-zaCsc5~?VkzX9Ooi&0F8nZ0e+=raBu%TDU)8P7HfH8V z>9yP`yuUWMBN~)l-|C_Y#~U|P=kN@$;UvBg+}r$?Q8iO^mfNnwUCsUN0MalRuJ-#AtosCv05mR=tk)05k_;U!W znP;a8F;$bb08?#w>$7Ekv66P(y4iT@IRuW``|I3Izo7bWhox54(-zz;o41QFofevH zBVLn}vrV)>A1i@Am)Z}UsB`y^nmkc(8K_zW&vYOkPBTTptfiN@Xf+$k71ma&^|=N= z&P7QyYcUq7UtMBNx0zRlc*Pyp+?e@gM;IBkJd5WouS-L{mRIOIC#2)q8K}>c$0~4; z^i{Aj2-?-*;OpvwWf-=($~P zycPlncDl3|g-EdpI0UlR?@HDrWJ_CJyfwj`c4@8q(%WDWpM3yvYiquAGL#;z#w@el zyQh;ZtYXZpv*F;8I>t+8d0d{glUF$DYE}HG$+6CZM+1{Vaeacd+Obt0S>jQ{%2Eo{ z*<8HUoV958cskK_A3PdK2Nw%%K_*+&h+W5=IwQJRTx*tYwqrrV%$b%{rp_#k2?C8A z3(YLs7~i8q>yjwHUM0jhHAi8V!?SMHiuV&;;=<`c;UxRt&!c?&80ge~qJ zTpyuTNGxI_Epeq5arY~g;-c#KQWp=O>t$tc(YWgj@W{ECy}pq2Cyqi4&|217)Xwh_ zZD)P)R~y#%w6zMe|0x!`J7fi1Ye|+PAm_t}^j#i^cqd-(ZnAW>jhp36naw6HGbzuM ztD|ManB^AaZLk)~bS{M;-C*!~Gr3&|h)Dpy#azvAhd--UojS!zt7cu-TF6W)5(k@y z)cfD95oj^iP0F;vtBsqKbCYS2)!oFsa=^8Se4Y``*=L*@y78w)rzXrMR;d+#WRjZ3 zq&O0N<`_o28>|IKBEU;4N0!R7aIvex7vt;2h^8=`rL&eZk+WiIi0i@VYAr`Bj7hAH z9VfQd0OB}X2w>Rw`%xSmx44`6c{_AQsIS8~MW&0h7sY8UJvfWAB}TSdP2wVMz7$%C zm(3T#B38w&JWuG_UDF}3VV|e=Jd9du0U;hnndYs*!)9SEqeZ5+y1A>^C!@_4(}Z2D zqGSEQZY>#;#XlNyf9uE)=4cIW8Y7G?buf6DVZf8I_cwc#bVRM7i?WfkAt`>Xb8 z`+n67$ZxF8;B5}8;BsyrQgPWe+HYPkn^>h%6;I>Pn=EnuPk^gVS1}Z5{8gTMQcA6ti1U@1NUkUKKm8@_x`tvtX3<$1w=q>fcYZtoq2sRO}X zOaV;%7~Lh_-stpO7E7kdEc$6?OHC)TNxKC2=tJOw-sO^QGVkv~Im^9SxHO*aP3m2R zOD)r67FkLKxbp^uo1AT;`!ua~ytqPic95I3+1U5uM!xN^w;C;%SqEJhYId9SnPA4z z)Xai!&IaAYcq{LusBJea$5IM4*&)0hEGXxR$QAs+sMWgR}zBbo)q6ERy z)cv{pvwEfo$z^D*3<2lYFJTI&%2?W^IZ9)ov9FF364mjVj!t)&t5#UWY2`$QdgM47 zpQ%kpja`*ly(vF@iS0ZooKcUbZl|eHh!&<7PlV12wGXF{N?~f-r8Ta7ZnzPV^$7Jg z`j*_tCPYS@-=0refqLAxs^*j}z>NqLTG}DPzB4#XaVdF!*G#}8r?112a672pnwyd( z*DBbNjMQv5J<(4F;o{J&zx48O$f1Zc7Mo)x?x$;4Xv%%)ZR$QaRd8@=Ng+>gu%!|S z@#usyjyzI`&EHnylJcnL;Fv?vOcTseN^Tl048KNE+u=Jp!iHUXwfZbxP^L@6aB;xw zEbp#XKKMW+A(SPNqcepuAQ{ywZM9;4-X9IQvhSJmLj^ieh4HX_>Rf5cV%P#)i-4^x z;K1Y97_M}lt&P)!uoFQWa+l1efJK#{GeX1dQfx1Y?^RkNX?6zlR85mjDE48hPO;M} zQsar%*W?UkhuRX}vPf=SSOO_JLtY=QL*1l^t}%=an`(dTAcZ&Qi^a+9J0kTe0mL|6 z$R!YOiom{>FXPJOG8Rpve!2jpZ!N7vlTpOhyLB92U+6;{L?y=GtAFFivKA0I3r|I{ z-c;0EPKJ+(hL6_4qy1DlU3}Qjq=Q=>>iFF4l|#NbthMS}Y5L#j!BOEl>UOT$z)eo| z#ti1Wd|SUarVzHY#1v2QgeR+fodr-dh~sW*b+^-grO*CQNahB!Wvr;=&1`N2g3Y788x)c%4qw<0w;+-rJ$eAqKS__l@ZPKjn1)t=PnLm#YW$yPtL!kFHG% z7Xik!U)i0{uMATf!2t&ifx!IUToP>92OKdR%fvkjdb0(4XE4Rth#>ao=o>(Ag3@et z^7>G1^EFDxAsBjD-0@;p5f6%P9gbWNXYZik1ROtkAhJWO9I8!M+^PljDy$x>jLTt# zh!z6KSy`+1{9Cc7PIK28puskRH`bV`QGh6#s@3Xk?G>x!3lo_e2$x=LoMqY^K3=Jo zrjYU3@=T*rt1eA=Y&it$Y^xwnCf+62>fl-~E7*lr;n|^%J9A>FX3bCgc4`L)zYUx= zJMi9Rwzg!lbmpks(nb(TdEz@^@3UB}*W-xSVu~z5#iyJVPw$M__nc{MA@*wpbunUhWnl7+*cT?WIMl}nRaFST1$-<7jV8kL3Ruop*F8?sg}sPvY>m_4 zbr*W|#()xyob z>B$_spLIu*t=2h7Vo@r||E_=r*&|&ZGTk`rlMt zUBu`r@Pejehbh~4=yprxS8a)5F271WLEmAHmZI=;_(nFqAgR=YjW>Aql`dm1A|wyj z1dg3tkOLiZf;D@}V7J;DD!wEi-Ccv#T>7`Y!Mqtvv!s%YFi9)bapU_GUi@rpQ6lJ` z&^-r9|72-JT3N+5QC@wa{4Q2TWA}5Zq{SJebq{WM)42GzRE-)ntiR06E@q`B{LW<) zZxsPbJ@!$I@7?*@)~z~G0Lvs?XWugJxtE{K&wHP`a7OINdOV~wymuhd{t zBidT)_iV5qox%$;&UI~wl#+Ju zJGF4DgDZ=?2&l!FEFp00JDD0hm`ck$yxW4i%EGyHK%qiM6w+K`g~+4B2Hf&UO~<`A zSGwsTSYN?~x8D}|4tKNkgC@0D?5!-cKG_Rrg4P?F?jgp3Cp?l9?~z@eoy?XN%UvKi z2984`MK~99-=$s;S(ds*>r)3LO>%KUXYSCCb=J*U>*W894Me<(}Q7}$k=h($6rlL*lsF^Pq zwbokXv%*`8DlpC_MiVPmrDqk91g+Xpf+rU$%w^3kmOzfqlw&5Anj&DPH`&Tmk7D(v zxh*DplLf1Xr6Tb@FS5yMgYv&K8?)1U2NufRWB@i4hr8z*<-KajJA8c1YyxY8%of?| zD?_&2wrDNk%i@z+Y#?vixe0B*QPLErE4(sU)FBIBWF$ryMr?HAQIOqunssAl z(?5e9__(&IG&-v9;n1%f7I}*s-rbp|S9)tOW5ZXp%r;43N2LQp5zYL%fe z#_iJBdztNdTD#L0RbZS=TBkCd15Sd9XX6#C z&}wO`L|Pm*hDC^*DX+>5y^AWsWX19gu^k3iU{6%B!)#=Z&bE1jj7{9bc(fwBxwsNc zMo=dm9cs{VtRu~OOhnZOwkoe{d#f@A&f$%`RoPr^@&8SBbQPh75QVDG&F<>ZDAQ+M zYBi5LpJW=J9%PnSsLpO@h76p+jU$bn95T|3Ew$-DaMqaSbvcr8%n`3Yv)EEhh8DvB z(W9z#KUg+~)iEn-iEw45Gc$SH>mOjRKY5bOw%$u1(PT8cz@F;tEv~P_smAL1b_w!1 zqb`Hyf;`xg_Su^(kdrW1EzRtU%u~9!19Uz!?WlkI09|+ zogbvP)@;tL(OAMV@2^=`qq%=G#GaS(LQA<|PWx74#&ksi&v!b;EUjMe=E_K6V0~?h z_NL+0`RaTP51Qj3IreLGM}>a#%ZBoJX%0&ODAgDJ#2aOC!QN z+Gz6Xr5v~jann!#ZkQ}UuWr?jHdm^}Z|ZQh);u2@V{H(4i3(h;aUHF;SQK4{aRT zZX?mY5Ng4F&loqVr3oAqtJTXhY~+eLa;avZri?nz-O7M^WVIFjxs-IUL6uTV8ftn= z30;bONqXEM*ycBXo;FilZL_gdl5%me(iyuJlqFED*?=JFIm_wp`kZXo%3%!4buEQNs0Qd^?2%51$x)2HQ`&yN{Mi_ojuvY#kt30@Pu{wTHXATB|*}vTIYg_Wr-mys3T( z{Ng_oxbk*T1&9%};F!L1p`vIeHto_H;qf%CL)&^|Lyu9xJY&)M1xAOQ9GPmTRW0OB zl2}U~_Ov_TFZKOE!8nRXp`ljd3>Kvc+_-{4QFQd?ZAY!!jF80KNHj>>hjg@|U&Zy- z3~t@IZu8&<1db*~N2BuI(Q>^JH7J&(gEOa{cG`+V%e(MIW@);NK$g|Sk)<=*gY&3W=`WY=K@;ntpF2Zmxl{tyiqhYQAx0_?wK4)sysF| zG(Q~0p!ge=0Id!Tmngh*T6u8uB%XC94y(6f?SoK8~!v2m`dLO*mF2ybssloI

OmWgpAttJ4a15MNZCi6qU?x+HHf2$(E7h^`-ZVD{aLs&qW)|BR z($Ex3Xf{Nrl~Un)GH1{mR@Lsjnl_GAXN`cy#Bq3c6g=Av#CsuFuHOSQ+n1K z)MgrIX*8$JlUJWy6&h|&XBAO((YmFfF`zBP~+ z>tQUWp7Fn z*cbS21m%9V>3ZUPUP@2I#OPuVya;c%7PE^dh4zKOn$%d1-9sCa3SjDytEn_`)v#-B z8=XqE^F~)9#cd?{q%<`xdTh?wv@ANYSeaUa+M2Z&VzFuVpg5`1<5MRVm6wf6U6?f5 z(SW_djoESolRUhKfjRncv}adkbQe-n?T{+QMMCje8btC_&_Nj%vZpqa88lHy9x+=e zsO=$1Rwm}z$5lsnl}C5uXi@_Uf$6MJO_+T5_o3QdsJNWdaNSxmskeQ-*HZ^E_IE$bhbpmd4>KFveN?J!bhEUK&Go$f+{) zrJ}d;oYcl9(b-^_6nf8(u9Il?gkIVvTTw>W^@sUo*XbRsq)qM^?=gq(r){!RL$R^h z_LHwZvo5KNuJHf5yRzoCaU{IIXv(sk#Cgm(njPgDmz_;*?F);xB}W=rQe??-_Sf&% z4T88DAV^V`YoBIfkw6niA75W=3!iI!`%eV40msw)J#X&x7%4hphd4EF?459)yn7~} z`@DChb04>h_-+Fxr6hUI&hT#h8KvydkE$Zqf_pF`U*0*85yA$?Ek_TJdS4^w9rW~} zkvFCN0hTt%+-R3EMJRf9Ce?Y9ws6=fAscu&$5%vj`;7*#WbfLm-#L^QMFS$tio zASC7=t`I}6N>N3nqm~?sL42hO>z82iFt0qA4D;kz!VTsP_;+aDkZMWAKN;nqq#>JVfn>dqtsIx3?H_!WqH-n6}5JT_TsAI`n$F0O&UH2IqdERc0f1 zx3E&BsCzi=#qj;Y<@P-hbUPLZvUI!5U2m|aNoyed1AGTDs8yVFxmuBO7%0?zppouRi%E-N*@oKZFPz2+h#%3*~%che0F>FGr0c_gs52s2Bo59FI8s)1ja{<6`(=NC}Y6 zfB_~#Zg&PzhO>*0H}1n)m2Gxyy`Gf!(|O?h;X@+fPhf0Ih>sAApmX)Qx^{4zY}O@! zs}XJxmdL6~FdGq6(Ww|2uQF~Nb-H(!#;8+TK_R68Aqn&H1^^n+jH28=jjEX$ZwW_m zFpCr6`z&}crfnfI0^+({+>Q0l#0ZU!Anw_5b{P^~r~J=6}H5gEAc#zc8Wy?>b}J~mLs!pC0C zSm@ZRtrs>J2#z5-;U|$3u7#oJ=Z}F;U~z;y`?Gi)H8N;x80vH}e)4gB3p#FK*O8O8 z7uMZot_T~~>YvD`G+POUS>Q6q-c%6^W~2yttw!~Dvlg$;{Su9!*)Zb*=;2PFB;1a* zg@WF1?$L75iVCaYFwD1vCuSkgD5S|MC0R0dej>|@Zt<2yLIpA5^;H|?*@&tow zWn8Da16R|?%L3&>dupjPBV0!{6=2v9634xfj&acIA{=Wo4^6BVf~mLfO+Z?J23Gwb zo2$(U_{Mf&FFt$Dr;}o_tU~#F+XLKu4X^=ufxI6UXeWOe;x881+tYzmn}2m4Q84zs z1-`(*VRS`?tuXXc)h|>9EfcbzDMX2x!#>iu6i`Y+9V*<8qN76H~^RO2deHTMN-C!lnSNm?CMPK#*nDlG@N z5g@BXsGC*`TQhq7Vh?EZo zaK#^hE;fY$q9(1YL*uU=OAMH@F%>KjN}C7GD!%l3j@B=|N1s6Vo8m@)2pTXk_#qjs?j8Y3ZW(NCu zHeIZ?8_qVQKOs}{&W~iI+=%G~!yyPL3nh79&;>?*Mxf;FYK@lFDD4_J!Xw`k!*>P) zf?VJmrDAnMM10o4nBKyZ>mpn|OGtZqPy_^sIYkCX76`yTBo7Es?6wMAU=Id&`vd`% z9gkoJxStsLa!7|>eqTO;deU;hXaxMEb?AVot+hi9$SY2D5Fy9?90FIATY%(Fz*}>#{%*x_V!%*gTPi3k;ez3l+R9F3fR}REUE?SU+wI7!t$niLEc! z$mFsZT_!H4)bckzV=foSvvEFmIUwPECO z8*2>$anxp)XYLvGou9bMDTmGgsbN&?26&v(1dX#N+W$I? zM9xk|h0TPdnI)g0;=)x0-j_Rt$Hno6; zUsKSOT>G>9B5AGa_5|iGRiP|!$HzamD9RXWyExY9K|!4w(Q$h@A(`BV`bDhH*8-GP zsoBroBFm%*^PEp=0I|RlT+Tr&Rh%y?Cw5N@hs>xLtb_SPw%XH+AAZ5aO@q_%e0_}wK>!<*43ZI6&e!T_?wMg z_p~>3B%C?Ekg{=@ejpqUgd9HNCCK;n5qPxiak=n54}f`s|Ea{>CD^#2IoG z^MplwAZjhl8G(Ud36zUFeE;=k4&&MC{XJO~lhsl2u)3MQL507c<@%Nr!6z#UErEBE zI~GvX&d5K;QJ!|7Pj)m1CLCX$xlhnoJ-gocAxx6?^gHmV@whWO4I zIT0O(NWu{ns26C)L%JE7X)RZsaK>q#h870Nk_Tggw!?E!LDeczY4*9*#6&C^T9t{) zAMJBbLW)Ze__h?}gD)S6&-oTtPb3J%OZGQekl$=!96fzc!qq6l9W-zMIw|x0m|AM? zx8DY#i-M8{w@AuD27Mxqaa??|8s?#vUn|erbJG^OUS7_+8Kp#oiC>lm%UC=e8lt)YrGVp^Q-COvYT5oscpcSj#LW)5$dp-tGQRwqmJr9ol7=7f+C&RSB0qmjpfwiqe z=sDO0%x!kzFxuADX8hy%H79%D1L&o_#k7mCjT$L0N3I3tE5$*^;5EhRP-j+iI{d-c zQeogJ=J(k=CNV#+nulUq99qfIpXD*vV}*SM`v!&t%p6>>AQ}v>9TlURo{JfSTyJ1_ z6DOAZ6EFb3kINMjN9L$8*U9`z@*@gT5g8Ilr6$Q_co6~nn%PIj!3rRqcunsS%3dyt z%@Q`)`eC2nF7RW}fzLNAsTK_VFNEF!feK3JfN)Saw%$wZeX5o|ES5~}u6ep{%U zIhAnEonc6+h{J2f2Ye7fU0JG7#3+=tCi$Zy1x_I(fEj{_BNZ{PRRAQKqZ(yp@$b6Z zr^PoYHKyfOEO0*HOT;NMdNrjHOw{0Afmgz{ z4?+$?BjBGJg7;9FzHlpSafO`;#V4<>kziiZ3cXTr6-~v{%N#L@m%w{Dwcp zdCZ0HymcJ4P$???tqURak(I_53YRaIdS3}jPb5H2&e{k{Dt#X=sZF?NMZ~yfgXmDa z-beoVYJT2s#!oqwd4oU;HcD-#%K${0VM>D>gjFieO<_cSqWXbE$!mmxKx%onme*LS zF&R4u4dT--ObPKu(xQXAkek1gyUpf^%Z1wLVo^fk2h0B&1to70`&QoE zAm+u%{2ekzxcXJxQ=z}GsSH_Dk4fThmVqN_^u$9 z5eQ3_B8B4HxZ+L5qkZLbBknzO(@X2X<#v(5E>q-Ti6LLc%=ON4IZ{&gQJjc2IK!+y zC9cx1%BVP?f7gxSLwFgI0qz!5rhH2d&8Xhkz-yoBBKtVIy3F7g35@++XN(;;9zE&l z$_K$Tq~388ozCi=bIVQ@q{3F#BO>A|okPB4#2#&>w#ym!bYAZoVFn6m3Quz`!*W&T z>jt)Ee?V_1lG4yAfY6sM*6Hs@&9DKzw=7&@PDx3VVkk}TdrQOt!T@-~rLUaQ`8eG! z%Jr{eQgwnJA;9=ia77{l8oDnx_?k1j9%xW2TX#=27RS-5|zPSwQ{9jQuk+@VDsUE#1lo#p!SWIE+A zqU6S?)htYJpvF{rI2V6#YK2)ON;2PtFlji60+Kz4K($^Bo)vb3KG2Fl$w2k3>BDL% zb)`ATCMlB8N^-pvdKnysBx(kbnecR|v#soY>LkHdwXYHpv+2{^uIpB?O9YKG*mQO! zcx=utXFYA35T>0G1Z{|Z4?hlw=J4Qv=sj3zu;b|fAtG78s(RfRT%W7DsuXVyPGs72 zf<9iAq0+95S_+|;CTx}Mc=%XFWbj7AVhR>b{D_0?w7Uwl+v!z6kXE}@pxCUB-YQf| z6aI6DXxx!fuz;GLe41VlUY{@LY^~BgooeD3N-%UCg1!4dEaJckkj8cGUN9y^i;zaa~$a6Gq zO~q?9)SJh-t(mOkAsun%ZG8@gmmyqHRXYwypRE9DOJtLAhcSeH#Sr|UFw&)vwxg|`y5^J&C3{qvhSqUNGR4)m~Y7N!4> zj`(f^m=h2a`~Wj7BxUxYkN#2lYh=@>n@-qy-a(hCiayn4s@puyt%?C94XzDS1smrj zmf>%zV0R=`l;7AeN0Q>-2|0=@+_B7b-!wZ(Vk3Rf8cCPqv_G_|4W0ibxNl#-(M@UT zX=E8kDW*~}bc+q+33w|qqI1&6ugUGHtNZQkY{vDInZ!*DFq^*>HfNwP?^gX&qVAM* zE-#rZDB6)&Ht0W{WI_EkI060Vt))R9I#n$=>|SVk{?}FV>mY!fBjyf50hBUk-Bm=3bdy{AL~$$v(|W=8cy%|^CDbEG%K=_~w- zbo)+5!BrO(Dy{uz1&i~tVRG3bp`&qCFPeyVnH4(yKAx`zgD=a)IST1e(Kxk+W`NZ8 zny1?D&0E6l6ppCA$B-;yaPDWB`BFP;=nH1+y61FQ5Z;j+>*@&3e#MUi6f`*=02P2u zw}adjch2WY&62jueMxidOh=TvRt@e6tW`(%ME+XwX>NIx+#4X@+~V%(sX)-f!xA15 zG-)XwkN9>OOy9c+L<8qkC>uO#T&LL! zR$KN=M3vIn9-v#M3{?%Q2Eh4PZ1tkE!7&XheNe0xgQQ*I&`7A70ax|RB7%W6axOOh zoz_%4qNR;Q91i}}q`f%gkqL|I=M7Mz{;U^@4H9|8?|Lu5gF9gi4!sEC**};lwXI$Q z1a+`{ITnNh!BHx1Z|mv7aW8X8eWTkfYnq+)gRk+L#BXYsgSJahLU6u3z^vNBmjFT~ zPg6(v=s*yCph|lo(m%1!2NN}%*4V12tq5n)ecY#7z*ayGy@NO!NQmO*>8ZS)J`O1P z<6&Cd%u8gV)wSDo{E7V}CDLX*MwKWY@8uDrYGrJF8niZ7&)T1{nLMmrI8l1vUzYXA zAFo@|7{h^+6^i0ti=WfQZE-n%*xrxvC=OOxT#xUjivpcJZ@%k4t;d`1>*Y`V&oSQ7 zze8s^hDOD|7fZB4T}}#QNZyT$$^GWyl&D1@-B)%KD3CT;Ad-a8q`=hb?KasYtJ@?d+mIH} zjsb^E9AU=C@JB}x@iB^T1ROg|C?cXWS{%m_hw+Kpkq+ZvhheZ|{e9czSw~N^tk1rKe?J`` zaVxR2d8kk+XgEKz-AXJp@0yy@>+19`g5FQKNmF1w>Jp?(E0EW|F{3d+!gOmBaI4Pd ze3)y+8xlJ=CX;QP!|#L}0IuGROC{1ej`WsYdYQab#=yman*r`@x4d*BtIH$3_X8Jq z<1&d>9Y=b<>(Wc{+n7li@-_i?5V-dVc~N|4_O+x8c@yBj2Hf=mw@Tu&roUw0D3tGT z+m|!-5^g_m!){z_x&>9Lbb`7cxCyu3wv5qp4ZyuXPHTntTOyazco%>^3fx_8y~$*& zj=K!F*cq1fX%8-K1e%P<0C&F!mq{lzy(})kJ?O!;7>Pyp?Fa5*4=$V3J0uR=0pK3> z;BuL)OYcG87CgAtv>reT-EV-?3y)u0M(+@c%b$Szxsa#wAeG4Gw8rFb{h5~a2e;l- zvQ3XO>1_f|FMNEYjl_xpknqK2i~&M<&rPUa(cg! z-iLhU)zF95gGqc_)@MV%~-AYOFKqxm$IYs*OxK3g$?z6M-H$ivic zv3WPunlNzSClKsk3LMS5+}}21;-J161@3olTso1|<3hLxfcuLV*Ftr&5dAygj(Tv( zl%DrA4>hc{tXBn&=K=gpr;Kq$ZJa^Q6~%G4gxph#$^&o zJ${5c2HYn+xTG<^5bm(+Y|xEDOQ zWKPcmlGpSO%lf+qmugK*rT8S=4&eUf!fl)T+m{IT!KXmYZ>yir$NshE$%eVZj4^w( z0gQQTE`OXp@ufa;2-F;?`6AM={TXy4Ts=Y1 ztKiz~Ymqgdr9R%mB+V`$G3K`&n|toWVKDGDu)$iW=&%KNqtJbq#!w)uVIfdtxl>;c0M=u-F-S z_R=|GjFLGr9cJ?}ge!JszJAZ2oj&3@!3H$5UHa?DLmM$+#H2aTK1En6FXL*W2csza z@cAGv76`%9s;%B!aja6R?43!b^3x!D3S)(l;$)tnvW>#DZ7EC@8I08{erB{-o=7Hp z$HzLxC-xS0m5WCE>pD8Fh;O*AciScLOmkZ^n<_EgvJ%<1)r#B^i=1CyS9cE#qqQDg z)P-*&#O5<&cdy!V#wpi64Fs>-1U4I!3>V2!@@Jg- z17Lp)*9N_Q$f-XF{#S9u_4*x7{R`m#6xXGC{fJY49Q;>sv1h&X@1sur1&G52Tyed< zkY7#Q*keb^9pG}SX@^Ia6OWs!Z^yRGQr~sexAXJw0wHSyZ5>t0o2j#txexpDSu_eOl}BwuMzOJ7&DS8X%f zw#atxufC7Z(_?gV_3dcStn3`Fz8zctNjt}?Z|4`=YWi}y{>63w-oV&iuAR#rqnGG* z7ORh^F$Zm}zTI-|WX~$u@151_!#38*vu@swrh^~gT5a8f`!^YN0QbjmHChK1^&BYL z+BRCh$NgbktF3?F-o$vv74J06y9ReU+iA2YtKO%02}RLv zq|u_WLHnyli@ww2w9z^r_cEip6-Dy4Fdk8K&fI9xzGoAouEzaxMp2&A1G|w~em$e8 z#SMz;Wfb9VVib8jz$n7qqNweRqS_BKilWQ?rDr)|8`+HgEl{i3`hsj;&AjFm#s1rY zwWzRu$Z84q9Y&Fk?=lKE>rqBg?e`dko5uS-!Igi#Qjn><7e+1WRw#J}!3h$W;AZo<4<}zd9kdE1t)?iM-h9!k^_c%f?*h7Cpa`p9L~Mq zkiQOR0UQ!Y`NMVn7MxWE=S6U+oPsMFp?S_Rfsj;gIh%i;0t-3sX~9{IifDvHcw3!I z0|#ZbYBdVZK5)oFE@xI?D378M%6)Dp2t|F_)9MLu9t6UX^SqEl%d2RF&AKFl73l?Y z4xCe!_9nP{2pmUF2b<_E>z&{R*)!s4^+|AEHspN8!}$p~w3Bgk{S_Q4G}lKXaokZY zinMwCxttMGHt!G|IzG(t0`6KAPwPGMxLe+o`LYenlriFK$J zNx4%BFFtXJV!J+43G;*15tKm4KlSX{TnnNzL%CiDCenGUlbfl>mUoyq{ke}`Kr~7;80peBQy^c zz)%MS$@!GPP>S$O5JKp?ARh*%4m4ey_X}_+P7deaLJp-!G$MvNXe!i3fBS&qgjoU~ z<`Y7H^ME||dkX7s9gy5;glsU2{>A~bFhVn@x13MQ9F(`=iUwdV7Z^&%XoTh*Z)p`6 zO1@}>erG$)1KJ`mlt#edPEp`R_U?}ahEgO5vzDeV6bg3`<|=_9aY2~<0z)5s#+JS9 zjLLrs%;k$<2B;E+)`>y7zAP{s7s0G20VoMvL2^DLFtq**vbm0wpwL_$BCz z=5>Lgb!`yl4l)*{1y>N}KLV3o1ak{Hgp$J*BQ|^|b8C~my|=%TOxgC-XkoHAWKUEkyLz+z zrQH+dB0fgO3gxbAr~7W0&iD2w>~wc&S2Ei%UM?30E8~-$#o@x9a;0lJkJ8=SX4@lU zd+fm(9N^pCGIUc7=Ys&_foEUNeaB zDQovn*eotchh6xQWr^@46Lyb1Su7XX?=iZ;$by?$sJNJwjh7>wa@FHSn5sSb6s9uI zzzI`XvJHJXQmohm6Lz6o9v>`Vlxu^mztU=V7N;tc<9oaMR;WLb{L=$=e}}ylLt!9c z=WCZjX?QzS6pj}2eHe%zuAO$(k(9uE_|wa_Y)ZzYP~GgZ_?+yTcSGnt(RW7FvMP1# z%4DHbnd+iRt~!5~m@V`9WJ2q)t^HeUcdu2gYN^nf!(4l~rN@f5Im4q`&r*v&2fR_ZP~V=i>%MyDbtleS$L8k#Il zO^pv%+mlP>Xx{+lvMo+X^VzLge|5sC@2WyZe-#)< zj=vs9#!~g(l^mW8?C%1|XGhN>xPANfSsQ|Gg!glt36T~oh%lH?80EBG+neOz}v1Ja&{+MZ91$Q zEsTv6?ZOyQudVZ^Q<&E}{yExvS(;fsg$r%=E#mW6ONq2(y|+Xpw4n6kM&1NFX7X zvDqQz%WJ8nWr$lOZeNHBLU)7hzru9G^P9k%+}w$jc#~4JxH>zy+H4Pn18R9)8?Ci+ zSj}tf2^8K2iO+uOq@Esk;VDxSVaQJLM^cTP3ffrLB0v8xe&B+m`jR%pgM(W2sPCac zE&9_}ajm8tXXvY+@M__+nsAg>$Ke&*)H^fJ%8HbxhA;r+QA;?(OG=jx(DLwP9O8%! zI~l4S*H|CL=ooN{D1 zzvfpX!+X@E>vCl2x@Zu})2{Ahrf2i5cE^o9eK+>zdk6aY8IzN|-6`bN5PvPz#`|mP z6;$oT0Y{CmIo?+=`AOGXuM(7td=P6V^UFOWGev}Xj8zLwZ@o(3|HAkZQ=NR1!8fba zCMSebDt_8wW`?tu3qfJfiHH6|lKvet7{M4VV{kT(VL+g;OXR$w*$I& z`mkKdRkglKbyly*mf^zgQhBfVdzwl7aRY$b>$(oqUE^L(Q#~pyc^+x{SS9Jac=+s literal 0 HcmV?d00001 diff --git a/entityx/out/Pool.o b/entityx/out/Pool.o new file mode 100644 index 0000000000000000000000000000000000000000..4d0bc5d794a1f5c994577a0c4a20211c7b778069 GIT binary patch literal 12428 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 Q@u{LcGdfi|o*!fX2biT+Pyhe` literal 0 HcmV?d00001 diff --git a/entityx/out/System.o b/entityx/out/System.o new file mode 100644 index 0000000000000000000000000000000000000000..6b388229cd68c8ca3d6a7dd4f9026d24535b3323 GIT binary patch literal 21295 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 + * All rights reserved. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. + * + * Author: Alec Thomas + */ + +#pragma once + +#include +#include +#include "entityx/Entity.h" + +namespace entityx { +namespace tags { + +/** + * Allow entities to be tagged with strings. + * + * entity.assign("tag1", "tag2"); + * + * ComponentPtr tags; + * for (Entity entity : entity_manager.entities_with_components(tags)) + */ +class TagsComponent : public Component { + public: + /** + * Construct a new TagsComponent with the given tags. + * + * eg. TagsComponent tags("a", "b", "c"); + */ + template + TagsComponent(const std::string &tag, const Args & ... tags) { + set_tags(tag, tags ...); + } + + std::unordered_set tags; + + private: + template + void set_tags(const std::string &tag1, const std::string &tag2, const Args & ... tags) { + this->tags.insert(tag1); + set_tags(tag2, tags ...); + } + + void set_tags(const std::string &tag) { + tags.insert(tag); + } +}; + +} // namespace tags +} // namespace entityx diff --git a/freetype6.dll b/freetype6.dll new file mode 100644 index 0000000000000000000000000000000000000000..e35edc6bb07a741798aef2b642c13005b8b8ffde GIT binary patch literal 522240 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

3;kYxczwOC% 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%0Dy#{TMfqvmj8^ln4r zL9Zin3s&?>&p1Q%3KG>ti4j^eh(3aq0*TaY=)F4mUGA-+9Ig}@qgCJQgzM+TpG5c* zIoty|c;g2IgaDu<(O#=rO^u82tt_q3O4zF`bVrwZxbd&kHSxo}R{7LvKKNXS3{5%* z=&qFRt9|qU6@gD#`>+d>(Pm-NK6;o99Il6Zqx5iFF5`9K@y!S4#&dE`-u}7E;;B@R zoF;&>som!HiTycu_1eg5Bw_?6rbHUtl~Urlj|}F&XATigPArMcn`+lu9Li5VurWR4 zIHBvb=w4aSyy5>7_wMmgRpEfQX#a zG!2(pBom+t7@Q2rW;-_4Yg=16=h#zD>k+(xc!30z;H?F%S8AnN?H=O=wE{(De(%rP zdmz%D-|PGR>pL&V-g{l2^{i(->silw*0U(WF&^`sZtoOo;>YG7Cfl||$vr`CbXMZW zI{F9+m(Z{0aqgyD-&)x}OB3;i)NwX|>57N?ag})!kqToC;Bb9q0lt*a<93(udANhf zwPIgEJa?|?)OQoitgV%U*k( zj-^mj zaPN3cxRa{o;?eh;c||Fz7y;@mE5|TJz&ck+MX`u`W4L{Jp|w34 zUSxmJ|JrbSPRQCmFTB`(x&QUy_QJ5Wh3fkMI^6zIk+r=(`~&-OpC|OcI-E7SwS89j zGTk6G+@3Vv+Oj14L$V3lJo|?wFpKu+!hf^6s=yJd>x)|K=C))X(uEILtY25(6wsI+ z;d~aa9-p(T@|^3;@UJZ0U6n25pOMk|u=K-d!taM}T4N6{;S0_Af05PNk+_>LYsZcE z@)#?R=mqw)LOs&7P+KU+5#<9_hJjgKKNn(SSDt!?)m_BvK-DT3t@Ib-v#|?T1=l_l z?xZ^L-;U9Is8jS|b^V7@Fm7)(UDkk-LDN#~(It)U;olqHgj=Z~8>qQ6nwuKk*PikY zYT#kpnX0=#BZ+z82*(j-sX!HUgDHsZhumMA)4bTR1r9>bAuf_2-E5`fz__1|66TTi zfX4<&HY;!pPFx_g2kaGv9pCjQPG{XlG8#VVToQD)-_94qDGzZ)Bku;!a}A!y-lOHf z(af$-IMtr#KKu)FKDZtLDs}d^Aa!}6yOBWHu4=L;6$)&8_t3nRPo|rf~CIt|{?KSz#sf^a_q4O#eWAaM~ zMzDBS2;i5TEZSiXb$%QbZ}!L0%`5fc?N2&eSLwrZJqu6d!`a%SAnz29v*Q{*%)AIu zT3yRNp+wK8vrj2@RR{^g5ae$R3C=CDr^%&G7ZBj77!uJ)wWsBiOhmD}Haj5T?Mn(| zRlhov{08&vKl1+M`#=xfPNDtOe1U3?*YhDpT+ElKoH-fCJCG)i`RbM2L``^+bED?> zNCN+P8tw}g1sLf|32ft+Q+-l~Iug8A=NowvKJIi!;d(hp+H{Oxx@#(Q$9IL`C)k5W0$59(&Dko~+B8&4z3K%sT@ zxxB3(-7_nEPOLwR)4a#b5#kxCoSk^jsc-)s7yg~Y?P~CUdrh9*l;2ZVkbGZ2&7xcI zsxrl^tJu_4d5ro}=HfwQtfIkFsjpaX_>mDRIO|fz)NEZX#F$#Y^iONuL#gC!ANIK6s!z(Ga&A3%_mbExPRVhZ!HomB5wjEeqwYY6Fe^Qs{HaD5m z?jZ#DUAk;HgUQzHCIOq|=q)lr3m}Jdv z=mVi5#0A18pE5wBT=#(%(!OT{Y1V8{R0ewoGN8tcs$t4icD=%{dW*f<<7ER8H#FQz z_&`ONzZr~$^xYJ7LFbkVadrRJhRDCO|5Rb_RJid!Oiuu-e``Z<=&cR@eHiI`TiT0| zB8KaNCgfJq<04hXwwdz0Yc*<*mp78->u_UIFlwN>NDwI_vqvPQn^36HY*fBz&k;gFa0#GM_ZgaZ2@2-duDyl{M~zu{OqRrWq&p|jRd z@B4|8-UvOA7ir>Bk<=Jdmc6^!ZR0mPKGAu z_`M)QV2QrT2Z~2|u}v+{OD(6#P}hk&M7*(=3t@$H$mCIQ3LS)oiKgh+kXdl(P~Fwq z8DBdf0>f3!q86*mR+4$FM+`}To}(F8jTxNT+FMul{+g*O(OIiZiNb>%mj&s6rQ1^D z8{Gpp;~%CvI6!`G&6pc$bbm((?V;vur*{LP6yZC|xoQiz)u<^--L29Z-G5j1D1%^~ zzV#!kiax*5jT7g&|C~KHwIbN)Mit<>0G&TOwIaLG{WlYmt$cGXW}~msjhK*Jg(z2E zqx)?WVmLnTM(2g|QunCgjqVqTfJh1ky7jH!>^TG78_XMn5D2oAf-&x0ra1r7)G}&# z=OzPk!9bmQuV?@_1Hm z`~F5@?kg`0f%5Di75m3ZszM)clg+@6d9WXI$wB;!teP1c>8zU(=hQ$1qF1Q`n6xSw zl3?qAN${YY-c#`bN*faUQ!kc=xs_!|Hn=9!9-P@A=YIyq54@BpO2Om` zs#^PzcIU4O?hc-pky!HCLy22W)n$Y2XT!HUC$hc1m^wSJ476Kam5A%rWrNGy$fA)A zq?9tD!M*rNqicFFgLFVXlEAgTwuzABEKkv8y7;bZsLZ}xr|9)PPzj6xEFZwt`HayK zgpfyLf2A`w54K(G-w&}$sN)8QXr6aB#9IHmV-&rkvSO2Sb#``@GrhvQuf(S~E-SI8 zlsnUFFm$@Wi{ToR8U@cSVUL*LZx2)z3XXxQkRJBjQhSPbqe;#28%>TRf>-@7x0$fQ z69Br@WIC6c%;!>*zp)9L;$0()t)qS?IRi>%#^mP z`|Lj6M&^ti-F^eDcqf)XiEB)^jD3RE9w0g~FKZ;ngyw;|dE>luLgGQ51G;o)Z@FOz zL9Pd{a?LB17^(_5>yn7PzZnJQS8XiKW9*9(1|%;Z&yq8A;s`uHZQvlF@eq-{ty-4D=1r=;12^n~tY`$OJe0 zsTm(YrAm;%W)C)sBs)(3*dvGQ(%9-c0`^q(iOgQrK5rOOnCGUL(ey`kx_4xQ9#a!1 zaxl$`t)VFJE!ebjxd~f121LiYf9RphX|8wC$SuGDJ*dPF{;T6mZ;bwhFSp|{GfJqg zP364}<2pjP6~DscXY&XJAHt<9C3qxCMy-9+3>Xh65dM%Ly*G_%0j3{>kjn*o3y@8a zP5oZ_H2TX)Dg@r)HSZ2nQsR<#myM*wDm6BEnw&zm=bJJ*FZg2g(i9Sz!j`=~(MxZ| zp76NRkbV?$Rq(xD!5)ZK>_60~6R7(cpPj2Sz80;(elXX&hyLSjvh&*UOZD7yAWI5C zHQVVeh5%9iU3;a-$R{XZ@ti=d&cvI9Aa1|6)_!kn(tdnO?5NHU-AmYt4G`dFUJm@U zZt-AFFaDhL6{cuC9qx&-x_(5dT(;Ag(Q#lx-^bfjiT%p^cOKq%;Y6>Ljy=Y)>)YiBuJ<-h>KGVNt)GM#q>?&Q7}uS=w3MOUQ+=GAq1* zYkqi7w(v*en@7fu;}jeJ4eQqgn_%E*>@)C(14Jk0O&pOto3(N4!Clrz7`hut=#Kue8M;2J8HgR1N(?*bB}qEvU$6C2dSf0k68%APqC9Ovh2ZX=9ywAM zcvPdLnw=sjD>y2lX*I*Triw2sK8}2T^=o&DUVVlLxTZg2w-UB?w?q~wbrlq_5}o2e zRhR&HE)%65*`u?e5nU%Vf{)YrK!#iC;LF{c>ve5F!DfiX>betj*wy)XCN@4|&G-5M z9<;h{C&s%+sh(nWk5a9k+@r)DzUCgK9PUxF;t5S;gHIi&P)4OU7~h81GDy@un%nay zK4(Df9|K~;q9QP}EIdy4n>21kDOQSg2}^AZ^9}TRJDN8s}l4wn56meolpl(A&FT=Os? z2)d@kB|%WGl4GxZ+%RL2zV7GC{mWkrpwzCWfh)l)9=8!#Icf19GSex`R# zdAIX)f0{6TXdDA7+KTTauQG8i%G&f}^{l*%o5Vq1mE1>-Ug8@`O!wVFDyJ?)u$ndD zkh4SidhMh5=e+^G`ft+2H#~$zafQ}TzcH!N1W$(bWlxsx}4baQr9&f%d zRsMo1k;y&$I)xj3oQx}A1n2K*gG-%@aR)>`F|$0-BZrPrK{xgPSN{qc5=ow-3A zLHTK851*V?+{UoivNuPaaPTBAKSs}s>&NBLa`G-1baiF&r{aAO=N(4w(PfD(w8edB zyJ=#wpHzS*me*?kXi9PmT{7BI1`bZNm9x92AKW)rk zR^n$4J=WOgH4`~MQx_)kA52sp(RCo6BexZkAUw0^K|Y{%wQY~mab%E!W*{_0O?4qN zTqJi`@!e{#H|?8AU2eA1#UQXyjA+digAXOLNU#%JgIfVmXj;2dz$7I-b-^e9`T+%c zywtv^Ao&8Hpc`6WN;x7@cLvmS=_Q1;q(h#u(V0C89+G`vfVq z#eOvT+YfPb%Kd;p_c7?)EI|M%s_O%pop>9p_+_Wa3H#%HSJfncYx)cPz9hD~kqGzE zb*7;{e%OGgh=H1yg2ZVRy@5w{*=>4Q*Dg`9#Ib7IrfwRaE~L{h#GkotR3T3NOThu2 z;N==zD_=4kzr4UhsiGvXhDdOMHiu#03~PO-Wsm=|QjBJ;vNoBTmS<6T&O zk@nkGybB_o(C1T2!1(`Xy^XrRSNc-)GC`+Pvl!?d)>-IM0)( zJnz&W{A&J$K3~sjbn|T?xQ6?Y=?J3>_w;NfWSoq4z<$?L5i6%$pN(KJ?~I1K5N^ zJuh|br`jU+HTvH$^XhIdp7lXsPtQws|AhU10jGk;PtCo`2h|vWzJm&9><2(wwrPXf zw(gsNq{YGKd1`O3XojbRUj*?99#Kq9IIPBHk;G{1v$hH^O{T!lZuwLTUm=3@A!oD5 zKau+mZk;NFc9QO^=>PL@mMu56NG!Zr9ME3Z#{0m!CH&PdQL>(%s&MXnfe(9=kssIn zQSaT_YISZppm(#=>fHGklSUh@&SgPooy(_l(_8#yiD|Z6?VG!Zv^Oo#-*;AC+H59F zv!y^Sp;R;4y1cO;%xG|y;8FC$Mw(NPS|O6U{*TH*r=pf*KSKZA|3tX+Q4xEj7@fr> zyY82|0)h(bIhdSqXz*^|Zmgb#4nt~z9+w7Tz-@YqiP*{-v=-G0i3$ppn^(G_9c&$b zGy{%q@)Yj;;SD`h#6+AxxN5>57d8R0N5-qe zwL@yV{q9Kox%PC0f5oRb-o4?am~Sum!O_d`OZP3Ec=@xHYb}>GlI^FRk1e$vEPYZdg!rNtioFE-f$?2fdqbcNEBb+a)3GnD>gbxyPC2m@e&& zJ(ZPQ3#-~)6aGRVxrMjHqyoT_N>%j$TCTHI73prFi%NIbWz(^H`5qVBqj;~|I0~zi ziG@Du?Mda>`rK-I)HC;3r!99eih1G5iHnvrsP!}4Z{H~*(?Hc;g#PEdUzXGZsW?mJ zOsy1(DW{$cI;(WfY;KsEA18hm8{F&~(A+|MhO9M8mBy(o1oU#Y$+*W^$)aeVqTw*f z3&CgX^?<#suwxCSFTgzF3mMKP4NCl6Iy*M<5*4h_*IB#2;Irs(b2{f`#|G8BR z`mEV=xy2&r=IdkVCjCoF1+EKZ#&PIMQ*j|yBy%oqPAxBV|Dup3Kw4{{01323%p~8v z>o+E9G7XWBl)|x3*uu~L zTL?=O_B#1tYtz2K`yLcGP!>=ymd@w`iWiWZQ8${o%5#M5VW?8K0Kh}xX=d!M3acX8K3yJ0sXJyubX!a1P%|V zJ$6IB)%9zW4*LP6qqNo#sAGK7GMO^34jup2dt~*hyijca(+0EE=bgzZhGCWo(Ji(Ywq2U(0f--lH-f1 zUQvdybHDziV>MQ1Yx6rV0zsCfmbGYQ-nb|{!;L%((PBM|0>S3~5^}ShJK!vuXU|=b zWQ`;n2eXf?3&)Ez^*|nBXL@ApN1XM2jOuc!2nVbkWit}&ThB;T2e>>SiPuX;Dc7mg zMJP0vLeGpeaNEEi?#bff^T_Vt7^9;iihWRTSJ=!y;-G5mrS;Ak=2{-{g)mH*C9ybH zA`;*l&(-MxU~SYnI%a1;1z9{f1~QMv8WS zN3A`nK7J?>+-Og#h?dgM*se@#`{H9pgt;=6^R8VM>km%vaFv4_#(Y$_9>?(mCva@< zy=0dO7cxxB2~S_DKu?BKBg&o8^nhl~LM5U}1(8K!lOgxP%^tRPgQ^0}Mv|rBGUH>9 z1}82FmoVrRz<%9&tEWCZrUyp^Z0zCK%G%y=3}5)wDQsMbQ{_PC#lw6kzHHb2+e@{)0K&Hz92vDlxFC4Mw4_FAUq340ADlGl<@Hj87p(b+y~ zZF&agoXwyI3Y7t~9m7Oz4rA2Qv8W&o+Ze!eGl%1I_F0==u&3uGa>wDY zA2<8>>(9&i$ey21%SxSxCBu3rj_mvNZl7;$nI8=NqKkLoA@)e2nbzPXmBZ~i#KwOH z(>e_gdRr_wK% zZ7T7@RL&l2)60h8WPv-oDKF8$*qw4Lwu|;Hf-6)XGl?ORr^wp>dS1>z&L{R|`N_`# zjpi8-oN*pFYEAMh#6V---s-(-FNS?c5_@>f>N1{|A&I332bz!>LU&$a+QQnM3$+%~ z|9-JixA>tUF&Bw4ej{~_=)nM zo4*X5l+&f<8CZ1GgqK=9l7SB~@dim`CSsl?CUI9Ci><_zOl+%KtnRHQe^tQvy=VAQ z?^5b0rIZrW!PK4w?c(vc>`m+HGo){4_sW^AefiQv`StLVB{ohSF?^eVp~Qs!gJZ!@ zqB2v^uDIAhvpwP&ku6Qx{W;H(F=UtgY~Q==W?He~Kyzrp{^%FtwCCM@$>;j!?J zdlEAO5N^wgQ&HswcH8@e1MZbj^Fxr12y1w($o)OkUM zW#0*RH4SJh1ZT63BR4Phs6@0`@EyE)*dGxYp`KOFx2^8)Qwx=?H0awhvg%(e~oq0aUKEU$Ekzu#o|-marEKWlT;4WplQ~nUP<%*Xo{49-$t%>ID}( zgA^CbD9@Q+kSN(@#fp_gd$}qTHkJGg)RdT!C0ttF*HXF~Xl<`z>`XCZ2WJ>T`x*Px z!vi6T9H?U+=gh^qiE7iCR`-16QQPTIxP;+W`;=!F{v#xkWWkKAu0MhpvlTNAYO(Q0 zpP7#NYdWS_F_&c@9;guPOOUH%5Ni>Ayt4NYh)rc%BFAvkp({lyQaO9=x_tYHF6tgkwu|$>WY;|ACoa+&? z=R0m`@=irp`IxLQ(NhBScd1A0gWFV0cCtA%z*4)PQpZDIpJ1CJI)G z!at>U>a{jkE<}8rf4_RqY&l)McPMJY+l<=@sj_zyUZVCZ__hzG$>}E$v~~4clxWCJ zmh7-%13stBhtQoYH>|72@z*4j-8u;+h_Gmgr#gnkJ_$z8?|&!gWWnfA%$g{#D2#q5 zmA$*nR&&+VBPjo36hJ#$Xs6~ie;hB?j@*_Btq*5;w77I|^Y(G4W@PY2Ni?Kg*B`H^BwbJE@p^K- zdbq$dXxxh`pHJi$|1ZT~O7Y@d@T?_R^LJhq%1F#9jW)=|mbK$e`<+&&va}WEbnf&C zPh%wlFD_a$%Gz+MV&SU6hOxOF9JFT* z26xw-k`XYT>W_f*=-|bsqb7g4aNK4u^a`JMx+z?DQ2dK2e14{sO#e`L&CBrdm$4xl zWeRWYWde&*bW{@P>r$^Xr6uPvcg1HDA{D0OFDvs%Ab zlY6%@{0a&GNWkg7xll@ciCgo7$&F~FA&ONJGel%*na19QKpb^XxyPf*{oLWHT>bNT+I=Q6`3F<8QRf@&Y|kfo5=CBPWTx`M0=Gsk|o_B)yf8Icvzb?5sbv`z%or^w6Wlh4lm{cV}oRPVgnGkIN)N%|awmTbRI~Of=t9jmF9hlT>i1ynnyps=$Q#p?&vjtr`5%=SoM4u9xkeF}_ocud2d{F(JtOZ)u z+}>1sNYcUfaU`Pfa(I-BuY<44~|w11%gt3$#4kf|iOTl0z5Ei6sbsj`Qp z>Y7Xf`$$q#mk2k>hKs*z(+OCOiKSVo%L`&}eB3m15!X^C9}yjD?Y+dVDo_S78M*SZ zm*ppyKtWz>&f|^!rLtO<``>34Xr+74o!)A<%Sx~)_D*JUh9;0Y&kMl+P1~ZdCBZy6H<}WAD`PnVZl5Fq)WP>JfG+ndvIK;6{Q|I#2V>|Ph6P?Vms)OyP zRPt5!#ESQ1n!Rhg5NqC8Gop|gsK_S(Lv<-^GQ2YrHQ_vtEl(yB)Slm7>@3Y69H}{W zZlLUm_J6VWjD2CBo5(NF$-ZD&`S57ovcK5-%AQ#EdTZ~+X5;7L`7F-N{*Ts#O;l9q zl!Bmw0q_3PNzNjwC>yksluod-EPpV&*DL?*e=PqS>GF|!US3{+_vHgY24F!}C0;1) z!ft=Z&vzy&7_-ST)A@$AfXg`fv zf(+D6R>VMEh4(1eBelGx*?n`NS9psTG0%G}&?B{_lfTXG07%ptts~b!ZAhVMl?7#+SA9^qdJ#cRk%P0dBp7c_>2%I5|Uq2Y*dJ_QqBQgDdvOR_2y1e|GK4 z?2%Y#cRV@xq~WPsHCr~hmryOY02of~nczgf2h;ZKZs^Y?9e3I<+2sZjWyxLniTv7-0JlYcr)fm{xZOdYrkK0 zcr9VS;QK@C5CT<)v=`jZrv_~vZpF^`GBJTm-;xOaB+}$we~aHS$BQ2ArJ~F+=`!~) zw|iy6i5FP$cjyXgCrO6c0YT|`JcSkCODtn<0V(X;4pNid7z7LZ+D@+N*IqG@R9llf zi#ZF$mF-W4zdn1C9sjeYhq5Oj|Xe}R8J|_ zkji=76pRn)jxV4iJ)WSN^*xDL-%Ha+x;?D#Yr|gMU(_SyIkrO)d?J%KJ(GH;-564$ zifEfRtIlIs7$#@GXmx)MXsj(`?Ed)EgI{DVGba;i0oZd)_zATQL5I?68`wIReW$VQ ziTzf*n_l&o)`_XZ(6-H6u>=Jqi%a#lG?(V623+yy~R*narEnn zhT%vm^HzKoGz>#Sn}vMlmugQd8a&M}#$W7bQyEfull$04LySIAGd>yT@B=HpO4ILc zW`_82q2`IELc|N5884*Yjen3t_eLThe&;r6jP0A1+MX61h->KUXUD}_A^TZP?t|Y; zlfBlK@prwfjI0ZO{i%rOh`@divMRLK-avL|dMHtRCcASE6>{g54lEq zx$>>;|By?T-qcm_54qS!OjMo>XwqOtWUCZxiI%$RuyN5iiSJxzPNB8cwJ$B_j7UwQ<_8(h z<)I-bP*zkpb3)GL1@^Q3pRk19W$k#*+VRxby=DCalR_$})xMO|C@VOPvRhwcKOkU= zSLr;Na=$~UJ`YuDN9at>EX zj~%o>?0-EN_|Q(m{Q^%Vg75UZd9CQBs34*PEvVSkAFT|3$qQNL?Pt8xI{Dj zTP$eMS<;Wl{Bv8%+`%wPIebdmqg(AtE`1)3myJ5z@Lid0&&XxhH`bq5_Rg}G>>m~; ze+^h>pB$B`?A=*kTk%RQP+m^dN?FVR__979HG_4Fl*QAIPbQaWGI@a*R=4xTb+iqy z!Ioq+vHbIL8G=I2kM+%p?VL^Od^kql;F(jbu6zbH?HE6nBIw@|jLuZdoFEGT_Moh8 znbpC|j<{yiR7**+lA(r_r$ETj#0F(7lFO8TXn#j@OH+Ia?n8s z1eQCoqgfpZc=h<$+uG}il1-ZxMS4b0?OZi3mC-T6iyt=OF=+3`{s~W)z1eQ951tis zL*ms`n3-g|@5}(}gS})5+rgjdMBRbJoNUcDR(GBOWHgP1od@j3r2+%)9blSKEgt)i z{?n2FwhSb&VfqS2k-)Tou8F;t%_^B3 zHAr8c35W^iYJ&DCtLqQq#yh=4>?j#ZHHlC@C{eaOIT#&Qr9$+{g!9uOIkwC_W~>Ft z@gi`W9Juwxf@H47%Uq2QP}tx}eprXd@I(9MV7MS>CkmvHI00+`&;_&=o5s|mnli2U zcOYA9%P3Sysy->}k3?mdcC!~QpBITahye}W7G!MZFh1 zK7m)Lq5EI<)RJTlrObpZLy*1>Sxbx7Z*|>=QYYCCP4#*MPy^Ik)*3GX|JMUFAKYj= zubATU8KB9z)T;rx>coKjW^Z~x7ArLa@^{{VEOpQMNqRsQdjoPa`%z|~?P6~&&0UQ7 zlC@=IRdShFyykQl1PxuM9*_vY8{=J6Y%BjWEBqV5TmQp-#v0} z=ba@;Ht^mY!-<4ucLvqk{tc8xujM%p+{&AC#>XgQ@V;TrVt(*jnt{HjP#ah?-S#7j0X`~9FTnpd_aZ^f{(HTmtQ zIp4(V!9glMZb1RNNG<0?`MkNt+ErGu^zO?TLIsJkHZ^6>Y;>Rh`OwHdM+O)85@(KL z5zyf7VU}lgzX|5&Ow&k_0dQ!2)3Ba>xMGXFn%PqyKD%dD_$&$^yUTtdI^Eht-YgVx zUHAy7)@YP<$c&HSil6kqTEH^Q+A`-@&Q1-Hmv~L(yu_VPU9Z!o_R$EgBN1{lJF>)1 zrOm^}5F@j^iUJs2{Qb1NtMrzZQhC} zO;)SxKZ&9|hP@Ba90Sm6*w@ z6czI6B2M?=m<1fn_baw1+udZdvyHJ4#}bS>reE{qUUx7L0vBLT*Q5LCQ3qkV73XHekz9A zGu(c{)R4EMS@vovV8(MQeK=SeuNzHdGbcwWM)&90-WRhY>t5BYT*qzi*S@7=?W}u? z^tb^#YaZ8lkD0+({}QPw_NL-bGhRz+ti-2sJy}%Wu7`Jw4)QIGW|v(pW%P=3kfk>g zH=O^Jtk<=Vs2Zcj!%v-edrXcMe@V4*=0yoPU!#Nr27;w+5;G9yImB{{Vpq(|+SJL5 zal+zU+G4HKv2pT-d01N~=MJ9ITO}LE=d5*02`U=}e@MqxoLW{L>^R^wWaIyHTaaR+ znRgAdpNqYb89Np*mZ3rMr5DYd?o2HJ`&mEMO5wygyCx6W^5Yu6fR>TOX($x42_Xa_t(@BJ-lYxGE7}V+wbg5WpYPM4q;zN1?r%}ihpId)}cRujdKqq#p{)w>P zo!J-b8|Hy3R%P#rG1w7Z*liE^dJOVrIPHZdqRcx=X~k9|;OX>I4$nc|+1W*^FH!#+ z!N7CCZ|1*9oBaf|vVmxCYQwrH7e1{66wYP21C^dF{qk%q@L9{Z%IgVE$J}N!T5^3~ zO-(v-Bf`{dWxwEF_#%R|kxcvs#H$6QKOXKDFtOeFp2r8j_VwPSN}QGTPm)&V#SR>c zeGp(nR5Xl=^j<@qu}2GHuLWX{2l2RSL_so$YFlGJ!mr@EId?0bDL()h`9Tw8p5OmeLo;MrBg@r#CvHSNd?$+6@%pV7#~{Z^EJ080Y_)TS6S0TvGzM8~<<9V3JvLX2X7q zWLmzBZ}8@$0DF--3<)x^3Mo5y)srSqN1l6wGS%jp!x}}YjzTwP0@B9ip0@)X;=F_E z-RW4X1Cc9GZVeycG4@Y(hxo%=yxT{|c^(PJK2N-6nrX{9dt4ka3&6DZ~(g~s#YilKQMs~#QC;8kt;NuSz0#ORPSr3bpDdBz|I$9#4 zalbTU2y?rHGUz$t_7ay)a_diqB)LFP`i4uWCOoeL6#57moE2fXStoBYV}76MVioV$ zjEN%GXCp!_Sg*Z;*Rm$OJt3tH%YCF-sWd#(EA*u%PuI89o@>X!dSV~3sDBT-a&XE9j)qhT40X1(1X@q@MCrRrwGaF+N*An7s1O}=OKN)k!O~Xh=RLwo&z+| zSP}_N>yK60`dBVuDw0+9{))G(?H2~D?QOECTWRl0_KRS>>s07QLq*LI#+(|ICaVtz zs*PV(Jhdj~jzF)pd(!-X-CTek30mqSrL=6r?TbRto$%6+qGpf1qTarA79vZ!+(}_Z zhA_mvcCo(D;g@0u`t}{gC#*fG$iKP;NWvnhst{xsc+cAOCwo$f{lgafqPB)+cT@Ke z!rSBlemmu@zgpzUK@R{Ho&jGCaTbU1YuN0}ucuxU;9d2CV;S@W51H;kQ85op$Sfp6 z&WtseIZI*AYrb!PXl)uqW^K-JBH7O5T+k{uL|4D1#~tP@Jo{bLlc-LiBnb2$eu+Lm zpjeMB#a4x9!+w7#0=xPSbu0n&@hQBjKEg#;ktBWsQs%VAd=}Bu%_90miZb2!2cu~T zR3>HXkeEEI>^-adi!?pfhcUdYOWUx3kUz*dQs_$%-<9($ta@eguPi`0EEs=}0fn73A^DuLRR)yDA&)2F+x^MyCOlK&?F!#Anzg^IYQ`O^q>|C;+i6!Y z69^2mvih`B&ZTA=!tPf2qU5u-uLP8($5_vDW(WK3!?M#gdRY5$J2~NPG;<$;f?`mb zu|tUELrgs5e*Lko-AA)f-jC5fTl*>2mT}cFnX7(vy}qVWmiq(B+J{@FZ(WxKX%ofv4Kwbqfm>wq-Ug|$5|j@EY{r!AoDPf zLPz*4nd^O+CId|dx8%KPKO1{}MEvQi%97tCe`_zJWpc)kf}^k&p1!XoJeh?f2Ts=1 z0bM-{@KbuuOqViYf8~_;(`&}4`$m+x9dyQsNg#6a;Dc*1%vMEK*PlUJ&zT0GUGPX= zJr`10o+Q9XJU}}8MPEReus>b;;C~_qme}ubg#3{GxUn4FrXqorE@Gu1AW5(V|iw#*ZgD5h2l>YJ$-uVyTFRCt< zj6pe0_uoW6zQu;Kq6K9t0g?r_c2Po;`<+SXhK#iapBYGj?bz>qS%K9-g&^Tc#Z+KI zveRkUUL9^ia?@$@n%uwDDOaAK<{nJ|P3|iSjOpD^d5<`FlRIF-^{yZF-lMJ9CU=tw z*SmhyeoxSZ-)zG5uAkCtXQ9cx%7p7(Kczpy6I%)su6O;E{$rj^?nNeC@A@gdu+3Rb z6Rvmt@LIU_EmQtE3h&mtex%=84BKyVN0@NE>xbMr&|Tzz3{1*b*ubO$Jy;;4cR*x_ zxQ9_kkTSVioM?FlE-H?N z)v4~URwIJz=v5xNTRRwbZ&{$?^Nj^qbCU{3q2hcywY=C}O%yngl4YyO{IO9PNNu|l z2lj?a5^Hi%VZ?Ule!PwKRmKOuviHt4u%A@cgpG2ucN>##)-_bjdxCx+IucG zIG2HHZW>=_t}{ml^C`_si2Bk?3XWls_;uYtyI~2zCm zfmoN``3;y;>fYNmCPZPkq~EG1o2cqi?_qczU0JUGVl%0w#hza!8c}5K0Z_kk`sxNU zI5%$4--P*FRf^;NkL}+jRu`B(L%X)r-uuC?=mD-D;NAhdqufhx@3vP@ra7yZ5W7<* z5&8CWiPiOY4QFlquqkU&i*r$%UE5+$Ys0;?>M$I|>F&|{kJS$QMupq=shxIQ;dVmd z=&JlvNf^7~bDv7UaH)+kkmdgP zJD;RD`Ayoio8w6*+#Kh+ONpjO^EkE*y7Jrw-gmy|#yH=Nc;5wHe4$(6eTTgGkUQS{ z4#Rm1rNt9Wg<<6~{$-VKH(^FTFMOJPn*nu4efTr>G}Mot?*jZA zYb(ZY^JLn#fV}ghIO_cikV0YXPm@Z@vf8(SonpEvA>RO}+EZuivNbj{Gn?HTeyXv~6$kPdP|DQXXjkVB z_Vgwi17?DwHdVvP<-v`<-@dWw2F9DgAef5`#MBJIo1FToATeQY*WPTRR>jA+CQXU?{~21uv0{dh6>p(rjsr!*#qIyHD7$SUP)JiP*CwT@ z=Hfc_5s}MY1MU#@YGtV26B^DVro@WL#mD;Lq{BYr4$_M{Px%E4?FHl)ag`7N&6jiLvdL&9BTg$O0TuYQ9%gRxIp9(t4y+; z^TxiDs0&0IO)DV8($vgi(*zKU%RD84HE>-DS2^zvo|>Wk!=yR;ZQu=|wN`S3hKaP; zh!yZe1CteRBPiY3kp4ireaQwQ64SFpiB_zbkIprL?^$tens=_rZ1pa#Uf-03-abJiU7< zxQRH;+0G=1|3&mtF<1`^>pTneglf(}1JYdRoI!Ii(VrDAY#)hU)3!P7*aX zxL<$pNKOOUlF3ewPf0~s#`3?|E&8^Zk4{A8s$2^2ruLe!5p(zsQIr5MfS5Dk&N)c- zh3!9CpQXN*Gs^OEt1FwQwdJ5Uj91i|s;#&-N5Cy*Yar#><>6Fw2ortv2A!(|_RcvD z?h$5X1rqH#8Bl0+qi0yLuPM$u$=vk?y=%)TKis)$3F5w0tyu2+E=AlJM$tdy!{@tZiqABCnP?h5}gIZsxTP+>>h6ehh_O3~jqWH&3wgvH$xZWkphVsYsZ?Oqx{8`Zl&Jw_#C$ZYg)?+{he`x=HL~t&#ylkw)rQ zX%luWqt6oZj`I!=9U&yxD zVr&e9fg~vl1R&v>ZUkV2h=#<%+{Q(@K0J@1^82Uo{1W>0;Q8IB;7Kk9haNsdPP6G} z27#8<_DhGK&N_pd?0u@MKY30hQ8JQN7wkJGrW5w7Y@$jLKPX5yegfH{{ZRo5w$E7< zAb$zI*U1B66@!c#h-SR>zGO-ckUEtcPQJqvnzGMN%F^ffI6FQsB^=2QiF@|w@AZ8;t z8x&#eXUdNU0&fu|WOT&5`U<&74Pf7~Vt*tQR{cGzYfyvs+g8`(gm|fja9m9{@aT@d zL{oqx;<0-*vLCcY^ilmBj)3ocA;bQyBK&UnkunRiMFr043{RBZu9;5aggLp$fnH})AwJhSmGmsq-8JPWSGGa9uoH7u7pBfvLgB8M z{}t3(lbUg&e5p+c8;|dv)Y2ekj-1`{)7Ajz0poUkM)}vQuJz;+%|19Jw?C4s_{}GBlTRaR*<+^vlUERvSd&%ut`$2CfT76C zta!G0%S2mnjOg`sS#oZRXTwxEj_0t`N|obx?tk>e?cA^Q2p(UxW!+1nh5YayxMK&_D=+NvSoRL250B-;^hALruvws95LHj6l?V}TCn zy^LiH(OPObm$b0Mj#kF3Q{v)oZR7c4EJxoW!A$qIAIP34H{q4XCQvk8YZnLNRXqT7 zh3ike8kLk6+U18v7HPvsjdQPDY=jJy?YHuY-Y{-vp}00V(G&>~=aM#ON{~VYqJHF6 z!x3jQfJ1OaQln?j1#SUL!qOA9m-w%{eek&G*0s*}7utTaF^=haC5U|gkh#D)14|ZG z|8QULOt=+)fI`p^7wh5eMzKF~fO-SJXF;%v50?)r7A*QfrHLEN*GznH=8{h&$M#9t zy(XU(J5ObKAA_@6dqus)X8V0;#ymfxSFq;zEQL_Gr@EJ4_jKW2SqR*#tk`pa02i<8 z*qEq06A5}%`>!9IOOJoNjk85uKZf(~n^cOo_b7kws%g$~WS%JX1_Q1jx1T9{A3ho# zZ0nr3xZ?}n@rG6HXFbqn3TDqd!~T=~yg23+IC_w5@hLb@ZcE2R#izUPM2(&*6ai_~ zvYVK;qrQ$XIh=unEomARbe#yM}2J=?O(bLV^P_T0$IRU;Ib( zGM_K_pWNB0&)faacfHSC@+on~5R#zYgOp}2nf9;(U?>5Y>Ho}mb1 zuj>wyFl5D&vvNyw z)S7Y$Nh1su-Qn5J#9cznes3-#%j)jt@8piJkW{5rSJhN1o2tm%s zElNZ|BKrn+1y*UIcF*od!$fY0RWyus3sU&WMgN*;=gRze%4rYc8e2p(H9Kn*1XB#o zp|0^f;Lc*y2=CcV4ekKi)su@^pkh4J6o~9Eg4^R1Y@w(Gxb>}u3uCZI(xh&y^Lfxi z;d@EYZ0>?OG1|LMW2Tk74UKjZ@7)zeyg&TAbcd*kXSbC2CX+usMWp#b{2-V!^~kb7 zZNQ%4s|I{9rxxm$e4JFKtZTTXQs!4r)4t>~FK>E~cdJz*v`eX((VlGPdAuL*8J^Y` z)>RtY<6ciY0=pkz&!vuqNioO}v?Xs5VN((8|a&Z8~_dD%>{4N-Wn#&-Hz`qjkf#kYnEBPe)%`pNY6r zTsop-@A11Hp7-v0pn{GE9S(ey^)aCo+t1tmOho_fT)&4xVn-393|osmqR%6l(H!Gn z`!{f~M7#?a5_6BpuEMh)v$_`%K}(Gk;2Aw>aj=S(e@tRcYBiu*t7Na`$%nAarc=bS z)Gx^<&=0}+{gxI;zW$Y=1U|GA2RRSJ_!lvO%%ysGmTqj#VH|C*6i;>v$vNKGh5R2N=G>*YgRdTAK~43K)3?hS>%C&$`NNu z>Cf?qp!LkYrF7T$fuN(ckW<)$1X~{8-#QSSg89xkt^ixbA~rh+4|D&w~VeT0!zGAw#XGVOfMa@Ikeq)h?NAm#_C$ zc)H!l>iSntK%XoxTC1~xrye{=0Z?OHMO|B|c)0?dh3|$EKCq~Xt`TX*f39&ssxJx-ZC zY%0z5E1eMi*CpwhAS)yJHySO`$%^%Jph|q;8Y6|up?n^Aojo^kZ}SXEvs; ze^P_`I2TH`nFM(h6QYykRieathX;3nah>+8cKF39dU2q1zt-_810pDsK8=-hX^ z3JU&`B0{WZq<%?O6E9wV+{hSt6YZDN*+yFVj(|FH;coZ>7e6}L7x?|8%Gf0xjx_7} z!$cHqkMKvehuj+%WZ`aHEi&_kXS>|@YiyTyaX8Ji)Z4&@+JeqVXRYeM<60XYe=)CE zICf8kU6t?OPfD8Xaokq=SXm^0d6v|>dvXg)rqK50@ymI=@tkahlqqWsb8!-;Z@@&oOn6y1v=X zD>6qdV*1h#Yo<@Wke!Ha;2V#L?mSb# z;4OrE{ujh6;jiL%(4u)%wxn%P;Y!XGZ39=Qt3&p2%f_Y$4vY_tn0M23L)%;bUAMT| zJ^zQFinY3?Bht`Uf7dCoVtWsFArhb^R@|#NUyr*~L926FYirqME!GWaa*rkoA3lvh zdro%enkJa;QPQ=pT{HKbtmUJCSJ`40=4OieVYHlk#K)8lKEmkSUtWcTdyNqjG%xM4 zD??C9v1+wcjB{B_tGzh0)oGg5n$@(R73W=B*G$m`20C2!n$@+5f{TDYg`VsZOk zADe6fbgko?slgO^i~0l-UE1PA+M+eiZ#U?h^R*HKkCSPWyYP#jaCgPP2{LVRn+OsU z@_;)*KICHF6k=2Dp(gihezJQ_g+BTEw5$GF`-o;uqp_u{1IbU&;y|~pviF%b7x*WG zpp3iNLb#b1!H>#brnLVEKZ|8W`NIqwaxx5Q!>__84YelsCj^~n1I%;siFPEBU9f3; z+qzaVh7c)SZSEQZFmUdeOklE)q~cZCi3d0Ejep-36hV}nydMpvy{j>SHgN1SGZKrr zZkug9cb^vx|10LEn{^ufR(!U!ncG!B)|%*yhUSQS=f!vlzEiQggX1*epjVxl+M)nw zyZ)xdLJ5U4yiJW7w+riN4T+sz!Rb-)cOl0cRQ8N~XGZR!onUppI$FoU-&89r3;yt% zy2Z%?qaVP9SEO;#| zv(4z#H~evoL_A8I^lq!J%#L3uSlLy~pbw%#F0%xt8RSrnU?K zL;?_jxpyuyfH6p5w++G8wMR1$b@j;FoY}F!ylm6117|swmrV~EcQGt;*M2*LruPL| zrq(&;g|uXw27yBKOpYYP+Img+RX(h(HR0)jJtB&8O_C6S8h>~cdh_!qwRaz~ z6;ak!PxoeRy*Kn zkk-~0oaRs>_u@p&dK?{uOtOuBGFIukI(D0&PrN!>5xUQX|L03CMR?JIF`IX5E4~vG zxib^N^@+m1z%vss4O-prYIu5>EPIpL*^h#!Gwc>w7 z0;kc$6(weISiA5#TKoIYoz&XTdGxf1_D=ooNpZu7^I0Fwa18fucK6U2YwMvo_!6?; zd*)RVh-2Af((xNjyos}~zg?X&DU@xOhuy=JZ*J)l$vd0XrKxW=yX9$+67v~$(u+he zj)5kc-EV#0hscWmgm5O;lLy_JlLp;Xf6%qIuAP{X+40qZ<3>xZX@ezRG$(0_^bMDI zS#LrPRi}sNxnNGf-KJ^Q%!~Pnn>LV$J+gKzG2Z<*6RuI0)ZT_C6QxJx!gQ|msEn}w zjG*~_gc2IsHkeVlz#G+&i9dA5k!bBh;Xc(;D-Qh@1-BBST=fBZly5%w@OdC(6ah~V z;PcoC`&(HB>?X=Tw3~r9y*h!KtQcD4{SnT=jfzkb7)+17>p+B z^W?lbl-y6fLbj)?Y<9nL&Pi05Pt6gQBVw#G+ZGu3!k>l@r!_3IU@}q=um&s?TNtVF z>1lSYtzBW=MG)9k_M(;eqDS(`;o(H|@jSTbw$Gka=LU*vViv8L(H1ck-g7dSSfdJ! z=`Due6!=BP@l`an2Fq6ig-!w+ZZz-Y!mG)u8-XUx2IoBn|;^p=-I7kEI6jhspY{Q zy^qxU$mBsyPsaMPJZm2IkIn9`!jpRaHxwA5NiC7KQqwCBd!zgWMtfAHFCS-?xzV#L z{F%)jKG?0wPE%#4B`<_mM-nI`nojWQde3~;AFsZI0^`!gyrWCwylYf! znGm)BwtdU(ploJyVs_9Sm4^EyZfT{V{eQ+SFF)JIXh(h|v2FtpYpv4k_Fr-mrhhBC z^MpeuklYHkbe>w13g^O7q+LfC6Mo*k@j>B@`p9vVLRWfYh!)7x}k*ei6dfGInJ7p2=feTiC$!FVu92b z-d1+)YqF@%J)A^gB!ftKa?I^N8tni3Ib$D>?F`wta?I*KIvjCm?BwVQl`w)57(m!^ zc-JN{4{)ZJw0^>l=h*;aMc031c-h{LXGMV9{k9EYss7fvYTJr>YwM(W*4E~K0TO=PwVFm-s$Zt3u`r;>6XXtkkg~mV~^I;M)s`X zu)!$q$fLu`B6%xL2jcAE#G9kBzUl;LlnN%48RrrHQa)xx4U1?zvn|_hS=J5x)|S5~ zYQ7Vsdx9J?>UzvuI9Of(O@_p+BgC6^Tf=sIZ^-G*vST^B@w?vw>a5qQx)Iyj2&^;tcc)me?%coqHI z^htvUz=;%L+$Sbwr?quXWS~MCkPLf%+dy3lFL>?@a-^DC=~7ez{jUwTKOCqthuQ2k z1vU=c))e_`ReOFo_Gkf~A^tUN#*Dy8&Hxspo0Tc~;jKX-q|I z7mA2g@1{w`K4O?+P&-f`kzN?ZR!vsQx$Yq}LJTBr(`giGr|Egp*!^q&tlQ45_&Jog zF=%yZy%uR~>%4V+O1KAESB!h|C{0BlL>lpSx29IWAs+8*%4q+_7 z($VfG4i8P-;Aiq;}f|&GR&=Y0H+V2?+reWg%~<0cneAM5;(OfC`wf zyTHxm+O)p5kF7qf&r_?mT17z6ynqmVsq*3rz9GJ#dxoDoKa=<9CmBQEA3pe|84Ll!^RoUr`s5$M5_%g<3!NK%C}3 zIxp}7jY?^?^D@s0uoLDf@)l$%?%&cXx21yywv@F#WOqqZ(Z9eXx4;XRLHKnL2kQHr zGs&IwS*ZXEEZw3xT4QFgv3w6tSg>X3E&up-H$NDY^kHdpTl}h%zf82QUrnl}w!Spp zh&}=+amNtbxrT$@#yg6su(H)IJZLq}uin=;EiOEz zNa@}sBd{sd9w&_2BaHfCkH|TXxd}ev-Z&nO*!|Qce5!A+mkU>=5%KZ(*nlXDUCE}d zX%;iPzG(C>nqg(fNHOd%4Z^j=CqcZS=RGt71wyt4L=`q-vLUis=9L5YD4fmBTjI$x z+l%+%(ZLE&axxbR2?RS0+Wc(}MUhTog(MQn2<2;&*B?ox62`<|gxJGx8j-A%XzxaI zeQ%KU)8_k?*+Mn&fVTehqr`txXk28ypVKm25U)^;Y(dlHh_5u=*Zc%4fyV*SyH@7q z#s~UA`%6D)uant`$;F*CT^i83M!MbG@blS5^boXKBeJBgyQ3$Nm7WwHk}pbHw?0`y zQwMR-uBevc)T!FYL#b=upb)O`&cqDz37WB0`Hk9#1M=Q*3R+z!t)>SjC zwOtgT5=qnSoXzG)$!G#;y^^fsXkHcq8&Q+hjjB@Gow`L`)i84gT%w+C7r2}nTu`(p z_@cF{i#Jt^txt$Ec0|TUO3uzRqCd_`3Hc8tKt*co2n%ralAq(45$XxuBaNAX$lorD@z0;hS9 zWbz7w2agyxtp+#zMt|W6Z?SW4w5xyrDSO@HTCVqb!e!R=8Er#KCWieb*Mu`l&JX)a zu52zy4o2+5#Nfs~aU#A$46c%E*6gP)qISwi(^n)bgsHB=H9X{%aNgb!FI&zqz+R|`4GDxmAiXGW@?S-PGXQcp4UJo+!{k)AJlt!V2Lj0l|gu}Rz_NjNS=Z`sL%{9_98 zhreO=95x+uuUMLy9sTE<%T)%u{#5Un$f5K_8wfs{4|hrN?}Fvw#}vq}PI-}1_LT|5 z!cGDBjF=CEk0*t={}hG0X;-r zar3A$iQOwhfiW^&Zsv-7=~*-}*$@9oqfn)0C5lgqA1qJxd8dq$O5yX*jGIn^uguS* zPlcbeOXgZYu`4>HJBCWP8?k*dMD;Y&QdLly)6DO6;lz0dl}u<&6~;BVBP;L zKh|1lt@lL~+ts>wZDNxTy&Sb9w$JE-xM=R7T%8ukot(A24n@ zNAqHh8s~HE3dVVt5&Z$F*7%G__aGIXm9^bw;y%cVZWA=B=ia_FRXep-dloHp>l*LY zwR}Kb)v3C!*L78^F-%=*43{#pZ2yb2%`=i~wg!3mbDaI#@7W$t$DgKV{>0pV;6wDg z00fi;Lx9TyJ|EV7aKy-N!GtThl898%@XJvSmVtdNsx|xG1HIq0tX0uxZGZS&o>%`WXvuM1Oc%O*4ZaiQC` zYWq{rn2-c_0pLzn;G}O&7gk^ZtP4`Gb|OrGb%DStflg0+$|8RPNB!l*!GxAY%o)S_ zhWO8+P2XUQ{t3gWvfE-Im??X<56H07=E?XcAG5s0Pl+Tom^dv+_N11g6cfvmG442$ z?go^a#Oh`QtDDEF_+l)*9WxHi7`ZtWDye6byRb20@1vrSn+s*E>JhTE!FgBU&D4cZ z!=L3frG|HNdR%lm9j^wXm}{qw%|ILJTRPr^@N|{(1X`9T<+qFIFM-+lL?t8W4`1Vx;%8S1)GWAT4bRw~g~ zn`YI-?aQT>JQrV=aG05f|nBV$hsDs z5_pXUPN3HLH+E2mqP5oI;09_Ml0 zn={3LuNpFl7*C3$=s=~b#;TzLESSs?xKL#vzkBw8i0sk; z>8mahq_5Pn!H69eBch(ef+`-q5p!JLTA}i~%O_t=e5bM#L&4$RHnW0zw<6*QY%UgW<>jG zq)_>e{!Z5jBGNT$Wm#v$w$ZM$76j&xI}3da$HZBhR+1~kxij;~Opo#4C-jfvn>$F3 zpQCIRvci>ivkWJk&e~EQaqH1kvi(0wQS+|Kfpjur4e(`AqVP4wi7hu;A}D9|R`w&y zyO7rC+(dgKpC`iKHn;!wz?W1~K(N#>m+eYK9`9ymp4q1FP=h()kZ)XhaGznf1B*Tv z)P2nl^@G<1Jh8!QON}dH27iLgt(Se%DqkzgP=Z?)59}qP3kO#};#cVKxblI<nW_?<=y2 z0yoAVtSIu&oo5Y!bwq?(6-6?T#gfNk29M&C$fKV}aiW$3&qIhZZ<3Ma6h8!-^z-9K zk_iOj;?d~>z`S1Wc$4zn55bcZH^+#-q#(o#aW0C)*=VU;HcI$@fEY`6iBRMwxGiU~ z(>3<|AhF*sfbg_cN-Zbg&bOki&ip-M<0|TEXeVr~J%J(CQj(Jw zPA~2KXrnLZKT3P!2#dR=$_tqDM*D-^YxJCV9KASl6F5D|NBKvWrpEuKq!+yrI}^8m z3d;01VYEztZX~U3AAwuH=@ih(=`>qFi_uGjl>F-t`j>s6e<7f&0X>`wl47)|%XwWu zqr)imr#!<6vY`wJcuDm0#7d!YP27*823*p!L|)~eJB67~JL3TWhc^nXkJ1;`IY;RW zQ9sx^-xrS5Ccu>G(^U>u0!+0=#e_}?*_?cmzf+tET#bgORNSF zY2KRnY!y>xfVobDu@UmW92f3#jowox z_uRekf%1_WMW&QFQ7z{?sa$t&U|eAV_?$h5SyY zW@+DKc7P>ws3soyrKX9*_oxVFKvP8jJqfsls`OcbKV$Pn~3y zl|ikY%LyEF$78iMH8lr_P&h)C7{nvkCIw{?*I-_n=5&xDSf&c=p+65ACNTl)2j z6q=zDQwl^5SA95HsMbojIuBCsTEv0$=g4iT9-UL5dek{rxr(F;pI3?sb15T7hE}rS zXOeii`yzVIX_9FgnOgc~8bsn{sZ4w0pPi>UT$@K4%vRBJoRbirx@T_yFa7iuPm}HC zilki3nIh@sxCXis6OuB}6g^)v7e7R`oJfW>LiPiySPde&x?jcxpbN6cn!8K&|N0sT>tyIFAWH`kJ#Y8;sbw zG_7cB?{FrG*_LlxgEe8B&#ZXSgUa)wZ%pveg7;|0on$xHsG0aanT6>OENAl}nMlF- zQylr$%@nxKE@AwnYHh^+Oj^`Xhv7aywiM@GM#ndAOFh2 z3qk#H!DU6DMM1T)e-+z0zkn<9$R~BqQ zaCb>o*Xm~#>vq-E#19?R&CwIDa}Tr@e2>!Y^I#ektcPzBt65Q^Qx|n!V=#~o6{O=6 z4@*ttk(c;?x!`rhWO<#`o`__Tf6ktFmH!xnO`RRk`cIbCs?{GkHlWTjeBFJR`z>{t z;3X_>+18ZorjxPhbB7xnO(pBYCpY=cb-^ujK9sO(xbBbl2DkKnjKkr2pFPLxCThQZ zRUWS;D~I5M6SKdP5IoXxoHkj4TIydaGTHFXsoK(=(8K; zmW3SiG}#J`s~GRxvl-mf`y!uT^7X!%^i_~E4*AyAGZHJMc{TAxoSN@hBG2-VJswv} zX&~L|khu#+!*@QVt%QGJEfLFMKR`A2lU zm0kSS#Jg3xJj*|jpPOA1e?Sr|vnA#7DT%o`HSyo6lpIN+?A*MX_%fA}Cn?fo5fU}= zCIwBNloq&IGd@rnK-If&WwT-=R zCFx#5_l6kr)m%1tFrN3e1er8qI{{(cEWo%9;C`tZJLm{c*g$PQt}U(P%J5irMam?m z<_Hye+lc;}Ob|XG$702@n=eOZD*|VFQBiEtQGyyB@Kwo> z@Y$Hph}oA>$2}x7lZmHeIXTT-D|9rQ8ll+U_=h_c#i9}qM?n;S{m7HjJmt_m)xFEaxM!x)|A`3Jb|Lb>TETU1HoOeV6c6vc!L> zJPQ}5q`OkKa#so+<*t;a+?7~Ri3L8&%@j*t@+^OQA5QY2_EpM( z8}lMP5&&5uYh2YBZVpyu&7IB4lsgb!N)TT^T}9wDI=K-=?&s(xW1i7D*t}qZ(OH|e zaomYsONnrr`Bu8JMQz*3(Niw0Bg{VT{o(ROKUAks|62(Qwp8VMh5=qeDqe|lh=L@k zfi%APReQ{k?t|&QneFx%qx+z5%T6w_GaeiQjpf9ExNsE2{{jP$z;!QjYNkV^h1~XX zHPMLrlK(7uGYFMl6aSy@^v{2jb-&C%2R4YbX|ASmz6%JPWoBbDfe(z8UUS`+-CK4> z-mdx1ePqd8$K7>%xJ)gr^=%<&WY^imSKi&d%h$cz*Sc%3WZAv!gfb!{UAIodCNi$m zy*sVjA$FCQ+hT%GhrbosRoK19r>JE*ie5(aR|1YRk;<0~u7k?8gN@E%W=$j1=lYw$ z_@9{<%@DGS_ubh1kx!eOEJL%f@b%a{vnI#9DA#&K_4p$SL7bi58*KLWj8$$-T*;CyS<>6e(%L5RkhZLh?A#RMi+q`W=bRQ4ux81g=%sj{*>NdUAMtCi?)%F9m!+M(V zwBEtC8Z*q9KFxIEyr;j26zhFg7ADP|E<=jw6W>1ZBm1?;Vc|%;KYuNBg8t*8V5e9}yZJ`#v1kBKVR%r~cq#b|We!V@LtQ7QKa_CY7CjCH*q(_)VK{Fe8n znIIDoWX$=#)oRK1k@=-;9di?-TC$abkj;TX?qoa-&p%O=B}~%v_#EeYy}-{VirgGH}JyUZ=&Q_Vxr z(A-|uy;F$YcEZT*(XDoFVe8s*FkK)k z6o2G9$v*j2?;nz~xt=zKi2%OeT;Efw)F6DS7$RUiTOySZ#{L`l&yXVK%<=q+BLS%f zH?QzU*A}|xv*Y{jZ<`P>l6}&9Rzv%;O=|o^-Wt*sPv7>wv9injJY#~d5O0U$1=LWv zu}XsEw0wS6^VXK@yy>nk z&jCWn&HIz8JcG67W9fkpZxCgf{Q~hJd_shP(w^HvdbVBsT*0-d6+B=sCQuVlWsZ!7vX{tFAT(HTuBPveKhmTv7Sc|h ziOY9Ug~$a>+Jb(h#nDKrs>*PFKwTaDKcaX2>QZ1yt@7(!PljYlfu!_q6j>$?mXo*? zE8q);e9Bd1!C>Pq4h1unL4PebXEAK1Gmz`8mSq&>Z9H%r0U`kE+hmC|-CEPad(r-A zmvy-x-Y*XiU$)NNtH=3n#`#{xd2xR82j*Vu8ZAzXZ??|mEbRzu2xFpr6sm|H+gRj7 zUvNj$E<1exVfjoiEeK3+?YX5?pwq+U9y+~5DyE|Fsck2SJUK=^7zfC*qsXK@3M%=nTY}!TZ$n%75>l@PJY|zvIXjWq7a@uU&)XraywTC9L zDI!;Do`t~(E)b%di&Yk)mB6N)a+Je7h{NetL<)89^x4JU!{%n~Q+5DP6TDAUFMskk zYN|1xndv#OO&#b~khfrV(vSt-;O5E7F=$38{y<*3XX+FrW}|iTjK5W0m42(h@2T{O zfa$4JGEt;0|Btr@$89-cr+k&693I7TZ^87$5-9`R>OiBpjUcI%r470#ulKi|z(jm@ z?+NX=f5_CZd*t>qJ2ziV!!kFN^q+>+96UnJ!DmZfhJmH$;a#bDSn-W@&4kg{j5ngs zKycz(XzV#TzIZ<+Ms7CO$t{K;mwuZfB&1WjI#yH2`?1BgOPYC|&&1u$XI+{hTC^Oj zzXV1-1x7V~3X!#tBUAd;(fBD%wjQ!9FW-D-S=$-nFN5)`NZh_NH_Qve*iVwoSj~J00Yd zYlmVd^MLKGg)%aY-2|!I21|RQJgN4``8v-Nx-n~Lq|q^4HHL=h>0%|92-A`TEh$nh z2^bH)Y^=1TC6zXz7yB15BzIpkwwMQGR%k{hv^e*p5SPf zhh#j%gc8K#;}1sDCyx zs=qQa5IR$s_TonLRS-R}UB-z7_Y&Sh-KtYeFek(<*MuR^Gtgf~!(qzztLDg=`!vs|3Xgy=(yv7)1rnd<_+Q079)g{$Jcu1Q+#Gid5`Ro(bY7pc%MjH2hJ* zd!3pV#ZR?5K2(|SvjkB&rVVY`M&>1(7w|xq@+Ptr>F@kp@BpVi$BsKs%;< zhGIClO1kq8fb?tGkD;t;4$Y#hTK73;XxfX8*!sb9mvjVUsekKeLex~ zH>qt4y|-~#O_%H>iuH}DFnSK$j&xN({`0_wJd%y*0$O;u^KP*0ms2*!4|m=>Fwu)- zJg|Wp*;(2OsKcEP=?t<#B=D~$!{N>~I#I|j^Y1QlMs}4N(LKO~>Dehc$R~CwKH#Tn zP<|eMChI8^|ByXJTJQqNTKch)tQ3^pcHb&l(HhWc-L=*!%w|Ph=OhxKwDgCpV^}{g z%NfS7Ss!_4gxRy~mF~nKb@m5}NwbL?Fkx+e>}g{6fFFQ`Ts`HvuqJ1QW6@Ia_n;pY ziN@s$xb5QIsQr$u3yVizh^V-V8ptGN?JK=@_EXm7qZqGJ$h@Z5&c0bfGhdQxrkR)e z2sA;m3z~qTBm2om)9G{yL0MHtyQ0$^ zA9j?XZNp_v`Z-i&EdheZvrKtsvVblI5RBHNBxend&4p(Nt|+IK}&M*`!3%6arl9Q&jN{ z+?pk8Exh2XL0odO;yT;K(R?xeswtsbHpzZ{aynsQ{&T2^2uNqY(zs07o>mKWgTPHm|@l=71YSoI><8Y$)47K0Kdf?=`w4IOPzhB3!kje<7sXV zq!mKM|46`wo=U}bmrpf6b4Ob124RaTHPp;_ycO4gqnYRxq#`>or&!Gy@J<#t0vk)` zz?MB@!CAB-Xxb%D{0kqaav8BwaOAGB*NkX~jCA_{apftBp$pVDleJQLrzAW6*CQP*c>BPD+-{lrF0U0s_|c+#94+r1F}UMIj&T=K$ma|$l2KV{qn13 z%9X;>@WhZ$h&L{6FdqnOQnwP$U8&O1P6JR zz2a()=P1o_!Pn|RN^dl`Mc$TEEMhBdTdsbT`C|iGWIJv>T;k+k_u5@TqBllFUzvjr4{DDu6CC`Zr9P6>NSE~awSq<%DmibO?ODiKT?`QM^ zQSO6#n=&@~PR--3%~-4u!cJI(Trz?a^9oV714(xI{SOqoyv~;a>@s$g5gQ4S-SHSXF3&lQ*TbF9YH2Dm zOQxUw{F=KFg3IKBxehU|x?LiV&U;L#z=maN2f4XP2a0g%mgD#`3WjdJWdE0y=N(#e%G|-l{0@D-zUXnf1{sK;=&8ILU zc}nRc5y@s+Lr?2~c`Gq4!+BYeV%q>xL}j_4{6!CUzN)^MTV&S$2kdpYbH{+ZFNdLhXi~}7W0PvuKO>bC`#Mqy z<7qvR^8-T>hx?!8==C~grY0hvr`qbAp-hBV7jeiS@xxlU8tH$3z<2iHM zA_ztAOrvvy z90F?Otix~mn_09VP8N{t2-A0lh!n=Q{*=U9QZh5Fv!XTkF(ty^@CK_aJNZ>} zb^~!-S?%*RB*)KHf%K5S!5W)I#s;%yxB{g`0Rtq9C3M&oFAdhDETY%@$+$@BOF{G} zdENyKv|-6=HB#0I`!}Y6*|286#_cLU(ME^5C|lPBEMoK-v3Y59z;kl#x*CNiIPKz1 zsuYlVx8I^PG1+fz@=U)C@wxrBRrIkwev`ak?YH``?>8xM%zjffx&5ZMi(El5Cf6B` zt7B3Cj|*7ieG+x^0y+<>JPttXqSDb9aRu2_8b>~rG_JxW8EZbfq}{&6%LO%VesgN6 zImDdkbERlcxl+KLbgJoRc(@g(Q_;(^r~#4j06%%Kv$j3V=i@k1A0ib*5IRmhNunh^ zpmZaGwT`l{Ev-#774~UJH;mM~3Moyx9Mx!;oLymE$CA~V#JXBk4}qgkzrjv z$ir`{Z&6kVD0jdQP`1j@%pVteY1V7K$Rn#5cUj zKpMZeZ?oPocGdWQplF21)kPuL-gvMqE7Vwesu$#%hH_u-(>k}FDdB8c??@%q5GS44 zF9f+&(I$#EW!0*pWN9G_;cSOajz9U7g3u7eqbGW@?q6Zk2p1f2441^?rH5sHDfgK@ zk)0#dth=lm(*foJ%?z2hJRwZxwjcP49colKx>D(^mgiCn6Wk;E_xPhsF7)_px5q^t z=+^}6-Mk^(!tvF6Dce4S>sC` zj^y-5;xeX1keKBnanArG&Xu{}RYhFlp5hb?Y{d^zN&wL40=RPkfE+%KOU{5^VcRbO z*^lc-Xr->+EiI(%qk&untxC&iRi)n-m9WoPcdf2_hFe-@m%h@~$+~53QKf^V^ef$~ zOHX%8i;V9p{amuNNO)EH5mJ)((XaqcDkYsQoo%KF$ z>j%;|E{8y>3f?e!i>}_eiy^LV8jZawdGzAcnk`%PDpm_VPTYc;UpKjNA31FfPFKYb z`qDkqz{D>sTbZ{;wot0#Prrrwg27T5$eM5L1Jyua#8PR4z?@APoT!GGl?9VS8YY`& zwefp^IfW6UV3y~t5i5OdeC`04XE7K7>Ta=TG?0k}wJ!P^rzu}xqK5R!96H?EJ#srsd3SpzKEvpaw$cQ%e z;UdWjm$vG_kG>9{8#O)$FcK9Ez~{^)K0gwC3Yavt)6QE6cgdN=Cr#mFPaQ&wCbTRZ z;xS(hA8(J%*f^HQb#TuFJW1hW#RcQ?CY!tCO>d^y>Zm?NhBpccxrZD3uVOoW{isj~ ze~AR%2Hm@S=~su0SSzm%C#(|e=Cnt<7z8Dl)zFNLj!kUsmf*X=N_SD)RF9&~S>Yzu z)}^f*Zz&ZP_nS`9YhX7D;^4QV_Nhn8HVpgJc;uNC|| z^;xo4{SciFUAWU=RMR^&rcm~qZ%`kbIA6mYf%1qxM%7f3d zBA+MQR(a;N8IB+7ZXA>Fs10zsYLMCuUjhz#FGoo(Y@C3x8uPHK%I-Y>!b7cFmzB~J z)d9ASWz$CcI}l%%tYXaCP8uB`B`GwYH=?5j2#FDUjrV$aH==*yuSiAVSBS7es=)v! zKd6@cV7`y^3~8A^1c!UG$ITMy5j!|g76=rGW$Ob@mMtiS5;zM_o#NeBUX^IZia#kn zXhhO}Ken2_Ux4xc40BuhRI%Du#b5g}4Xgd>L(`k5ATsPlUUT6T$;I%V&;Rw%mDl># zCxsSz?r_^>owk2HgAvmilV>KVbRNHk9pfYotougg(a4yxiK6i{K9R^lwJRE4V5Mr;VI!9~D>#L1^a z*rKVBifii3S8?lE`2u_v4J-qWlCwf6&RN2J<(wrN{Y@z}XES}NIOp=bT0ymTCP5(@ z4{0r#DN}}K7;8)(l$y;a)z&*ClRY6Yzo%R`DP1*3A49=UwO?~i z)6HR=&5rHiItT*h%;$f=j}q{@7p$uSR#P4;cym#1Pi261CY)3G-2MasfUqx~($|aH zC*UmU;m+?Jm8`C$jJ)GBqNC8tlU*yF!yXYOkWi2J{q);B{QHZ?BHrx`x+H@4Ys(H{ z6@3I0!%xGA{){?A3oxQnc+xA@2}8kGIhZt1{Y)8AHSnP_FnpJXq#I1pezj#FCXs;A zxlv3x6Ov2Ra=RFhnUj)PRYupv1{2N}2?jIMWA0V<8%O+M7!Ood{}5HnxR7?sbHDNN zZ;;}DkI6^NweVKFvsjVB?Ktjky$VeficB%0A5g2>GmO5?lQxf5rzm1XuM}&aUaB9{ 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%0D`EY1S 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%0DS=- zfXM(eAOVmC*a#>G90yzg+ylIH2Xz6c0fPZw0DJ&uz+6BoU=^SMuoJK!@FSoZ@F$@C z-FDR0z!xwZkOWu>*aFxGXarmb{0(^JPviyY18@h72lxP{ z0pPd#Ac4e0z9T^-n1ql} zVkTi^8VM&6B$7mt>0}0(NoJARq#ETCmYB{Qb0D5LQ+IF zlP#o}Y$YXR8`(~FkW#Xfl#y~$L3WYdWDlt%Rb(%zCN*RqsU`bK9XUV_l6rE8941G| zQF4qNCnv~Ba*CWLXUJL7KpM%9 z?O_fzvN%Ejm$j$C_n(5tVFF@--8Q+g#t`##BaJ=G!vb-vF~S(hhKx4*8NI&@4LAC; zuj2-qB44OX+dx@eq)%Ml-UECiP16mLMsL1w-UIynygiKmhN$33?@?yIs9<9Ra$lOHI+hMU>SdYGp3k!eZ1`Q~IZVv`sTHl*n6*CD~P!U8Sd#s!<%+Ogk9 zntZ|y;cWHT_fcqM*{eWznu+(IK%;Na`0ywr&A|(W3XNn7#C{xSjQlb*j14sU4K;;E znnD9;zMjEmb2wjK^a<~Q9-c_Z5Du2{X8Fil2=xj#hk@{HS!ftbK2LLah=DDx7&Oul z8W05rmqn)udJhZrGqN;gF%d#r(<0E*6dr+e@rjmjA!FWV@z9A4wRJX2DPn-z+v8lLjz1; zaDks`Dickio}cN4ETQa^R4T5XGG?L8H_}Y8sBmC0WkD<_dzrzd9Ie`Z5(@j` zS992`e~AY%5@{SfGcw%JHaFU_+J^CxfF%iEPOord7)(!XF$L-BEyo>eoM8%;sztlB zw_FghxNPVcpJ3CpC@EDga7HLEtHj*Uew>u!T8R>S&_FZSpV+((&fr2b#l$ zmSC~Qn_oy6jT{=`kA6(^8fu83Y{_Lp8HpwFuuxN^h3w+Rk~gHvNMApQY`(_`;nL9R zJ<^0e&9^c8>}d*x&}0WQ?jr(NQn6o$g+}nwoqI*Xym)2bxj~MWlzsh@l@7FlM6toX zu;pj5=qF2V=SEp?dDj_bh{VVv2vfX;n`WXT2;&SNz>0^kU{(O)8FHTHz&&}7HhYgn z4`VBWAYP(^jl=z;l-H?qT#bhro`@GLsm{cM|zKNQCA=YsyoTv$=o_ZbiGA{EQMi%0A)o zU%z<|uZdNUdL!@DhzduG-wqwaZaY9oV3&bx`h)RpVaXznAaRF5Jb1c>N z-J&{UjSw*CgtE~`2ol(dWnG?U#~Fi-zT60h5t^pVhsfgdAwqPB0k;2%T}TKJ6NrRb z=o1y-JrvqCmn1tx4-Cct2GIs71*s6pNgEm&!?%Yq!W0ntPanNZGmXJ)UMyuOzPvZn zcZ*h`0Z<0K|1~%I@n5o|11dXEf~4FiJWwJ!t<8YdqU-AGW5q>zzjPLZ<=89A7xGOIjO#^ZR-GHhI+nbV`C zsBDl$T)wODC{&=x5}~g{W}7%B;qszEBPUO6gCxl{J|QnoSLWZwLSK-@psxd1T}Af2 zP0cBer^y)X$FTsHISp(>4e8;mYp%@h9(>6#@TLhHBp??36*5H|8 zQY*8mb0Lx>7UF|TxIk7@6v)a(p^Qh>M~lFb7)&e+De(#$%Ztt;c!?;lwxk>hS)+qe zgz*NJxzKkpn?atE&ME~7%B`S<4w)nlfwCa^AUFZi%p49ZbBMQ>IhdOi@PQ+Zp#dE2 z`2ZGyS5Ek#v1SY)>{!SLSjZMW>`Q1!WIQ*fqxm8+N1(4`qe3z85&uYUUvqdUn%orO z?T>Lm7GjnSQNZ(K#iWTQhqnN#v_(+u(GVPL_VxB*=fIX!xqH&wq(u%w{4+_VXwr*rddw5KsV+#F70NI?SC zq>%8aP#F6DxBkY%A}IXzSF|UO@E$A+n}o1VR_$R&lkm``lmH!|KVT$a5@0GI5D*5K35W)y0I~sjfD%9@;1J*x;5^_u z;68w$tQ`QIX_*1S-~Z`l{FInNX%{l0zR6Be~Mtgk#SH%WuV7ZVY> zx<7!xLP_Tx+{<~3Re!885pQqU38C_0tVTX&;tewpotI$!lu*_SHB)*;TY-%uzYD>V z6nTp=_)tmvAp@U*U_$yZ{=Td_fNx61-#<7iB9O+>G5%&cin=lAX&4XO=`SiXh=Ep! z0c0@aA8CY*avFpD1Gu!qnGmk$A^vm*z1KGoD_B?`W1lfE#NRCXOf7(To=u-oG8!Jo zOpBo9N@RroN=POX5f+ZwHI~`PGKO|sh$Q?iXP?>XkhSzV)R%o($33$d<v07^Zvx7}OD%RSHwPk!0V8r0DqX&=FsQFK%7ry;}2_X^FeZwP#+}VQv>px@o z^?!60{D(DdH2JIe#nOCqC;TSj7e7S8vjUG{o%0{UU$Vv;FGa?m9REHdfPbRfhEx1Q zG!TDse42jlzu=$4x9gqSlLFcl{9k$(N_*)q5AQDjk={`!Vh89Cu;OJ|H1huEzi2M! z=xDaU^j|!ZnwlC?bH0YO9@#(|TA!0`m!6Zvz&{B53g8z4zYzEtz@H6#_y9O_|Jj= z9Qe{lUMqD9`CX|MNc%3yA;t$0aO&VsjAR@X+Qv&DG+M z`z}TM=kKy;Z4mhM#ZW0FE*l|#AaFP$W}EL~L>_^Ee<40gHyW2ujwP)4%6^b%B*f>? z<(XT?M|Sj&#^?VmzYC$_FOMvyFMbdn{ulAvmS2b_{=N`jUN~UkmHsc(Umyq#5~Kd( zcRpt>qkoA1uiwRl#WITN(;T^6#gbX1Z~0wFh~jePxBMucOl<@IT!n=e14hBF+haZR)d^^nW#R!9+ zMkstQM&maGvFYCsghauogQly&7;gu!kU-=V32Z0$j`Txr6k~>n(HG;p86n~D_@MqC zW;_MpsW0%1hzAEY{I#|Zwzh%?iHXGuMI0`_@krf>Ts#rWi2uf;JYj4I&6}nciZtvH zLhDIOMX^nYZ-~Ruta=pmp@e+YG$XlG0f6y7WZ|rM?}TH}!l8$8#j!>_A%sykBS> znkrZJFnl+|E5?Yj(L88rsMicFix7|II~}3aQ-(|BJ2rJ%I$BOzB0JX0W;$X8>Wzt^zfT@XztZ8!e#;<)QJpoI>GG zByan+G>HHY*r7#*I#V8_EkfIlQo_L2>oe4aQu;GKcdoX+Ed9;ErTKjZ4BGM(hpRP> z&rymiw`FV49B9oVP;%NwXp7U9roWUe^uzfhWT^`;ya$(NJTCxm^LxQUjA zQZ^DmpJ{$G*b>pyI7(4|{Wrd*e9UpD)Q%h#DA!o>22GpxDIwes=~JHJsM`nOl){u2 zFZLnJ{zkci_NXYf^t6t&6appv@y>DIRHQT>eYG$Codo!V=O@~Zv|WV$NBJRyjYa!} zz_mhpw9F>H&r+(|!KZ8-e9GE#32j}W$IvAh<}(wOGN(UWqbfu%6l`T`em za)(MFN-vIMF}alQ`tqi zoa2(dDA@qyPH928lYXN#rzIAoie;Nvay4x|u8n9)wADFT(iV#gjX)V_Z8^^8BoS91 zp}Ydu3av^@9*Wi$!>)~dr=^th=l@O`R047` zjiaF*#-xAdVPur%*jSer43$%t*zI`g@DD}bsmI9ny zpgmupA&o=F2g<)RUv89>$nk{a+5Gl2>qsQ z`jo$-__V217o=I+US$-yl#Y>7&l32HmX793`IwWVbadc2$_rYAC%*f!UpSg_*p%}* z-lF+Zc|k|Awp{w}(u1RgrJSFH6egk`RPIvwZ3kI03%StJgs|hxFgyzs`)6u#eL$cw z9c|70ct*!{N+-)Q(mM1)9#k)p`X1E%~hEmQ52B*={J%kOP$cEGOLqK1OjSU(2`;L5Mk?(kXp}m6QQ5g&?4U5-S4=!d? zZ9Bqpp)c02m`%e2-r82s^DW0gfvS{Blw-&Xt?!7k`=KT<)ua9|Aq_92VMZ7?^2_!0 zwk4t&JFz@q8K-R<{u>|khc~$udK&$Y{#ok&Gtf_Fpmc3(+!v+eDD1(;n!wUhsOd1Y z7agDJUw3v!!%>~;O`Keo`12*}D|E{9|Nj1G6o7%B&gBLvM=7T%QEiVZ^*ZM=w>@sZ(#dQXm&QHiU&<-!KDr$JdOeB8-a&ji zpsY~AsUMt2$U^lT%{fgw`xf0%{TV$1a73 zopY;mflDXXcij%Sxw^wKpG~g|&F=!0tuW6khiaB+E@*=6E9@Qg&iY~c(faZF$@-~! ze|@mt)oGB^P^ZyOfli@LkxsLn<~jK}FLKUyE^yxET<5&RMeiC&>Cwui`$YAI8Vjq~ zFF{C8l~U!T`bu>UTPZ$Jf1>tPhp1<$6V%t$ch!vMb&Z>5w8mdEM-#8f(yXCk($0#l z$8ywri~g+sioTE21gHH@PhD(XJGtuJ#<&^XzIR*fw$ZK1jVP^HT70dXttwJktLxOO z?JsC2VPl3B+b;ceYxKRG&bVTck9~jS^p@*0w|?#<-HNUQkuvQ${T=;(oZfNz$mw$@ z2PY4wsZMFGPhFkdJl)2+HMo;pE?%N~nd=7ESKLU672Cem&KI3?T>83Bqx7q>LSMzo znR1?edj~JaFZGA@vz!(?zvSZP66t!<)zj^q8#!e~*^0cWo~Bu>Db;LsIN*3gTj12w z+0nVD3qD-n^6^xM+rOhnzO7un9My|7D>R!l6`FgRS15nM!qEx;#^@4sZ_zgI#IWhk z)BNJ-d$maor4pp z;l5$O#pXS(YzORZ_1*Q?^dU|NyTGt?o~YWP>1=Or-_voP<4x@dr#UY1F8f?gx%j$$ z0=hA5U&~iksy@_2+goYZX{YLb*WK0G=({*Sbk1;5yRLUtxS8Azy7hEljv6aqwSg^1 zImO=Ap^t;T!(<18!)J~jjw2kS9OpQGrOVN6)Ok3UI5#-!TykAJUB|iha_jA$O=;Ch z!P36FGFEv`SqkpHuX&;wVLwoJ*>xYKubqPB&HviBb9l$$QwN>XAFk0X-4$$q%TY~M z?^6GUSfAM&?5El9v%hbD!J((4kK^}_PaHk82X(KZ-(~5q>tA>J1by!tr^QaG=xtA3 z54$~f>+Al2Z7&5CFT?{Lc|dwHds)#XiO%-l5DP!ZF$Lgkv}D6zxx1d);@s6}oLYqkggesNT+LveQ%`W-qP5s>Fx@~jQy9c}1(ln zx?cLhdV_v0q}s3gaOXJZb}sL_EOy!G@~Nx4>w0$*#?fz*vX8xoeX)HPhZu*O4&xkm zIgZeNt39E;sLjy*s2i^L(;v_`==(cuc6uMZwYy88ONmQ+*O{&bu5;W@x?OU6PTL|{ z!SYlmO}%EV!)R@?_NMk#z0PTj^J?czmlH0_DNc!k?I(}yKXdubWu@yew?6Kqh6`J+ zUaPKD`|C?66P@D1oE&Crm+P+SZs;HA$pr<=<8vL>ICP}STr2nfs>@uLv2N2KzpUBs zO8v`D0Z!3QB+Q!aSD!nno%BxQKt}^4uGwk2Q!-jV+i8u{2B$5wFGO?kZlh%%X|r@B zoqONtzRi7)`vJ%;Yqrc(@_L}}ySKS_v6Gfu;NtXF zPgMV|ZdP}qvbYs{;_)*{y+Hkn<}HnjCR$&l*EqR4`JoipTa0h^sxKkyZCGCaUFm5* zR=-YvO8;Mdyz>=zVrRq3@>i8_DIL_~)nBX6YJwb&JACapMVGAmP(Rmcx6@sxfv*2` z?F3qIxN}suRe!3QG${_}9WOiHaXg|wt^Zx`;5@>4tn+2pJFY8OzPDlN{6u3AO*z@tI=>?Ivxt_Mmo=(-Nn3PQ=TGEq`Z6JI5C72l`%mH@(LFYjiB0*4PAyE}gFxYn`2@pG+OtJluf#%L3@8?^7~ zy6HYepP8ncsavY6*PnCw-DN!T`3^iW)9r~Hp=n#~t_T4(P}QF8r!G#v#LPxm%WdrTc!0-)h71wnFu)s*7rjYBI*hwd#%P zE$SU=EA213Mb0U}vSs;Xn6jfPSev2ks2iapcD8I={$iiuQ0;KQ;i$t7-744qXdhcv z-eoJ#s17;*?3(U&%NpneH2Ce*JB!3PRphuR#vuHFGsn?W61$+wXK}aJ=St z%ki<}b4Q(alGa=Moi6}HL5V}||8>9Me%<{qcj9GBRV$2p?Uk=7yC{1rRm#aqqcTkSy)s_8 zSec{DQx+@tDK9A>DF0U4sMM-~sTXzq9jG3w z_5nxCS7)f#skf_Z)o0X~c&)}BW2Y_42k7I-v4gUc@=axD<@-uIO?OQ%O>d1-W3SPn zNA=fuXohM=YP>Y#HIp<`G*dN!nlQ~wO|&Lflc-67PL{37(d26KG@CUgni>rWvn5_w z=n&IWc31X7ZInuTrB3Oh?633ye~eUmDaR`(DW@o{Rqa(BRGn0BLf6ezX7P~>XfPh`q_Ea1=SVRbybV1RnBub)Y&}9j1;{ z&s5J*N2_DiiRu(}wmL_htIksws5h%CAO~yIhtxyuC)rQ2pK2dwA89|+ehzewMEex` zZ2KJh3-(v+uiLlSw_==oWd9VpQfG(v9qb&2YDa3lwBx}UQ?ygHe%e57F!&={cZJxG3yIEVJE!9?NE44M+I_)9tG3_aBgZ7;Ey!L|jiuSs; zMcb;quYII_iVeHgy7sybx=y+`b)9wZ>+E#hb-i@Gp>NphbUGJZf1L;TaHP&lH(obM zH$^v9=cfzQ1?$3ek?5IobkVw4U7{{Um#$l)%Z4tHtIN|B=r-$0bfvlqU8Sx@SEoCq zJEl9OYtWt3o!4E^UC~|Fwdh)P_jQkSPqAItTHjvZLElOLroOZOeZ3vDnO^$ddZpf8 zuhYBe`|CaQL-ix|UeL5B>8C)~_R|Mq)DQa~-JBtG>PQrZ*>gBu1OkCTR3H$Dib

r&XcBGALU%*XsJ zz=CHMBP_}u7(otfF$Msb&SJ-4P%w{dtX0NQny13#V>$Ac6 zx+iSPW?!y;$M&Z?@Nh5paX%06AP@0-^r#4r@&}Hv&f{G1Bywn)XLy$9c%DD;0x$9s zFY^ko@@J&eI&bhMf8jQ7@iu?u9o|K!>G3`v@F5@ZF`w`$pK*uJ`GPO`im&;GZ~2bz z`GFttLc7=S8Ga*R1dWh!Z-kAA5j7qRVo+4!d;NW`yrHo&y&@_yqJsW96id7e9|3V? zY0H6J$fFFa6q449>Z`drsC(-lQ|R$@?mSUE$9E2kAhAipT11OtRwo+Ol3E6C^60La z!g@rHg2<$v($kjB@n@}sA!ABvF} zi-~YV6xEuQIa!j=vL+j{DPM4k4$f_%mTIH6YJ)x(cno6Rilcs0kLkzEV-_>$ooDIt zj*d~l-PB_?x`W#p9NfhYH5fqM5!74u0@aur2}JSrA=8o!KC_ zf2y(-+u=h80gy;QUlznwK$#7)`k=`HK|9=g0HhEj32PT%>N@P)fsx0s@CxSjz_wu+ zHVLa1;vWWc?UlrQod!EukrR3Ggju_YbXx{XRq-rp$iEHI6feRCTW#?wI-)Dykl*`a z0M_2mZ7OCsySZ3^y_Hytjo6Bv*o%^^%DU{xE;bT9%xeQVlp{IDZel8D(!u<;kW0Ce zYq^nI>_YbP09rlDt9;6@0xF^&6j5=dz;8xnRbD-*qAIJ3dR8^n0MWK;t5?-kJ+M7g zBQ;SoOr7qtTH{&mK>HD&h45NF%a1)p&QKbmesaituE$} zp4GS3$R^vwF0oG>5=YDxcOK>b6T@w0_(_j1kRq9qIp)wM*`ee6(eFdrJ+gmB%W8S; zNsFLb2n??DQ0)G@bum3xf?EgMSQO6wX6q*0`9^!7Xh4S`X@VWt3_Q6#JbE!^30C~( z!zqmIy87LAuIv8Jbl=?eZZ_9zpPlw@G}mW~E0eh%b1fFQ7_0;$`{#TxMK<`A&V4Wg zu-k)(e}~aqDnFR~Ao7Dpm&SuQiV)0r+m&Ugttbkctwy;He{RMKJ#5}P` zERkw&*m3SWHFqQYFW4!OGIDU0Jj1$m>@%9!mD;35+DOG6OK5MJG<`%ir$garH1D~L`{{J-~%%%y7-evoc$z4a;K_VvLz z%LUG^IbD27 xa7XkP?{7<0w}$!sIVx@_bjp;G{$ETvA3Cg50~rZ~vK}zW^q-^nCyT literal 0 HcmV?d00001 diff --git a/glew32.dll b/glew32.dll new file mode 100644 index 0000000000000000000000000000000000000000..c7e3cc2218af608e181c57538be45b3b87b8b88d GIT binary patch literal 568892 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 literal 0 HcmV?d00001 diff --git a/include/common.hpp b/include/common.hpp index 71039c7..1178540 100644 --- a/include/common.hpp +++ b/include/common.hpp @@ -45,6 +45,7 @@ // windows stuff #ifdef __WIN32__ +using uint = unsigned int; #undef near #endif diff --git a/include/mingw.condition_variable.h b/include/mingw.condition_variable.h new file mode 100644 index 0000000..b664758 --- /dev/null +++ b/include/mingw.condition_variable.h @@ -0,0 +1,211 @@ +/** +* @file condition_variable.h +* @brief std::condition_variable implementation for MinGW +* +* (c) 2013-2016 by Mega Limited, Auckland, New Zealand +* @author Alexander Vassilev +* +* @copyright Simplified (2-clause) BSD License. +* You should have received a copy of the license along with this +* program. +* +* This code 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. +* @note +* This file may become part of the mingw-w64 runtime package. If/when this happens, +* the appropriate license will be added, i.e. this code will become dual-licensed, +* and the current BSD 2-clause license will stay. +*/ + +#ifndef MINGW_CONDITIONAL_VARIABLE_H +#define MINGW_CONDITIONAL_VARIABLE_H +#include +#include +#include "mingw.mutex.h" +#include +#include +#include +#ifdef _GLIBCXX_HAS_GTHREADS +#error This version of MinGW seems to include a win32 port of pthreads, and probably \ + already has C++11 std threading classes implemented, based on pthreads. \ + It is likely that you will get errors about redefined classes, and unfortunately \ + this implementation can not be used standalone and independent of the system \ + header, since it relies on it for \ + std::unique_lock and other utility classes. If you would still like to use this \ + implementation (as it is more lightweight), you have to edit the \ + c++-config.h system header of your MinGW to not define _GLIBCXX_HAS_GTHREADS. \ + This will prevent system headers from defining actual threading classes while still \ + defining the necessary utility classes. +#endif + +namespace std +{ + +enum class cv_status { no_timeout, timeout }; +class condition_variable_any +{ +protected: + recursive_mutex mMutex; + atomic mNumWaiters; + HANDLE mSemaphore; + HANDLE mWakeEvent; +public: + typedef HANDLE native_handle_type; + native_handle_type native_handle() {return mSemaphore;} + condition_variable_any(const condition_variable_any&) = delete; + condition_variable_any& operator=(const condition_variable_any&) = delete; + condition_variable_any() + :mNumWaiters(0), mSemaphore(CreateSemaphore(NULL, 0, 0xFFFF, NULL)), + mWakeEvent(CreateEvent(NULL, FALSE, FALSE, NULL)) + {} + ~condition_variable_any() { CloseHandle(mWakeEvent); CloseHandle(mSemaphore); } +protected: + template + bool wait_impl(M& lock, DWORD timeout) + { + { + lock_guard guard(mMutex); + mNumWaiters++; + } + lock.unlock(); + DWORD ret = WaitForSingleObject(mSemaphore, timeout); + + mNumWaiters--; + SetEvent(mWakeEvent); + lock.lock(); + if (ret == WAIT_OBJECT_0) + return true; + else if (ret == WAIT_TIMEOUT) + return false; +//2 possible cases: +//1)The point in notify_all() where we determine the count to +//increment the semaphore with has not been reached yet: +//we just need to decrement mNumWaiters, but setting the event does not hurt +// +//2)Semaphore has just been released with mNumWaiters just before +//we decremented it. This means that the semaphore count +//after all waiters finish won't be 0 - because not all waiters +//woke up by acquiring the semaphore - we woke up by a timeout. +//The notify_all() must handle this grafecully +// + else + throw system_error(EPROTO, generic_category()); + } +public: + template + void wait(M& lock) + { + wait_impl(lock, INFINITE); + } + template + void wait(M& lock, Predicate pred) + { + while(!pred()) + { + wait(lock); + }; + } + + void notify_all() noexcept + { + lock_guard lock(mMutex); //block any further wait requests until all current waiters are unblocked + if (mNumWaiters.load() <= 0) + return; + + ReleaseSemaphore(mSemaphore, mNumWaiters, NULL); + while(mNumWaiters > 0) + { + auto ret = WaitForSingleObject(mWakeEvent, 1000); + if ((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED)) + throw system_error(EPROTO, generic_category()); + } + assert(mNumWaiters == 0); +//in case some of the waiters timed out just after we released the +//semaphore by mNumWaiters, it won't be zero now, because not all waiters +//woke up by acquiring the semaphore. So we must zero the semaphore before +//we accept waiters for the next event +//See _wait_impl for details + while(WaitForSingleObject(mSemaphore, 0) == WAIT_OBJECT_0); + } + void notify_one() noexcept + { + lock_guard lock(mMutex); + if (!mNumWaiters) + return; + int targetWaiters = mNumWaiters.load() - 1; + ReleaseSemaphore(mSemaphore, 1, NULL); + while(mNumWaiters > targetWaiters) + { + auto ret = WaitForSingleObject(mWakeEvent, 1000); + if ((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED)) + throw system_error(EPROTO, generic_category()); + } + assert(mNumWaiters == targetWaiters); + } + template + std::cv_status wait_for(M& lock, + const std::chrono::duration& rel_time) + { + long long timeout = chrono::duration_cast(rel_time).count(); + if (timeout < 0) + timeout = 0; + bool ret = wait_impl(lock, (DWORD)timeout); + return ret?cv_status::no_timeout:cv_status::timeout; + } + + template + bool wait_for(M& lock, + const std::chrono::duration& rel_time, Predicate pred) + { + wait_for(lock, rel_time); + return pred(); + } + template + cv_status wait_until (M& lock, + const chrono::time_point& abs_time) + { + return wait_for(lock, abs_time - Clock::now()); + } + template + bool wait_until (M& lock, + const std::chrono::time_point& abs_time, + Predicate pred) + { + auto time = abs_time - Clock::now(); + if (time < 0) + return pred(); + else + return wait_for(lock, time, pred); + } +}; +class condition_variable: protected condition_variable_any +{ +protected: + typedef condition_variable_any base; +public: + using base::native_handle_type; + using base::native_handle; + using base::base; + using base::notify_all; + using base::notify_one; + void wait(unique_lock &lock) + { base::wait(lock); } + template + void wait(unique_lock& lock, Predicate pred) + { base::wait(lock, pred); } + template + std::cv_status wait_for(unique_lock& lock, const std::chrono::duration& rel_time) + { return base::wait_for(lock, rel_time); } + template + bool wait_for(unique_lock& lock, const std::chrono::duration& rel_time, Predicate pred) + { return base::wait_for(lock, rel_time, pred); } + template + cv_status wait_until (unique_lock& lock, const chrono::time_point& abs_time) + { return base::wait_for(lock, abs_time); } + template + bool wait_until (unique_lock& lock, const std::chrono::time_point& abs_time, Predicate pred) + { return base::wait_until(lock, abs_time, pred); } +}; +} +#endif // MINGW_CONDITIONAL_VARIABLE_H diff --git a/include/mingw.mutex.h b/include/mingw.mutex.h new file mode 100644 index 0000000..d453202 --- /dev/null +++ b/include/mingw.mutex.h @@ -0,0 +1,275 @@ +/** +* @file mingw.mutex.h +* @brief std::mutex et al implementation for MinGW +** (c) 2013-2016 by Mega Limited, Auckland, New Zealand +* @author Alexander Vassilev +* +* @copyright Simplified (2-clause) BSD License. +* You should have received a copy of the license along with this +* program. +* +* This code 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. +* @note +* This file may become part of the mingw-w64 runtime package. If/when this happens, +* the appropriate license will be added, i.e. this code will become dual-licensed, +* and the current BSD 2-clause license will stay. +*/ + +#ifndef WIN32STDMUTEX_H +#define WIN32STDMUTEX_H +#ifdef _GLIBCXX_HAS_GTHREADS +#error This version of MinGW seems to include a win32 port of pthreads, and probably \ + already has C++11 std threading classes implemented, based on pthreads. \ + You are likely to have class redefinition errors below, and unfirtunately this \ + implementation can not be used standalone \ + and independent of the system header, since it relies on it for \ + std::unique_lock and other utility classes. If you would still like to use this \ + implementation (as it is more lightweight), you have to edit the \ + c++-config.h system header of your MinGW to not define _GLIBCXX_HAS_GTHREADS. \ + This will prevent system headers from defining actual threading classes while still \ + defining the necessary utility classes. +#endif +// Recursion checks on non-recursive locks have some performance penalty, so the user +// may want to disable the checks in release builds. In that case, make sure they +// are always enabled in debug builds. + +#if defined(STDMUTEX_NO_RECURSION_CHECKS) && !defined(NDEBUG) + #undef STDMUTEX_NO_RECURSION_CHECKS +#endif + +#include +#include +#include + +#ifndef EPROTO + #define EPROTO 134 +#endif +#ifndef EOWNERDEAD + #define EOWNERDEAD 133 +#endif + +namespace std +{ +class recursive_mutex +{ +protected: + CRITICAL_SECTION mHandle; +public: + typedef LPCRITICAL_SECTION native_handle_type; + native_handle_type native_handle() {return &mHandle;} + recursive_mutex() noexcept + { + InitializeCriticalSection(&mHandle); + } + recursive_mutex (const recursive_mutex&) = delete; + recursive_mutex& operator=(const recursive_mutex&) = delete; + ~recursive_mutex() noexcept + { + DeleteCriticalSection(&mHandle); + } + void lock() + { + EnterCriticalSection(&mHandle); + } + void unlock() + { + LeaveCriticalSection(&mHandle); + } + bool try_lock() + { + return (TryEnterCriticalSection(&mHandle)!=0); + } +}; +template +class _NonRecursive: protected B +{ +protected: + typedef B base; + DWORD mOwnerThread; +public: + using base::native_handle_type; + using base::native_handle; + _NonRecursive() noexcept :base(), mOwnerThread(0) {} + _NonRecursive (const _NonRecursive&) = delete; + _NonRecursive& operator= (const _NonRecursive&) = delete; + void lock() + { + base::lock(); + checkSetOwnerAfterLock(); + } +protected: + void checkSetOwnerAfterLock() + { + DWORD self = GetCurrentThreadId(); + if (mOwnerThread == self) + { + fprintf(stderr, "FATAL: Recursive locking or non-recursive mutex detected. Throwing sysetm exception\n"); + fflush(stderr); + throw system_error(EDEADLK, generic_category()); + } + mOwnerThread = self; + } + void checkSetOwnerBeforeUnlock() + { + DWORD self = GetCurrentThreadId(); + if (mOwnerThread != self) + { + fprintf(stderr, "FATAL: Recursive unlocking of non-recursive mutex detected. Throwing system exception\n"); + fflush(stderr); + throw system_error(EDEADLK, generic_category()); + } + mOwnerThread = 0; + } +public: + void unlock() + { + checkSetOwnerBeforeUnlock(); + base::unlock(); + } + bool try_lock() + { + bool ret = base::try_lock(); + if (ret) + checkSetOwnerAfterLock(); + return ret; + } +}; + +#ifndef STDMUTEX_NO_RECURSION_CHECKS + typedef _NonRecursive mutex; +#else + typedef recursive_mutex mutex; +#endif + +class recursive_timed_mutex +{ +protected: + HANDLE mHandle; +public: + typedef HANDLE native_handle_type; + native_handle_type native_handle() const {return mHandle;} + recursive_timed_mutex(const recursive_timed_mutex&) = delete; + recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; + recursive_timed_mutex(): mHandle(CreateMutex(NULL, FALSE, NULL)){} + ~recursive_timed_mutex() + { + CloseHandle(mHandle); + } + void lock() + { + DWORD ret = WaitForSingleObject(mHandle, INFINITE); + if (ret != WAIT_OBJECT_0) + { + if (ret == WAIT_ABANDONED) + throw system_error(EOWNERDEAD, generic_category()); + else + throw system_error(EPROTO, generic_category()); + } + } + void unlock() + { + if (!ReleaseMutex(mHandle)) + throw system_error(EDEADLK, generic_category()); + } + bool try_lock() + { + DWORD ret = WaitForSingleObject(mHandle, 0); + if (ret == WAIT_TIMEOUT) + return false; + else if (ret == WAIT_OBJECT_0) + return true; + else if (ret == WAIT_ABANDONED) + throw system_error(EOWNERDEAD, generic_category()); + else + throw system_error(EPROTO, generic_category()); + } + template + bool try_lock_for(const std::chrono::duration& dur) + { + DWORD timeout = (DWORD)chrono::duration_cast(dur).count(); + + DWORD ret = WaitForSingleObject(mHandle, timeout); + if (ret == WAIT_TIMEOUT) + return false; + else if (ret == WAIT_OBJECT_0) + return true; + else if (ret == WAIT_ABANDONED) + throw system_error(EOWNERDEAD, generic_category()); + else + throw system_error(EPROTO, generic_category()); + } + template + bool try_lock_until(const std::chrono::time_point& timeout_time) + { + return try_lock_for(timeout_time - Clock::now()); + } +}; + +class timed_mutex: public _NonRecursive +{ +protected: + typedef _NonRecursive base; +public: + using base::base; + timed_mutex(const timed_mutex&) = delete; + timed_mutex& operator=(const timed_mutex&) = delete; + template + void try_lock_for(const std::chrono::duration& dur) + { + bool ret = base::try_lock_for(dur); +#ifndef STDMUTEX_NO_RECURSION_CHECKS + if (ret) + checkSetOwnerAfterLock(); +#endif + return ret; + } +public: + template + bool try_lock_until(const std::chrono::time_point& timeout_time) + { + bool ret = base::try_lock_until(timeout_time); +#ifndef STDMUTEX_NO_RECURSION_CHECKS + if (ret) + checkSetOwnerAfterLock(); +#endif + return ret; + } +}; +// You can use the scoped locks and other helpers that are still provided by +// In that case, you must include before including this file, so that this +// file will not try to redefine them +#ifndef _GLIBCXX_MUTEX + +/// Do not acquire ownership of the mutex. +struct defer_lock_t { }; + + /// Try to acquire ownership of the mutex without blocking. +struct try_to_lock_t { }; + + /// Assume the calling thread has already obtained mutex ownership + /// and manage it. +struct adopt_lock_t { }; + +constexpr defer_lock_t defer_lock { }; +constexpr try_to_lock_t try_to_lock { }; +constexpr adopt_lock_t adopt_lock { }; + +template +class lock_guard +{ +protected: + M& mMutex; +public: + typedef M mutex_type; + lock_guard(const lock_guard&) = delete; + lock_guard& operator=(const lock_guard&) = delete; + explicit lock_guard(mutex_type& m): mMutex(m) { mMutex.lock(); } + lock_guard(mutex_type& m, std::adopt_lock_t):mMutex(m){} + ~lock_guard() { mMutex.unlock(); } +}; + +#endif +} +#endif // WIN32STDMUTEX_H diff --git a/include/mingw.thread.h b/include/mingw.thread.h new file mode 100644 index 0000000..6c1a997 --- /dev/null +++ b/include/mingw.thread.h @@ -0,0 +1,167 @@ +/** +* @file mingw.thread.h +* @brief std::thread implementation for MinGW +* (c) 2013-2016 by Mega Limited, Auckland, New Zealand +* @author Alexander Vassilev +* +* @copyright Simplified (2-clause) BSD License. +* You should have received a copy of the license along with this +* program. +* +* This code 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. +* @note +* This file may become part of the mingw-w64 runtime package. If/when this happens, +* the appropriate license will be added, i.e. this code will become dual-licensed, +* and the current BSD 2-clause license will stay. +*/ + +#ifndef WIN32STDTHREAD_H +#define WIN32STDTHREAD_H + +#include +#include +#include +#include +#include +#include + +#ifdef _GLIBCXX_HAS_GTHREADS +#error This version of MinGW seems to include a win32 port of pthreads, and probably \ + already has C++11 std threading classes implemented, based on pthreads. \ + It is likely that you will get class redefinition errors below, and unfortunately \ + this implementation can not be used standalone \ + and independent of the system header, since it relies on it for \ + std::unique_lock and other utility classes. If you would still like to use this \ + implementation (as it is more lightweight), you have to edit the \ + c++-config.h system header of your MinGW to not define _GLIBCXX_HAS_GTHREADS. \ + This will prevent system headers from defining actual threading classes while still \ + defining the necessary utility classes. +#endif + +//instead of INVALID_HANDLE_VALUE _beginthreadex returns 0 +#define _STD_THREAD_INVALID_HANDLE 0 +namespace std +{ + +class thread +{ +public: + class id + { + DWORD mId; + void clear() {mId = 0;} + friend class thread; + public: + id(DWORD aId=0):mId(aId){} + bool operator==(const id& other) const {return mId == other.mId;} + }; +protected: + HANDLE mHandle; + id mThreadId; +public: + typedef HANDLE native_handle_type; + id get_id() const noexcept {return mThreadId;} + native_handle_type native_handle() const {return mHandle;} + thread(): mHandle(_STD_THREAD_INVALID_HANDLE){} + + thread(thread&& other) + :mHandle(other.mHandle), mThreadId(other.mThreadId) + { + other.mHandle = _STD_THREAD_INVALID_HANDLE; + other.mThreadId.clear(); + } + + thread(const thread &other)=delete; + + template + explicit thread(Function&& f, Args&&... args) + { + typedef decltype(std::bind(f, args...)) Call; + Call* call = new Call(std::bind(f, args...)); + mHandle = (HANDLE)_beginthreadex(NULL, 0, threadfunc, + (LPVOID)call, 0, (unsigned*)&(mThreadId.mId)); + } + template + static unsigned int __stdcall threadfunc(void* arg) + { + std::unique_ptr upCall(static_cast(arg)); + (*upCall)(); + return (unsigned long)0; + } + bool joinable() const {return mHandle != _STD_THREAD_INVALID_HANDLE;} + void join() + { + if (get_id() == GetCurrentThreadId()) + throw system_error(EDEADLK, generic_category()); + if (mHandle == _STD_THREAD_INVALID_HANDLE) + throw system_error(ESRCH, generic_category()); + if (!joinable()) + throw system_error(EINVAL, generic_category()); + WaitForSingleObject(mHandle, INFINITE); + CloseHandle(mHandle); + mHandle = _STD_THREAD_INVALID_HANDLE; + mThreadId.clear(); + } + + ~thread() + { + if (joinable()) + std::terminate(); + } + thread& operator=(const thread&) = delete; + thread& operator=(thread&& other) noexcept + { + if (joinable()) + std::terminate(); + swap(std::forward(other)); + return *this; + } + void swap(thread&& other) noexcept + { + std::swap(mHandle, other.mHandle); + std::swap(mThreadId.mId, other.mThreadId.mId); + } + static unsigned int hardware_concurrency() noexcept + { + static int ncpus = -1; + if (ncpus == -1) + { + SYSTEM_INFO sysinfo; + GetSystemInfo(&sysinfo); + ncpus = sysinfo.dwNumberOfProcessors; + } + return ncpus; + } + void detach() + { + if (!joinable()) + throw system_error(); + if (mHandle != _STD_THREAD_INVALID_HANDLE) + { + CloseHandle(mHandle); + mHandle = _STD_THREAD_INVALID_HANDLE; + } + mThreadId.clear(); + } +}; + +namespace this_thread +{ + inline thread::id get_id() {return thread::id(GetCurrentThreadId());} + inline void yield() {Sleep(0);} + template< class Rep, class Period > + void sleep_for( const std::chrono::duration& sleep_duration) + { + Sleep(chrono::duration_cast(sleep_duration).count()); + } + template + void sleep_until(const std::chrono::time_point& sleep_time) + { + sleep_for(sleep_time-Clock::now()); + } +} + +} +#endif // WIN32STDTHREAD_H diff --git a/src/world.cpp b/src/world.cpp index a82fc8b..7ca3cce 100644 --- a/src/world.cpp +++ b/src/world.cpp @@ -9,7 +9,6 @@ #include #include #include -#include #include using namespace std::literals::chrono_literals; @@ -57,9 +56,6 @@ extern std::string xmlFolder; // wait static bool waitToSwap = false; -// particle mutex -std::mutex partMutex; - // externally referenced in main.cpp int worldShade = 0; -- 2.39.5