├── doc ├── doxygen │ ├── api_footer.html │ ├── api_header.html │ ├── banner.jpg │ ├── banner.xcf │ ├── doc_footer.html │ └── doc_header.html └── web │ ├── banner.jpg │ └── img │ └── forkme_left_green_007200.png ├── examples ├── CMakeLists.txt ├── demo │ ├── web │ │ ├── fonts │ │ │ ├── Simple-Line-Icons.eot │ │ │ ├── Simple-Line-Icons.ttf │ │ │ ├── Simple-Line-Icons.woff │ │ │ └── Simple-Line-Icons.woff2 │ │ ├── secure.html │ │ ├── css │ │ │ └── demo.css │ │ ├── js │ │ │ └── demo.js │ │ └── index.html │ ├── pages │ │ ├── directors_page.cpp │ │ ├── movie_page.hpp │ │ ├── directors_page.hpp │ │ ├── main_page.hpp │ │ ├── main_page.cpp │ │ └── movie_page.cpp │ ├── templates │ │ ├── main.matador │ │ ├── header.matador │ │ ├── menu.matador │ │ ├── director_create.matador │ │ ├── director_details.matador │ │ ├── director_edit.matador │ │ ├── director_delete.matador │ │ └── director_list.matador │ ├── models │ │ ├── credential.hpp │ │ ├── person.hpp │ │ └── user.hpp │ ├── services │ │ ├── auth_service.hpp │ │ └── movie_service.hpp │ └── CMakeLists.txt ├── net │ ├── echo_server_main.cpp │ ├── echo_server.hpp │ ├── echo_client_main.cpp │ ├── echo_client.hpp │ ├── echo_client.cpp │ ├── echo_server_connection.hpp │ ├── echo_client_connection.hpp │ ├── echo_server.cpp │ ├── CMakeLists.txt │ └── echo_server_connection.cpp └── http │ ├── main.cpp │ └── CMakeLists.txt ├── .gitignore ├── src ├── object │ ├── json_object_mapper.cpp │ ├── action.cpp │ ├── object_proxy_accessor.cpp │ ├── basic_has_many_to_many_item.cpp │ ├── object_json_serializer.cpp │ ├── abstract_has_many.cpp │ └── update_action.cpp ├── sql │ ├── query.cpp │ ├── type.cpp │ ├── value.cpp │ ├── token.cpp │ ├── connection_impl.cpp │ ├── sql_logger.cpp │ ├── row.cpp │ ├── condition.cpp │ ├── column_serializer.cpp │ └── database_error.cpp ├── utils │ ├── serializer.cpp │ ├── blob.cpp │ ├── thread_helper.cpp │ ├── field_attributes.cpp │ ├── constraints.cpp │ ├── string_cursor.cpp │ ├── html.cpp │ ├── sequence_synchronizer.cpp │ └── buffer.cpp ├── orm │ └── identifier_column_resolver.cpp ├── net │ ├── address_resolver.cpp │ ├── io_service.cpp │ ├── error.cpp │ ├── handler.cpp │ └── fdset.cpp ├── json │ ├── json_mapper.cpp │ ├── generic_json_parser.cpp │ └── json_format.cpp ├── logger │ ├── basic_file_sink.cpp │ ├── log_level.cpp │ └── logger.cpp ├── db │ ├── mssql │ │ ├── mssql_dialect_linker.cpp │ │ └── mssql_dialect_compiler.cpp │ ├── postgresql │ │ ├── postgresql_exception.cpp │ │ ├── limit.txt │ │ └── postgresql_getvalue.cpp │ ├── CMakeLists.txt │ └── sqlite │ │ └── sqlite_exception.cpp ├── http │ ├── detail │ │ ├── template_command_factory.cpp │ │ └── template_filter_factory.cpp │ ├── middleware │ │ └── routing_middleware.cpp │ └── middleware.cpp ├── unit │ └── CMakeLists.txt └── CMakeLists.txt ├── test ├── http │ ├── JwtTest.hpp │ ├── MiddlewareTest.hpp │ ├── RouteEngineTest.hpp │ ├── HttpClientTest.hpp │ ├── HttpTestServer.hpp │ ├── TemplateEngineTest.hpp │ ├── ResponseParserTest.hpp │ ├── RouteEndpointTest.hpp │ ├── RequestParserTest.hpp │ ├── HttpServerTest.hpp │ ├── MiddlewareTest.cpp │ └── JwtTest.cpp ├── utils │ ├── TreeTest.hpp │ ├── HtmlTest.hpp │ ├── BlobTestUnit.hpp │ ├── UrlTest.hpp │ ├── FileTestUnit.hpp │ ├── OptionalTest.hpp │ ├── IdentifierTest.hpp │ ├── ThreadPoolTest.hpp │ ├── VersionTest.hpp │ ├── StringTestUnit.hpp │ ├── EncryptionTest.hpp │ ├── BufferViewTest.hpp │ ├── OSTest.hpp │ ├── Base64Test.hpp │ ├── FactoryTestUnit.hpp │ ├── AnyTestUnit.hpp │ ├── OptionalTest.cpp │ ├── SequencerTestUnit.hpp │ ├── HtmlTest.cpp │ ├── DependencyInjectionTest.hpp │ ├── TimeTestUnit.hpp │ ├── FileTestUnit.cpp │ ├── DateTestUnit.hpp │ ├── BlobTestUnit.cpp │ ├── IdentifierTest.cpp │ ├── StreamsTest.hpp │ ├── UrlTest.cpp │ ├── ThreadPoolTest.cpp │ ├── StringTestUnit.cpp │ └── EncryptionTest.cpp ├── net │ ├── IPTestUnit.hpp │ ├── FDSetTest.hpp │ ├── SocketTest.hpp │ ├── AddressResolverTest.hpp │ ├── SocketInterrupterTest.hpp │ ├── IOServiceTest.hpp │ ├── LeaderFollowerThreadPoolTest.hpp │ ├── AddressTest.hpp │ ├── ReactorTest.hpp │ ├── SocketInterrupterTest.cpp │ ├── IOEchoServer.hpp │ ├── IOEchoServerConnection.hpp │ ├── AddressResolverTest.cpp │ ├── IOEchoServerConnection.cpp │ ├── EchoServer.hpp │ └── IPTestUnit.cpp ├── sql │ ├── ValueUnitTest.hpp │ ├── SqlLoggerTest.hpp │ ├── ConnectionInfoTest.hpp │ ├── SQLiteDialectTestUnit.hpp │ ├── MSSQLDialectTestUnit.hpp │ ├── TestDialect.hpp │ ├── PostgreSQLDialectTestUnit.hpp │ ├── ConditionUnitTest.hpp │ ├── ConnectionTestUnit.hpp │ └── DialectTestUnit.hpp ├── object │ ├── PrimaryKeyUnitTest.hpp │ ├── HasManyUnitTest.hpp │ ├── JsonObjectMapperTest.hpp │ ├── ObjectPrototypeTestUnit.hpp │ ├── HasManyUnitTest.cpp │ ├── PrototypeTreeTest.hpp │ ├── HasManyListUnitTest.hpp │ ├── ObjectTransactionTestUnit.hpp │ ├── RelationTestUnit.hpp │ └── PrimaryKeyUnitTest.cpp ├── connections.hpp.in ├── json │ ├── JsonTestUnit.hpp │ ├── JsonSerializerTest.hpp │ └── JsonMapperTestUnit.hpp ├── orm │ ├── JsonOrmTest.hpp │ ├── PrimaryKeyTestUnit.hpp │ ├── OrmRelationTestUnit.hpp │ ├── OrmTestUnit.hpp │ ├── BlogUnitTest.hpp │ ├── OrmReloadTestUnit.hpp │ └── TransactionTestUnit.hpp ├── unit │ └── TestSuiteTestUnit.hpp ├── logger │ ├── file.hpp │ ├── file.cpp │ └── LoggerTest.hpp └── has_many_list.hpp ├── include └── matador │ ├── utils │ ├── enable_if.hpp │ ├── calendar.h │ ├── conditional.hpp │ ├── thread_helper.hpp │ ├── export.hpp │ ├── html.hpp │ ├── strptime.hpp │ ├── url.hpp │ ├── hmac.hpp │ ├── contraints.hpp │ ├── is_builtin.hpp │ ├── base_class.hpp │ └── cascade_type.hpp │ ├── db │ ├── mysql │ │ ├── mysql_bool.hpp │ │ ├── mysql_constants.hpp │ │ ├── mysql_dialect.hpp │ │ ├── mysql_result_info.hpp │ │ └── mysql_statement.hpp │ ├── postgresql │ │ ├── postgresql_exception.hpp │ │ ├── postgresql_dialect.hpp │ │ └── postgresql_dialect_compiler.hpp │ ├── mssql │ │ ├── mssql_dialect_linker.hpp │ │ ├── mssql_dialect.hpp │ │ ├── mssql_exception.hpp │ │ ├── mssql_dialect_compiler.hpp │ │ └── mssql_statement.hpp │ └── sqlite │ │ ├── sqlite_dialect.hpp │ │ ├── sqlite_exception.hpp │ │ ├── sqlite_statement.hpp │ │ └── sqlite_dialect_compiler.hpp │ ├── sql │ ├── token_list.hpp │ ├── export.hpp │ ├── commands.hpp │ ├── statement_context.hpp │ ├── query.md │ ├── query_value_creator.hpp │ ├── query_value_column_processor.hpp │ └── value.hpp │ ├── http │ ├── enum_class_hash.hpp │ ├── export.hpp │ ├── detail │ │ ├── template_filter_factory.hpp │ │ ├── template_command_factory.hpp │ │ └── template_filter.hpp │ ├── middleware │ │ └── routing_middleware.hpp │ ├── default_responses.hpp │ └── static_file_service.hpp │ ├── net │ ├── handler_creator.hpp │ ├── error.hpp │ ├── export.hpp │ ├── socket_interrupter.hpp │ └── os.hpp │ ├── orm │ ├── export.hpp │ ├── persistence_observer.hpp │ └── persistence_observer.tpp │ ├── object │ ├── action_vector.hpp │ ├── object_proxy_accessor.hpp │ ├── export.hpp │ ├── value_type_traits.hpp │ ├── type_traits.hpp │ ├── basic_has_many_to_many_item.hpp │ ├── action_remover.hpp │ ├── container_type_traits.hpp │ ├── object_exception.hpp │ ├── action_inserter.hpp │ └── update_action.hpp │ ├── json │ ├── export.hpp │ └── json_exception.hpp │ ├── logger │ ├── export.hpp │ ├── log_sink.hpp │ ├── basic_file_sink.hpp │ └── log_level.hpp │ └── version.hpp.in ├── scripts └── sed4ghpages.sh.in ├── sandbox └── CMakeLists.txt └── cmake ├── FindMatadorBackendMSSQL.cmake ├── FindMatadorBackendMySQL.cmake ├── FindMatadorBackendSQLite.cmake └── Matador.cmake /doc/doxygen/api_footer.html: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /doc/doxygen/api_header.html: -------------------------------------------------------------------------------- 1 | --- 2 | layout: reference 3 | title: $title 4 | --- 5 | -------------------------------------------------------------------------------- /doc/web/banner.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/doc/web/banner.jpg -------------------------------------------------------------------------------- /doc/doxygen/banner.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/doc/doxygen/banner.jpg -------------------------------------------------------------------------------- /doc/doxygen/banner.xcf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/doc/doxygen/banner.xcf -------------------------------------------------------------------------------- /examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(net) 2 | ADD_SUBDIRECTORY(http) 3 | #ADD_SUBDIRECTORY(demo) -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | doc/api/ 3 | doc/web/api/ 4 | oos.geany 5 | .idea 6 | *.user 7 | .vscode/ 8 | Package -------------------------------------------------------------------------------- /doc/doxygen/doc_footer.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /src/object/json_object_mapper.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/object/json_object_mapper.hpp" 2 | 3 | namespace matador { 4 | } 5 | -------------------------------------------------------------------------------- /doc/web/img/forkme_left_green_007200.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/doc/web/img/forkme_left_green_007200.png -------------------------------------------------------------------------------- /examples/demo/web/fonts/Simple-Line-Icons.eot: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/examples/demo/web/fonts/Simple-Line-Icons.eot -------------------------------------------------------------------------------- /examples/demo/web/fonts/Simple-Line-Icons.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/examples/demo/web/fonts/Simple-Line-Icons.ttf -------------------------------------------------------------------------------- /examples/demo/web/fonts/Simple-Line-Icons.woff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/examples/demo/web/fonts/Simple-Line-Icons.woff -------------------------------------------------------------------------------- /examples/demo/web/fonts/Simple-Line-Icons.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zussel/matador/HEAD/examples/demo/web/fonts/Simple-Line-Icons.woff2 -------------------------------------------------------------------------------- /src/sql/query.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/query.hpp" 2 | 3 | namespace matador { 4 | 5 | query select(columns cols) 6 | { 7 | query q; 8 | return q.select(cols); 9 | } 10 | 11 | } -------------------------------------------------------------------------------- /examples/demo/pages/directors_page.cpp: -------------------------------------------------------------------------------- 1 | #include "directors_page.hpp" 2 | 3 | directors_page::directors_page(matador::http::server &server, matador::persistence &p) 4 | : crud_page({"Director", "Directors", "director"}, server, p) 5 | {} 6 | -------------------------------------------------------------------------------- /src/utils/serializer.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 2/1/16. 3 | // 4 | #include "matador/utils/serializer.hpp" 5 | 6 | namespace matador { 7 | 8 | //void serializer::serialize(const char *id, matador::basic_identifier &x) 9 | //{ 10 | // x.serialize(id, *this); 11 | //} 12 | 13 | } -------------------------------------------------------------------------------- /src/sql/type.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // @author sascha on 9/23/16. 3 | // 4 | 5 | #include "matador/sql/types.hpp" 6 | 7 | namespace matador { 8 | 9 | //std::ostream& operator<<(std::ostream &out, const matador::database_type type) 10 | //{ 11 | // out << type; 12 | // return out; 13 | //} 14 | 15 | } -------------------------------------------------------------------------------- /src/orm/identifier_column_resolver.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace matador { 4 | namespace detail { 5 | 6 | void identifier_column_resolver::on_primary_key(const char *id, std::string &, size_t /*size*/) 7 | { 8 | col_.name = id; 9 | } 10 | 11 | } 12 | } -------------------------------------------------------------------------------- /test/http/JwtTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JWTTEST_HPP 2 | #define MATADOR_JWTTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class JwtTest : public matador::unit_test 7 | { 8 | public: 9 | JwtTest(); 10 | 11 | void test_jwt_token(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_JWTTEST_HPP 16 | -------------------------------------------------------------------------------- /test/utils/TreeTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_TREETEST_HPP 2 | #define MATADOR_TREETEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class TreeTest : public matador::unit_test 7 | { 8 | public: 9 | TreeTest(); 10 | 11 | void test_tree(); 12 | }; 13 | 14 | #endif //MATADOR_TREETEST_HPP 15 | -------------------------------------------------------------------------------- /test/utils/HtmlTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HTMLTEST_HPP 2 | #define MATADOR_HTMLTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class HtmlTest : public matador::unit_test 7 | { 8 | public: 9 | HtmlTest(); 10 | 11 | void test_escape(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_HTMLTEST_HPP 16 | -------------------------------------------------------------------------------- /test/utils/BlobTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BLOBTESTUNIT_HPP 2 | #define BLOBTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class BlobTestUnit : public matador::unit_test 7 | { 8 | public: 9 | BlobTestUnit(); 10 | 11 | void test_create(); 12 | }; 13 | 14 | #endif /* BLOBTESTUNIT_HPP */ 15 | 16 | -------------------------------------------------------------------------------- /src/net/address_resolver.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/net/address_resolver.hpp" 2 | 3 | namespace matador { 4 | namespace detail { 5 | 6 | template<> 7 | int determine_socktype() 8 | { 9 | return SOCK_STREAM; 10 | } 11 | 12 | template<> 13 | int determine_socktype() 14 | { 15 | return SOCK_DGRAM; 16 | } 17 | 18 | } 19 | } -------------------------------------------------------------------------------- /test/utils/UrlTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_URLTEST_HPP 2 | #define MATADOR_URLTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class UrlTest : public matador::unit_test 7 | { 8 | public: 9 | UrlTest(); 10 | 11 | void test_encode(); 12 | void test_decode(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_URLTEST_HPP 17 | -------------------------------------------------------------------------------- /test/net/IPTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_IPTESTUNIT_HPP 2 | #define MATADOR_IPTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class IPTestUnit : public matador::unit_test 7 | { 8 | public: 9 | IPTestUnit(); 10 | 11 | void test_tcp(); 12 | void test_udp(); 13 | }; 14 | 15 | #endif /* MATADOR_IPTESTUNIT_HPP */ -------------------------------------------------------------------------------- /test/utils/FileTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_FILETESTUNIT_HPP 2 | #define MATADOR_FILETESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class FileTestUnit : public matador::unit_test 7 | { 8 | public: 9 | FileTestUnit(); 10 | 11 | void test_file(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_FILETESTUNIT_HPP 16 | -------------------------------------------------------------------------------- /test/utils/OptionalTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_OPTIONALTEST_HPP 2 | #define MATADOR_OPTIONALTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class OptionalTest : public matador::unit_test 7 | { 8 | public: 9 | OptionalTest(); 10 | 11 | void test_bad_access(); 12 | }; 13 | 14 | #endif //MATADOR_OPTIONALTEST_HPP 15 | -------------------------------------------------------------------------------- /test/http/MiddlewareTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_MIDDLEWARETEST_HPP 2 | #define MATADOR_MIDDLEWARETEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class MiddlewareTest : public matador::unit_test 7 | { 8 | public: 9 | MiddlewareTest(); 10 | 11 | void test_middleware(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_MIDDLEWARETEST_HPP 16 | -------------------------------------------------------------------------------- /test/http/RouteEngineTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ROUTEENGINETEST_HPP 2 | #define MATADOR_ROUTEENGINETEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class RouteEngineTest : public matador::unit_test 7 | { 8 | public: 9 | RouteEngineTest(); 10 | 11 | void test_routes(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_ROUTEENGINETEST_HPP 16 | -------------------------------------------------------------------------------- /test/net/FDSetTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_FDSETTEST_HPP 2 | #define MATADOR_FDSETTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class FDSetTest : public matador::unit_test 7 | { 8 | public: 9 | FDSetTest(); 10 | 11 | void test_fdset(); 12 | void test_select_fdsets(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_FDSETTEST_HPP 17 | -------------------------------------------------------------------------------- /test/utils/IdentifierTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_IDENTIFIERTEST_HPP 2 | #define MATADOR_IDENTIFIERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class IdentifierTest : public matador::unit_test 7 | { 8 | public: 9 | IdentifierTest(); 10 | 11 | void test_identifier(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_IDENTIFIERTEST_HPP 16 | -------------------------------------------------------------------------------- /test/utils/ThreadPoolTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_THREADPOOLTEST_HPP 2 | #define MATADOR_THREADPOOLTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class ThreadPoolTest : public matador::unit_test 7 | { 8 | public: 9 | ThreadPoolTest(); 10 | 11 | void test_threadpool(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_THREADPOOLTEST_HPP 16 | -------------------------------------------------------------------------------- /test/utils/VersionTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_VERSIONTEST_HPP 2 | #define MATADOR_VERSIONTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class VersionTest : public matador::unit_test 7 | { 8 | public: 9 | VersionTest(); 10 | 11 | void test_version(); 12 | void test_parse(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_VERSIONTEST_HPP -------------------------------------------------------------------------------- /src/sql/value.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/value.hpp" 2 | #include "matador/sql/token_visitor.hpp" 3 | #include "matador/sql/basic_dialect.hpp" 4 | 5 | namespace matador { 6 | 7 | value::value() 8 | : token(detail::token::VALUE) 9 | {} 10 | 11 | void value::accept(token_visitor &visitor) 12 | { 13 | return visitor.visit(*this); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /test/net/SocketTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_SOCKETTEST_HPP 2 | #define MATADOR_SOCKETTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class SocketTest : public matador::unit_test 7 | { 8 | public: 9 | SocketTest(); 10 | 11 | void test_socket_v4(); 12 | void test_acceptor_v4(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_SOCKETTEST_HPP 17 | -------------------------------------------------------------------------------- /test/utils/StringTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef STRINGTESTUNIT_HPP 2 | #define STRINGTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class StringTestUnit : public matador::unit_test 7 | { 8 | public: 9 | StringTestUnit(); 10 | 11 | void test_split(); 12 | void test_trim(); 13 | }; 14 | 15 | 16 | #endif /* OOS_STRINGTESTUNIT_HPP */ 17 | -------------------------------------------------------------------------------- /test/sql/ValueUnitTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_VALUEUNITTEST_HPP 2 | #define OOS_VALUEUNITTEST_HPP 3 | 4 | 5 | #include "matador/unit/unit_test.hpp" 6 | 7 | class ValueUnitTest : public matador::unit_test 8 | { 9 | public: 10 | ValueUnitTest(); 11 | 12 | void test_values(); 13 | void test_serialize(); 14 | }; 15 | 16 | 17 | #endif //OOS_VALUEUNITTEST_HPP 18 | -------------------------------------------------------------------------------- /src/sql/token.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/token.hpp" 2 | 3 | #include 4 | 5 | namespace matador { 6 | namespace detail { 7 | 8 | token::token(t_token tok) 9 | : type(tok) 10 | {} 11 | 12 | table_name_token::table_name_token(token::t_token tok, std::string table_name) 13 | : token(tok) 14 | , table_name(std::move(table_name)) 15 | {} 16 | 17 | } 18 | } -------------------------------------------------------------------------------- /test/utils/EncryptionTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ENCRYPTIONTEST_HPP 2 | #define MATADOR_ENCRYPTIONTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class EncryptionTest : public matador::unit_test 7 | { 8 | public: 9 | EncryptionTest(); 10 | 11 | void test_sha256(); 12 | void test_hmac(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_ENCRYPTIONTEST_HPP 17 | -------------------------------------------------------------------------------- /examples/demo/templates/main.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | {% include "../templates/header.matador" %} 4 | 5 |
6 |

{{title}}

7 |
8 | Movies 9 | Directors 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/sql/connection_impl.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/connection_impl.hpp" 2 | 3 | namespace matador { 4 | void connection_impl::enable_log() 5 | { 6 | log_enabled_ = true; 7 | } 8 | 9 | void connection_impl::disable_log() 10 | { 11 | log_enabled_ = false; 12 | } 13 | 14 | bool connection_impl::is_log_enabled() const 15 | { 16 | return log_enabled_; 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /test/sql/SqlLoggerTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_SQLLOGGERTEST_HPP 2 | #define MATADOR_SQLLOGGERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class SqlLoggerTest : public matador::unit_test 7 | { 8 | public: 9 | SqlLoggerTest(); 10 | 11 | void test_null_logger(); 12 | void test_sql_logger(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_SQLLOGGERTEST_HPP 17 | -------------------------------------------------------------------------------- /include/matador/utils/enable_if.hpp: -------------------------------------------------------------------------------- 1 | #ifndef ENABLE_IF_HPP 2 | #define ENABLE_IF_HPP 3 | 4 | namespace matador { 5 | 6 | /// @cond MATADOR_DEV 7 | 8 | template 9 | struct enable_if {}; 10 | 11 | template 12 | struct enable_if { typedef T type; }; 13 | 14 | /// @endcond MATADOR_DEV 15 | 16 | } 17 | 18 | #endif /* ENABLE_IF_HPP */ 19 | -------------------------------------------------------------------------------- /test/utils/BufferViewTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_BUFFERVIEWTEST_HPP 2 | #define MATADOR_BUFFERVIEWTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class BufferViewTest : public matador::unit_test 7 | { 8 | public: 9 | BufferViewTest(); 10 | 11 | void test_buffer_view(); 12 | void test_array(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_BUFFERVIEWTEST_HPP 17 | -------------------------------------------------------------------------------- /examples/demo/web/secure.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | Logout 7 | 8 | 9 | 10 |

Secure page

11 | Logout 12 | 13 | -------------------------------------------------------------------------------- /test/net/AddressResolverTest.hpp: -------------------------------------------------------------------------------- 1 | #include "matador/unit/unit_test.hpp" 2 | 3 | #ifndef MATADOR_ADDRESSRESOLVERTEST_HPP 4 | #define MATADOR_ADDRESSRESOLVERTEST_HPP 5 | 6 | 7 | class AddressResolverTest : public matador::unit_test 8 | { 9 | public: 10 | AddressResolverTest(); 11 | 12 | void test_resolver_v4(); 13 | }; 14 | 15 | 16 | #endif //MATADOR_ADDRESSRESOLVERTEST_HPP 17 | -------------------------------------------------------------------------------- /test/net/SocketInterrupterTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_SOCKETINTERRUPTERTEST_HPP 2 | #define MATADOR_SOCKETINTERRUPTERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class SocketInterrupterTest : public matador::unit_test 7 | { 8 | public: 9 | SocketInterrupterTest(); 10 | 11 | void test_interrupter(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_SOCKETINTERRUPTERTEST_HPP 16 | -------------------------------------------------------------------------------- /test/object/PrimaryKeyUnitTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_PRIMARYKEYUNITTEST_HPP 2 | #define OOS_PRIMARYKEYUNITTEST_HPP 3 | 4 | 5 | #include "matador/unit/unit_test.hpp" 6 | 7 | class PrimaryKeyUnitTest : public matador::unit_test 8 | { 9 | public: 10 | PrimaryKeyUnitTest(); 11 | 12 | void test_create(); 13 | void test_share(); 14 | }; 15 | 16 | 17 | #endif //OOS_PRIMARYKEYUNITTEST_HPP 18 | -------------------------------------------------------------------------------- /scripts/sed4ghpages.sh.in: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # change to build dir 4 | cd @CMAKE_BINARY_DIR@/doc 5 | 6 | if [ ! -d "gh-pages" ]; then 7 | mkdir gh-pages 8 | elif [ "$(ls -A gh-pages)" ]; then 9 | rm gh-pages/* 10 | fi 11 | 12 | cd api 13 | 14 | for file in *.html; do 15 | sed 's/href="\([^"#]*\).html\(#[^"]*\)\?"/href="\/api\/\1\/index.html\2"/g' $file > ../gh-pages/$file 16 | done 17 | -------------------------------------------------------------------------------- /test/utils/OSTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_OSTEST_HPP 2 | #define OOS_OSTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class OSTest : public matador::unit_test 7 | { 8 | public: 9 | OSTest(); 10 | 11 | void test_mkdir(); 12 | void test_mkpath(); 13 | void test_remove_file(); 14 | void test_rename_file(); 15 | void test_access_file(); 16 | }; 17 | 18 | #endif // OOS_OSTEST_HPP -------------------------------------------------------------------------------- /src/object/action.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/object/action.hpp" 2 | #include "matador/object/object_serializer.hpp" 3 | #include "matador/object/object_deserializer.hpp" 4 | 5 | namespace matador { 6 | 7 | action::action() 8 | : serializer_(new object_serializer), deserializer_(new object_deserializer) {} 9 | 10 | action::~action() { 11 | delete serializer_; 12 | delete deserializer_; 13 | } 14 | 15 | } -------------------------------------------------------------------------------- /test/connections.hpp.in: -------------------------------------------------------------------------------- 1 | #ifndef CONNECTIONS_HPP 2 | #define CONNECTIONS_HPP 3 | 4 | namespace connection { 5 | const char* const mysql = "@MYSQL_CONNECTION_STRING@"; 6 | const char* const sqlite = "@SQLITE_CONNECTION_STRING@"; 7 | const char* const mssql = "@MSSQL_CONNECTION_STRING@"; 8 | const char* const postgresql = "@POSTGRESQL_CONNECTION_STRING@"; 9 | } 10 | 11 | #endif /* CONNECTIONS_HPP */ 12 | -------------------------------------------------------------------------------- /test/utils/Base64Test.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_BASE64TEST_HPP 2 | #define MATADOR_BASE64TEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class Base64Test : public matador::unit_test 7 | { 8 | public: 9 | Base64Test(); 10 | 11 | void test_encode(); 12 | void test_encode_url(); 13 | void test_decode(); 14 | void test_complete(); 15 | }; 16 | 17 | 18 | #endif //MATADOR_BASE64TEST_HPP 19 | -------------------------------------------------------------------------------- /include/matador/utils/calendar.h: -------------------------------------------------------------------------------- 1 | #ifndef CALENDAR_H 2 | #define CALENDAR_H 3 | 4 | int gc2jd(int day, int month, int year); 5 | void jd2gc(int jday, int &day, int &month, int &year); 6 | 7 | int time2seconds(unsigned int hour, unsigned int minute, unsigned int second); 8 | void seconds2time(unsigned int seconds, unsigned int &hour, unsigned int &minute, unsigned int &second); 9 | 10 | #endif /* CALENDAR_H */ 11 | -------------------------------------------------------------------------------- /src/object/object_proxy_accessor.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 9/2/16. 3 | // 4 | 5 | #include "matador/object/object_holder.hpp" 6 | #include "matador/object/object_proxy_accessor.hpp" 7 | 8 | namespace matador { 9 | 10 | namespace detail { 11 | 12 | matador::object_proxy *object_proxy_accessor::proxy(const object_holder &holder) const 13 | { 14 | return holder.proxy_; 15 | } 16 | 17 | } 18 | 19 | } -------------------------------------------------------------------------------- /test/json/JsonTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JSONTESTUNIT_HPP 2 | #define MATADOR_JSONTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class JsonTestUnit : public matador::unit_test 7 | { 8 | public: 9 | JsonTestUnit(); 10 | 11 | void test_simple(); 12 | void test_access(); 13 | void test_compare(); 14 | void test_parser(); 15 | }; 16 | 17 | 18 | #endif //MATADOR_JSONTESTUNIT_HPP 19 | -------------------------------------------------------------------------------- /test/utils/FactoryTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef FACTORYTESTUNIT_HPP 2 | #define FACTORYTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class FactoryTestUnit : public matador::unit_test 7 | { 8 | public: 9 | FactoryTestUnit(); 10 | 11 | void create_factory(); 12 | void insert_items(); 13 | void produce_items(); 14 | void list_items(); 15 | }; 16 | 17 | #endif /* FACTORYTESTUNIT_HPP */ 18 | -------------------------------------------------------------------------------- /include/matador/db/mysql/mysql_bool.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 02.01.20. 3 | // 4 | 5 | #ifndef MATADOR_MYSQL_BOOL_HPP 6 | #define MATADOR_MYSQL_BOOL_HPP 7 | 8 | #ifdef _MSC_VER 9 | #include 10 | #else 11 | #include 12 | #endif 13 | 14 | #if !MARIADB_PACKAGE_VERSION_ID && MYSQL_VERSION_ID >= 80001 15 | typedef bool my_bool; 16 | #endif 17 | 18 | #endif //MATADOR_MYSQL_BOOL_HPP 19 | -------------------------------------------------------------------------------- /include/matador/db/mysql/mysql_constants.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MYSQL_CONSTANTS_HPP 2 | #define MYSQL_CONSTANTS_HPP 3 | 4 | #ifdef _MSC_VER 5 | #include 6 | #else 7 | #include 8 | #endif 9 | 10 | namespace matador { 11 | 12 | namespace mysql { 13 | 14 | class mysql 15 | { 16 | public: 17 | static const long version = MYSQL_VERSION_ID; 18 | }; 19 | 20 | } 21 | } 22 | #endif /* MYSQL_CONSTANTS_HPP */ -------------------------------------------------------------------------------- /test/http/HttpClientTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HTTPCLIENTTEST_HPP 2 | #define MATADOR_HTTPCLIENTTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class HttpClientTest : public matador::unit_test 7 | { 8 | public: 9 | HttpClientTest(); 10 | 11 | void test_get(); 12 | void test_post(); 13 | void test_put(); 14 | void test_delete(); 15 | }; 16 | 17 | 18 | #endif //MATADOR_HTTPCLIENTTEST_HPP 19 | -------------------------------------------------------------------------------- /include/matador/utils/conditional.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CONDITIONAL_HPP 2 | #define CONDITIONAL_HPP 3 | 4 | namespace matador { 5 | 6 | /// @cond MATADOR_DEV 7 | 8 | template 9 | struct conditional { typedef T type; }; 10 | 11 | template 12 | struct conditional { typedef F type; }; 13 | 14 | /// @endcond MATADOR_DEV 15 | 16 | } 17 | 18 | #endif /* CONDITIONAL_HPP */ 19 | -------------------------------------------------------------------------------- /test/object/HasManyUnitTest.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 19.09.19. 3 | // 4 | 5 | #ifndef MATADOR_HASMANYUNITTEST_HPP 6 | #define MATADOR_HASMANYUNITTEST_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class HasManyUnitTest : public matador::unit_test 12 | { 13 | public: 14 | HasManyUnitTest(); 15 | 16 | void test_one_to_many(); 17 | }; 18 | 19 | 20 | #endif //MATADOR_HASMANYUNITTEST_HPP 21 | -------------------------------------------------------------------------------- /test/orm/JsonOrmTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JSONORMTEST_HPP 2 | #define MATADOR_JSONORMTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class JsonOrmTest : public matador::unit_test 7 | { 8 | public: 9 | JsonOrmTest(const std::string &prefix, std::string dns); 10 | 11 | void test_insert_from_json(); 12 | 13 | private: 14 | std::string dns_; 15 | }; 16 | 17 | 18 | #endif //MATADOR_JSONORMTEST_HPP 19 | -------------------------------------------------------------------------------- /test/net/IOServiceTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_IOSERVICETEST_HPP 2 | #define MATADOR_IOSERVICETEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | #include 7 | 8 | class IOServiceTest : public matador::unit_test 9 | { 10 | public: 11 | IOServiceTest(); 12 | 13 | void test_shutdown(); 14 | void test_acceptor(); 15 | void test_connector(); 16 | }; 17 | 18 | 19 | #endif //MATADOR_IOSERVICETEST_HPP 20 | -------------------------------------------------------------------------------- /test/net/LeaderFollowerThreadPoolTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_LEADERFOLLOWERTHREADPOOLTEST_HPP 2 | #define MATADOR_LEADERFOLLOWERTHREADPOOLTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class LeaderFollowerThreadPoolTest : public matador::unit_test 7 | { 8 | public: 9 | LeaderFollowerThreadPoolTest(); 10 | 11 | void test_thread_pool(); 12 | }; 13 | 14 | 15 | #endif //MATADOR_LEADERFOLLOWERTHREADPOOLTEST_HPP 16 | -------------------------------------------------------------------------------- /test/unit/TestSuiteTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 12/23/16. 3 | // 4 | 5 | #ifndef OOS_TESTSUITETESTUNIT_HPP 6 | #define OOS_TESTSUITETESTUNIT_HPP 7 | 8 | 9 | class TestSuiteTestUnit 10 | { 11 | public: 12 | bool test_create(); 13 | bool test_init(); 14 | bool test_list(); 15 | bool test_method(); 16 | bool test_unit(); 17 | bool test_suite(); 18 | }; 19 | 20 | 21 | #endif //OOS_TESTSUITETESTUNIT_HPP 22 | -------------------------------------------------------------------------------- /test/net/AddressTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ADDRESSTEST_HPP 2 | #define MATADOR_ADDRESSTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class AddressTest : public matador::unit_test 7 | { 8 | public: 9 | AddressTest(); 10 | 11 | void test_address_v4(); 12 | void test_address_v6(); 13 | void test_peer_v4(); 14 | void test_peer_v6(); 15 | 16 | void test_ip(); 17 | }; 18 | 19 | 20 | #endif //MATADOR_ADDRESSTEST_HPP 21 | -------------------------------------------------------------------------------- /examples/demo/templates/header.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {{title}} 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /include/matador/sql/token_list.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_TOKEN_LIST_HPP 2 | #define OOS_TOKEN_LIST_HPP 3 | 4 | #include "matador/sql/token.hpp" 5 | 6 | #include 7 | 8 | namespace matador { 9 | 10 | typedef std::shared_ptr token_ptr; /**< Shortcut to a token shared pointer */ 11 | typedef std::list token_list_t; /**< Shortcut to a list of token shared pointer */ 12 | 13 | } 14 | 15 | #endif //OOS_TOKEN_LIST_HPP 16 | -------------------------------------------------------------------------------- /src/json/json_mapper.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/json/json_mapper.hpp" 2 | 3 | namespace matador { 4 | 5 | std::string json_mapper::to_string(const json &js, const json_format &format) 6 | { 7 | return js.str(format); 8 | } 9 | 10 | json json_mapper::to_json(const std::string &str) 11 | { 12 | return json_parser_.parse(str); 13 | } 14 | 15 | json json_mapper::to_json(const char *str) 16 | { 17 | return json_parser_.parse(str); 18 | } 19 | 20 | } -------------------------------------------------------------------------------- /test/utils/AnyTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 10/4/16. 3 | // 4 | 5 | #ifndef OOS_ANYTESTUNIT_HPP 6 | #define OOS_ANYTESTUNIT_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class AnyTestUnit : public matador::unit_test 12 | { 13 | public: 14 | AnyTestUnit(); 15 | 16 | void test_any(); 17 | void test_any_visitor(); 18 | void test_any_visitor_class(); 19 | }; 20 | 21 | 22 | #endif //OOS_ANYTESTUNIT_HPP 23 | -------------------------------------------------------------------------------- /test/json/JsonSerializerTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JSONSERIALIZERTEST_HPP 2 | #define MATADOR_JSONSERIALIZERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class JsonSerializerTest : public matador::unit_test 7 | { 8 | public: 9 | JsonSerializerTest(); 10 | 11 | void test_date_to_string_object(); 12 | void test_to_string_object(); 13 | void test_to_string_array(); 14 | }; 15 | 16 | 17 | #endif //MATADOR_JSONSERIALIZERTEST_HPP 18 | -------------------------------------------------------------------------------- /test/sql/ConnectionInfoTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_CONNECTIONINFOTEST_HPP 2 | #define MATADOR_CONNECTIONINFOTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class ConnectionInfoTest : public matador::unit_test 7 | { 8 | public: 9 | ConnectionInfoTest(); 10 | 11 | void test_parse_connection_info(); 12 | void test_connection_info_to_string(); 13 | void test_connection_info_from_json(); 14 | }; 15 | 16 | 17 | #endif //MATADOR_CONNECTIONINFOTEST_HPP 18 | -------------------------------------------------------------------------------- /examples/net/echo_server_main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include "echo_server.hpp" 5 | 6 | using namespace matador; 7 | 8 | int main(int argc, char* argv[]) 9 | { 10 | if (argc < 2) { 11 | std::cout << "usage: echo_server [port]\n"; 12 | return 1; 13 | } else { 14 | 15 | net::init(); 16 | 17 | echo_server server(std::atoi(argv[1])); 18 | 19 | server.run(); 20 | 21 | net::cleanup(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/json/generic_json_parser.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/json/generic_json_parser.hpp" 2 | 3 | namespace matador { 4 | bool is_error(const char *start, const char *end, long long value) { 5 | return start == end || (errno == ERANGE && (value == 0 || value == LLONG_MAX || value == LLONG_MIN)); 6 | } 7 | 8 | bool is_error(const char *start, const char *end, double value) { 9 | return start == end || (errno == ERANGE && (value == 0 || value == -HUGE_VAL || value == HUGE_VAL)); 10 | } 11 | } -------------------------------------------------------------------------------- /src/logger/basic_file_sink.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/logger/basic_file_sink.hpp" 2 | 3 | namespace matador { 4 | 5 | basic_file_sink::basic_file_sink(FILE *f) 6 | : stream(f) 7 | {} 8 | 9 | void basic_file_sink::write(const char *message, size_t size) 10 | { 11 | fwrite(message, sizeof(char), size, stream); 12 | fflush(stream); 13 | } 14 | 15 | void basic_file_sink::close() 16 | { 17 | if (stream) { 18 | fclose(stream); 19 | stream = nullptr; 20 | } 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /test/orm/PrimaryKeyTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_PRIMARYKEYTESTUNIT_HPP 2 | #define MATADOR_PRIMARYKEYTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class PrimaryKeyTestUnit : public matador::unit_test 7 | { 8 | public: 9 | PrimaryKeyTestUnit(const std::string &prefix, std::string dns); 10 | 11 | void test_long_pk(); 12 | void test_varchar_pk(); 13 | 14 | private: 15 | std::string dns_; 16 | }; 17 | 18 | 19 | #endif //MATADOR_PRIMARYKEYTESTUNIT_HPP 20 | -------------------------------------------------------------------------------- /test/sql/SQLiteDialectTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 29.07.16. 3 | // 4 | 5 | #ifndef OOS_SQLITEDIALECTTESTUNIT_HPP 6 | #define OOS_SQLITEDIALECTTESTUNIT_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class SQLiteDialectTestUnit : public matador::unit_test 12 | { 13 | public: 14 | SQLiteDialectTestUnit(); 15 | 16 | void test_update_with_limit(); 17 | void test_delete_with_limit(); 18 | }; 19 | 20 | 21 | #endif //OOS_SQLITEDIALECTTESTUNIT_HPP 22 | -------------------------------------------------------------------------------- /include/matador/http/enum_class_hash.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ENUM_CLASS_HASH_HPP 2 | #define MATADOR_ENUM_CLASS_HASH_HPP 3 | 4 | #include 5 | 6 | namespace matador { 7 | namespace http { 8 | namespace detail { 9 | /// @cond MATADOR_DEV 10 | struct enum_class_hash 11 | { 12 | template 13 | std::size_t operator()(T t) const 14 | { 15 | return static_cast(t); 16 | } 17 | }; 18 | /// @endcond 19 | } 20 | } 21 | } 22 | #endif //MATADOR_ENUM_CLASS_HASH_HPP 23 | -------------------------------------------------------------------------------- /examples/net/echo_server.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ECHO_SERVER_HPP 2 | #define MATADOR_ECHO_SERVER_HPP 3 | 4 | #include 5 | #include 6 | 7 | class echo_server 8 | { 9 | public: 10 | explicit echo_server(unsigned short port); 11 | 12 | void run(); 13 | 14 | private: 15 | void prepare_accept(); 16 | 17 | private: 18 | matador::io_service service_; 19 | std::shared_ptr acceptor_; 20 | }; 21 | 22 | 23 | #endif //MATADOR_ECHO_SERVER_HPP 24 | -------------------------------------------------------------------------------- /include/matador/net/handler_creator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HANDLER_CREATOR_HPP 2 | #define MATADOR_HANDLER_CREATOR_HPP 3 | 4 | #include "matador/net/export.hpp" 5 | 6 | namespace matador { 7 | 8 | /// @cond MATADOR_DEV 9 | 10 | class handler; 11 | 12 | class OOS_NET_API handler_creator 13 | { 14 | public: 15 | virtual ~handler_creator() = default; 16 | 17 | virtual void notify_close(handler *hndlr) = 0; 18 | }; 19 | 20 | /// @endcond 21 | 22 | } 23 | #endif //MATADOR_HANDLER_CREATOR_HPP 24 | -------------------------------------------------------------------------------- /include/matador/orm/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ORM_EXPORT_HPP 2 | #define MATADOR_ORM_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | //#ifdef matador_orm_EXPORTS 6 | //#define OOS_ORM_API __declspec(dllexport) 7 | //#define EXPIMP_ORM_TEMPLATE 8 | //#else 9 | //#define OOS_ORM_API __declspec(dllimport) 10 | //#define EXPIMP_ORM_TEMPLATE extern 11 | //#endif 12 | #define OOS_ORM_API 13 | #pragma warning(disable: 4251) 14 | #else 15 | #define OOS_ORM_API 16 | #endif 17 | 18 | #endif //MATADOR_ORM_EXPORT_HPP 19 | -------------------------------------------------------------------------------- /include/matador/object/action_vector.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ACTION_VECTOR_HPP 2 | #define MATADOR_ACTION_VECTOR_HPP 3 | 4 | #include "matador/object/action.hpp" 5 | 6 | #include 7 | #include 8 | 9 | namespace matador { 10 | 11 | typedef std::shared_ptr action_ptr; /**< Shortcut to an action shared pointer */ 12 | typedef std::vector t_action_vector; /**< Shortcut to a vector of action shared pointer */ 13 | 14 | } 15 | 16 | #endif //MATADOR_ACTION_VECTOR_HPP 17 | -------------------------------------------------------------------------------- /src/utils/blob.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/blob.hpp" 2 | 3 | namespace matador { 4 | 5 | blob::blob() 6 | {} 7 | 8 | blob::~blob() 9 | { 10 | } 11 | 12 | void blob::append(const void *data, std::size_t len) 13 | { 14 | data_.insert(data_.begin(), (unsigned char*)data, (unsigned char*)(data)+len); 15 | } 16 | 17 | blob::size_type blob::size() const 18 | { 19 | return data_.size(); 20 | } 21 | 22 | const unsigned char* blob::data() const 23 | { 24 | return &data_.front(); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /test/utils/OptionalTest.cpp: -------------------------------------------------------------------------------- 1 | #include "OptionalTest.hpp" 2 | 3 | #include "matador/utils/optional.hpp" 4 | 5 | using namespace matador; 6 | 7 | OptionalTest::OptionalTest() 8 | : unit_test("optional", "optional test") 9 | { 10 | add_test("bad_access", [this] { test_bad_access(); }, "optional bad access test"); 11 | } 12 | 13 | void OptionalTest::test_bad_access() 14 | { 15 | optional bad_int; 16 | 17 | UNIT_ASSERT_EXCEPTION(bad_int.value(), bad_optional_access, "bad optional access"); 18 | } 19 | -------------------------------------------------------------------------------- /include/matador/net/error.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ERROR_HPP 2 | #define MATADOR_ERROR_HPP 3 | 4 | #include "matador/net/export.hpp" 5 | 6 | namespace matador { 7 | namespace detail { 8 | 9 | /// @cond MATADOR_DEV 10 | 11 | OOS_NET_API void throw_logic_error(const char* msg); 12 | OOS_NET_API void throw_logic_error_with_errno(const char* msg, int err); 13 | OOS_NET_API void throw_logic_error_with_gai_errno(const char* msg, int err); 14 | 15 | /// @endcond 16 | 17 | } 18 | } 19 | 20 | #endif /* MATADOR_ERROR_HPP */ -------------------------------------------------------------------------------- /src/utils/thread_helper.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/thread_helper.hpp" 2 | 3 | #include 4 | #include 5 | 6 | namespace matador { 7 | std::size_t acquire_thread_index(std::thread::id id) 8 | { 9 | static std::size_t next_index = 0; 10 | static std::mutex my_mutex; 11 | static std::map ids; 12 | std::lock_guard lock(my_mutex); 13 | if(ids.find(id) == ids.end()) { 14 | ids[id] = next_index++; 15 | } 16 | return ids[id]; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /test/utils/SequencerTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 12/23/16. 3 | // 4 | 5 | #ifndef OOS_SEQUENCERTESTUNIT_HPP 6 | #define OOS_SEQUENCERTESTUNIT_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class SequencerTestUnit : public matador::unit_test 12 | { 13 | public: 14 | SequencerTestUnit(); 15 | 16 | void test_init(); 17 | void test_inc(); 18 | void test_reset(); 19 | void test_exchange(); 20 | void test_sync(); 21 | }; 22 | 23 | 24 | #endif //OOS_SEQUENCERTESTUNIT_HPP 25 | -------------------------------------------------------------------------------- /examples/net/echo_client_main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "matador/net/os.hpp" 4 | 5 | #include "matador/logger/log_manager.hpp" 6 | 7 | #include "echo_client.hpp" 8 | 9 | using namespace matador; 10 | 11 | int main(int argc, char* argv[]) 12 | { 13 | if (argc < 2) { 14 | std::cout << "usage: echo_client [port]\n"; 15 | return 1; 16 | } else { 17 | 18 | net::init(); 19 | 20 | echo_client client(argv[1]); 21 | 22 | client.run(); 23 | 24 | net::cleanup(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/db/mssql/mssql_dialect_linker.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 19.08.16. 3 | // 4 | 5 | #include "matador/db/mssql/mssql_dialect_linker.hpp" 6 | 7 | #include "matador/sql/dialect_token.hpp" 8 | 9 | namespace matador { 10 | 11 | namespace mssql { 12 | 13 | void mssql_dialect_linker::visit(const matador::detail::top &limit) 14 | { 15 | std::stringstream res; 16 | res << token_string(limit.type) << " (" << limit.limit_ << ") "; 17 | append_to_result(*top().dialect, res.str()); 18 | } 19 | 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /include/matador/net/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_NET_EXPORT_HPP 2 | #define MATADOR_NET_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | // #ifdef matador_net_EXPORTS 6 | // #define OOS_NET_API __declspec(dllexport) 7 | // #define EXPIMP_NET_TEMPLATE 8 | // #else 9 | // #define OOS_NET_API __declspec(dllimport) 10 | // #define EXPIMP_NET_TEMPLATE extern 11 | // #endif 12 | #define OOS_NET_API 13 | #pragma warning(disable: 4251) 14 | #else 15 | #define OOS_NET_API 16 | #endif 17 | 18 | #endif //MATADOR_NET_EXPORT_HPP -------------------------------------------------------------------------------- /test/sql/MSSQLDialectTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 6/13/16. 3 | // 4 | 5 | #ifndef OOS_MSSQLDIALECTTESTUNIT_HPP 6 | #define OOS_MSSQLDIALECTTESTUNIT_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class MSSQLDialectTestUnit : public matador::unit_test 12 | { 13 | public: 14 | MSSQLDialectTestUnit(); 15 | 16 | void test_limit(); 17 | void test_query_select_sub_select(); 18 | void test_query_select_sub_select_result(); 19 | }; 20 | 21 | 22 | #endif //OOS_MSSQLDIALECTTESTUNIT_HPP 23 | -------------------------------------------------------------------------------- /test/utils/HtmlTest.cpp: -------------------------------------------------------------------------------- 1 | #include "HtmlTest.hpp" 2 | 3 | #include "matador/utils/html.hpp" 4 | 5 | HtmlTest::HtmlTest() 6 | : unit_test("html", "html test unit") 7 | { 8 | add_test("escape", [this] { test_escape(); }, "test escape"); 9 | } 10 | 11 | void HtmlTest::test_escape() 12 | { 13 | std::string input("1 < 5 \"hello\" 'world' > 1 & 1 = 2"); 14 | 15 | auto result = matador::html::escape(input); 16 | 17 | UNIT_ASSERT_EQUAL("1 < 5 "hello" 'world' > 1 & 1 = 2", result); 18 | } 19 | -------------------------------------------------------------------------------- /include/matador/json/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JSON_EXPORT_HPP 2 | #define MATADOR_JSON_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | //#ifdef matador_json_EXPORTS 6 | // #define OOS_JSON_API __declspec(dllexport) 7 | // #define EXPIMP_JSON_TEMPLATE 8 | // #else 9 | // #define OOS_JSON_API __declspec(dllimport) 10 | // #define EXPIMP_JSON_TEMPLATE extern 11 | // #endif 12 | #define OOS_JSON_API 13 | #pragma warning(disable: 4251) 14 | #else 15 | #define OOS_JSON_API 16 | #endif 17 | 18 | #endif //MATADOR_JSON_EXPORT_HPP 19 | -------------------------------------------------------------------------------- /include/matador/http/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HTTP_EXPORT_HPP 2 | #define MATADOR_HTTP_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | // #ifdef matador_http_EXPORTS 6 | // #define OOS_HTTP_API __declspec(dllexport) 7 | // #define EXPIMP_HTTP_TEMPLATE 8 | // #else 9 | // #define OOS_HTTP_API __declspec(dllimport) 10 | // #define EXPIMP_HTTP_TEMPLATE extern 11 | // #endif 12 | #define OOS_HTTP_API 13 | #pragma warning(disable: 4251) 14 | #else 15 | #define OOS_HTTP_API 16 | #endif 17 | 18 | #endif //MATADOR_HTTP_EXPORT_HPP 19 | -------------------------------------------------------------------------------- /include/matador/utils/thread_helper.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_THREAD_HELPER_HPP 2 | #define MATADOR_THREAD_HELPER_HPP 3 | 4 | #include "matador/utils/export.hpp" 5 | 6 | #include 7 | 8 | namespace matador { 9 | 10 | /** 11 | * Returns the current unique number for the given 12 | * thread id. 13 | * 14 | * @param id Thread id for which a unique is acquired. 15 | * @return The thread number. 16 | */ 17 | OOS_UTILS_API std::size_t acquire_thread_index(std::thread::id id); 18 | 19 | } 20 | 21 | #endif //MATADOR_THREAD_HELPER_HPP 22 | -------------------------------------------------------------------------------- /test/http/HttpTestServer.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HTTPTESTSERVER_HPP 2 | #define MATADOR_HTTPTESTSERVER_HPP 3 | 4 | #include "matador/net/os.hpp" 5 | 6 | #include 7 | 8 | class HttpTestServer 9 | { 10 | public: 11 | explicit HttpTestServer(unsigned short port); 12 | 13 | void run(); 14 | 15 | bool is_running() const; 16 | void shutdown() const; 17 | 18 | private: 19 | unsigned short port_{}; 20 | std::atomic_bool running_{false}; 21 | socket_type client_id_{}; 22 | }; 23 | 24 | 25 | #endif //MATADOR_HTTPTESTSERVER_HPP 26 | -------------------------------------------------------------------------------- /examples/demo/models/credential.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_CREDENTIAL_HPP 2 | #define MATADOR_CREDENTIAL_HPP 3 | 4 | #include "matador/utils/access.hpp" 5 | 6 | #include 7 | 8 | struct credential 9 | { 10 | std::string username {}; 11 | std::string password {}; 12 | 13 | template < class Operator > 14 | void process(Operator &op) 15 | { 16 | matador::access::attribute(op, "username", username, 255); 17 | matador::access::attribute(op, "password", password, 255); 18 | } 19 | }; 20 | 21 | #endif //MATADOR_CREDENTIAL_HPP 22 | -------------------------------------------------------------------------------- /test/http/TemplateEngineTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_TEMPLATEENGINETEST_HPP 2 | #define MATADOR_TEMPLATEENGINETEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class TemplateEngineTest : public matador::unit_test 7 | { 8 | public: 9 | TemplateEngineTest(); 10 | 11 | void test_replace_var(); 12 | void test_foreach(); 13 | void test_foreach_nested(); 14 | void test_foreach_empty(); 15 | void test_if_else(); 16 | void test_include(); 17 | void test_filter(); 18 | }; 19 | 20 | 21 | #endif //MATADOR_TEMPLATEENGINETEST_HPP 22 | -------------------------------------------------------------------------------- /test/logger/file.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_FILEHELPER_HPP 2 | #define MATADOR_FILEHELPER_HPP 3 | 4 | #include 5 | 6 | #ifdef _MSC_VER 7 | #include 8 | #else 9 | #include 10 | #endif 11 | 12 | namespace filehelper { 13 | 14 | class std_stream_switcher 15 | { 16 | public: 17 | explicit std_stream_switcher(FILE *str, const char* redirect); 18 | ~std_stream_switcher(); 19 | 20 | private: 21 | FILE *stream = nullptr; 22 | int fd = 0; 23 | fpos_t pos = {}; 24 | }; 25 | 26 | } 27 | 28 | #endif //MATADOR_FILEHELPER_HPP 29 | -------------------------------------------------------------------------------- /test/utils/DependencyInjectionTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_DEPENDENCYINJECTIONTEST_HPP 2 | #define MATADOR_DEPENDENCYINJECTIONTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class DependencyInjectionTest : public matador::unit_test 7 | { 8 | public: 9 | DependencyInjectionTest(); 10 | 11 | void test_basic(); 12 | void test_named(); 13 | void test_transient(); 14 | void test_singleton(); 15 | void test_instance(); 16 | void test_singleton_per_thread(); 17 | }; 18 | 19 | 20 | #endif //MATADOR_DEPENDENCYINJECTIONTEST_HPP 21 | -------------------------------------------------------------------------------- /include/matador/sql/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_SQL_EXPORT_HPP 2 | #define MATADOR_SQL_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | #ifdef matador_sql_EXPORTS 6 | #define OOS_SQL_API __declspec(dllexport) 7 | #define EXPIMP_SQL_TEMPLATE 8 | #else 9 | #define OOS_SQL_API __declspec(dllimport) 10 | #define EXPIMP_SQL_TEMPLATE extern 11 | #endif 12 | // #define OOS_SQL_API 13 | #pragma warning(disable: 4251) 14 | #pragma warning(disable: 4355) 15 | #else 16 | #define OOS_SQL_API 17 | #endif 18 | 19 | #endif //MATADOR_SQL_EXPORT_HPP 20 | -------------------------------------------------------------------------------- /include/matador/logger/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_LOGGER_EXPORT_HPP 2 | #define MATADOR_LOGGER_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | //#ifdef matador_logger_EXPORTS 6 | // #define OOS_LOGGER_API __declspec(dllexport) 7 | // #define EXPIMP_LOGGER_TEMPLATE 8 | // #else 9 | // #define OOS_LOGGER_API __declspec(dllimport) 10 | // #define EXPIMP_LOGGER_TEMPLATE extern 11 | // #endif 12 | #define OOS_LOGGER_API 13 | #pragma warning(disable: 4251) 14 | #else 15 | #define OOS_LOGGER_API 16 | #endif 17 | 18 | #endif //MATADOR_LOGGER_EXPORT_HPP 19 | -------------------------------------------------------------------------------- /include/matador/db/postgresql/postgresql_exception.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 24.05.19. 3 | // 4 | 5 | #ifndef MATADOR_POSTGRESQL_EXCEPTION_HPP 6 | #define MATADOR_POSTGRESQL_EXCEPTION_HPP 7 | 8 | #include 9 | #include 10 | 11 | #include "matador/sql/sql_exception.hpp" 12 | 13 | namespace matador { 14 | 15 | namespace postgresql { 16 | 17 | void throw_database_error(PGresult *res, PGconn *db, const std::string &source, const std::string &sql = ""); 18 | 19 | } 20 | 21 | } 22 | 23 | #endif //MATADOR_POSTGRESQL_EXCEPTION_HPP 24 | -------------------------------------------------------------------------------- /include/matador/object/object_proxy_accessor.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_OBJECT_PROXY_ACCESSOR_HPP 2 | #define OOS_OBJECT_PROXY_ACCESSOR_HPP 3 | 4 | #include "matador/object/export.hpp" 5 | 6 | namespace matador { 7 | 8 | class object_proxy; 9 | class object_holder; 10 | 11 | namespace detail { 12 | 13 | /// @cond MATADOR_DEV 14 | 15 | class MATADOR_OBJECT_API object_proxy_accessor 16 | { 17 | public: 18 | matador::object_proxy* proxy(const object_holder &holder) const; 19 | }; 20 | 21 | /// @endcond 22 | 23 | } 24 | } 25 | #endif //OOS_OBJECT_PROXY_ACCESSOR_HPP 26 | -------------------------------------------------------------------------------- /src/net/io_service.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/net/io_service.hpp" 2 | 3 | #include "matador/logger/log_manager.hpp" 4 | 5 | namespace matador { 6 | 7 | io_service::io_service() 8 | : log_(matador::create_logger("IOService")) 9 | {} 10 | 11 | io_service::~io_service() 12 | { 13 | reactor_.shutdown(); 14 | } 15 | 16 | void io_service::run() 17 | { 18 | reactor_.run(); 19 | } 20 | 21 | bool io_service::is_running() const 22 | { 23 | return reactor_.is_running(); 24 | } 25 | 26 | void io_service::shutdown() 27 | { 28 | reactor_.shutdown(); 29 | } 30 | 31 | } -------------------------------------------------------------------------------- /include/matador/utils/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_UTILS_EXPORT_HPP 2 | #define MATADOR_UTILS_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | #define OOS_UTILS_API 6 | // #ifdef matador_utils_EXPORTS 7 | // #define OOS_UTILS_API __declspec(dllexport) 8 | // #define EXPIMP_UTILS_TEMPLATE 9 | // #else 10 | // #define OOS_UTILS_API __declspec(dllimport) 11 | // #define EXPIMP_UTILS_TEMPLATE extern 12 | // #endif 13 | #define OOS_UTILS_API 14 | #pragma warning(disable: 4251) 15 | #else 16 | #define OOS_UTILS_API 17 | #endif 18 | 19 | #endif //MATADOR_UTILS_EXPORT_HPP -------------------------------------------------------------------------------- /test/net/ReactorTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_REACTORTEST_HPP 2 | #define MATADOR_REACTORTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | #include 7 | 8 | class ReactorTest : public matador::unit_test 9 | { 10 | public: 11 | ReactorTest(); 12 | 13 | void test_event_types(); 14 | void test_fdset(); 15 | void test_handler(); 16 | void test_connector(); 17 | void test_shutdown(); 18 | void test_reactor_acceptor(); 19 | void test_reactor_connector(); 20 | void test_timeout(); 21 | }; 22 | 23 | 24 | #endif //MATADOR_REACTORTEST_HPP 25 | -------------------------------------------------------------------------------- /test/sql/TestDialect.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 2/26/16. 3 | // 4 | 5 | #ifndef OOS_TESTDIALECT_HPP 6 | #define OOS_TESTDIALECT_HPP 7 | 8 | 9 | #include "matador/sql/types.hpp" 10 | #include "matador/sql/basic_dialect.hpp" 11 | 12 | class TestDialect : public matador::basic_dialect 13 | { 14 | public: 15 | 16 | TestDialect(); 17 | 18 | const char* to_database_type_string(matador::data_type type) const override; 19 | 20 | matador::dialect_traits::identifier identifier_escape_type() const override; 21 | }; 22 | 23 | #endif //OOS_TESTDIALECT_HPP 24 | -------------------------------------------------------------------------------- /examples/demo/templates/menu.matador: -------------------------------------------------------------------------------- 1 |
2 | DEMO 3 | 14 |
-------------------------------------------------------------------------------- /test/http/ResponseParserTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_RESPONSEPARSERTEST_HPP 2 | #define MATADOR_RESPONSEPARSERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class ResponseParserTest : public matador::unit_test 7 | { 8 | public: 9 | ResponseParserTest(); 10 | 11 | void test_empty_response(); 12 | void test_body_response(); 13 | void test_from_file_response(); 14 | void test_partial_response_header(); 15 | void test_partial_response_body(); 16 | void test_partial_response_body_2(); 17 | }; 18 | 19 | 20 | #endif //MATADOR_RESPONSEPARSERTEST_HPP 21 | -------------------------------------------------------------------------------- /test/http/RouteEndpointTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ROUTEENDPOINTTEST_HPP 2 | #define MATADOR_ROUTEENDPOINTTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class RouteEndpointTest : public matador::unit_test 7 | { 8 | public: 9 | RouteEndpointTest(); 10 | 11 | void test_route_endpoint(); 12 | 13 | private: 14 | void check_route( 15 | const std::string &route_spec, 16 | const std::string &expected_regex_result, const std::string &valid_route, 17 | size_t num_path_params 18 | ); 19 | }; 20 | 21 | 22 | #endif //MATADOR_ROUTEENDPOINTTEST_HPP 23 | -------------------------------------------------------------------------------- /sandbox/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | SET (SANDBOX_SOURCES sandbox.cpp) 2 | 3 | ADD_EXECUTABLE(sandbox ${SANDBOX_SOURCES}) 4 | ADD_EXECUTABLE(datetime datetime.cpp) 5 | 6 | TARGET_LINK_LIBRARIES(sandbox 7 | matador-unit 8 | matador-utils 9 | matador-json 10 | matador-logger 11 | matador-object 12 | matador-http 13 | matador-net 14 | matador-sql 15 | matador-orm 16 | ${CMAKE_DL_LIBS} 17 | ${MATADOR_DB_LIBRARIES} 18 | ${NET_LIBRARIES} 19 | ${CMAKE_THREAD_LIBS_INIT} 20 | ) 21 | 22 | TARGET_LINK_LIBRARIES(datetime 23 | matador-utils 24 | ) 25 | -------------------------------------------------------------------------------- /test/utils/TimeTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef TIMETESTUNIT_HPP 2 | #define TIMETESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class TimeTestUnit : public matador::unit_test 7 | { 8 | public: 9 | TimeTestUnit(); 10 | 11 | void test_create(); 12 | void test_initialize(); 13 | void test_invalid(); 14 | void test_copy(); 15 | void test_assign(); 16 | void test_compare(); 17 | void test_modify(); 18 | void test_parse(); 19 | void test_format(); 20 | void test_to_date(); 21 | void test_strftime(); 22 | }; 23 | 24 | #endif /* TIMETESTUNIT_HPP */ 25 | 26 | -------------------------------------------------------------------------------- /test/object/JsonObjectMapperTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JSONOBJECTMAPPERTEST_HPP 2 | #define MATADOR_JSONOBJECTMAPPERTEST_HPP 3 | 4 | 5 | #include "matador/unit/unit_test.hpp" 6 | 7 | class JsonObjectMapperTest : public matador::unit_test 8 | { 9 | public: 10 | JsonObjectMapperTest(); 11 | 12 | void test_simple(); 13 | void test_derived(); 14 | void test_has_many(); 15 | void test_has_many_builtin(); 16 | void test_array(); 17 | void test_to_json(); 18 | void test_to_string(); 19 | void test_to_ptr(); 20 | }; 21 | 22 | 23 | #endif //MATADOR_JSONOBJECTMAPPERTEST_HPP 24 | -------------------------------------------------------------------------------- /include/matador/sql/commands.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_COMMANDS_HPP 2 | #define OOS_COMMANDS_HPP 3 | 4 | namespace matador { 5 | 6 | /** 7 | * Enumeration of query command types 8 | */ 9 | enum struct t_query_command { 10 | UNKNOWN, /**< Unknown query command */ 11 | CREATE, /**< Create query command */ 12 | DROP, /**< Drop query command */ 13 | SELECT, /**< Select query command */ 14 | INSERT, /**< Insert query command */ 15 | UPDATE, /**< Update query command */ 16 | REMOVE /**< Remove query command */ 17 | }; 18 | 19 | } 20 | 21 | #endif //OOS_COMMANDS_HPP 22 | -------------------------------------------------------------------------------- /include/matador/sql/statement_context.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_STATEMENT_CONTEXT_HPP 2 | #define MATADOR_STATEMENT_CONTEXT_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | namespace matador { 9 | namespace detail { 10 | 11 | /// @cond MATADOR_DEV 12 | 13 | struct statement_context 14 | { 15 | std::string sql; 16 | std::vector bind_vars; 17 | std::vector columns; 18 | std::string table_name; 19 | std::string command_name; 20 | }; 21 | 22 | /// @endcond 23 | 24 | } 25 | } 26 | 27 | #endif //MATADOR_STATEMENT_CONTEXT_HPP 28 | -------------------------------------------------------------------------------- /include/matador/db/mssql/mssql_dialect_linker.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 19.08.16. 3 | // 4 | 5 | #ifndef OOS_MSSQL_DIALECT_LINKER_HPP 6 | #define OOS_MSSQL_DIALECT_LINKER_HPP 7 | 8 | #include "matador/sql/basic_dialect_linker.hpp" 9 | 10 | namespace matador { 11 | 12 | namespace mssql { 13 | 14 | class mssql_dialect_linker : public detail::basic_dialect_linker 15 | { 16 | public: 17 | ~mssql_dialect_linker() override = default; 18 | 19 | void visit(const matador::detail::top &top) override; 20 | 21 | }; 22 | 23 | } 24 | 25 | } 26 | 27 | #endif //OOS_MSSQL_DIALECT_LINKER_HPP 28 | -------------------------------------------------------------------------------- /examples/demo/pages/movie_page.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_MOVIE_PAGE_HPP 2 | #define MATADOR_MOVIE_PAGE_HPP 3 | 4 | #include "crud_page.hpp" 5 | 6 | #include "../models/movie.hpp" 7 | 8 | #include "matador/orm/persistence.hpp" 9 | 10 | #include "matador/http/response.hpp" 11 | 12 | #include "matador/logger/logger.hpp" 13 | 14 | class movie_page : public crud_page 15 | { 16 | public: 17 | movie_page(matador::http::server &s, matador::persistence &p); 18 | 19 | protected: 20 | void prepare_json_form_data(matador::json &data) override; 21 | }; 22 | 23 | 24 | #endif //MATADOR_MOVIE_PAGE_HPP 25 | -------------------------------------------------------------------------------- /src/db/postgresql/postgresql_exception.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/database_error.hpp" 2 | 3 | #include "matador/db/postgresql/postgresql_exception.hpp" 4 | 5 | namespace matador { 6 | 7 | namespace postgresql { 8 | 9 | void throw_database_error(PGresult *res, PGconn *db, const std::string &source, const std::string &sql) 10 | { 11 | if (res == nullptr || 12 | (PQresultStatus(res) != PGRES_COMMAND_OK && 13 | PQresultStatus(res) != PGRES_TUPLES_OK)) { 14 | throw database_error(PQerrorMessage(db), source, PQresultErrorField(res, PG_DIAG_SQLSTATE), sql); 15 | } 16 | } 17 | 18 | } 19 | } -------------------------------------------------------------------------------- /examples/net/echo_client.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ECHO_CLIENT_HPP 2 | #define MATADOR_ECHO_CLIENT_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class echo_client 10 | { 11 | public: 12 | explicit echo_client(std::string port); 13 | 14 | void run(); 15 | 16 | private: 17 | void prepare_connect(); 18 | private: 19 | matador::io_service service_; 20 | std::shared_ptr connector_; 21 | std::string port_; 22 | }; 23 | 24 | 25 | #endif //MATADOR_ECHO_CLIENT_HPP 26 | -------------------------------------------------------------------------------- /include/matador/db/sqlite/sqlite_dialect.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_SQLITE_DIALECT_HPP 2 | #define OOS_SQLITE_DIALECT_HPP 3 | 4 | #include "matador/sql/basic_dialect.hpp" 5 | 6 | namespace matador { 7 | namespace sqlite { 8 | 9 | class sqlite_dialect : public basic_dialect 10 | { 11 | public: 12 | sqlite_dialect(); 13 | 14 | const char* to_database_type_string(matador::data_type type) const override; 15 | database_type string_type(const char *type) const; 16 | 17 | dialect_traits::identifier identifier_escape_type() const override; 18 | }; 19 | 20 | } 21 | } 22 | 23 | #endif //OOS_SQLITE_DIALECT_HPP 24 | -------------------------------------------------------------------------------- /src/object/basic_has_many_to_many_item.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "matador/object/basic_has_many_to_many_item.hpp" 4 | 5 | namespace matador { 6 | 7 | basic_has_many_to_many_item::basic_has_many_to_many_item(std::string left_column, std::string right_column) 8 | : left_column_(std::move(left_column)) 9 | , right_column_(std::move(right_column)) 10 | {} 11 | 12 | std::string basic_has_many_to_many_item::left_column() const 13 | { 14 | return left_column_; 15 | } 16 | 17 | std::string basic_has_many_to_many_item::right_column() const 18 | { 19 | return right_column_; 20 | } 21 | 22 | } -------------------------------------------------------------------------------- /src/utils/field_attributes.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/field_attributes.hpp" 2 | 3 | namespace matador { 4 | 5 | field_attributes::field_attributes(size_t size) 6 | : size_(size) 7 | {} 8 | 9 | field_attributes::field_attributes(constraints options) 10 | : options_(options) 11 | {} 12 | 13 | field_attributes::field_attributes(size_t size, constraints options) 14 | : size_(size) 15 | , options_(options) 16 | {} 17 | 18 | size_t field_attributes::size() const 19 | { 20 | return size_; 21 | } 22 | 23 | constraints field_attributes::options() const 24 | { 25 | return options_; 26 | } 27 | 28 | } -------------------------------------------------------------------------------- /test/utils/FileTestUnit.cpp: -------------------------------------------------------------------------------- 1 | #include "FileTestUnit.hpp" 2 | 3 | #include "matador/utils/file.hpp" 4 | #include "matador/utils/os.hpp" 5 | 6 | using namespace matador; 7 | 8 | FileTestUnit::FileTestUnit() 9 | : unit_test("file", "file test unit") 10 | { 11 | add_test("file", [this] { test_file(); }, "test file"); 12 | } 13 | 14 | void FileTestUnit::test_file() 15 | { 16 | file f("test.txt", "w"); 17 | 18 | UNIT_ASSERT_TRUE(matador::os::exists("test.txt")); 19 | 20 | f.close(); 21 | 22 | matador::os::remove("test.txt"); 23 | 24 | UNIT_ASSERT_FALSE(matador::os::exists("test.txt")); 25 | } 26 | -------------------------------------------------------------------------------- /include/matador/object/export.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_OBJECT_EXPORT_HPP 2 | #define MATADOR_OBJECT_EXPORT_HPP 3 | 4 | #ifdef _MSC_VER 5 | // #ifdef matador_object_EXPORTS 6 | // #define MATADOR_OBJECT_API __declspec(dllexport) 7 | // #define EXPIMP_OBJECT_TEMPLATE 8 | // #else 9 | // #define MATADOR_OBJECT_API __declspec(dllimport) 10 | // #define EXPIMP_OBJECT_TEMPLATE extern 11 | // #endif 12 | #define MATADOR_OBJECT_API 13 | #pragma warning(disable: 4251) 14 | #pragma warning(disable: 4275) 15 | #else 16 | #define MATADOR_OBJECT_API 17 | #endif 18 | 19 | #endif //MATADOR_OBJECT_EXPORT_HPP 20 | -------------------------------------------------------------------------------- /src/utils/constraints.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/contraints.hpp" 2 | 3 | namespace matador { 4 | 5 | //std::unordered_map constraints_to_name_map() { 6 | // std::unordered_map m { 7 | // { constraints::NONE, "none" }, 8 | // { constraints::NOT_NULL, "not null" }, 9 | // { constraints::INDEX, "index" }, 10 | // { constraints::UNIQUE, "unique" }, 11 | // { constraints::PRIMARY_KEY, "primary key" }, 12 | // { constraints::FOREIGN_KEY, "foreign key" }, 13 | // { constraints::DEFAULT, "default" } 14 | // }; 15 | // return m; 16 | //} 17 | 18 | } -------------------------------------------------------------------------------- /test/object/ObjectPrototypeTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OBJECT_PROTOTYPE_TESTUNIT_HPP 2 | #define OBJECT_PROTOTYPE_TESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class ObjectPrototypeTestUnit : public matador::unit_test 7 | { 8 | public: 9 | ObjectPrototypeTestUnit(); 10 | 11 | void empty_store(); 12 | void test_find(); 13 | void test_size(); 14 | void test_is_parent_of(); 15 | void test_decrement(); 16 | void one_prototype(); 17 | void prototype_hierachy(); 18 | void prototype_traverse(); 19 | void prototype_relation(); 20 | }; 21 | 22 | #endif /* OBJECT_PROTOTYPE_TESTUNIT_HPP */ 23 | -------------------------------------------------------------------------------- /test/utils/DateTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef DATETESTUNIT_HPP 2 | #define DATETESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class DateTestUnit : public matador::unit_test 7 | { 8 | public: 9 | DateTestUnit(); 10 | 11 | void test_create(); 12 | void test_parse(); 13 | void test_julian_date(); 14 | void test_initialize(); 15 | void test_invalid(); 16 | void test_copy(); 17 | void test_assign(); 18 | void test_compare(); 19 | void test_set(); 20 | void test_modify(); 21 | void test_difference(); 22 | void test_to_string(); 23 | }; 24 | 25 | #endif /* DATETESTUNIT_HPP */ 26 | 27 | -------------------------------------------------------------------------------- /test/sql/PostgreSQLDialectTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 04.06.19. 3 | // 4 | 5 | #ifndef MATADOR_POSTGRESQLDIALECTTESTUNIT_HPP 6 | #define MATADOR_POSTGRESQLDIALECTTESTUNIT_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class PostgreSQLDialectTestUnit : public matador::unit_test 12 | { 13 | public: 14 | PostgreSQLDialectTestUnit(); 15 | 16 | void test_placeholder(); 17 | void test_placeholder_condition(); 18 | void test_update_limit(); 19 | void test_update_limit_prepare(); 20 | void test_table_name(); 21 | }; 22 | 23 | 24 | #endif //MATADOR_POSTGRESQLDIALECTTESTUNIT_HPP 25 | -------------------------------------------------------------------------------- /examples/demo/pages/directors_page.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_DIRECTORS_PAGE_HPP 2 | #define MATADOR_DIRECTORS_PAGE_HPP 3 | 4 | #include "crud_page.hpp" 5 | 6 | #include "../models/person.hpp" 7 | 8 | #include "matador/orm/persistence.hpp" 9 | 10 | #include "matador/http/response.hpp" 11 | 12 | #include "matador/logger/logger.hpp" 13 | 14 | class directors_page : public crud_page 15 | { 16 | public: 17 | directors_page(matador::http::server &s, matador::persistence &p); 18 | 19 | protected: 20 | void prepare_json_form_data(matador::json &/*data*/) override {} 21 | }; 22 | 23 | 24 | #endif //MATADOR_DIRECTORS_PAGE_HPP 25 | -------------------------------------------------------------------------------- /include/matador/utils/html.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HTML_HPP 2 | #define MATADOR_HTML_HPP 3 | 4 | #include "matador/utils/export.hpp" 5 | 6 | #include 7 | 8 | namespace matador { 9 | 10 | /** 11 | * Html utils 12 | */ 13 | class OOS_UTILS_API html 14 | { 15 | private: 16 | html() = default; 17 | 18 | public: 19 | /** 20 | * Method html escapes a given string and 21 | * returns the result. 22 | * 23 | * @param value String to be html escaped 24 | * @return The html escaped string 25 | */ 26 | static std::string escape(const std::string &value); 27 | }; 28 | 29 | } 30 | #endif //MATADOR_HTML_HPP 31 | -------------------------------------------------------------------------------- /test/orm/OrmRelationTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_ORMRELATIONTESTUNIT_HPP 2 | #define OOS_ORMRELATIONTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class OrmRelationTestUnit : public matador::unit_test 7 | { 8 | public: 9 | OrmRelationTestUnit(const std::string &prefix, std::string dns); 10 | 11 | void test_has_many_varchars(); 12 | void test_has_many_ints(); 13 | void test_has_many_delete(); 14 | void test_belongs_to(); 15 | void test_many_to_many(); 16 | void test_save(); 17 | void test_save_object(); 18 | 19 | private: 20 | std::string dns_; 21 | }; 22 | 23 | #endif //OOS_ORMRELATIONTESTUNIT_HPP 24 | -------------------------------------------------------------------------------- /examples/demo/web/css/demo.css: -------------------------------------------------------------------------------- 1 | .button-success, 2 | .button-error, 3 | .button-warning, 4 | .button-secondary { 5 | color: white; 6 | border-radius: 4px; 7 | text-shadow: 0 1px 1px rgba(0, 0, 0, 0.2); 8 | } 9 | 10 | .button-success { 11 | background: rgb(28, 184, 65); 12 | /* this is a green */ 13 | } 14 | 15 | .button-error { 16 | background: rgb(202, 60, 60); 17 | /* this is a maroon */ 18 | } 19 | 20 | .button-warning { 21 | background: rgb(223, 117, 20); 22 | /* this is an orange */ 23 | } 24 | 25 | .button-secondary { 26 | background: rgb(66, 184, 221); 27 | /* this is a light blue */ 28 | } -------------------------------------------------------------------------------- /test/net/SocketInterrupterTest.cpp: -------------------------------------------------------------------------------- 1 | #include "SocketInterrupterTest.hpp" 2 | 3 | #include "matador/net/socket_interrupter.hpp" 4 | 5 | using namespace matador; 6 | 7 | SocketInterrupterTest::SocketInterrupterTest() 8 | : unit_test("socket_interrupter", "socket interrupter test") 9 | { 10 | add_test("interrupter", [this] { test_interrupter(); }, "socket interrupter test"); 11 | } 12 | 13 | void SocketInterrupterTest::test_interrupter() 14 | { 15 | socket_interrupter interrupter; 16 | 17 | UNIT_ASSERT_TRUE(interrupter.socket_id() > 0); 18 | 19 | interrupter.interrupt(); 20 | 21 | UNIT_ASSERT_TRUE(interrupter.reset()); 22 | } 23 | -------------------------------------------------------------------------------- /include/matador/db/mssql/mssql_dialect.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 3/9/16. 3 | // 4 | 5 | #ifndef OOS_MSSQL_DIALECT_HPP 6 | #define OOS_MSSQL_DIALECT_HPP 7 | 8 | #include "matador/sql/basic_dialect.hpp" 9 | 10 | namespace matador { 11 | namespace mssql { 12 | 13 | class mssql_dialect : public basic_dialect 14 | { 15 | public: 16 | mssql_dialect(); 17 | const char* to_database_type_string(matador::data_type type) const override; 18 | database_type string_type(const char *type) const; 19 | 20 | dialect_traits::identifier identifier_escape_type() const override; 21 | }; 22 | 23 | } 24 | } 25 | 26 | #endif //OOS_MSSQL_DIALECT_HPP 27 | -------------------------------------------------------------------------------- /test/object/HasManyUnitTest.cpp: -------------------------------------------------------------------------------- 1 | #include "HasManyUnitTest.hpp" 2 | #include "../entities.hpp" 3 | 4 | #include "matador/object/has_one_to_many_item.hpp" 5 | 6 | using namespace matador; 7 | 8 | HasManyUnitTest::HasManyUnitTest() 9 | : unit_test("container", "has many base unit tests") 10 | { 11 | add_test("one_to_many", [this] { test_one_to_many(); }, "test one to many item"); 12 | } 13 | 14 | using many_list_varchars = many_builtins; 15 | 16 | void HasManyUnitTest::test_one_to_many() 17 | { 18 | has_one_to_many_item_scalar item(255); 19 | 20 | UNIT_ASSERT_EQUAL("", item.right()); 21 | } 22 | -------------------------------------------------------------------------------- /src/db/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | IF (SQLITE3_FOUND) 2 | ADD_SUBDIRECTORY(sqlite) 3 | ELSE(SQLITE3_FOUND) 4 | MESSAGE(STATUS "Skip building SQLite3 backend") 5 | ENDIF(SQLITE3_FOUND) 6 | 7 | IF (MYSQL_FOUND) 8 | ADD_SUBDIRECTORY(mysql) 9 | ELSE(MYSQL_FOUND) 10 | MESSAGE(STATUS "Skip building MySQL backend") 11 | ENDIF(MYSQL_FOUND) 12 | 13 | IF (ODBC_FOUND) 14 | ADD_SUBDIRECTORY(mssql) 15 | ELSE(ODBC_FOUND) 16 | MESSAGE(STATUS "Skip building ODBC backend") 17 | ENDIF(ODBC_FOUND) 18 | 19 | IF (POSTGRESQL_FOUND) 20 | ADD_SUBDIRECTORY(postgresql) 21 | ELSE(POSTGRESQL_FOUND) 22 | MESSAGE(STATUS "Skip building PostgreSQL backend") 23 | ENDIF(POSTGRESQL_FOUND) 24 | -------------------------------------------------------------------------------- /include/matador/db/sqlite/sqlite_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef SQLITE_EXCEPTION_HPP 2 | #define SQLITE_EXCEPTION_HPP 3 | 4 | #ifdef _MSC_VER 5 | #ifdef matador_sqlite_EXPORTS 6 | #define OOS_SQLITE_API __declspec(dllexport) 7 | #else 8 | #define OOS_SQLITE_API __declspec(dllimport) 9 | #endif 10 | #pragma warning(disable: 4355) 11 | #else 12 | #define OOS_SQLITE_API 13 | #endif 14 | 15 | #include 16 | 17 | namespace matador { 18 | 19 | namespace sqlite { 20 | 21 | void throw_database_error(int ec, sqlite3 *db, const std::string &source, const std::string &sql = ""); 22 | 23 | } 24 | 25 | } 26 | 27 | #endif /* SQLITE_EXCEPTION_HPP */ 28 | -------------------------------------------------------------------------------- /test/object/PrototypeTreeTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef PROTOTYPE_TREE_TESTUNIT_HPP 2 | #define PROTOTYPE_TREE_TESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class PrototypeTreeTestUnit : public matador::unit_test 7 | { 8 | public: 9 | PrototypeTreeTestUnit(); 10 | 11 | void test_empty(); 12 | void test_insert(); 13 | void test_find(); 14 | void test_remove(); 15 | void test_erase(); 16 | void test_clear(); 17 | void test_has_many(); 18 | void test_decrement(); 19 | void test_count(); 20 | void test_child_of(); 21 | void test_traverse(); 22 | void test_const_traverse(); 23 | }; 24 | 25 | #endif /* PROTOTYPE_TREE_TESTUNIT_HPP */ 26 | -------------------------------------------------------------------------------- /test/json/JsonMapperTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_JSONMAPPERTESTUNIT_HPP 2 | #define MATADOR_JSONMAPPERTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class JsonMapperTestUnit : public matador::unit_test 7 | { 8 | public: 9 | JsonMapperTestUnit(); 10 | 11 | void test_fields(); 12 | void test_array_of_builtins(); 13 | void test_array_of_objects(); 14 | void test_nested_object(); 15 | void test_nested_array_of_object(); 16 | void test_complex(); 17 | void test_failure(); 18 | void test_false_types(); 19 | void test_special_chars(); 20 | void test_json_to_string(); 21 | }; 22 | 23 | 24 | #endif //MATADOR_JSONMAPPERTESTUNIT_HPP 25 | -------------------------------------------------------------------------------- /test/logger/file.cpp: -------------------------------------------------------------------------------- 1 | #include "file.hpp" 2 | 3 | #include "matador/utils/os.hpp" 4 | 5 | namespace filehelper { 6 | 7 | std_stream_switcher::std_stream_switcher(FILE *str, const char *redirect) 8 | : stream(str) 9 | { 10 | fflush(stream); 11 | fgetpos(stream, &pos); 12 | fd = matador::os::dup(stream); 13 | matador::os::freopen(redirect, "w+", stream); 14 | } 15 | 16 | std_stream_switcher::~std_stream_switcher() 17 | { 18 | fflush(stream); 19 | #ifdef _MSC_VER 20 | _dup2(fd, _fileno(stream)); 21 | _close(fd); 22 | #else 23 | dup2(fd, fileno(stream)); 24 | close(fd); 25 | #endif 26 | clearerr(stream); 27 | fsetpos(stream, &pos); 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /test/orm/OrmTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_ORMTESTUNIT_HPP 2 | #define OOS_ORMTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class OrmTestUnit : public matador::unit_test 7 | { 8 | public: 9 | OrmTestUnit(const std::string &prefix, std::string dns); 10 | 11 | void test_demo(); 12 | void test_persistence(); 13 | void test_table(); 14 | void test_create(); 15 | void test_insert(); 16 | void test_select(); 17 | void test_update(); 18 | void test_delete(); 19 | void test_multiple_delete(); 20 | void test_save(); 21 | void test_flush(); 22 | 23 | private: 24 | std::string dns_; 25 | }; 26 | 27 | 28 | #endif //OOS_ORMTESTUNIT_HPP 29 | -------------------------------------------------------------------------------- /examples/demo/services/auth_service.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_AUTH_SERVICE_HPP 2 | #define MATADOR_AUTH_SERVICE_HPP 3 | 4 | #include "matador/http/response.hpp" 5 | 6 | #include "matador/logger/logger.hpp" 7 | 8 | namespace matador { 9 | namespace http { 10 | 11 | class server; 12 | class request; 13 | 14 | } 15 | } 16 | 17 | class auth_service 18 | { 19 | public: 20 | explicit auth_service(matador::http::server &s); 21 | 22 | matador::http::response login(const matador::http::request &req); 23 | matador::http::response logout(const matador::http::request &req); 24 | 25 | private: 26 | matador::logger log_; 27 | }; 28 | 29 | 30 | #endif //MATADOR_AUTH_SERVICE_HPP 31 | -------------------------------------------------------------------------------- /examples/http/main.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/logger/log_manager.hpp" 2 | 3 | #include "matador/http/http_server.hpp" 4 | #include "matador/http/response.hpp" 5 | 6 | using namespace matador; 7 | 8 | int main(int /*argc*/, char* /*argv*/[]) 9 | { 10 | matador::add_log_sink(matador::create_file_sink("log/server.log")); 11 | matador::add_log_sink(matador::create_stdout_sink()); 12 | 13 | http::server server(8081); 14 | server.add_routing_middleware(); 15 | 16 | server.on_get("/api/user", [](const http::request &) { 17 | return http::response::ok("hello world", http::mime_types::TYPE_TEXT_PLAIN); 18 | }); 19 | server.run(); 20 | 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /include/matador/version.hpp.in: -------------------------------------------------------------------------------- 1 | #ifndef APP_VERSION_HPP 2 | #define APP_VERSION_HPP 3 | 4 | // the configured options and settings for Tutorial 5 | #define VERSION_MAJOR @APP_MAJOR_VERSION@ 6 | #define VERSION_MINOR @APP_MINOR_VERSION@ 7 | #define PATCH_LEVEL @APP_PATCH_LEVEL@ 8 | 9 | #define STRINGIZE_(x) #x 10 | #define STRINGIZE(x) STRINGIZE_(x) 11 | 12 | namespace matador { 13 | namespace version { 14 | const char *str = STRINGIZE(VERSION_MAJOR) "." STRINGIZE(VERSION_MINOR) "." STRINGIZE(PATCH_LEVEL); 15 | int major = VERSION_MAJOR; 16 | int minor = VERSION_MINOR; 17 | int patch_level = PATCH_LEVEL; 18 | } 19 | } 20 | 21 | #endif /* APP_VERSION_HPP */ 22 | -------------------------------------------------------------------------------- /test/object/HasManyListUnitTest.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 1/19/16. 3 | // 4 | 5 | #ifndef OOS_HASMANYLISTUNITTEST_HPP 6 | #define OOS_HASMANYLISTUNITTEST_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class HasManyListUnitTest : public matador::unit_test 12 | { 13 | public: 14 | HasManyListUnitTest(); 15 | 16 | void test_join_table(); 17 | void test_const_iterator(); 18 | void test_erase_scalar(); 19 | void test_erase_object(); 20 | void test_remove_scalar(); 21 | void test_remove_object(); 22 | void test_integer(); 23 | void test_string(); 24 | void test_varchar(); 25 | }; 26 | 27 | 28 | #endif //OOS_HASMANYLISTUNITTEST_HPP 29 | -------------------------------------------------------------------------------- /include/matador/db/mysql/mysql_dialect.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 3/8/16. 3 | // 4 | 5 | #ifndef OOS_MYSQL_DIALECT_HPP 6 | #define OOS_MYSQL_DIALECT_HPP 7 | 8 | #include "matador/sql/column.hpp" 9 | #include "matador/sql/basic_dialect.hpp" 10 | 11 | namespace matador { 12 | namespace mysql { 13 | 14 | class mysql_dialect : public basic_dialect 15 | { 16 | public: 17 | mysql_dialect(); 18 | const char* to_database_type_string(matador::data_type type) const override; 19 | database_type string_type(const char *type) const; 20 | 21 | dialect_traits::identifier identifier_escape_type() const override; 22 | }; 23 | 24 | } 25 | } 26 | 27 | #endif //OOS_MYSQL_DIALECT_HPP 28 | -------------------------------------------------------------------------------- /include/matador/sql/query.md: -------------------------------------------------------------------------------- 1 | ```sql 2 | CREATE TABLE (,); 3 | ``` 4 | 5 | ```sql 6 | SELECT FROM
WHERE ORDER BY LIMIT ; 7 | 8 | SELECT TOP FROM
WHERE ORDER BY ; 9 | ``` 10 | 11 | ```sql 12 | UPDATE
SET WHERE ; 13 | ``` 14 | 15 | ```sql 16 | INSERT INTO
() VALUES (); 17 | ``` 18 | 19 | ```sql 20 | DELETE FROM
WHERE ; 21 | ``` 22 | 23 | kind of columns 24 | - name only (select, insert) 25 | - name + type (create) -> varchar, primary/foreign keys 26 | - name + value (update) 27 | -------------------------------------------------------------------------------- /test/orm/BlogUnitTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_BLOGUNITTEST_HPP 2 | #define MATADOR_BLOGUNITTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | #include 7 | 8 | class BlogUnitTest : public matador::unit_test 9 | { 10 | public: 11 | BlogUnitTest(const std::string& prefix, std::string dns); 12 | ~BlogUnitTest() override = default; 13 | 14 | void initialize() override; 15 | void finalize() override; 16 | 17 | void test_blog_single_post(); 18 | void test_blog_multiple_post(); 19 | 20 | private: 21 | std::string dns_; 22 | 23 | std::unique_ptr persistence_; 24 | }; 25 | 26 | 27 | #endif //MATADOR_BLOGUNITTEST_HPP 28 | -------------------------------------------------------------------------------- /test/sql/ConditionUnitTest.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 22.02.16. 3 | // 4 | 5 | #ifndef OOS_CONDITIONUNITTEST_HPP 6 | #define OOS_CONDITIONUNITTEST_HPP 7 | 8 | #include "matador/unit/unit_test.hpp" 9 | 10 | class ConditionUnitTest : public matador::unit_test 11 | { 12 | public: 13 | ConditionUnitTest(); 14 | 15 | void test_col_literal(); 16 | void test_logical_condition(); 17 | void test_and_condition(); 18 | void test_or_condition(); 19 | void test_not_condition(); 20 | void test_in_condition(); 21 | void test_in_query_condition(); 22 | void test_between_condition(); 23 | void test_like_condition(); 24 | }; 25 | 26 | 27 | #endif //OOS_CONDITIONUNITTEST_HPP 28 | -------------------------------------------------------------------------------- /test/http/RequestParserTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_REQUESTPARSERTEST_HPP 2 | #define MATADOR_REQUESTPARSERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class RequestParserTest : public matador::unit_test 7 | { 8 | public: 9 | RequestParserTest(); 10 | 11 | void test_reset_request_parser(); 12 | void test_common_get_request(); 13 | void test_common_get_query_request(); 14 | void test_short_get_request(); 15 | void test_query_post_request(); 16 | void test_post_form_data_request(); 17 | void test_xml_post_request(); 18 | void test_xml_post_partial_request(); 19 | void test_xml_post_partial_request_2(); 20 | }; 21 | 22 | 23 | #endif //MATADOR_REQUESTPARSERTEST_HPP 24 | -------------------------------------------------------------------------------- /test/logger/LoggerTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_LOGGERTEST_HPP 2 | #define MATADOR_LOGGERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class LoggerTest : public matador::unit_test 7 | { 8 | public: 9 | LoggerTest(); 10 | 11 | void test_log_level_range(); 12 | void test_file_sink(); 13 | void test_rotating_file_sink(); 14 | void test_logger(); 15 | void test_logging(); 16 | void test_stdout(); 17 | void test_stderr(); 18 | void test_log_level(); 19 | 20 | private: 21 | void validate_log_file_line(const std::string &filename, int line_index, const std::string &level, const std::string &src, const std::string &msg); 22 | }; 23 | 24 | 25 | #endif //MATADOR_LOGGERTEST_HPP 26 | -------------------------------------------------------------------------------- /test/net/IOEchoServer.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_IOECHOSERVER_HPP 2 | #define MATADOR_IOECHOSERVER_HPP 3 | 4 | #include "matador/net/io_service.hpp" 5 | 6 | #include 7 | 8 | class IOEchoServer 9 | { 10 | public: 11 | explicit IOEchoServer(unsigned short port); 12 | ~IOEchoServer(); 13 | 14 | void start(); 15 | void stop(); 16 | 17 | void accept(); 18 | void connect(); 19 | 20 | matador::io_service& service(); 21 | 22 | private: 23 | matador::io_service service_; 24 | std::shared_ptr acceptor_; 25 | std::shared_ptr connector_; 26 | std::thread service_thread_; 27 | unsigned short port_; 28 | }; 29 | 30 | 31 | #endif //MATADOR_IOECHOSERVER_HPP 32 | -------------------------------------------------------------------------------- /test/sql/ConnectionTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef SESSION_TEST_UNIT_HPP 2 | #define SESSION_TEST_UNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | namespace matador { 7 | class session; 8 | } 9 | 10 | class ConnectionTestUnit : public matador::unit_test 11 | { 12 | public: 13 | ConnectionTestUnit(const std::string &prefix, std::string dns); 14 | ~ConnectionTestUnit() override = default; 15 | 16 | void test_open_close(); 17 | void test_client_version(); 18 | void test_server_version(); 19 | void test_reopen(); 20 | void test_reconnect(); 21 | void test_connection_failed(); 22 | 23 | private: 24 | std::string dns_; 25 | std::string db_vendor_; 26 | }; 27 | 28 | #endif /* SESSION_TEST_UNIT_HPP */ -------------------------------------------------------------------------------- /test/orm/OrmReloadTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_ORMRELOADTESTUNIT_HPP 2 | #define OOS_ORMRELOADTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class OrmReloadTestUnit : public matador::unit_test 7 | { 8 | public: 9 | OrmReloadTestUnit(const std::string &prefix, std::string dns); 10 | 11 | void test_load(); 12 | void test_load_twice(); 13 | void test_load_has_one(); 14 | void test_load_has_many(); 15 | void test_load_has_many_to_many(); 16 | void test_load_has_many_to_many_remove(); 17 | void test_load_has_many_int(); 18 | void test_load_has_many_varchar(); 19 | void test_load_belongs_to_many(); 20 | 21 | private: 22 | std::string dns_; 23 | }; 24 | 25 | #endif // OOS_ORMRELOADTESTUNIT_HPP 26 | -------------------------------------------------------------------------------- /src/http/detail/template_command_factory.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/http/detail/template_command_factory.hpp" 2 | 3 | namespace matador { 4 | namespace http { 5 | namespace detail { 6 | 7 | template_command_factory::template_command_factory() 8 | { 9 | factory_.insert("for", new factory_type::default_producer()); 10 | factory_.insert("if", new factory_type::default_producer()); 11 | factory_.insert("include", new factory_type::default_producer()); 12 | } 13 | 14 | std::shared_ptr template_command_factory::produce(const std::string &key) const 15 | { 16 | auto value = factory_.create(key); 17 | return std::shared_ptr(value); 18 | } 19 | 20 | } 21 | } 22 | } -------------------------------------------------------------------------------- /test/object/ObjectTransactionTestUnit.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 3/9/16. 3 | // 4 | 5 | #ifndef OOS_OBJECTTRANSACTIONTESTUNIT_HPP 6 | #define OOS_OBJECTTRANSACTIONTESTUNIT_HPP 7 | 8 | 9 | #include "matador/unit/unit_test.hpp" 10 | 11 | class ObjectTransactionTestUnit : public matador::unit_test 12 | { 13 | 14 | public: 15 | ObjectTransactionTestUnit(); 16 | 17 | void test_insert(); 18 | void test_insert_rollback(); 19 | void test_update(); 20 | void test_update_rollback(); 21 | void test_delete(); 22 | void test_delete_rollback(); 23 | void test_nested(); 24 | void test_nested_rollback(); 25 | void test_foreign(); 26 | void test_foreign_rollback(); 27 | }; 28 | 29 | #endif //OOS_OBJECTTRANSACTIONTESTUNIT_HPP 30 | -------------------------------------------------------------------------------- /test/net/IOEchoServerConnection.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_IOECHOSERVERCONNECTION_HPP 2 | #define MATADOR_IOECHOSERVERCONNECTION_HPP 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | class IOEchoServerConnection : public std::enable_shared_from_this 11 | { 12 | public: 13 | IOEchoServerConnection(matador::io_stream &stream, matador::tcp::peer endpoint); 14 | 15 | void start(); 16 | void read(); 17 | void write(); 18 | 19 | private: 20 | std::array buf_ = {}; 21 | std::string echo_; 22 | matador::io_stream &stream_; 23 | matador::tcp::peer endpoint_; 24 | }; 25 | 26 | 27 | #endif //MATADOR_IOECHOSERVERCONNECTION_HPP 28 | -------------------------------------------------------------------------------- /test/utils/BlobTestUnit.cpp: -------------------------------------------------------------------------------- 1 | #include "BlobTestUnit.hpp" 2 | 3 | #include "matador/utils/blob.hpp" 4 | 5 | #include 6 | 7 | using namespace matador; 8 | 9 | BlobTestUnit::BlobTestUnit() 10 | : unit_test("blob", "blob test unit") 11 | { 12 | add_test("create", std::bind(&BlobTestUnit::test_create, this), "create blob"); 13 | } 14 | 15 | void BlobTestUnit::test_create() 16 | { 17 | blob b1; 18 | 19 | int val = 8; 20 | b1.append(val); 21 | b1.append(val); 22 | 23 | UNIT_ASSERT_EQUAL(b1.size(), 8UL); 24 | 25 | blob b2; 26 | 27 | b2.append(val); 28 | b2.append(val); 29 | 30 | UNIT_ASSERT_EQUAL(b2.size(), 8UL); 31 | 32 | const unsigned char *data = b1.data(); 33 | 34 | UNIT_ASSERT_TRUE(data != nullptr); 35 | } 36 | -------------------------------------------------------------------------------- /test/http/HttpServerTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HTTPSERVERTEST_HPP 2 | #define MATADOR_HTTPSERVERTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | namespace matador { 7 | namespace http { 8 | class request; 9 | class response; 10 | } 11 | } 12 | 13 | class HttpServerTest : public matador::unit_test 14 | { 15 | public: 16 | HttpServerTest(); 17 | 18 | void initialize() override; 19 | void finalize() override; 20 | 21 | void test_shutdown(); 22 | void test_get(); 23 | void test_post(); 24 | void test_put(); 25 | void test_delete(); 26 | 27 | private: 28 | void send_request(unsigned int port, const matador::http::request &request, matador::http::response &response); 29 | }; 30 | 31 | 32 | #endif //MATADOR_HTTPSERVERTEST_HPP 33 | -------------------------------------------------------------------------------- /include/matador/utils/strptime.hpp: -------------------------------------------------------------------------------- 1 | #ifndef STRPTIME_HPP 2 | #define STRPTIME_HPP 3 | 4 | #include 5 | 6 | namespace matador { 7 | namespace detail { 8 | /** 9 | * @brief Convert a string representation of time to a time tm structure 10 | * 11 | * @note We do not implement alternate representations. However, we always 12 | * check whether a given modifier is allowed for a certain conversion. 13 | * 14 | * @param buf The string buffer with the time representation 15 | * @param fmt The time format string 16 | * @param tm The tm struct to fill 17 | * @return Pointer to the first character not processed 18 | */ 19 | char* strptime(const char *buf, const char *fmt, struct tm *tm); 20 | } 21 | } 22 | #endif /* STRPTIME_HPP */ 23 | -------------------------------------------------------------------------------- /examples/demo/models/person.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_PERSON_HPP 2 | #define MATADOR_PERSON_HPP 3 | 4 | #include "matador/utils/access.hpp" 5 | #include "matador/utils/date.hpp" 6 | 7 | #include 8 | 9 | struct person 10 | { 11 | unsigned long id; 12 | std::string name; 13 | matador::date birthday; 14 | 15 | person() = default; 16 | person(std::string n, matador::date bd) 17 | : name(std::move(n)), birthday(std::move(bd)) 18 | {} 19 | 20 | template < class Operator > 21 | void process(Operator &op) 22 | { 23 | matador::access::primary_key(op, "id", id); 24 | matador::access::attribute(op, "name", name, 255); 25 | matador::access::attribute(op, "birthday", birthday); 26 | } 27 | }; 28 | 29 | 30 | #endif //MATADOR_PERSON_HPP 31 | -------------------------------------------------------------------------------- /include/matador/db/postgresql/postgresql_dialect.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 24.05.19. 3 | // 4 | 5 | #ifndef MATADOR_POSTGRESQL_DIALECT_HPP 6 | #define MATADOR_POSTGRESQL_DIALECT_HPP 7 | 8 | #include 9 | 10 | namespace matador { 11 | namespace postgresql { 12 | 13 | class postgresql_dialect : public basic_dialect 14 | { 15 | public: 16 | postgresql_dialect(); 17 | 18 | const char *to_database_type_string(matador::data_type type) const override; 19 | 20 | database_type string_type(const char *type) const; 21 | 22 | dialect_traits::identifier identifier_escape_type() const override; 23 | 24 | std::string next_placeholder() const override; 25 | }; 26 | 27 | } 28 | } 29 | 30 | #endif //MATADOR_POSTGRESQL_DIALECT_HPP 31 | -------------------------------------------------------------------------------- /src/utils/string_cursor.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/string_cursor.hpp" 2 | #include "matador/utils/string.hpp" 3 | 4 | #include 5 | 6 | namespace matador { 7 | 8 | string_cursor::string_cursor(const char *str) 9 | : cursor_(str) 10 | {} 11 | 12 | string_cursor &string_cursor::operator=(const char *str) 13 | { 14 | cursor_ = str; 15 | return *this; 16 | } 17 | 18 | char string_cursor::skip_whitespace() 19 | { 20 | cursor_ = skip_ws(cursor_); 21 | return cursor_[0]; 22 | } 23 | 24 | char string_cursor::next_char() 25 | { 26 | if (is_null()) { 27 | throw std::logic_error("no current string"); 28 | } 29 | return (++cursor_)[0]; 30 | } 31 | 32 | char string_cursor::current_char() const 33 | { 34 | return cursor_[0]; 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /examples/demo/pages/main_page.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_MAIN_PAGE_HPP 2 | #define MATADOR_MAIN_PAGE_HPP 3 | 4 | #include "matador/http/response.hpp" 5 | 6 | #include "matador/logger/logger.hpp" 7 | 8 | namespace matador { 9 | class persistence; 10 | namespace http { 11 | namespace detail { 12 | class template_part; 13 | } 14 | class server; 15 | class request; 16 | } 17 | } 18 | 19 | class main_page 20 | { 21 | public: 22 | main_page(matador::http::server &s, matador::persistence &p); 23 | 24 | matador::http::response view(const matador::http::request &p); 25 | 26 | private: 27 | matador::logger log_; 28 | 29 | matador::persistence& persistence_; 30 | 31 | std::shared_ptr index_template_; 32 | }; 33 | 34 | 35 | #endif //MATADOR_MAIN_PAGE_HPP 36 | -------------------------------------------------------------------------------- /src/sql/sql_logger.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/sql_logger.hpp" 2 | 3 | #include "matador/utils/os.hpp" 4 | 5 | #include "matador/logger/log_manager.hpp" 6 | 7 | namespace matador { 8 | 9 | sql_logger::sql_logger() 10 | : sql_logger(1000000, 5) 11 | {} 12 | 13 | sql_logger::sql_logger(size_t /*max_size*/, size_t /*file_count*/) 14 | : LOG(create_logger("SQL")) 15 | { 16 | // auto path = matador::os::build_path("log", "sql.log"); 17 | // add_log_sink(create_rotating_file_sink(path, max_size, file_count)); 18 | // add_log_sink(create_stdout_sink()); 19 | } 20 | 21 | void sql_logger::on_execute(const std::string &stmt) 22 | { 23 | LOG.info("execute: " + stmt); 24 | } 25 | 26 | void sql_logger::on_prepare(const std::string &stmt) 27 | { 28 | LOG.info("prepare: " + stmt); 29 | } 30 | } -------------------------------------------------------------------------------- /examples/http/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | SET(NET_LIBRARIES) 2 | 3 | SET (HTTP_SERVER_SOURCES 4 | main.cpp) 5 | 6 | ADD_EXECUTABLE(http_server ${HTTP_SERVER_SOURCES}) 7 | 8 | TARGET_LINK_LIBRARIES(http_server 9 | matador-unit 10 | matador-utils 11 | matador-json 12 | matador-logger 13 | matador-http 14 | matador-net 15 | ${CMAKE_DL_LIBS} 16 | ${CMAKE_THREAD_LIBS_INIT} 17 | ${NET_LIBRARIES} 18 | ) 19 | 20 | SET (HTML_BUILDER_SOURCES 21 | html_builder_main.cpp) 22 | 23 | ADD_EXECUTABLE(html_builder_server ${HTML_BUILDER_SOURCES}) 24 | 25 | TARGET_LINK_LIBRARIES(html_builder_server 26 | matador-unit 27 | matador-utils 28 | matador-json 29 | matador-logger 30 | matador-http 31 | matador-net 32 | ${CMAKE_DL_LIBS} 33 | ${CMAKE_THREAD_LIBS_INIT} 34 | ${NET_LIBRARIES} 35 | ) 36 | -------------------------------------------------------------------------------- /examples/demo/models/user.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_USER_HPP 2 | #define MATADOR_USER_HPP 3 | 4 | #include "matador/utils/access.hpp" 5 | 6 | #include 7 | 8 | struct user 9 | { 10 | unsigned long id {}; 11 | std::string username {}; 12 | std::string password {}; 13 | std::string first_name {}; 14 | std::string last_name {}; 15 | 16 | template < class Operator > 17 | void process(Operator &op) 18 | { 19 | matador::access::primary_key(op, "id", id); 20 | matador::access::attribute(op, "username", username, 255); 21 | matador::access::attribute(op, "password", password, 255); 22 | matador::access::attribute(op, "first_name", first_name, 255); 23 | matador::access::attribute(op, "last_name", last_name, 255); 24 | } 25 | }; 26 | 27 | 28 | #endif //MATADOR_USER_HPP 29 | -------------------------------------------------------------------------------- /src/http/detail/template_filter_factory.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/http/detail/template_filter_factory.hpp" 2 | 3 | namespace matador { 4 | namespace http { 5 | namespace detail { 6 | 7 | template_filter_factory::template_filter_factory() 8 | { 9 | factory_.insert("escape", new factory_type::default_producer()); 10 | factory_.insert("capfirst", new factory_type::default_producer()); 11 | factory_.insert("upper", new factory_type::default_producer()); 12 | factory_.insert("lower", new factory_type::default_producer()); 13 | } 14 | 15 | std::shared_ptr template_filter_factory::produce(const std::string &key) const 16 | { 17 | auto value = factory_.create(key); 18 | return std::shared_ptr(value); 19 | } 20 | 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /test/orm/TransactionTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef TRANSACTION_TEST_UNIT_HPP 2 | #define TRANSACTION_TEST_UNIT_HPP 3 | 4 | #include "matador/object/object_store.hpp" 5 | 6 | #include "matador/unit/unit_test.hpp" 7 | 8 | namespace matador { 9 | class session; 10 | } 11 | 12 | class TransactionTestUnit : public matador::unit_test 13 | { 14 | public: 15 | explicit TransactionTestUnit(const std::string &prefix, std::string dns = "memory"); 16 | ~TransactionTestUnit() override = default; 17 | 18 | void test_simple(); 19 | void test_nested(); 20 | void test_foreign(); 21 | void test_has_many_list_commit(); 22 | void test_has_many_list_rollback(); 23 | void test_has_many_list(); 24 | void test_has_many_vector(); 25 | 26 | private: 27 | std::string dns_; 28 | 29 | }; 30 | 31 | #endif /* TRANSACTION_TEST_UNIT_HPP */ 32 | -------------------------------------------------------------------------------- /examples/net/echo_client.cpp: -------------------------------------------------------------------------------- 1 | #include "echo_client.hpp" 2 | #include "echo_client_connection.hpp" 3 | 4 | using namespace matador; 5 | 6 | echo_client::echo_client(std::string port) 7 | : connector_(std::make_shared()) 8 | , port_(std::move(port)) 9 | { 10 | matador::add_log_sink(matador::create_file_sink("log/client.log")); 11 | //matador::add_log_sink(matador::create_stdout_sink()); 12 | 13 | prepare_connect(); 14 | } 15 | 16 | void echo_client::run() 17 | { 18 | service_.run(); 19 | } 20 | 21 | void echo_client::prepare_connect() 22 | { 23 | service_.connect(connector_, port_, [this](tcp::peer ep, io_stream &stream) { 24 | // create echo server connection 25 | auto conn = std::make_shared(stream, service_, std::move(ep)); 26 | conn->start(); 27 | }); 28 | } 29 | -------------------------------------------------------------------------------- /examples/net/echo_server_connection.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ECHO_SERVER_CONNECTION_HPP 2 | #define MATADOR_ECHO_SERVER_CONNECTION_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include 9 | #include 10 | 11 | class echo_server_connection : public std::enable_shared_from_this 12 | { 13 | public: 14 | echo_server_connection(matador::io_stream &stream, matador::tcp::peer endpoint); 15 | 16 | void start(); 17 | void read(); 18 | void write(); 19 | 20 | private: 21 | matador::logger log_; 22 | std::array buf_ = {}; 23 | std::string echo_; 24 | matador::io_stream &stream_; 25 | matador::tcp::peer endpoint_; 26 | }; 27 | 28 | 29 | #endif //MATADOR_ECHO_SERVER_CONNECTION_HPP 30 | -------------------------------------------------------------------------------- /include/matador/db/mysql/mysql_result_info.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MYSQL_RESULT_INFO_HPP 2 | #define MYSQL_RESULT_INFO_HPP 3 | 4 | #include "matador/db/mysql/mysql_bool.hpp" 5 | 6 | #ifdef _MSC_VER 7 | #include 8 | #else 9 | #include 10 | #endif 11 | 12 | #include 13 | 14 | namespace matador { 15 | 16 | namespace mysql { 17 | 18 | struct mysql_result_info 19 | { 20 | unsigned long length = 0; 21 | my_bool is_null = false; 22 | my_bool error = false; 23 | // std::unique_ptr buffer; 24 | char *buffer = nullptr; 25 | unsigned long buffer_length = 0; 26 | bool is_allocated = false; 27 | 28 | ~mysql_result_info() 29 | { 30 | if (is_allocated) { 31 | delete [] buffer; 32 | } 33 | } 34 | }; 35 | 36 | } 37 | 38 | } 39 | 40 | #endif // MYSQL_RESULT_INFO_HPP 41 | 42 | -------------------------------------------------------------------------------- /examples/demo/templates/director_create.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | {% include "../templates/header.matador" %} 4 | 5 |
6 |

{{title}}

7 |
8 |
9 |
10 |
11 | 12 | 13 |
14 |
15 | 16 | Cancel 17 |
18 |
19 | 20 | 21 | -------------------------------------------------------------------------------- /examples/net/echo_client_connection.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ECHO_CLIENT_CONNECTION_HPP 2 | #define MATADOR_ECHO_CLIENT_CONNECTION_HPP 3 | 4 | #include 5 | 6 | namespace matador { 7 | class io_stream; 8 | class io_service; 9 | } 10 | class echo_client_connection : public std::enable_shared_from_this 11 | { 12 | public: 13 | explicit echo_client_connection(matador::io_stream &stream, matador::io_service &service, matador::tcp::peer endpoint); 14 | 15 | void start(); 16 | 17 | void read(); 18 | 19 | void write(); 20 | 21 | private: 22 | matador::logger log_; 23 | std::array buf_ = {}; 24 | matador::io_stream &stream_; 25 | matador::io_service &service_; 26 | matador::tcp::peer endpoint_; 27 | std::string message_; 28 | }; 29 | 30 | 31 | #endif //MATADOR_ECHO_CLIENT_CONNECTION_HPP 32 | -------------------------------------------------------------------------------- /include/matador/db/mssql/mssql_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MSSQL_EXCEPTION_HPP 2 | #define MSSQL_EXCEPTION_HPP 3 | 4 | #ifdef _MSC_VER 5 | #ifdef matador_mssql_EXPORTS 6 | #define OOS_MSSQL_API __declspec(dllexport) 7 | #else 8 | #define OOS_MSSQL_API __declspec(dllimport) 9 | #endif 10 | #pragma warning(disable: 4355) 11 | #else 12 | #define OOS_MSSQL_API 13 | #endif 14 | 15 | #include "matador/sql/sql_exception.hpp" 16 | 17 | #if defined(_MSC_VER) 18 | #include 19 | #endif 20 | 21 | #include 22 | 23 | namespace matador { 24 | 25 | namespace mssql { 26 | 27 | void throw_database_error(SQLRETURN ret, SQLSMALLINT htype, SQLHANDLE hndl, const std::string &source, const std::string &sql = ""); 28 | 29 | bool is_success(SQLRETURN ret); 30 | 31 | } 32 | 33 | } 34 | 35 | #endif /* MSSQL_EXCEPTION_HPP */ 36 | -------------------------------------------------------------------------------- /src/utils/html.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/html.hpp" 2 | 3 | namespace matador { 4 | 5 | std::string html::escape(const std::string &value) 6 | { 7 | std::string result; 8 | result.reserve((size_t)((float)value.size() * 1.1)); 9 | for (size_t pos = 0; pos != value.size(); ++pos) { 10 | switch (value[pos]) { 11 | case '&': 12 | result.append("&"); 13 | break; 14 | case '\"': 15 | result.append("""); 16 | break; 17 | case '\'': 18 | result.append("'"); 19 | break; 20 | case '<': 21 | result.append("<"); 22 | break; 23 | case '>': 24 | result.append(">"); 25 | break; 26 | default: 27 | result.append(&value[pos], 1); 28 | break; 29 | } 30 | } 31 | return result; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /include/matador/json/json_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef REACTOR_JSON_EXCEPTION_HPP 2 | #define REACTOR_JSON_EXCEPTION_HPP 3 | 4 | #include 5 | #include 6 | 7 | namespace matador { 8 | 9 | /** 10 | * @brief Exception representing json errors 11 | * 12 | * The exception class represents all kind of 13 | * json errors occuring while parsing a json 14 | * string. 15 | */ 16 | class json_exception : public std::logic_error 17 | { 18 | public: 19 | /** 20 | * Creates a object_exception 21 | * 22 | * @param what The message of the exception. 23 | */ 24 | explicit json_exception(const char *what) 25 | : std::logic_error(what) 26 | {} 27 | 28 | /** 29 | * Destroys the json exception 30 | */ 31 | ~json_exception() noexcept override = default; 32 | }; 33 | 34 | } 35 | 36 | #endif //REACTOR_JSON_EXCEPTION_HPP 37 | -------------------------------------------------------------------------------- /include/matador/net/socket_interrupter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_SOCKET_INTERRUPTER_HPP 2 | #define MATADOR_SOCKET_INTERRUPTER_HPP 3 | 4 | #include "matador/net/export.hpp" 5 | #include "matador/net/ip.hpp" 6 | 7 | #include "matador/logger/logger.hpp" 8 | 9 | #include 10 | 11 | namespace matador { 12 | 13 | /// @cond MATADOR_DEV 14 | 15 | class OOS_NET_API socket_interrupter 16 | { 17 | public: 18 | socket_interrupter(); 19 | ~socket_interrupter(); 20 | 21 | socket_type socket_id() const; 22 | 23 | void interrupt(); 24 | bool reset(); 25 | 26 | private: 27 | matador::tcp::socket server_; 28 | matador::tcp::socket client_; 29 | 30 | matador::logger log_; 31 | 32 | std::array indicator_ = { { 0 } }; 33 | std::array consumer_ = {}; 34 | }; 35 | /// @endcond 36 | 37 | } 38 | 39 | #endif //MATADOR_SOCKET_INTERRUPTER_HPP 40 | -------------------------------------------------------------------------------- /src/logger/log_level.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/logger/log_level.hpp" 2 | 3 | #include 4 | 5 | namespace matador { 6 | 7 | std::ostream& operator<<(std::ostream &os, log_level lvl) 8 | { 9 | switch (lvl) { 10 | case log_level::LVL_ERROR: 11 | os << "ERROR"; 12 | break; 13 | case log_level::LVL_FATAL: 14 | os << "FATAL"; 15 | break; 16 | case log_level::LVL_DEBUG: 17 | os << "DEBUG"; 18 | break; 19 | case log_level::LVL_INFO: 20 | os << "INFO"; 21 | break; 22 | case log_level::LVL_TRACE: 23 | os << "TRACE"; 24 | break; 25 | case log_level::LVL_WARN: 26 | os << "WARN"; 27 | break; 28 | case log_level::LVL_ALL: 29 | os << "ALL"; 30 | break; 31 | default: 32 | os << "UNKNOWN"; 33 | break; 34 | } 35 | return os; 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /src/sql/row.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/row.hpp" 2 | 3 | namespace matador { 4 | 5 | bool row::add_column(const std::string &column) 6 | { 7 | return add_column(std::make_shared(column)); 8 | } 9 | 10 | bool row::add_column(const column_ptr &col) 11 | { 12 | if (has_column(col->name)) { 13 | return false; 14 | } 15 | 16 | columns_.push_back(col); 17 | return columns_by_name_.insert({col->name, col}).second; 18 | } 19 | 20 | bool row::has_column(const std::string &column) const 21 | { 22 | return columns_by_name_.find(column) != columns_by_name_.end(); 23 | } 24 | 25 | void row::set(const std::string &column, const std::shared_ptr &value) 26 | { 27 | columns_by_name_.at(column)->val.value_ = value->value_; 28 | } 29 | 30 | void row::clear() 31 | { 32 | columns_.clear(); 33 | columns_by_name_.clear(); 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /src/logger/logger.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/logger/logger.hpp" 2 | 3 | namespace matador { 4 | 5 | logger::logger(std::string source, std::shared_ptr log_domain) 6 | : source_(std::move(source)) 7 | , logger_domain_(std::move(log_domain)) 8 | {} 9 | 10 | logger::logger(logger&& l) noexcept 11 | : source_(std::move(l.source_)) 12 | , logger_domain_(std::move(l.logger_domain_)) 13 | {} 14 | 15 | logger& logger::operator=(logger&& l) noexcept { 16 | source_ = std::move(l.source_); 17 | logger_domain_ = std::move(l.logger_domain_); 18 | return *this; 19 | } 20 | 21 | const std::string& logger::source() const 22 | { 23 | return source_; 24 | } 25 | 26 | std::string logger::domain() const 27 | { 28 | return logger_domain_->name(); 29 | } 30 | 31 | void logger::log(log_level lvl, const char *what) 32 | { 33 | logger_domain_->log(lvl, source_, what); 34 | } 35 | } -------------------------------------------------------------------------------- /test/net/AddressResolverTest.cpp: -------------------------------------------------------------------------------- 1 | #include "AddressResolverTest.hpp" 2 | 3 | #include "matador/net/ip.hpp" 4 | 5 | AddressResolverTest::AddressResolverTest() 6 | : matador::unit_test("address_resolver", "ip address resolver test unit") 7 | { 8 | add_test("resolver_v4", [this] { test_resolver_v4(); }, "ip address resolver v4 test"); 9 | 10 | } 11 | 12 | void AddressResolverTest::test_resolver_v4() 13 | { 14 | 15 | matador::tcp::resolver resolver; 16 | 17 | auto peers = resolver.resolve(std::string("localhost"), std::string("80")); 18 | 19 | UNIT_ASSERT_FALSE(peers.empty()); 20 | UNIT_ASSERT_GREATER(peers.size(), 0UL); 21 | 22 | // for (const auto &p : peers) { 23 | // if (p.addr().is_v4()) { 24 | // UNIT_ASSERT_EQUAL("127.0.0.1:80", p.to_string()); 25 | // } else { 26 | // UNIT_ASSERT_EQUAL("::1:80", p.to_string()); 27 | // } 28 | // } 29 | } 30 | -------------------------------------------------------------------------------- /include/matador/db/mssql/mssql_dialect_compiler.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_MSSQL_DIALECT_COMPILER_HPP 2 | #define OOS_MSSQL_DIALECT_COMPILER_HPP 3 | 4 | #include 5 | 6 | #include "matador/sql/basic_dialect_compiler.hpp" 7 | 8 | namespace matador { 9 | 10 | namespace mssql { 11 | 12 | class mssql_dialect_compiler : public detail::basic_dialect_compiler 13 | { 14 | public: 15 | mssql_dialect_compiler() = default; 16 | 17 | void visit(const matador::detail::select &select1) override; 18 | void visit(const matador::detail::update &update1) override; 19 | void visit(const matador::detail::remove &remove1) override; 20 | void visit(const matador::detail::top &top1) override; 21 | 22 | protected: 23 | void on_compile_start() override; 24 | 25 | private: 26 | std::stack commands_; 27 | }; 28 | 29 | } 30 | } 31 | #endif //OOS_MSSQL_DIALECT_COMPILER_HPP 32 | -------------------------------------------------------------------------------- /include/matador/sql/query_value_creator.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_QUERY_VALUE_CREATOR_HPP 2 | #define OOS_QUERY_VALUE_CREATOR_HPP 3 | 4 | #include "matador/sql/value.hpp" 5 | 6 | #include "matador/utils/any.hpp" 7 | #include "matador/utils/any_visitor.hpp" 8 | 9 | #include 10 | 11 | namespace matador { 12 | namespace detail { 13 | 14 | /// @cond MATADOR_DEV 15 | 16 | class query_value_creator 17 | { 18 | public: 19 | query_value_creator(); 20 | 21 | std::shared_ptr create_from_any(any &a); 22 | 23 | private: 24 | template < class T > 25 | void process(T &val) 26 | { 27 | value_ = std::make_shared(val); 28 | } 29 | void process(char *val); 30 | void process(const char *val); 31 | 32 | private: 33 | any_visitor visitor_; 34 | std::shared_ptr value_; 35 | }; 36 | 37 | /// @endcond 38 | 39 | } 40 | } 41 | #endif //OOS_QUERY_VALUE_CREATOR_HPP 42 | -------------------------------------------------------------------------------- /include/matador/object/value_type_traits.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_VALUE_TYPE_TRAITS_HPP 2 | #define MATADOR_VALUE_TYPE_TRAITS_HPP 3 | 4 | #include "matador/utils/is_builtin.hpp" 5 | 6 | #include "matador/object/object_ptr.hpp" 7 | 8 | namespace matador { 9 | 10 | template < class Type, class Enable = void > 11 | struct value_type_traits; 12 | 13 | template < class Type > 14 | struct value_type_traits::value>::type> 15 | { 16 | using value_type = Type; 17 | using pointer = Type*; 18 | using reference = Type&; 19 | }; 20 | 21 | template < class Type > 22 | struct value_type_traits::value>::type> 23 | { 24 | using value_type = object_ptr; 25 | using pointer = object_ptr*; 26 | using reference = object_ptr&; 27 | }; 28 | 29 | } 30 | 31 | #endif //MATADOR_VALUE_TYPE_TRAITS_HPP 32 | -------------------------------------------------------------------------------- /src/sql/condition.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/condition.hpp" 2 | 3 | namespace matador { 4 | 5 | namespace detail { 6 | 7 | std::array 8 | basic_condition::operands = { {"=", "<>", "<", "<=", ">", ">=", "OR", "AND", "NOT", "IN", "LIKE"} }; 9 | 10 | } 11 | 12 | condition equals(const column &col, detail::basic_query &q) 13 | { 14 | return condition(col, detail::basic_condition::EQUAL, q); 15 | } 16 | 17 | condition in(const column &f, detail::basic_query &q) 18 | { 19 | return condition(f, detail::basic_condition::IN_LIST, q); 20 | } 21 | 22 | condition like(const matador::column &col, const std::string &val) 23 | { 24 | return condition(col, detail::basic_condition::LIKE, val); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /include/matador/object/type_traits.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_TYPE_TRAITS_HPP 2 | #define MATADOR_TYPE_TRAITS_HPP 3 | 4 | #include 5 | 6 | namespace matador { 7 | 8 | template < class Type > 9 | class object_ptr; 10 | 11 | template 12 | class varchar; 13 | 14 | template < typename Type > 15 | struct type_traits 16 | { 17 | using real_type = Type; 18 | using object_type = Type; 19 | using value_type = Type; 20 | }; 21 | 22 | template < class ObjectType > 23 | struct type_traits> 24 | { 25 | using real_type = ObjectType; 26 | using object_type = ObjectType; 27 | using value_type = object_ptr; 28 | }; 29 | 30 | template < long Size > 31 | struct type_traits> 32 | { 33 | using real_type = varchar; 34 | using object_type = std::string; 35 | using value_type = std::string; 36 | }; 37 | 38 | } 39 | #endif //MATADOR_TYPE_TRAITS_HPP 40 | -------------------------------------------------------------------------------- /src/net/error.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/net/error.hpp" 2 | #include "matador/utils/os.hpp" 3 | 4 | #include 5 | 6 | #ifdef _WIN32 7 | #include 8 | #else 9 | #include 10 | #endif 11 | 12 | namespace matador { 13 | namespace detail { 14 | 15 | void throw_logic_error(const char* msg) 16 | { 17 | throw std::logic_error(msg); 18 | } 19 | 20 | void throw_logic_error_with_errno(const char* msg, int err) 21 | { 22 | char error_buffer[1024]; 23 | os::strerror(err, error_buffer, 1024); 24 | 25 | char message_buffer[1024]; 26 | os::sprintf(message_buffer, 1024, msg, error_buffer); 27 | throw std::logic_error(message_buffer); 28 | } 29 | 30 | void throw_logic_error_with_gai_errno(const char* msg, int err) 31 | { 32 | char message_buffer[1024]; 33 | os::sprintf(message_buffer, 1024, msg, gai_strerror(err)); 34 | throw std::logic_error(message_buffer); 35 | } 36 | 37 | } 38 | } -------------------------------------------------------------------------------- /src/net/handler.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/net/handler.hpp" 2 | 3 | #include 4 | 5 | namespace matador { 6 | 7 | time_t handler::next_timeout() const 8 | { 9 | return next_timeout_; 10 | } 11 | 12 | time_t handler::interval() const 13 | { 14 | return interval_; 15 | } 16 | 17 | reactor *handler::get_reactor() const 18 | { 19 | return reactor_; 20 | } 21 | 22 | void handler::register_reactor(reactor *r) 23 | { 24 | reactor_ = r; 25 | } 26 | 27 | void handler::schedule(time_t offset, time_t interval) 28 | { 29 | next_timeout_ = ::time(nullptr) + offset; 30 | interval_ = interval; 31 | } 32 | 33 | void handler::cancel_timer() 34 | { 35 | next_timeout_ = 0; 36 | interval_ = 0; 37 | } 38 | 39 | void handler::calculate_next_timeout(time_t now) 40 | { 41 | if (interval_ > 0) { 42 | next_timeout_ = now + interval_; 43 | } else { 44 | next_timeout_ = 0; 45 | } 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /test/utils/IdentifierTest.cpp: -------------------------------------------------------------------------------- 1 | #include "IdentifierTest.hpp" 2 | 3 | #include "matador/utils/identifier.hpp" 4 | 5 | IdentifierTest::IdentifierTest() 6 | : matador::unit_test("identifier", "identifier test") 7 | { 8 | add_test("id", [this] { test_identifier(); }, "identifier test"); 9 | } 10 | 11 | using namespace matador; 12 | 13 | void IdentifierTest::test_identifier() 14 | { 15 | identifier id1; 16 | 17 | UNIT_ASSERT_TRUE(id1.is_null()); 18 | UNIT_ASSERT_FALSE(id1.is_valid()); 19 | 20 | id1 = 7; 21 | 22 | UNIT_ASSERT_FALSE(id1.is_null()); 23 | UNIT_ASSERT_TRUE(id1.is_valid()); 24 | 25 | id1 = std::string("id"); 26 | 27 | UNIT_ASSERT_EQUAL("id", id1.str()); 28 | 29 | { 30 | auto shared_id = id1.share(); 31 | 32 | UNIT_ASSERT_EQUAL(2UL, shared_id.use_count()); 33 | UNIT_ASSERT_EQUAL(2UL, id1.use_count()); 34 | } 35 | 36 | UNIT_ASSERT_EQUAL(1UL, id1.use_count()); 37 | } 38 | -------------------------------------------------------------------------------- /include/matador/http/detail/template_filter_factory.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_TEMPLATE_FILTER_FACTORY_HPP 2 | #define MATADOR_TEMPLATE_FILTER_FACTORY_HPP 3 | 4 | #include "matador/http/export.hpp" 5 | 6 | #include "matador/utils/singleton.hpp" 7 | #include "matador/utils/factory.hpp" 8 | 9 | #include "matador/http/detail/template_filter.hpp" 10 | 11 | namespace matador { 12 | namespace http { 13 | namespace detail { 14 | 15 | /// @cond MATADOR_DEV 16 | 17 | class OOS_HTTP_API template_filter_factory : public singleton 18 | { 19 | private: 20 | using factory_type = factory; 21 | 22 | public: 23 | template_filter_factory(); 24 | 25 | std::shared_ptr produce(const std::string &key) const; 26 | 27 | private: 28 | factory_type factory_; 29 | }; 30 | 31 | /// @endcond 32 | 33 | } 34 | } 35 | } 36 | 37 | #endif //MATADOR_TEMPLATE_FILTER_FACTORY_HPP 38 | -------------------------------------------------------------------------------- /include/matador/http/detail/template_command_factory.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_TEMPLATE_COMMAND_FACTORY_HPP 2 | #define MATADOR_TEMPLATE_COMMAND_FACTORY_HPP 3 | 4 | #include "matador/http/export.hpp" 5 | 6 | #include "matador/utils/singleton.hpp" 7 | #include "matador/utils/factory.hpp" 8 | 9 | #include "matador/http/detail/template_command.hpp" 10 | 11 | namespace matador { 12 | namespace http { 13 | namespace detail { 14 | 15 | /// @cond MATADOR_DEV 16 | 17 | class OOS_HTTP_API template_command_factory : public singleton 18 | { 19 | private: 20 | using factory_type = factory; 21 | 22 | public: 23 | template_command_factory(); 24 | 25 | std::shared_ptr produce(const std::string &key) const; 26 | 27 | private: 28 | factory_type factory_; 29 | }; 30 | 31 | /// @endcond 32 | 33 | } 34 | } 35 | } 36 | #endif //MATADOR_TEMPLATE_COMMAND_FACTORY_HPP 37 | -------------------------------------------------------------------------------- /src/object/object_json_serializer.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/object/object_json_serializer.hpp" 2 | 3 | #include "matador/utils/string.hpp" 4 | 5 | namespace matador { 6 | 7 | void object_json_serializer::on_primary_key(const char *id, std::string &pk, size_t /*size*/) 8 | { 9 | result_[id] = pk; 10 | } 11 | 12 | void object_json_serializer::on_attribute(const char *id, bool &x, const field_attributes &/*attr*/) 13 | { 14 | result_[id] = x; 15 | } 16 | 17 | void object_json_serializer::on_attribute(const char *id, std::string &x, const field_attributes &/*attr*/) 18 | { 19 | result_[id] = x; 20 | } 21 | 22 | void object_json_serializer::on_attribute(const char *id, date &to, const field_attributes &/*attr*/) 23 | { 24 | result_[id] = to_string(to); 25 | } 26 | 27 | void object_json_serializer::on_attribute(const char *id, time &to, const field_attributes &/*attr*/) 28 | { 29 | result_[id] = to_string(to); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /examples/net/echo_server.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "echo_server.hpp" 5 | #include "echo_server_connection.hpp" 6 | 7 | using namespace matador; 8 | 9 | echo_server::echo_server(unsigned short port) 10 | : acceptor_(std::make_shared(tcp::peer(address::v4::any(), port))) 11 | { 12 | matador::add_log_sink(matador::create_file_sink("log/server.log")); 13 | matador::add_log_sink(matador::create_stdout_sink()); 14 | 15 | prepare_accept(); 16 | } 17 | 18 | void echo_server::run() 19 | { 20 | service_.run(); 21 | } 22 | 23 | void echo_server::prepare_accept() 24 | { 25 | service_.accept(acceptor_, [](tcp::peer ep, io_stream &stream) { 26 | // create echo server connection 27 | auto conn = std::make_shared(stream, std::move(ep)); 28 | conn->start(); 29 | }); 30 | } 31 | -------------------------------------------------------------------------------- /test/sql/DialectTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_QUERYTESTUNIT_HPP 2 | #define OOS_QUERYTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class DialectTestUnit : public matador::unit_test 7 | { 8 | public: 9 | DialectTestUnit(); 10 | 11 | void test_escaping_quotes(); 12 | void test_create_query(); 13 | void test_drop_query(); 14 | void test_insert_query(); 15 | void test_insert_prepare_query(); 16 | void test_select_all_query(); 17 | void test_select_distinct_query(); 18 | void test_select_limit_query(); 19 | void test_select_ordered_query(); 20 | void test_select_grouped_query(); 21 | void test_select_where_query(); 22 | void test_update_query(); 23 | void test_update_where_query(); 24 | void test_update_prepare_query(); 25 | void test_update_where_prepare_query(); 26 | void test_delete_query(); 27 | void test_delete_where_query(); 28 | }; 29 | 30 | 31 | #endif //OOS_QUERYTESTUNIT_HPP 32 | -------------------------------------------------------------------------------- /include/matador/object/basic_has_many_to_many_item.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_BASIC_HAS_MANY_TO_MANY_ITEM_HPP 2 | #define MATADOR_BASIC_HAS_MANY_TO_MANY_ITEM_HPP 3 | 4 | #include "matador/object/export.hpp" 5 | 6 | #include 7 | 8 | namespace matador { 9 | 10 | /// @cond MATADOR_DEV 11 | 12 | class object_proxy; 13 | 14 | class MATADOR_OBJECT_API basic_has_many_to_many_item 15 | { 16 | protected: 17 | basic_has_many_to_many_item() = default; 18 | basic_has_many_to_many_item(std::string left_column, std::string right_column); 19 | 20 | virtual ~basic_has_many_to_many_item() = default; 21 | 22 | public: 23 | virtual basic_has_many_to_many_item* clone() const = 0; 24 | 25 | std::string left_column() const; 26 | std::string right_column() const; 27 | 28 | private: 29 | std::string left_column_; 30 | std::string right_column_; 31 | }; 32 | 33 | /// @endcond 34 | 35 | } 36 | #endif //MATADOR_BASIC_HAS_MANY_TO_MANY_ITEM_HPP 37 | -------------------------------------------------------------------------------- /examples/demo/pages/main_page.cpp: -------------------------------------------------------------------------------- 1 | #include "main_page.hpp" 2 | 3 | #include "matador/http/http_server.hpp" 4 | #include "matador/http/template_engine.hpp" 5 | 6 | #include "matador/logger/log_manager.hpp" 7 | 8 | using namespace matador; 9 | using namespace matador::http; 10 | 11 | main_page::main_page(matador::http::server &s, matador::persistence &p) 12 | : log_(matador::create_logger("MainPage")) 13 | , persistence_(p) 14 | { 15 | file f("../templates/main.matador", "r"); 16 | auto tmpl = read_as_text(f); 17 | f.close(); 18 | 19 | index_template_ = template_engine::build(tmpl); 20 | 21 | s.on_get("/", [this](const request &req) { 22 | return view(req); 23 | }); 24 | } 25 | 26 | matador::http::response main_page::view(const matador::http::request &) 27 | { 28 | json data; 29 | data["title"] = "Movies"; 30 | 31 | return response::ok(template_engine::render(index_template_, data), mime_types::TYPE_TEXT_HTML); 32 | } 33 | -------------------------------------------------------------------------------- /include/matador/utils/url.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_URL_HPP 2 | #define MATADOR_URL_HPP 3 | 4 | #include "matador/utils/export.hpp" 5 | 6 | #include 7 | #include 8 | 9 | namespace matador { 10 | namespace url { 11 | 12 | /** 13 | * URL encodes a given string and returns the 14 | * encoded string. 15 | * 16 | * @param str String to be URL encoded. 17 | * @return The URL encoded string. 18 | */ 19 | OOS_UTILS_API std::string encode(const std::string &str); 20 | 21 | /** 22 | * URL decodes the given string and writes 23 | * the result into the given string reference. 24 | * If string could be decoded successfully true 25 | * is returned. 26 | * 27 | * @param str String to be URL decoded. 28 | * @param decoded The decoded string 29 | * @return True on successfully decoding 30 | */ 31 | OOS_UTILS_API bool decode(const std::string &str, std::string &decoded); 32 | 33 | } 34 | } 35 | 36 | #endif //MATADOR_URL_HPP 37 | -------------------------------------------------------------------------------- /src/object/abstract_has_many.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/object/abstract_container.hpp" 2 | #include "matador/object/object_holder.hpp" 3 | #include "matador/object/object_proxy.hpp" 4 | #include "matador/object/basic_container_item_holder.hpp" 5 | 6 | namespace matador { 7 | 8 | void abstract_container::increment_reference_count(const object_holder &holder) const 9 | { 10 | if (holder.valid()) { 11 | ++(*(this->proxy(const_cast(holder)))); 12 | } 13 | } 14 | 15 | void abstract_container::decrement_reference_count(const object_holder &holder) const 16 | { 17 | if (holder.valid()) { 18 | --(*(this->proxy(holder))); 19 | } 20 | } 21 | 22 | void abstract_container::mark_holder_as_inserted(basic_container_item_holder &holder) 23 | { 24 | holder.is_inserted_ = true; 25 | } 26 | 27 | void abstract_container::mark_holder_as_removed(basic_container_item_holder &holder) 28 | { 29 | holder.is_inserted_ = false; 30 | } 31 | 32 | } -------------------------------------------------------------------------------- /test/utils/StreamsTest.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_STREAMSTEST_HPP 2 | #define MATADOR_STREAMSTEST_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | class StreamsTest : public matador::unit_test 7 | { 8 | public: 9 | StreamsTest(); 10 | 11 | void test_generate(); 12 | void test_collect_map(); 13 | void test_iterate(); 14 | void test_min(); 15 | void test_max(); 16 | void test_filter(); 17 | void test_map(); 18 | void test_flatmap(); 19 | void test_take(); 20 | void test_take_while(); 21 | void test_skip(); 22 | void test_skip_while(); 23 | void test_every(); 24 | void test_peek(); 25 | void test_concat(); 26 | void test_pack_every(); 27 | void test_first(); 28 | void test_last(); 29 | void test_at(); 30 | void test_any(); 31 | void test_all(); 32 | void test_none(); 33 | void test_count(); 34 | void test_reduce(); 35 | void test_join(); 36 | }; 37 | 38 | 39 | #endif //MATADOR_STREAMSTEST_HPP 40 | -------------------------------------------------------------------------------- /examples/demo/pages/movie_page.cpp: -------------------------------------------------------------------------------- 1 | #include "movie_page.hpp" 2 | 3 | #include "matador/http/http_server.hpp" 4 | #include "matador/http/request.hpp" 5 | #include "matador/http/template_engine.hpp" 6 | 7 | #include "matador/logger/log_manager.hpp" 8 | 9 | #include "matador/object/json_object_mapper.hpp" 10 | 11 | #include "matador/orm/session.hpp" 12 | 13 | #include "../models/movie.hpp" 14 | 15 | using namespace matador; 16 | using namespace matador::http; 17 | 18 | movie_page::movie_page(matador::http::server &server, matador::persistence &p) 19 | : crud_page({"Movie", "Movies", "movie"}, server, p) 20 | {} 21 | 22 | void movie_page::prepare_json_form_data(json &data) 23 | { 24 | using namespace matador; 25 | using namespace matador::http; 26 | 27 | session s(persistence_unit()); 28 | 29 | auto directors = s.select(); 30 | 31 | json_object_mapper mapper; 32 | 33 | data["directors"] = mapper.to_json(directors); 34 | } 35 | -------------------------------------------------------------------------------- /include/matador/net/os.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_NET_OS_HPP 2 | #define MATADOR_NET_OS_HPP 3 | 4 | #include "matador/net/export.hpp" 5 | 6 | #include 7 | 8 | #if _WIN32 9 | #include 10 | #endif 11 | 12 | #ifdef _WIN32 13 | using socket_type = SOCKET; 14 | #else 15 | using socket_type = int; 16 | #endif 17 | 18 | namespace matador { 19 | namespace net { 20 | 21 | OOS_NET_API void init(); 22 | OOS_NET_API void cleanup(); 23 | 24 | } 25 | 26 | bool is_valid_socket(socket_type fd); 27 | 28 | namespace os { 29 | 30 | OOS_NET_API int inet_pton(int af, const char *src, void *dst); 31 | OOS_NET_API const char* inet_ntop(int af, const void* src, char* dst, size_t size); 32 | 33 | enum class shutdown_type 34 | { 35 | READ = 0, 36 | WRITE = 1, 37 | READ_WRITE = 2 38 | }; 39 | 40 | OOS_NET_API int shutdown(socket_type fd, shutdown_type type); 41 | OOS_NET_API int close(socket_type fd); 42 | 43 | } 44 | } 45 | #endif //MATADOR_NET_OS_HPP 46 | -------------------------------------------------------------------------------- /src/object/update_action.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/object/update_action.hpp" 2 | #include "matador/object/action_visitor.hpp" 3 | #include "matador/object/object_proxy.hpp" 4 | 5 | namespace matador { 6 | 7 | update_action::update_action(object_proxy *proxy) 8 | : proxy_(proxy) 9 | , delete_action_(new delete_action(proxy)) 10 | {} 11 | 12 | void update_action::accept(action_visitor *av) 13 | { 14 | av->visit(this); 15 | } 16 | 17 | object_proxy* update_action::proxy() 18 | { 19 | return proxy_; 20 | } 21 | 22 | const object_proxy* update_action::proxy() const 23 | { 24 | return proxy_; 25 | } 26 | 27 | void update_action::backup(byte_buffer &buffer) 28 | { 29 | proxy_->backup(buffer, *serializer_); 30 | } 31 | 32 | void update_action::restore(byte_buffer &buffer, object_store*) 33 | { 34 | proxy_->restore(buffer, *deserializer_); 35 | } 36 | 37 | delete_action *update_action::release_delete_action() 38 | { 39 | return delete_action_.release(); 40 | } 41 | 42 | } -------------------------------------------------------------------------------- /src/db/postgresql/limit.txt: -------------------------------------------------------------------------------- 1 | SELECT "owner_id", "item_id" FROM "relation" WHERE ("owner_id" = 1 AND "item_id" = 1) LIMIT 1 2 | SELECT "owner_id", "item_id" FROM "relation" WHERE ("owner_id" = 1 AND "ident_id" = 1) LIMIT 1 3 | 4 | UPDATE "relations" SET "owner_id"=1 WHERE ("owner_id" = 1 AND "ident_id" = 1) LIMIT 1 5 | 6 | 1. copy where clause 7 | 2. get first condition from where clause 8 | 3. replace value with select of field of first condition and copied where clause limit 1 9 | 10 | UPDATE "relations" SET "owner_id"=1 WHERE "owner_id" = ( 11 | SELECT "owner_id" 12 | FROM "relations" 13 | WHERE ("owner_id" = 1 AND "ident_id" = 1) 14 | LIMIT 1 15 | ) 16 | 17 | UPDATE server_info SET status = 'active' 18 | WHERE status = 'standby' [[LIMIT 1???]] 19 | 20 | UPDATE server_info SET status = 'active' 21 | WHERE server_ip = ( 22 | SELECT server_ip 23 | FROM server_info 24 | WHERE status = 'standby' 25 | LIMIT 1 26 | ) -------------------------------------------------------------------------------- /examples/demo/web/js/demo.js: -------------------------------------------------------------------------------- 1 | $(document).ready(function() { 2 | let modal = $('.modal'); 3 | $('#submit').click(() => { 4 | const credentials = { 5 | username: $('input[name=username]').val(), 6 | password: $('input[name=password]').val() 7 | }; 8 | 9 | axios.post('/api/v1/auth/login', credentials) 10 | .then(function (res) { 11 | console.log(res); 12 | window.location = "secure" 13 | // output.className = 'container'; 14 | // output.innerHTML = res.data; 15 | }) 16 | .catch(function (err) { 17 | console.error(err); 18 | // output.className = 'container text-danger'; 19 | // output.innerHTML = err.message; 20 | }); 21 | }); 22 | $('#cancel').click(() => { 23 | modal.hide(); 24 | }); 25 | $('#login').click(() => { 26 | modal.show(); 27 | }); 28 | }); 29 | -------------------------------------------------------------------------------- /examples/net/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | SET(NET_LIBRARIES) 2 | 3 | SET (ECHO_SERVER_SOURCES 4 | echo_server_main.cpp 5 | echo_server_connection.cpp 6 | echo_server_connection.hpp 7 | echo_server.cpp echo_server.hpp) 8 | 9 | ADD_EXECUTABLE(echo_server ${ECHO_SERVER_SOURCES}) 10 | 11 | TARGET_LINK_LIBRARIES(echo_server 12 | matador-unit 13 | matador-utils 14 | matador-json 15 | matador-logger 16 | matador-net 17 | ${CMAKE_DL_LIBS} 18 | ${CMAKE_THREAD_LIBS_INIT} 19 | ${NET_LIBRARIES} 20 | ) 21 | 22 | # echo client example 23 | 24 | SET (ECHO_CLIENT_SOURCES 25 | echo_client_main.cpp 26 | echo_client_connection.cpp 27 | echo_client_connection.hpp 28 | echo_client.cpp echo_client.hpp) 29 | 30 | ADD_EXECUTABLE(echo_client ${ECHO_CLIENT_SOURCES}) 31 | 32 | TARGET_LINK_LIBRARIES(echo_client 33 | matador-unit 34 | matador-utils 35 | matador-json 36 | matador-logger 37 | matador-net 38 | ${CMAKE_DL_LIBS} 39 | ${CMAKE_THREAD_LIBS_INIT} 40 | ${NET_LIBRARIES} 41 | ) 42 | -------------------------------------------------------------------------------- /test/net/IOEchoServerConnection.cpp: -------------------------------------------------------------------------------- 1 | #include "IOEchoServerConnection.hpp" 2 | 3 | #include "matador/utils/buffer_view.hpp" 4 | 5 | IOEchoServerConnection::IOEchoServerConnection(matador::io_stream &stream, matador::tcp::peer endpoint) 6 | : stream_(stream) 7 | , endpoint_(std::move(endpoint)) 8 | {} 9 | 10 | void IOEchoServerConnection::start() 11 | { 12 | read(); 13 | } 14 | 15 | void IOEchoServerConnection::read() 16 | { 17 | auto self(shared_from_this()); 18 | stream_.read(matador::buffer_view(buf_), [this, self](int ec, int nread) { 19 | if (ec == 0) { 20 | echo_.assign(buf_.data(), nread); 21 | write(); 22 | } 23 | }); 24 | } 25 | 26 | void IOEchoServerConnection::write() 27 | { 28 | auto self(shared_from_this()); 29 | 30 | std::list data; 31 | data.emplace_back(echo_); 32 | 33 | stream_.write(std::move(data), [this, self](int ec, int /*nwrite*/) { 34 | if (ec == 0) { 35 | read(); 36 | } 37 | }); 38 | } 39 | -------------------------------------------------------------------------------- /include/matador/http/middleware/routing_middleware.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ROUTING_MIDDLEWARE_HPP 2 | #define MATADOR_ROUTING_MIDDLEWARE_HPP 3 | 4 | #include "matador/http/export.hpp" 5 | 6 | #include "matador/logger/log_manager.hpp" 7 | 8 | #include "matador/utils/optional.hpp" 9 | 10 | #include "matador/http/middleware.hpp" 11 | #include "matador/http/routing_engine.hpp" 12 | 13 | namespace matador { 14 | namespace http { 15 | namespace middlewares { 16 | 17 | /// @cond MATADOR_DEV 18 | 19 | class OOS_HTTP_API routing_middleware : public middleware 20 | { 21 | public: 22 | explicit routing_middleware(const routing_engine &router); 23 | 24 | response process(request &req, const next_func_t &next) override; 25 | 26 | private: 27 | optional match(request &req); 28 | 29 | private: 30 | matador::logger log_; 31 | 32 | const matador::http::routing_engine &router_; 33 | }; 34 | 35 | /// @endcond 36 | 37 | } 38 | } 39 | } 40 | #endif //MATADOR_ROUTING_MIDDLEWARE_HPP 41 | -------------------------------------------------------------------------------- /test/utils/UrlTest.cpp: -------------------------------------------------------------------------------- 1 | #include "UrlTest.hpp" 2 | 3 | #include "matador/utils/url.hpp" 4 | 5 | using namespace matador; 6 | 7 | UrlTest::UrlTest() 8 | : matador::unit_test("url", "url test") 9 | { 10 | add_test("encode", [this] { test_encode(); }, "test url encode"); 11 | add_test("decode", [this] { test_decode(); }, "test url decode"); 12 | } 13 | 14 | void UrlTest::test_encode() 15 | { 16 | std::string input("<=> hello ! (backslash: \\) %%"); 17 | std::string expected_result("%3C%3D%3E%20hello%20%21%20%28backslash%3A%20%5C%29%20%25%25"); 18 | 19 | auto output = url::encode(input); 20 | 21 | UNIT_EXPECT_EQUAL(expected_result, output); 22 | } 23 | 24 | void UrlTest::test_decode() 25 | { 26 | std::string input("%3C%3D%3E%20hello%20%21%20%28backslash%3A%20%5C%29%20%25%25"); 27 | std::string expected_result("<=> hello ! (backslash: \\) %%"); 28 | 29 | std::string output; 30 | UNIT_ASSERT_TRUE(url::decode(input, output)); 31 | 32 | UNIT_EXPECT_EQUAL(expected_result, output); 33 | } 34 | -------------------------------------------------------------------------------- /test/object/RelationTestUnit.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_RELATIONTESTUNIT_HPP 2 | #define MATADOR_RELATIONTESTUNIT_HPP 3 | 4 | #include "matador/unit/unit_test.hpp" 5 | 6 | 7 | class RelationTestUnit : public matador::unit_test 8 | { 9 | public: 10 | RelationTestUnit(); 11 | 12 | void test_has_one(); 13 | 14 | void test_insert_belongs_to_one(); 15 | void test_belongs_to_one(); 16 | void test_remove_belongs_to_one(); 17 | 18 | void test_insert_belongs_to_many(); 19 | void test_belongs_to_many(); 20 | void test_remove_belongs_to_many(); 21 | void test_belongs_to_many_first_belongs_to(); 22 | 23 | void test_insert_has_many_vector(); 24 | void test_has_many_vector(); 25 | 26 | void test_has_many_list(); 27 | void test_has_many_builtin(); 28 | 29 | void test_has_many_to_many(); 30 | void test_remove_has_many_to_many(); 31 | 32 | void test_blog_single_post(); 33 | void test_blog_multi_posts(); 34 | 35 | void test_output(); 36 | }; 37 | 38 | 39 | #endif //MATADOR_RELATIONTESTUNIT_HPP 40 | -------------------------------------------------------------------------------- /test/utils/ThreadPoolTest.cpp: -------------------------------------------------------------------------------- 1 | #include "ThreadPoolTest.hpp" 2 | 3 | #include "matador/utils/thread_pool.hpp" 4 | 5 | using namespace matador; 6 | 7 | ThreadPoolTest::ThreadPoolTest() 8 | : unit_test("thread_pool", "thread pool test") 9 | { 10 | add_test("thread_pool", [this] { test_threadpool(); }, "thread pool test"); 11 | } 12 | 13 | void task(int ) 14 | { 15 | // std::cout << "thread: starting task " << num << "\n"; 16 | std::this_thread::sleep_for(std::chrono::seconds (1)); 17 | // std::cout << "thread: finished task " << num << "\n"; 18 | } 19 | 20 | void ThreadPoolTest::test_threadpool() 21 | { 22 | thread_pool tp(2); 23 | 24 | UNIT_ASSERT_EQUAL(2UL, tp.size()); 25 | 26 | for (int i = 0; i < 8; ++i) { 27 | // std::cout << "schedule task " << i+1 << "\n"; 28 | tp.schedule([num = i + 1] { return task(num); }); 29 | } 30 | 31 | std::this_thread::sleep_for(std::chrono::seconds (2)); 32 | 33 | tp.wait(); 34 | tp.shutdown(); 35 | 36 | UNIT_ASSERT_EQUAL(0UL, tp.pending()); 37 | } 38 | -------------------------------------------------------------------------------- /test/utils/StringTestUnit.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 4/8/15. 3 | // 4 | 5 | #include "StringTestUnit.hpp" 6 | 7 | #include "matador/utils/string.hpp" 8 | 9 | StringTestUnit::StringTestUnit() 10 | : unit_test("string", "string test unit") 11 | { 12 | add_test("split", std::bind(&StringTestUnit::test_split, this), "test split"); 13 | add_test("trim", std::bind(&StringTestUnit::test_trim, this), "test trim"); 14 | } 15 | 16 | void StringTestUnit::test_split() 17 | { 18 | std::string str("1,2,3,5,6"); 19 | 20 | std::vector strvec; 21 | 22 | size_t count = matador::split(str, ',', strvec); 23 | 24 | UNIT_ASSERT_EQUAL(count, (size_t)5); 25 | UNIT_ASSERT_EQUAL(strvec.size(), (size_t)5); 26 | } 27 | 28 | void StringTestUnit::test_trim() 29 | { 30 | std::string str(" middle "); 31 | 32 | std::string result = matador::trim(str); 33 | 34 | UNIT_ASSERT_EQUAL(result, "middle"); 35 | 36 | result = matador::trim(str, "-"); 37 | 38 | UNIT_ASSERT_EQUAL(result, str); 39 | } 40 | -------------------------------------------------------------------------------- /include/matador/utils/hmac.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_HMAC_HPP 2 | #define MATADOR_HMAC_HPP 3 | 4 | #include "matador/utils/export.hpp" 5 | 6 | #include 7 | 8 | namespace matador { 9 | 10 | /** 11 | * Encodes the given string message with the given key and 12 | * returns the encoded string. 13 | * 14 | * @param key Key to be used for encoding. 15 | * @param message Message to be encoded. 16 | * @return The encoded message. 17 | */ 18 | OOS_UTILS_API std::string hmac(const std::string &key, const std::string &message); 19 | 20 | /** 21 | * Encodes the given string message with the given key and 22 | * returns the encoded string. 23 | * 24 | * @param key Key to be used for encoding. 25 | * @param keylen Length of the key. 26 | * @param message Message to be encoded. 27 | * @param msglen Length of the message. 28 | * @return The encoded message. 29 | */ 30 | OOS_UTILS_API std::string hmac(const char *key, size_t keylen, const char *message, size_t msglen); 31 | 32 | } 33 | 34 | #endif //MATADOR_HMAC_HPP 35 | -------------------------------------------------------------------------------- /include/matador/db/sqlite/sqlite_statement.hpp: -------------------------------------------------------------------------------- 1 | #ifndef SQLITE_STATEMENT_HPP 2 | #define SQLITE_STATEMENT_HPP 3 | 4 | #include "matador/db/sqlite/sqlite_parameter_binder.hpp" 5 | 6 | #include "matador/sql/statement_impl.hpp" 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | struct sqlite3_stmt; 13 | 14 | namespace matador { 15 | 16 | namespace sqlite { 17 | 18 | class sqlite_connection; 19 | 20 | class sqlite_statement : public matador::detail::statement_impl 21 | { 22 | public: 23 | sqlite_statement(sqlite3 *db, detail::statement_context &&context); 24 | ~sqlite_statement() override; 25 | 26 | void clear() override; 27 | detail::result_impl* execute() override; 28 | void reset() override; 29 | 30 | protected: 31 | 32 | detail::parameter_binder_impl *binder() const override; 33 | 34 | private: 35 | sqlite3 *db_; 36 | sqlite3_stmt *stmt_; 37 | 38 | std::unique_ptr binder_; 39 | }; 40 | 41 | } 42 | 43 | } 44 | 45 | #endif /* SQLITE_STATEMENT_HPP */ 46 | -------------------------------------------------------------------------------- /src/json/json_format.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/json/json_format.hpp" 2 | 3 | namespace matador { 4 | 5 | json_format json_format::compact { false, true, 0 }; /* NOLINT */ 6 | json_format json_format::pretty { true, false, 2 }; /* NOLINT */ 7 | 8 | inline json_format::json_format(bool enable_line_break) 9 | : enable_line_break_(enable_line_break) 10 | {} 11 | 12 | inline json_format::json_format(unsigned indentation) 13 | : indentation_(indentation) 14 | {} 15 | 16 | inline json_format::json_format(bool enable_line_break, bool skip_empty, unsigned indentation) 17 | : enable_line_break_(enable_line_break) 18 | , skip_empty_(skip_empty) 19 | , indentation_(indentation) 20 | {} 21 | 22 | bool json_format::show_line_break() const 23 | { 24 | return enable_line_break_; 25 | } 26 | 27 | bool json_format::skip_empty() 28 | { 29 | return skip_empty_; 30 | } 31 | 32 | unsigned json_format::indentation() const 33 | { 34 | return indentation_; 35 | } 36 | 37 | char json_format::indentation_char() const 38 | { 39 | return indentation_char_; 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /examples/demo/services/movie_service.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_MOVIE_SERVICE_HPP 2 | #define MATADOR_MOVIE_SERVICE_HPP 3 | 4 | #include "matador/logger/logger.hpp" 5 | 6 | #include "matador/http/response.hpp" 7 | 8 | namespace matador { 9 | class persistence; 10 | 11 | namespace http { 12 | 13 | class server; 14 | class request; 15 | 16 | } 17 | } 18 | 19 | class movie_service 20 | { 21 | public: 22 | movie_service(matador::http::server &s, matador::persistence &p); 23 | 24 | matador::http::response initialize(const matador::http::request &p); 25 | matador::http::response list(const matador::http::request &p); 26 | matador::http::response get_movie(const matador::http::request &p); 27 | matador::http::response create_movie(const matador::http::request &p); 28 | matador::http::response update_movie(const matador::http::request &p); 29 | matador::http::response delete_movie(const matador::http::request &p); 30 | 31 | private: 32 | matador::logger log_; 33 | 34 | matador::persistence& persistence_; 35 | }; 36 | 37 | 38 | #endif //MATADOR_MOVIE_SERVICE_HPP 39 | -------------------------------------------------------------------------------- /include/matador/object/action_remover.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_ACTION_REMOVER_HPP 2 | #define OOS_ACTION_REMOVER_HPP 3 | 4 | #include "matador/object/export.hpp" 5 | 6 | #include "matador/object/action_visitor.hpp" 7 | #include "matador/object/action.hpp" 8 | 9 | #include 10 | 11 | namespace matador { 12 | 13 | /// @cond MATADOR_DEV 14 | 15 | class object_proxy; 16 | 17 | class MATADOR_OBJECT_API action_remover : public action_visitor 18 | { 19 | public: 20 | typedef std::shared_ptr action_ptr; 21 | typedef std::vector t_action_vector; 22 | 23 | public: 24 | explicit action_remover(t_action_vector &actions); 25 | 26 | bool remove(t_action_vector::size_type index, object_proxy *proxy); 27 | 28 | void visit(insert_action *a) override; 29 | void visit(update_action *a) override; 30 | void visit(delete_action *a) override; 31 | 32 | private: 33 | t_action_vector &actions_; 34 | t_action_vector::size_type index_; 35 | object_proxy *proxy_ = nullptr; 36 | }; 37 | 38 | /// @endcond 39 | 40 | } 41 | 42 | #endif //OOS_ACTION_REMOVER_HPP 43 | -------------------------------------------------------------------------------- /src/sql/column_serializer.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/column_serializer.hpp" 2 | 3 | namespace matador { 4 | namespace detail { 5 | 6 | column_serializer::column_serializer(columns::t_brackets brackets) 7 | : brackets_(brackets) 8 | {} 9 | 10 | void column_serializer::on_primary_key(const char *id, std::string &, size_t /*size*/) 11 | { 12 | cols_->push_back(std::make_shared(id)); 13 | } 14 | 15 | void column_serializer::on_revision(const char *id, unsigned long long int &/*rev*/) 16 | { 17 | cols_->push_back(std::make_shared(id)); 18 | } 19 | 20 | void column_serializer::on_attribute(const char *id, char * /*x*/, const field_attributes &) 21 | { 22 | cols_->push_back(std::make_shared(id)); 23 | } 24 | 25 | void column_serializer::on_belongs_to(const char *id, identifiable_holder &, cascade_type) 26 | { 27 | cols_->push_back(std::make_shared(id)); 28 | } 29 | 30 | void column_serializer::on_has_one(const char *id, identifiable_holder &, cascade_type) 31 | { 32 | cols_->push_back(std::make_shared(id)); 33 | } 34 | 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /examples/demo/templates/director_details.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | {% include "../templates/header.matador" %} 4 | 5 |
6 |

{{title}}

7 |
8 | Edit 9 | Delete 10 | List 11 |
12 |
13 |
14 | 15 | 16 |
17 |
18 | 19 | 20 |
21 |
22 | 23 | 24 | -------------------------------------------------------------------------------- /src/unit/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | SET(SOURCES 2 | test_suite.cpp 3 | unit_test.cpp 4 | ) 5 | 6 | SET(HEADER 7 | ${CMAKE_SOURCE_DIR}/include/matador/unit/test_suite.hpp 8 | ${CMAKE_SOURCE_DIR}/include/matador/unit/unit_exception.hpp 9 | ${CMAKE_SOURCE_DIR}/include/matador/unit/unit_test.hpp 10 | ) 11 | 12 | ADD_LIBRARY(matador-unit SHARED ${SOURCES} ${HEADER}) 13 | 14 | # Set the build version (VERSION) and the API version (SOVERSION) 15 | SET_TARGET_PROPERTIES(matador-unit 16 | PROPERTIES 17 | VERSION ${APP_VERSION} 18 | SOVERSION ${APP_MAJOR_VERSION}) 19 | 20 | SOURCE_GROUP("include\\matador\\unit" FILES ${HEADER}) 21 | SOURCE_GROUP("src\\matador\\unit" FILES ${SOURCES}) 22 | 23 | INSTALL( 24 | TARGETS matador-unit 25 | ARCHIVE DESTINATION lib 26 | LIBRARY DESTINATION lib 27 | COMPONENT libraries 28 | ) 29 | 30 | INSTALL( 31 | TARGETS matador-unit 32 | DESTINATION lib 33 | COMPONENT libraries 34 | ) 35 | 36 | INSTALL( 37 | FILES ${HEADER} 38 | DESTINATION include/matador/unit 39 | COMPONENT headers 40 | ) 41 | -------------------------------------------------------------------------------- /include/matador/sql/query_value_column_processor.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_QUERY_VALUE_COLUMN_PROCESSOR_HPP 2 | #define OOS_QUERY_VALUE_COLUMN_PROCESSOR_HPP 3 | 4 | #include "matador/utils/time.hpp" 5 | #include "matador/utils/any_visitor.hpp" 6 | 7 | #include "matador/sql/columns.hpp" 8 | 9 | namespace matador { 10 | namespace detail { 11 | 12 | /// @cond MATADOR_DEV 13 | 14 | class query_value_column_processor 15 | { 16 | public: 17 | query_value_column_processor(std::shared_ptr update_columns, std::vector rowvalues); 18 | 19 | void execute(std::pair &a); 20 | 21 | private: 22 | template < class T > 23 | void process(T &val) 24 | { 25 | update_columns_->push_back(make_column(current_id_, val)); 26 | } 27 | void process(char *val); 28 | void process(const char *val); 29 | 30 | private: 31 | any_visitor visitor_; 32 | std::shared_ptr update_columns_; 33 | std::vector row_values_; 34 | std::string current_id_; 35 | }; 36 | 37 | /// @endcond 38 | 39 | } 40 | } 41 | #endif //OOS_QUERY_VALUE_COLUMN_PROCESSOR_HPP 42 | -------------------------------------------------------------------------------- /test/http/MiddlewareTest.cpp: -------------------------------------------------------------------------------- 1 | #include "MiddlewareTest.hpp" 2 | 3 | #include "matador/http/middleware.hpp" 4 | #include "matador/http/request.hpp" 5 | #include "matador/http/mime_types.hpp" 6 | 7 | MiddlewareTest::MiddlewareTest() 8 | : matador::unit_test("middleware", "middleware test") 9 | { 10 | add_test("middleware", [this]() { test_middleware(); }, "middleware test"); 11 | } 12 | 13 | using namespace matador::http; 14 | 15 | class testing_middleware : public middleware 16 | { 17 | public: 18 | matador::http::response process(request &, const next_func_t &next) override 19 | { 20 | auto resp = next(); 21 | return response::ok("check", mime_types::TYPE_TEXT_PLAIN); 22 | } 23 | }; 24 | 25 | void MiddlewareTest::test_middleware() 26 | { 27 | middleware_pipeline mp; 28 | 29 | auto tmw = std::make_shared(); 30 | 31 | mp.add(tmw); 32 | 33 | request req; 34 | 35 | auto resp = mp.process(req); 36 | 37 | UNIT_ASSERT_EQUAL(http::OK, resp.status()); 38 | UNIT_ASSERT_EQUAL("check", resp.body()); 39 | UNIT_ASSERT_EQUAL(mime_types::TEXT_PLAIN, resp.content().type); 40 | } 41 | -------------------------------------------------------------------------------- /include/matador/utils/contraints.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_CONTRAINTS_HPP 2 | #define MATADOR_CONTRAINTS_HPP 3 | 4 | #include 5 | #include 6 | 7 | namespace matador { 8 | 9 | enum class constraints : unsigned char { 10 | NONE = 0, 11 | NOT_NULL = 1 << 0, 12 | INDEX = 1 << 1, 13 | UNIQUE = 1 << 2, 14 | PRIMARY_KEY = 1 << 3, 15 | FOREIGN_KEY = 1 << 4, 16 | DEFAULT = 1 << 5, 17 | UNIQUE_NOT_NULL = UNIQUE | NOT_NULL 18 | }; 19 | 20 | //static std::unordered_map constraints_to_name_map(); 21 | 22 | inline constraints operator|(constraints a, constraints b) 23 | { 24 | return static_cast(static_cast(a) | static_cast(b)); 25 | } 26 | 27 | inline constraints operator&(constraints a, constraints b) 28 | { 29 | return static_cast(static_cast(a) & static_cast(b)); 30 | } 31 | 32 | inline bool is_constraint_set(constraints source, constraints needle) 33 | { 34 | return static_cast(source & needle) > 0; 35 | } 36 | 37 | } 38 | 39 | #endif //MATADOR_CONTRAINTS_HPP 40 | -------------------------------------------------------------------------------- /examples/demo/templates/director_edit.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | {% include "../templates/header.matador" %} 4 | 5 |
6 |

{{title}}

7 |
8 |
9 |
10 |
11 | 12 | 13 |
14 |
15 | 16 | 17 |
18 |
19 | 20 | Cancel 21 |
22 |
23 | 24 | 25 | -------------------------------------------------------------------------------- /test/utils/EncryptionTest.cpp: -------------------------------------------------------------------------------- 1 | #include "EncryptionTest.hpp" 2 | 3 | #include "matador/utils/sha256.hpp" 4 | #include "matador/utils/hmac.hpp" 5 | 6 | EncryptionTest::EncryptionTest() 7 | : matador::unit_test("encryption", "sha256 test") 8 | { 9 | add_test("sha256", [this] { test_sha256(); }, "test sha256 hashing"); 10 | add_test("hmac", [this] { test_hmac(); }, "test hmac encryption"); 11 | } 12 | 13 | using namespace matador::ext; 14 | 15 | void EncryptionTest::test_sha256() 16 | { 17 | auto enc = sha256("hello world"); 18 | 19 | UNIT_ASSERT_EQUAL("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9", enc); 20 | 21 | const char *test { "foo bar" }; 22 | 23 | enc = sha256(test, strlen(test)); 24 | 25 | UNIT_ASSERT_EQUAL("fbc1a9f858ea9e177916964bd88c3d37b91a1e84412765e29950777f265c4b75", enc); 26 | } 27 | 28 | void EncryptionTest::test_hmac() 29 | { 30 | const std::string key { "mykey" }; 31 | const std::string message { "helloworld" }; 32 | 33 | auto result = matador::hmac(key, message); 34 | 35 | UNIT_ASSERT_EQUAL("7fdfaa9c9c0931f52d9ebf2538bc99700f2e771f3af1c1d93945c2256c11aedd", result); 36 | } 37 | -------------------------------------------------------------------------------- /src/db/mssql/mssql_dialect_compiler.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/db/mssql/mssql_dialect_compiler.hpp" 2 | 3 | #include "matador/sql/basic_dialect.hpp" 4 | #include "matador/sql/sql.hpp" 5 | 6 | namespace matador { 7 | 8 | namespace mssql { 9 | 10 | void mssql_dialect_compiler::visit(const matador::detail::select &) 11 | { 12 | commands_.push(top().current); 13 | } 14 | 15 | void mssql_dialect_compiler::visit(const matador::detail::update &) 16 | { 17 | commands_.push(top().current); 18 | } 19 | 20 | void mssql_dialect_compiler::visit(const matador::detail::remove &) 21 | { 22 | commands_.push(top().current); 23 | } 24 | 25 | void mssql_dialect_compiler::visit(const matador::detail::top &) 26 | { 27 | if (commands_.empty()) { 28 | return; 29 | } 30 | 31 | // move limit behind select 32 | auto limit = *top().current; 33 | top().tokens_.erase(top().current); 34 | auto current_command = commands_.top(); 35 | commands_.pop(); 36 | top().tokens_.insert(++current_command, limit); 37 | } 38 | 39 | void mssql_dialect_compiler::on_compile_start() 40 | { 41 | while (!commands_.empty()) { 42 | commands_.pop(); 43 | } 44 | } 45 | 46 | } 47 | } -------------------------------------------------------------------------------- /src/db/postgresql/postgresql_getvalue.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/db/postgresql/postgresql_getvalue.hpp" 2 | 3 | namespace matador { 4 | namespace detail { 5 | 6 | void get_value(PGresult *res, size_t row, size_t col, char *val, size_t s) 7 | { 8 | if (PQgetisnull(res, (int)row, (int)col) == 1) { 9 | return; 10 | } 11 | auto value = PQgetvalue(res, (int)row, (int)col); 12 | 13 | size_t len = strlen(value); 14 | if (len > (size_t)s) { 15 | #ifdef _MSC_VER 16 | strncpy_s(val, s, value, s); 17 | #else 18 | strncpy(val, value, s); 19 | #endif 20 | val[s-1] = '\n'; 21 | } else { 22 | #ifdef _MSC_VER 23 | strcpy_s(val, s, value); 24 | #else 25 | strcpy(val, value); 26 | #endif 27 | } 28 | } 29 | 30 | void get_value(PGresult *res, size_t row, size_t col, unsigned char &val) 31 | { 32 | if (PQgetisnull(res, (int)row, (int)col) == 1) { 33 | return; 34 | } 35 | auto value = PQgetvalue(res, (int)row, (int)col); 36 | 37 | if (strlen(value) == 0) { 38 | return; 39 | } 40 | 41 | if (strlen(value) == 0) { 42 | return; 43 | } 44 | char *end; 45 | val = (unsigned char)strtoul(value, &end, 10); 46 | } 47 | } 48 | } -------------------------------------------------------------------------------- /src/http/middleware/routing_middleware.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/http/middleware/routing_middleware.hpp" 2 | 3 | #include "matador/http/request.hpp" 4 | 5 | namespace matador { 6 | namespace http { 7 | namespace middlewares { 8 | 9 | response routing_middleware::process(request &req, const middleware::next_func_t &) 10 | { 11 | auto route = match(req); 12 | 13 | if (!route.has_value()) { 14 | log_.error("route %s isn't valid", req.url().c_str()); 15 | return response::not_found(); 16 | } else { 17 | log_.debug("executing route spec: %s (regex: %s)", route.value()->path_spec().c_str(), route.value()->path_regex().c_str()); 18 | return route.value()->execute(req); 19 | } 20 | } 21 | 22 | routing_middleware::routing_middleware(const routing_engine &router) 23 | : log_(matador::create_logger("RoutingMiddleware")) 24 | , router_(router) 25 | {} 26 | 27 | optional routing_middleware::match(request &req) 28 | { 29 | auto route = router_.match(req); 30 | 31 | if (router_.valid(route)) { 32 | return make_optional(*route); 33 | } else { 34 | return nullopt; 35 | } 36 | } 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /test/net/EchoServer.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_ECHOSERVER_HPP 2 | #define MATADOR_ECHOSERVER_HPP 3 | 4 | #include "matador/utils/buffer.hpp" 5 | 6 | #include "matador/logger/log_manager.hpp" 7 | 8 | #include "matador/net/handler.hpp" 9 | #include "matador/net/ip.hpp" 10 | 11 | class EchoServer : public matador::handler 12 | { 13 | public: 14 | EchoServer(); 15 | 16 | void init(matador::tcp::socket sock, matador::tcp::peer endpoint); 17 | 18 | void open() override; 19 | 20 | socket_type handle() const override; 21 | 22 | void on_input() override; 23 | void on_output() override; 24 | void on_except() override {} 25 | void on_timeout() override; 26 | 27 | void on_close() override; 28 | void close() override; 29 | 30 | bool is_ready_write() const override; 31 | bool is_ready_read() const override; 32 | 33 | bool timeout_called() const; 34 | 35 | std::string name() const override; 36 | 37 | private: 38 | bool on_timeout_called_ = false; 39 | matador::tcp::socket stream_; 40 | matador::tcp::peer endpoint_; 41 | 42 | matador::buffer message_; 43 | 44 | matador::logger log_; 45 | }; 46 | 47 | 48 | #endif //MATADOR_ECHOSERVER_HPP 49 | -------------------------------------------------------------------------------- /test/http/JwtTest.cpp: -------------------------------------------------------------------------------- 1 | #include "JwtTest.hpp" 2 | 3 | #include "matador/json/json_mapper.hpp" 4 | 5 | #include "matador/http/auth/jwt_token.hpp" 6 | 7 | JwtTest::JwtTest() 8 | : matador::unit_test("jwt", "jwt test") 9 | { 10 | add_test("token", [this]() { test_jwt_token(); }, "jwt token test"); 11 | } 12 | 13 | using namespace matador::http::auth; 14 | using namespace matador; 15 | 16 | void JwtTest::test_jwt_token() 17 | { 18 | jwt_header h { "HSA256", "JWT" }; 19 | 20 | json_mapper mapper; 21 | 22 | auto result = mapper.to_string(h); 23 | 24 | UNIT_ASSERT_EQUAL(R"({"alg": "HSA256","typ": "JWT"})", result); 25 | 26 | jwt_payload p; 27 | p.issuer = "www.example.com"; 28 | p.subject = "123456789"; 29 | p.name = "John Doe"; 30 | 31 | result = mapper.to_string(p); 32 | 33 | UNIT_ASSERT_EQUAL(R"({"iss": "www.example.com","sub": "123456789","name": "John Doe"})", result); 34 | 35 | auto parsed_jwt_payload = mapper.to_object( result ); 36 | 37 | UNIT_ASSERT_EQUAL( p.issuer, parsed_jwt_payload.issuer ); 38 | UNIT_ASSERT_EQUAL( p.subject, parsed_jwt_payload.subject ); 39 | UNIT_ASSERT_EQUAL( p.name, parsed_jwt_payload.name ); 40 | } 41 | -------------------------------------------------------------------------------- /include/matador/db/sqlite/sqlite_dialect_compiler.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_SQLITE_DIALECT_COMPILER_HPP 2 | #define OOS_SQLITE_DIALECT_COMPILER_HPP 3 | 4 | #include "matador/sql/dialect_token.hpp" 5 | 6 | #include "matador/sql/basic_dialect_compiler.hpp" 7 | 8 | namespace matador { 9 | 10 | namespace sqlite { 11 | 12 | class sqlite_dialect; 13 | 14 | class sqlite_dialect_compiler : public detail::basic_dialect_compiler 15 | { 16 | public: 17 | void visit(const matador::detail::select &select1) override; 18 | void visit(const matador::detail::update &update1) override; 19 | void visit(const matador::detail::remove &remove1) override; 20 | void visit(const matador::detail::tablename &tab) override; 21 | void visit(const matador::detail::from &from1) override; 22 | 23 | void visit(const matador::detail::where &where1) override; 24 | void visit(const matador::detail::top &top1) override; 25 | 26 | protected: 27 | void on_compile_start() override; 28 | 29 | private: 30 | bool is_update = false; 31 | bool is_delete = false; 32 | 33 | std::string table_name_; 34 | token_list_t::iterator where_; 35 | }; 36 | 37 | } 38 | } 39 | 40 | #endif //OOS_SQLITE_DIALECT_COMPILER_HPP 41 | -------------------------------------------------------------------------------- /test/has_many_list.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_HAS_MANY_LIST_HPP 2 | #define OOS_HAS_MANY_LIST_HPP 3 | 4 | #include "matador/object/container.hpp" 5 | 6 | namespace hasmanylist { 7 | 8 | class item 9 | { 10 | public: 11 | unsigned long id{}; 12 | std::string name; 13 | 14 | item() = default; 15 | explicit item(std::string n) : name(std::move(n)) {} 16 | 17 | template < class Operator > 18 | void process(Operator &op) 19 | { 20 | matador::access::primary_key(op, "id", id); 21 | matador::access::attribute(op, "name", name); 22 | } 23 | }; 24 | 25 | class owner 26 | { 27 | public: 28 | typedef matador::container item_list_t; 29 | unsigned long id{}; 30 | std::string name; 31 | item_list_t items; 32 | 33 | owner() = default; 34 | explicit owner(std::string n) : name(std::move(n)) {} 35 | 36 | template < class Operator > 37 | void process(Operator &op) 38 | { 39 | matador::access::primary_key(op, "id", id); 40 | matador::access::attribute(op, "name", name); 41 | matador::access::has_many(op, "owner_item", items, "owner_id", "item_id", matador::cascade_type::ALL); 42 | } 43 | }; 44 | } 45 | 46 | #endif //OOS_HAS_MANY_LIST_HPP 47 | -------------------------------------------------------------------------------- /include/matador/object/container_type_traits.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CONTAINER_TYPE_TRAITS_HPP 2 | #define CONTAINER_TYPE_TRAITS_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | /// @cond MATADOR_DEV 10 | 11 | namespace matador { 12 | 13 | template < template < class ... > class Container> 14 | struct is_container_type : std::false_type { }; 15 | 16 | template <> struct is_container_type : std::true_type {}; 17 | template <> struct is_container_type : std::true_type {}; 18 | template <> struct is_container_type : std::true_type {}; 19 | 20 | template < template < class ... > class ContainerA, template < class ... > class ContainerB > 21 | struct is_same_container_type : std::false_type { }; 22 | 23 | template < template < class ... > class Container > 24 | struct is_same_container_type : std::true_type { }; 25 | 26 | /// @endcond 27 | 28 | } 29 | 30 | //template struct is_container > : std::true_type { }; 31 | //template struct is_container > : std::true_type { }; 32 | // ... 33 | 34 | #endif /* CONTAINER_TYPE_TRAITS_HPP */ 35 | -------------------------------------------------------------------------------- /include/matador/orm/persistence_observer.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_PERSISTENCE_OBSERVER_HPP 2 | #define OOS_PERSISTENCE_OBSERVER_HPP 3 | 4 | #include "matador/object/typed_object_store_observer.hpp" 5 | 6 | namespace matador { 7 | 8 | class persistence; 9 | 10 | /// @cond MATADOR_DEV 11 | 12 | template < class T > 13 | class persistence_observer : public typed_object_store_observer 14 | { 15 | public: 16 | 17 | explicit persistence_observer(persistence &p) : persistence_(p) {} 18 | template < class O > 19 | explicit persistence_observer(const persistence_observer *x) 20 | : persistence_(x->persistence_) 21 | {} 22 | 23 | void on_attach(prototype_node &node, T &proto) override; 24 | void on_detach(prototype_node &node, T &proto) override; 25 | 26 | void on_insert(object_proxy &proxy) override; 27 | void on_update(object_proxy &proxy) override; 28 | void on_delete(object_proxy &proxy) override; 29 | 30 | persistence& get_persistence() const { return persistence_; } 31 | private: 32 | 33 | template < class V > 34 | friend class persistence_observer; 35 | 36 | persistence& persistence_; 37 | }; 38 | 39 | /// @endcond 40 | 41 | } 42 | #endif //OOS_PERSISTENCE_OBSERVER_HPP 43 | -------------------------------------------------------------------------------- /src/utils/sequence_synchronizer.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/utils/sequence_synchronizer.hpp" 2 | 3 | namespace matador { 4 | 5 | void sequence_synchronizer::serialize(short &x, const field_attributes &/*attr*/) 6 | { 7 | sync_integral(x); 8 | } 9 | 10 | void sequence_synchronizer::serialize(int &x, const field_attributes &/*attr*/) 11 | { 12 | sync_integral(x); 13 | } 14 | 15 | void sequence_synchronizer::serialize(long &x, const field_attributes &/*attr*/) 16 | { 17 | sync_integral(x); 18 | } 19 | 20 | void sequence_synchronizer::serialize(long long int &x, const field_attributes &/*attr*/) 21 | { 22 | sync_integral(x); 23 | } 24 | 25 | void sequence_synchronizer::serialize(unsigned short &x, const field_attributes &/*attr*/) 26 | { 27 | sync_integral(x); 28 | } 29 | 30 | void sequence_synchronizer::serialize(unsigned int &x, const field_attributes &/*attr*/) 31 | { 32 | sync_integral(x); 33 | } 34 | 35 | void sequence_synchronizer::serialize(unsigned long &x, const field_attributes &/*attr*/) 36 | { 37 | sync_integral(x); 38 | } 39 | 40 | void sequence_synchronizer::serialize(unsigned long long int &x, const field_attributes &/*attr*/) 41 | { 42 | sync_integral(x); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /doc/doxygen/doc_header.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | Open Object Store 7 | 8 | 9 | 10 | 24 |
25 |
26 |
27 | -------------------------------------------------------------------------------- /examples/demo/templates/director_delete.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | {% include "../templates/header.matador" %} 4 | 5 |
6 |

{{title}}

7 |
8 |
9 | 10 |
11 |
12 | 13 | 14 |
15 |
16 | 17 | 18 |
19 |
20 | 21 | Cancel 22 |
23 |
24 | 25 | 26 | -------------------------------------------------------------------------------- /include/matador/object/object_exception.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OBJECT_EXCEPTION_HPP 2 | #define OBJECT_EXCEPTION_HPP 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | namespace matador { 9 | 10 | /** 11 | * Throws an serializable exception 12 | * 13 | * @param source The source of the exception 14 | * @param what Detailed information about the exception 15 | */ 16 | //void throw_error(const std::string &source, const std::string &what); 17 | 18 | /** 19 | * @class object_exception 20 | * @brief An serializable exception class 21 | * 22 | * This kind of exception is thrown, when 23 | * an serializable dealing error occurs. 24 | */ 25 | class object_exception : public std::runtime_error 26 | { 27 | public: 28 | /** 29 | * Creates a object_exception 30 | * 31 | * @param what The message of the exception. 32 | */ 33 | explicit object_exception(const char *what) noexcept 34 | : std::runtime_error(what) 35 | {} 36 | }; 37 | 38 | #define throw_object_exception(message) \ 39 | do { \ 40 | std::stringstream msg; \ 41 | msg << message; \ 42 | throw object_exception(msg.str().c_str()); \ 43 | } while(false) 44 | 45 | } 46 | 47 | #endif /* OBJECT_EXCEPTION_HPP */ 48 | -------------------------------------------------------------------------------- /include/matador/utils/is_builtin.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_IS_BUILTIN_HPP 2 | #define MATADOR_IS_BUILTIN_HPP 3 | 4 | #include "matador/utils/time.hpp" 5 | #include "matador/utils/date.hpp" 6 | #include "matador/utils/identifiable_holder.hpp" 7 | 8 | #include 9 | #include 10 | 11 | namespace matador { 12 | 13 | /// @cond MATADOR_DEV 14 | 15 | template 16 | struct is_identifiable { 17 | static const bool value = false; 18 | }; 19 | 20 | template 21 | struct is_identifiable< T, 22 | typename std::enable_if::value>::type> 23 | { 24 | static const bool value = true; 25 | }; 26 | 27 | template 28 | struct is_builtin { 29 | static const bool value = false; 30 | }; 31 | 32 | template 33 | struct is_builtin< T, 34 | typename std::enable_if< 35 | std::is_scalar::value || 36 | std::is_same::value || 37 | std::is_same::value || 38 | std::is_same::value>::type 39 | > 40 | { 41 | static const bool value = true; 42 | }; 43 | 44 | /// @endcond 45 | 46 | } 47 | 48 | #endif //MATADOR_IS_BUILTIN_HPP 49 | -------------------------------------------------------------------------------- /include/matador/db/mssql/mssql_statement.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MSSQL_STATEMENT_HPP 2 | #define MSSQL_STATEMENT_HPP 3 | 4 | #include "matador/sql/statement_impl.hpp" 5 | #include "matador/sql/sql.hpp" 6 | 7 | #include "matador/db/mssql/mssql_exception.hpp" 8 | #include "mssql_parameter_binder.hpp" 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | namespace matador { 19 | 20 | namespace mssql { 21 | 22 | class mssql_connection; 23 | 24 | class mssql_statement : public detail::statement_impl 25 | { 26 | public: 27 | mssql_statement(SQLHANDLE db, detail::statement_context &&context); 28 | ~mssql_statement() override; 29 | 30 | void clear() override; 31 | detail::result_impl* execute() override; 32 | void reset() override; 33 | 34 | protected: 35 | detail::parameter_binder_impl *binder() const override; 36 | 37 | private: 38 | void create_statement(); 39 | 40 | private: 41 | enum { NUMERIC_LEN = 21 }; 42 | 43 | SQLHANDLE stmt_ = nullptr; 44 | SQLHANDLE db_ = nullptr; 45 | 46 | std::unique_ptr binder_; 47 | }; 48 | 49 | } 50 | 51 | } 52 | 53 | #endif /* MSSQL_STATEMENT_HPP */ 54 | -------------------------------------------------------------------------------- /include/matador/db/postgresql/postgresql_dialect_compiler.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by sascha on 21.06.19. 3 | // 4 | 5 | #ifndef MATADOR_POSTGRESQL_DIALECT_COMPILER_HPP 6 | #define MATADOR_POSTGRESQL_DIALECT_COMPILER_HPP 7 | 8 | #include "matador/sql/basic_dialect_compiler.hpp" 9 | #include "matador/sql/dialect_token.hpp" 10 | 11 | namespace matador { 12 | namespace postgresql { 13 | 14 | class postgresql_dialect_compiler : public detail::basic_dialect_compiler 15 | { 16 | public: 17 | void visit(const matador::detail::select &select1) override; 18 | void visit(const matador::detail::update &update1) override; 19 | void visit(const matador::detail::remove &remove1) override; 20 | void visit(const matador::detail::tablename &tab) override; 21 | void visit(const matador::detail::from &from1) override; 22 | 23 | void visit(const matador::detail::where &where1) override; 24 | void visit(const matador::detail::top &limit) override; 25 | 26 | protected: 27 | void on_compile_start() override; 28 | 29 | private: 30 | bool is_update = false; 31 | bool is_delete = false; 32 | 33 | std::string tablename_; 34 | token_list_t::iterator where_; 35 | }; 36 | 37 | } 38 | } 39 | #endif //MATADOR_POSTGRESQL_DIALECT_COMPILER_HPP 40 | -------------------------------------------------------------------------------- /include/matador/http/default_responses.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_DEFAULT_RESPONSES_HPP 2 | #define MATADOR_DEFAULT_RESPONSES_HPP 3 | 4 | #include "matador/http/export.hpp" 5 | 6 | namespace matador { 7 | namespace http { 8 | 9 | /// @cond MATADOR_DEV 10 | 11 | class default_responses 12 | { 13 | public: 14 | static OOS_HTTP_API const char *OK; 15 | static OOS_HTTP_API const char *CREATED; 16 | static OOS_HTTP_API const char *ACCEPTED; 17 | static OOS_HTTP_API const char *NO_CONTENT; 18 | static OOS_HTTP_API const char *MULTIPLE_CHOICES; 19 | static OOS_HTTP_API const char *MOVED_PERMANENTLY; 20 | static OOS_HTTP_API const char *MOVED_TEMPORARILY; 21 | static OOS_HTTP_API const char *NOT_MODIFIED; 22 | static OOS_HTTP_API const char *BAD_REQUEST; 23 | static OOS_HTTP_API const char *UNAUTHORIZED; 24 | static OOS_HTTP_API const char *FORBIDDEN; 25 | static OOS_HTTP_API const char *NOT_FOUND; 26 | static OOS_HTTP_API const char *INTERNAL_SERVER_ERROR; 27 | static OOS_HTTP_API const char *NOT_IMPLEMENTED; 28 | static OOS_HTTP_API const char *BAD_GATEWAY; 29 | static OOS_HTTP_API const char *SERVICE_UNAVAILABLE; 30 | }; 31 | 32 | /// @endcond 33 | 34 | } 35 | } 36 | 37 | #endif //MATADOR_DEFAULT_RESPONSES_HPP 38 | -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | CONFIGURE_FILE (${CMAKE_SOURCE_DIR}/include/matador/version.hpp.in ${CMAKE_BINARY_DIR}/version.hpp) 2 | 3 | ADD_SUBDIRECTORY(object) 4 | ADD_SUBDIRECTORY(orm) 5 | ADD_SUBDIRECTORY(sql) 6 | ADD_SUBDIRECTORY(utils) 7 | ADD_SUBDIRECTORY(json) 8 | ADD_SUBDIRECTORY(logger) 9 | ADD_SUBDIRECTORY(net) 10 | ADD_SUBDIRECTORY(http) 11 | ADD_SUBDIRECTORY(unit) 12 | 13 | ADD_SUBDIRECTORY(db) 14 | 15 | ADD_CUSTOM_TARGET(matador 16 | ALL 17 | COMMAND ${CMAKE_COMMAND} -E echo Building matador libs 18 | DEPENDS 19 | matador-unit 20 | matador-utils 21 | matador-json 22 | matador-logger 23 | matador-net 24 | matador-http 25 | matador-object 26 | matador-sql 27 | matador-orm 28 | ) 29 | 30 | IF (SQLITE3_FOUND) 31 | ADD_DEPENDENCIES(matador matador-sqlite) 32 | ENDIF(SQLITE3_FOUND) 33 | 34 | IF (MYSQL_FOUND) 35 | ADD_DEPENDENCIES(matador matador-mysql) 36 | ENDIF(MYSQL_FOUND) 37 | 38 | IF (ODBC_FOUND) 39 | ADD_DEPENDENCIES(matador matador-mssql) 40 | ENDIF(ODBC_FOUND) 41 | 42 | IF (POSTGRESQL_FOUND) 43 | ADD_DEPENDENCIES(matador matador-postgresql) 44 | ENDIF(POSTGRESQL_FOUND) 45 | 46 | INSTALL( 47 | FILES ${CMAKE_BINARY_DIR}/version.hpp 48 | DESTINATION include/matador 49 | COMPONENT headers 50 | ) 51 | -------------------------------------------------------------------------------- /src/net/fdset.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/net/fdset.hpp" 2 | 3 | namespace matador { 4 | 5 | fdset::fdset() 6 | { 7 | reset(); 8 | } 9 | 10 | fdset::fdset(fdset&& x) noexcept 11 | : max_fd_set_(std::move(x.max_fd_set_)) 12 | , fd_set_(x.fd_set_) {} 13 | 14 | fdset& fdset::operator=(fdset&& x) noexcept 15 | { 16 | max_fd_set_ = std::move(x.max_fd_set_); 17 | fd_set_ = x.fd_set_; 18 | return *this; 19 | } 20 | 21 | // set all bits to zero 22 | void fdset::reset() 23 | { 24 | FD_ZERO(&fd_set_); 25 | max_fd_set_.clear(); 26 | max_fd_set_.insert(0); 27 | } 28 | 29 | bool fdset::is_set(socket_type fd) const 30 | { 31 | return FD_ISSET(fd, &fd_set_) > 0; 32 | } 33 | 34 | void fdset::clear(socket_type fd) 35 | { 36 | FD_CLR(fd, &fd_set_); 37 | max_fd_set_.erase(fd); 38 | } 39 | 40 | void fdset::set(socket_type fd) 41 | { 42 | FD_SET(fd, &fd_set_); 43 | max_fd_set_.insert(fd); 44 | } 45 | 46 | socket_type fdset::maxp1() const 47 | { 48 | return *max_fd_set_.begin(); 49 | } 50 | 51 | size_t fdset::count() const 52 | { 53 | return max_fd_set_.size() - 1; 54 | } 55 | 56 | bool fdset::empty() const 57 | { 58 | return count() == 0; 59 | } 60 | 61 | fd_set* fdset::get() 62 | { 63 | return &fd_set_; 64 | } 65 | 66 | } 67 | -------------------------------------------------------------------------------- /test/net/IPTestUnit.cpp: -------------------------------------------------------------------------------- 1 | #include "IPTestUnit.hpp" 2 | 3 | #include "matador/net/ip.hpp" 4 | 5 | using namespace matador; 6 | 7 | IPTestUnit::IPTestUnit() 8 | : matador::unit_test("ip", "ip test unit") 9 | { 10 | add_test("tcp", [this] { test_tcp(); }, "tcp test"); 11 | add_test("udp", [this] { test_udp(); }, "udp test"); 12 | } 13 | 14 | void IPTestUnit::test_tcp() 15 | { 16 | tcp tcp_v4 = tcp::v4(); 17 | 18 | UNIT_ASSERT_EQUAL(SOCK_STREAM, tcp_v4.type()); 19 | UNIT_ASSERT_EQUAL(IPPROTO_TCP, tcp_v4.protocol()); 20 | UNIT_ASSERT_EQUAL(PF_INET, tcp_v4.family()); 21 | 22 | tcp tcp_v6 = tcp::v6(); 23 | 24 | UNIT_ASSERT_EQUAL(SOCK_STREAM, tcp_v6.type()); 25 | UNIT_ASSERT_EQUAL(IPPROTO_TCP, tcp_v6.protocol()); 26 | UNIT_ASSERT_EQUAL(PF_INET6, tcp_v6.family()); 27 | } 28 | 29 | void IPTestUnit::test_udp() 30 | { 31 | udp udp_v4 = udp::v4(); 32 | 33 | UNIT_ASSERT_EQUAL(SOCK_DGRAM, udp_v4.type()); 34 | UNIT_ASSERT_EQUAL(IPPROTO_UDP, udp_v4.protocol()); 35 | UNIT_ASSERT_EQUAL(PF_INET, udp_v4.family()); 36 | 37 | udp udp_v6 = udp::v6(); 38 | 39 | UNIT_ASSERT_EQUAL(SOCK_DGRAM, udp_v6.type()); 40 | UNIT_ASSERT_EQUAL(IPPROTO_UDP, udp_v6.protocol()); 41 | UNIT_ASSERT_EQUAL(PF_INET6, udp_v6.family()); 42 | } 43 | -------------------------------------------------------------------------------- /src/db/sqlite/sqlite_exception.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of OpenObjectStore OOS. 3 | * 4 | * OpenObjectStore OOS is free software: you can redistribute it and/or modify 5 | * it under the terms of the GNU General Public License as published by 6 | * the Free Software Foundation, either version 3 of the License, or 7 | * (at your option) any later version. 8 | * 9 | * OpenObjectStore OOS is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | * GNU General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU General Public License 15 | * along with OpenObjectStore OOS. If not, see . 16 | */ 17 | 18 | #include "matador/sql/database_error.hpp" 19 | 20 | #include "matador/db/sqlite/sqlite_exception.hpp" 21 | 22 | namespace matador { 23 | 24 | namespace sqlite { 25 | 26 | void throw_database_error(int ec, sqlite3 *db, const std::string &source, const std::string &sql) 27 | { 28 | if (ec == SQLITE_OK) { 29 | return; 30 | } 31 | throw database_error(sqlite3_errmsg(db), source, sqlite3_errcode(db), sql); 32 | } 33 | 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /src/http/middleware.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/http/middleware.hpp" 2 | 3 | namespace matador { 4 | namespace http { 5 | 6 | middleware_processor::middleware_processor(middleware_ptr current, std::shared_ptr next) 7 | : current_(std::move(current)) 8 | , next_(std::move(next)) 9 | {} 10 | 11 | matador::http::response middleware_processor::process(request &req) 12 | { 13 | return current_->process(req, [&req, this]() { 14 | if (next_) { 15 | return next_->process(req); 16 | } else { 17 | return matador::http::response::not_found(); 18 | } 19 | }); 20 | } 21 | 22 | middleware_pipeline::middleware_pipeline() 23 | : processor_(std::make_shared(std::make_shared(), middleware_processor_ptr())) 24 | {} 25 | 26 | void middleware_pipeline::add(const middleware_ptr &mware) 27 | { 28 | processor_ = std::make_shared(mware, processor_); 29 | } 30 | 31 | matador::http::response middleware_pipeline::process(request &req) 32 | { 33 | return processor_->process(req); 34 | } 35 | 36 | matador::http::response sentinel_middleware::process(request &, const middleware::next_func_t &) 37 | { 38 | return matador::http::response::bad_request(); 39 | } 40 | 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /include/matador/logger/log_sink.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_LOG_SINK_HPP 2 | #define MATADOR_LOG_SINK_HPP 3 | 4 | #include "matador/logger/export.hpp" 5 | 6 | #include 7 | #include 8 | 9 | namespace matador { 10 | 11 | /** 12 | * @brief Base class for all log sinks 13 | * 14 | * This class must be the base class for all 15 | * log sinks and provides their interface 16 | * 17 | * The main interface is the write(...) interface 18 | * defining how the log message is written. 19 | * 20 | * The close() interface defines a way to close 21 | * the concrete log sink 22 | */ 23 | class OOS_LOGGER_API log_sink 24 | { 25 | public: 26 | /** 27 | * Destroys the log sink 28 | */ 29 | virtual ~log_sink() = default; 30 | 31 | /** 32 | * Writes the given log message with the given size 33 | * to the concrete sink 34 | * 35 | * @param message The message to log 36 | * @param size The size of the message 37 | */ 38 | virtual void write(const char *message, std::size_t size) = 0; 39 | 40 | /** 41 | * Closes the log sink if necessary. 42 | */ 43 | virtual void close() = 0; 44 | }; 45 | 46 | using sink_ptr = std::shared_ptr; /**< Shortcut to log sink shared pointer */ 47 | 48 | } 49 | 50 | #endif //MATADOR_LOG_SINK_HPP 51 | -------------------------------------------------------------------------------- /include/matador/sql/value.hpp: -------------------------------------------------------------------------------- 1 | #ifndef VALUE_HPP 2 | #define VALUE_HPP 3 | 4 | #include "matador/sql/token.hpp" 5 | 6 | #include "matador/utils/date.hpp" 7 | #include "matador/utils/time.hpp" 8 | #include "matador/utils/string.hpp" 9 | #include "matador/utils/serializer.hpp" 10 | #include "matador/utils/any.hpp" 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | namespace matador { 18 | 19 | /// @cond MATADOR_DEV 20 | 21 | struct value : public detail::token 22 | { 23 | value(); 24 | 25 | template> 26 | explicit value(T &&val) 27 | : token(detail::token::VALUE) 28 | , value_(val) 29 | {} 30 | 31 | template> 32 | value(T &&val, std::size_t s) 33 | : token(detail::token::VALUE) 34 | , value_(val) 35 | , size_(s) 36 | {} 37 | 38 | template < class T > T get() { 39 | return value_._(); 40 | } 41 | 42 | void accept(token_visitor &visitor) override; 43 | 44 | any value_; 45 | std::size_t size_ = 0; 46 | }; 47 | 48 | template < class T > 49 | value* make_value(const T &val) 50 | { 51 | return new value(val); 52 | } 53 | 54 | /// @endcond 55 | 56 | } 57 | 58 | #endif /* VALUE_HPP */ 59 | -------------------------------------------------------------------------------- /examples/demo/templates/director_list.matador: -------------------------------------------------------------------------------- 1 | 2 | 3 | {% include "../templates/header.matador" %} 4 | 5 |
6 |

{{title}}

7 |
8 | 9 | Home 10 | 11 |
12 |
13 |
14 | Create 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | {% for director in directorlist %} 24 | 25 | 26 | 27 | 28 | {% endfor %} 29 | 30 |
IDName
{{ director.id }}{{ director.name }}
31 | 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /test/object/PrimaryKeyUnitTest.cpp: -------------------------------------------------------------------------------- 1 | #include "PrimaryKeyUnitTest.hpp" 2 | 3 | #include 4 | 5 | PrimaryKeyUnitTest::PrimaryKeyUnitTest() 6 | : unit_test("pk", "Primary Key Unit Test") 7 | { 8 | add_test("create", [this] { test_create(); }, "test create"); 9 | add_test("share", [this] { test_share(); }, "test share"); 10 | } 11 | 12 | void PrimaryKeyUnitTest::test_create() 13 | { 14 | // long id57(57); 15 | // std::unique_ptr pkb(new matador::identifier(id57)); 16 | // 17 | // pkb->is_valid(); 18 | 19 | // long result = pkb->id(); 20 | // 21 | // UNIT_ASSERT_EQUAL(id57, result); 22 | } 23 | 24 | void PrimaryKeyUnitTest::test_share() 25 | { 26 | // std::string id("max@mustermann.de"); 27 | // std::string gollum("gollum@mittelerde.to"); 28 | // matador::identifier email(id); 29 | // 30 | // UNIT_ASSERT_EQUAL(id, email.value()); 31 | // 32 | // matador::identifier shared_email; 33 | // 34 | // UNIT_ASSERT_TRUE(shared_email.value().empty()); 35 | // 36 | //// email.share_with(shared_email); 37 | // 38 | //// UNIT_ASSERT_EQUAL(id, shared_email.value()); 39 | // 40 | // email.value(gollum); 41 | // 42 | // UNIT_ASSERT_EQUAL(gollum, email.value()); 43 | // UNIT_ASSERT_EQUAL(gollum, shared_email.value()); 44 | } 45 | -------------------------------------------------------------------------------- /examples/net/echo_server_connection.cpp: -------------------------------------------------------------------------------- 1 | #include "echo_server_connection.hpp" 2 | 3 | #include 4 | 5 | using namespace matador; 6 | 7 | echo_server_connection::echo_server_connection(io_stream &stream, matador::tcp::peer endpoint) 8 | : log_(matador::create_logger("EchoServerConnection")) 9 | , stream_(stream) 10 | , endpoint_(std::move(endpoint)) 11 | {} 12 | 13 | void echo_server_connection::start() 14 | { 15 | read(); 16 | } 17 | 18 | void echo_server_connection::read() 19 | { 20 | auto self(shared_from_this()); 21 | stream_.read(matador::buffer_view(buf_), [this, self](int ec, int nread) { 22 | if (ec == 0) { 23 | log_.info( 24 | "%s read (bytes: %d)> %s", 25 | endpoint_.to_string().c_str(), nread, std::string(buf_.data(), buf_.size()).c_str() 26 | ); 27 | echo_.assign(buf_.data(), nread); 28 | write(); 29 | } 30 | }); 31 | } 32 | 33 | void echo_server_connection::write() 34 | { 35 | auto self(shared_from_this()); 36 | 37 | std::list data{ matador::buffer_view(echo_) }; 38 | 39 | stream_.write(data, [this, self](int ec, int nwrite) { 40 | if (ec == 0) { 41 | log_.info("%s sent (bytes: %d)", endpoint_.to_string().c_str(), nwrite); 42 | read(); 43 | } 44 | }); 45 | } 46 | -------------------------------------------------------------------------------- /include/matador/logger/basic_file_sink.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_BASIC_FILE_SINK_HPP 2 | #define MATADOR_BASIC_FILE_SINK_HPP 3 | 4 | #include "matador/logger/export.hpp" 5 | 6 | #include "matador/logger/log_sink.hpp" 7 | 8 | #include 9 | 10 | namespace matador { 11 | 12 | /** 13 | * @brief A base class for file stream based sinks 14 | * 15 | * This class acts like a base class for all 16 | * concrete sinks working with a file stream to write 17 | * the log message. 18 | */ 19 | class OOS_LOGGER_API basic_file_sink : public log_sink 20 | { 21 | protected: 22 | basic_file_sink() = default; 23 | 24 | /** 25 | * Creates a basic_file_sink with a given file stream 26 | * 27 | * @param f File stream to write on 28 | */ 29 | explicit basic_file_sink(FILE *f); 30 | 31 | public: 32 | /** 33 | * Writes the log message to the internal 34 | * file stream. 35 | * 36 | * @param message The message to write 37 | * @param size The size of the message 38 | */ 39 | void write(const char *message, size_t size) override; 40 | 41 | /** 42 | * Closes the internal file stream. 43 | */ 44 | void close() override; 45 | 46 | protected: 47 | /// @cond MATADOR_DEV 48 | FILE *stream = nullptr; 49 | /// @endcond 50 | }; 51 | 52 | } 53 | #endif //MATADOR_BASIC_FILE_SINK_HPP 54 | -------------------------------------------------------------------------------- /include/matador/object/action_inserter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_ACTION_INSERTER_HPP 2 | #define OOS_ACTION_INSERTER_HPP 3 | 4 | #include "matador/object/export.hpp" 5 | 6 | #include "matador/object/action_visitor.hpp" 7 | #include "matador/object/action.hpp" 8 | 9 | #include 10 | #include 11 | 12 | namespace matador { 13 | 14 | /// @cond MATADOR_DEV 15 | 16 | class object_proxy; 17 | 18 | class MATADOR_OBJECT_API action_inserter : public action_visitor 19 | { 20 | public: 21 | typedef std::shared_ptr action_ptr; 22 | typedef std::vector t_action_vactor; 23 | typedef t_action_vactor::iterator action_iterator; 24 | 25 | public: 26 | action_inserter(t_action_vactor &actions); 27 | 28 | virtual ~action_inserter() { } 29 | 30 | t_action_vactor::size_type insert(object_proxy *proxy); 31 | 32 | virtual void visit(insert_action *a); 33 | virtual void visit(update_action *a); 34 | virtual void visit(delete_action *a); 35 | 36 | private: 37 | void* object(object_proxy *proxy) const; 38 | const char* type(object_proxy *proxy) const; 39 | 40 | private: 41 | std::reference_wrapper actions_; 42 | object_proxy *proxy_ = nullptr; 43 | bool inserted_ = false; 44 | }; 45 | 46 | /// @endcond 47 | 48 | } 49 | 50 | #endif //OOS_ACTION_INSERTER_HPP 51 | -------------------------------------------------------------------------------- /include/matador/http/static_file_service.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_STATIC_FILE_SERVICE_HPP 2 | #define MATADOR_STATIC_FILE_SERVICE_HPP 3 | 4 | #include "matador/http/export.hpp" 5 | 6 | #include "matador/http/http_server.hpp" 7 | 8 | #include "matador/logger/log_manager.hpp" 9 | 10 | namespace matador { 11 | namespace http { 12 | 13 | /** 14 | * Shortcut function for adding a static file route 15 | * to the given server. All files at the given path will 16 | * be served by the given server. 17 | * 18 | * @param path Where the static files resides 19 | * @param s The http server 20 | */ 21 | OOS_HTTP_API void serve_static_files_at(const std::string &path, server &s); 22 | 23 | /** 24 | * This class stands as a static file service 25 | * for a given server and path. 26 | */ 27 | class OOS_HTTP_API static_file_service 28 | { 29 | public: 30 | /** 31 | * Constructor creating a static file route 32 | * to the given server. All files at the given path will 33 | * be served by the given server. 34 | * 35 | * @param path 36 | * @param s 37 | */ 38 | static_file_service(const std::string &path, server &s); 39 | 40 | private: 41 | response serve(const request &req); 42 | 43 | private: 44 | matador::logger log_; 45 | }; 46 | 47 | } 48 | } 49 | 50 | #endif //MATADOR_STATIC_FILE_SERVICE_HPP 51 | -------------------------------------------------------------------------------- /include/matador/logger/log_level.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_LOG_LEVEL_HPP 2 | #define MATADOR_LOG_LEVEL_HPP 3 | 4 | #include "matador/logger/export.hpp" 5 | 6 | #include 7 | 8 | namespace matador { 9 | 10 | /** 11 | * Represents all available log levels 12 | */ 13 | enum class log_level 14 | { 15 | LVL_FATAL, /**< If a serious error occurred use FATAL level */ 16 | LVL_ERROR, /**< On error use ERROR level */ 17 | LVL_WARN, /**< Warnings should use WARN level */ 18 | LVL_INFO, /**< Information should go with INFO level */ 19 | LVL_DEBUG, /**< Debug output should use DEBUG level */ 20 | LVL_TRACE, /**< Trace information should use TRACE level */ 21 | LVL_ALL /**< This level represents all log levels and should be used for logging */ 22 | }; 23 | 24 | /** 25 | * Write log level in human readable string 26 | * to a given std::ostream. 27 | * 28 | * @param os std::stream to write to 29 | * @param lvl Log level to write 30 | * @return The std::ostream 31 | */ 32 | OOS_LOGGER_API std::ostream& operator<<(std::ostream &os, log_level lvl); 33 | 34 | /// @cond MATADOR_DEV 35 | 36 | struct log_level_range 37 | { 38 | log_level min_level = log_level::LVL_INFO; 39 | log_level max_level = log_level::LVL_FATAL; 40 | }; 41 | 42 | /// @endcond 43 | 44 | } 45 | #endif //MATADOR_LOG_LEVEL_HPP 46 | -------------------------------------------------------------------------------- /examples/demo/web/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Main page 8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 |

Page Title

16 |

A subtitle for your page goes here

17 |
18 | 19 |
20 |
21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 |
IDTitleYear
{{ movie.id }}{{ movie.title }}{{ movie.year }}
38 |
39 |
40 |
41 | 42 | -------------------------------------------------------------------------------- /include/matador/db/mysql/mysql_statement.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MYSQL_STATEMENT_HPP 2 | #define MYSQL_STATEMENT_HPP 3 | 4 | #include "matador/sql/statement_impl.hpp" 5 | 6 | #include "matador/db/mysql/mysql_result_info.hpp" 7 | #include "matador/db/mysql/mysql_parameter_binder.hpp" 8 | 9 | #ifdef _MSC_VER 10 | #include 11 | #else 12 | #include 13 | #endif 14 | 15 | #include 16 | #include 17 | #include 18 | 19 | namespace matador { 20 | 21 | class time; 22 | class date; 23 | 24 | namespace mysql { 25 | 26 | class mysql_connection; 27 | class mysql_prepared_result; 28 | 29 | class mysql_statement : public matador::detail::statement_impl 30 | { 31 | public: 32 | mysql_statement(MYSQL *db, detail::statement_context &&context); 33 | ~mysql_statement() override; 34 | 35 | void clear() override; 36 | detail::result_impl* execute() override; 37 | void reset() override; 38 | 39 | void unlink_result(mysql_prepared_result *result); 40 | 41 | protected: 42 | detail::parameter_binder_impl *binder() const override; 43 | 44 | private: 45 | MYSQL_STMT *stmt_ = nullptr; 46 | 47 | mysql_prepared_result *current_result = nullptr; 48 | 49 | std::unique_ptr binder_; 50 | }; 51 | 52 | } 53 | 54 | } 55 | 56 | #endif /* MYSQL_STATEMENT_HPP */ 57 | -------------------------------------------------------------------------------- /cmake/FindMatadorBackendMSSQL.cmake: -------------------------------------------------------------------------------- 1 | # Find MATADOR Backend MSSQL 2 | # Find the MATADOR MSSQL backend library 3 | # This module defines 4 | # MATADOR_BACKEND_MSSQL_LIBRARY, the library needed to use MATADOR with MSSQL. 5 | # MATADOR_BACKEND_MSSQL_FOUND, If false, do not try to use MATADOR. 6 | 7 | if(MATADOR_BACKEND_MSSQL_LIBRARY) 8 | set(MATADOR_BACKEND_MSSQL_FOUND TRUE) 9 | else() 10 | 11 | if(WIN32) 12 | find_library(MATADOR_BACKEND_MSSQL_LIBRARY matador-mssql 13 | PATHS 14 | $ENV{ProgramFiles}/matador/*/lib/ 15 | ${PROGRAMFILES}/matador/lib/ 16 | $ENV{SystemDrive}/matador/*/lib/ 17 | ) 18 | else() 19 | find_library(MATADOR_BACKEND_MSSQL_LIBRARY matador-mssql 20 | PATHS 21 | /usr/lib 22 | /usr/lib/matador 23 | /usr/local/lib 24 | /usr/local/lib/matador 25 | /opt/matador/lib 26 | ) 27 | endif() 28 | 29 | if(MATADOR_BACKEND_MSSQL_LIBRARY) 30 | set(MATADOR_BACKEND_MSSQL_FOUND TRUE) 31 | else() 32 | set(MATADOR_BACKEND_MSSQL_FOUND FALSE) 33 | if (MATADOR_FIND_REQUIRED) 34 | message(FATAL_ERROR "MATADOR MSSQL backend not found.") 35 | else () 36 | message(STATUS "MATADOR MSSQL backend not found.") 37 | endif () 38 | endif() 39 | 40 | mark_as_advanced(MATADOR_BACKEND_MSSQL_LIBRARY) 41 | 42 | endif() 43 | -------------------------------------------------------------------------------- /cmake/FindMatadorBackendMySQL.cmake: -------------------------------------------------------------------------------- 1 | # Find MATADOR Backend MySQL 2 | # Find the MATADOR MySQL backend library 3 | # This module defines 4 | # MATADOR_BACKEND_MYSQL_LIBRARY, the library needed to use MATADOR with MySQL. 5 | # MATADOR_BACKEND_MYSQL_FOUND, If false, do not try to use MATADOR. 6 | 7 | if(MATADOR_BACKEND_MYSQL_LIBRARY) 8 | set(MATADOR_BACKEND_MYSQL_FOUND TRUE) 9 | else() 10 | 11 | if(WIN32) 12 | find_library(MATADOR_BACKEND_MYSQL_LIBRARY matador-mysql 13 | PATHS 14 | $ENV{ProgramFiles}/matador/*/lib/ 15 | ${PROGRAMFILES}/matador/lib/ 16 | $ENV{SystemDrive}/matador/*/lib/ 17 | ) 18 | else() 19 | find_library(MATADOR_BACKEND_MYSQL_LIBRARY matador-mysql 20 | PATHS 21 | /usr/lib 22 | /usr/lib/matador 23 | /usr/local/lib 24 | /usr/local/lib/matador 25 | /opt/matador/lib 26 | ) 27 | endif() 28 | 29 | if(MATADOR_BACKEND_MYSQL_LIBRARY) 30 | set(MATADOR_BACKEND_MYSQL_FOUND TRUE) 31 | else() 32 | set(MATADOR_BACKEND_MYSQL_FOUND FALSE) 33 | if (MATADOR_FIND_REQUIRED) 34 | message(FATAL_ERROR "MATADOR MySQL backend not found.") 35 | else () 36 | message(STATUS "MATADOR MySQL backend not found.") 37 | endif () 38 | endif() 39 | 40 | mark_as_advanced(MATADOR_BACKEND_MYSQL_LIBRARY) 41 | 42 | endif() 43 | -------------------------------------------------------------------------------- /include/matador/utils/base_class.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BASE_CLASS_HPP 2 | #define BASE_CLASS_HPP 3 | 4 | #include 5 | 6 | namespace matador { 7 | 8 | /** 9 | * @brief Safely casts a given derived class to its base class 10 | * 11 | * @tparam B The base class type 12 | * @tparam D The class type of the derived class 13 | * @param derived The derived object 14 | * @return The casted object 15 | */ 16 | template < class B, class D> 17 | const B* base_class(const D *derived) 18 | { 19 | static_assert(!std::is_same::value, "class B must not be of same type as class D"); 20 | static_assert(std::is_base_of::value, "class B must be base of class D"); 21 | return static_cast(derived); 22 | } 23 | 24 | /** 25 | * @brief Safely casts a given derived class to its base class 26 | * 27 | * @tparam B The base class type 28 | * @tparam D The class type of the derived class 29 | * @param derived The derived object 30 | * @return The casted object 31 | */ 32 | template < class B, class D> 33 | B* base_class(D *derived) 34 | { 35 | static_assert(!std::is_same::value, "class B must not be of same type as class D"); 36 | static_assert(std::is_base_of::value, "class B must be base of class D"); 37 | return static_cast(derived); 38 | } 39 | 40 | } 41 | 42 | #endif /* BASE_CLASS_HPP */ 43 | -------------------------------------------------------------------------------- /cmake/FindMatadorBackendSQLite.cmake: -------------------------------------------------------------------------------- 1 | # Find MATADOR Backend SQLite 2 | # Find the MATADOR sqlite backend library 3 | # This module defines 4 | # MATADOR_BACKEND_SQLITE_LIBRARY, the library needed to use MATADOR with sqlite. 5 | # MATADOR_BACKEND_SQLITE_FOUND, If false, do not try to use MATADOR. 6 | 7 | if(MATADOR_BACKEND_SQLITE_LIBRARY) 8 | set(MATADOR_BACKEND_SQLITE_FOUND TRUE) 9 | else() 10 | 11 | if(WIN32) 12 | find_library(MATADOR_BACKEND_SQLITE_LIBRARY matador-sqlite 13 | PATHS 14 | $ENV{ProgramFiles}/matador/*/lib/ 15 | ${PROGRAMFILES}/matador/lib/ 16 | $ENV{SystemDrive}/matador/*/lib/ 17 | ) 18 | else() 19 | find_library(MATADOR_BACKEND_SQLITE_LIBRARY matador-sqlite 20 | PATHS 21 | /usr/lib 22 | /usr/lib/matador 23 | /usr/local/lib 24 | /usr/local/lib/matador 25 | /opt/matador/lib 26 | ) 27 | endif() 28 | 29 | if(MATADOR_BACKEND_SQLITE_LIBRARY) 30 | set(MATADOR_BACKEND_SQLITE_FOUND TRUE) 31 | else() 32 | set(MATADOR_BACKEND_SQLITE_FOUND FALSE) 33 | if (MATADOR_FIND_REQUIRED) 34 | message(FATAL_ERROR "MATADOR SQLite backend not found.") 35 | else () 36 | message(STATUS "MATADOR SQLite backend not found.") 37 | endif () 38 | endif() 39 | 40 | mark_as_advanced(MATADOR_BACKEND_SQLITE_LIBRARY) 41 | 42 | endif() 43 | -------------------------------------------------------------------------------- /src/utils/buffer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "matador/utils/buffer.hpp" 4 | 5 | namespace matador { 6 | 7 | using namespace std; 8 | 9 | void buffer::append(const char *chunk, size_t size) 10 | { 11 | std::lock_guard lock(mutex_); 12 | if (size_ + size > buf_.max_size()) { 13 | throw std::out_of_range("size exceeds buffer capacity"); 14 | } 15 | memcpy((void*)(buf_.data() + size_), chunk, size); 16 | size_ += size; 17 | } 18 | 19 | void buffer::append(const buffer &buf) 20 | { 21 | append(buf.data(), buf.size()); 22 | } 23 | 24 | void buffer::append(const string &str) 25 | { 26 | append(str.data(), str.size()); 27 | } 28 | 29 | char* buffer::data() 30 | { 31 | return buf_.data(); 32 | } 33 | 34 | const char* buffer::data() const 35 | { 36 | return buf_.data(); 37 | } 38 | 39 | size_t buffer::capacity() const 40 | { 41 | return buf_.max_size(); 42 | } 43 | 44 | size_t buffer::size() const 45 | { 46 | return size_; 47 | } 48 | 49 | void buffer::size(std::size_t s) 50 | { 51 | std::lock_guard lock(mutex_); 52 | size_ = s; 53 | } 54 | 55 | bool buffer::empty() const 56 | { 57 | std::lock_guard lock(mutex_); 58 | return size_ == 0; 59 | } 60 | 61 | void buffer::clear() 62 | { 63 | std::lock_guard lock(mutex_); 64 | size_ = 0; 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /cmake/Matador.cmake: -------------------------------------------------------------------------------- 1 | SET(MATADOR_DB_LIBRARIES) 2 | 3 | IF(ODBC_FOUND) 4 | MESSAGE(STATUS "Appending ODBC libs: ${ODBC_LIBRARIES}") 5 | LIST(APPEND MATADOR_DB_LIBRARIES ${ODBC_LIBRARIES}) 6 | MESSAGE(STATUS "Adding ODBC include directory: ${ODBC_INCLUDE_DIRS}") 7 | INCLUDE_DIRECTORIES(${ODBC_INCLUDE_DIRS}) 8 | ENDIF() 9 | 10 | IF(MYSQL_FOUND) 11 | MESSAGE(STATUS "Appending MySQL libs: ${MYSQL_LIBRARY}") 12 | LIST(APPEND MATADOR_DB_LIBRARIES ${MYSQL_LIBRARY}) 13 | MESSAGE(STATUS "Adding MySQL include directory: ${MYSQL_INCLUDE_DIR}") 14 | INCLUDE_DIRECTORIES(${MYSQL_INCLUDE_DIR}) 15 | ENDIF() 16 | 17 | IF(SQLite3_FOUND) 18 | MESSAGE(STATUS "Found SQLite3 version ${SQLite3_VERSION}") 19 | MESSAGE(STATUS "Appending SQLite3 libs: ${SQLite3_LIBRARIES}") 20 | LIST(APPEND MATADOR_DB_LIBRARIES ${SQLite3_LIBRARIES}) 21 | MESSAGE(STATUS "Adding SQLite3 include directory: ${SQLite3_INCLUDE_DIRS}") 22 | INCLUDE_DIRECTORIES(${SQLite3_INCLUDE_DIRS}) 23 | ENDIF() 24 | 25 | IF(PostgreSQL_FOUND) 26 | MESSAGE(STATUS "Found PostgreSQL version ${PostgreSQL_VERSION_STRING}") 27 | MESSAGE(STATUS "Appending PostgreSQL libs: ${PostgreSQL_LIBRARIES}") 28 | LIST(APPEND MATADOR_DB_LIBRARIES ${PostgreSQL_LIBRARIES}) 29 | MESSAGE(STATUS "Adding PostgreSQL include directory: ${PostgreSQL_INCLUDE_DIRS}") 30 | INCLUDE_DIRECTORIES(${PostgreSQL_INCLUDE_DIRS}) 31 | ENDIF() -------------------------------------------------------------------------------- /examples/demo/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | SET(NET_LIBRARIES) 2 | 3 | IF(WIN32) 4 | MESSAGE(STATUS "Appending Windows Socket libs: wsock32 ws2_32") 5 | LIST(APPEND NET_LIBRARIES wsock32 ws2_32) 6 | ENDIF() 7 | 8 | SET (DEMO_SOURCES 9 | main.cpp 10 | services/auth_service.cpp 11 | services/auth_service.hpp 12 | models/credential.hpp 13 | models/user.hpp 14 | pages/movie_page.cpp 15 | pages/movie_page.hpp 16 | models/movie.hpp 17 | models/person.hpp 18 | services/movie_service.cpp 19 | services/movie_service.hpp pages/main_page.cpp pages/main_page.hpp 20 | pages/crud_page.hpp 21 | pages/directors_page.cpp 22 | pages/directors_page.hpp) 23 | 24 | ADD_EXECUTABLE(demo ${DEMO_SOURCES}) 25 | 26 | add_custom_command(TARGET demo PRE_BUILD 27 | COMMAND ${CMAKE_COMMAND} -E copy_directory 28 | ${CMAKE_SOURCE_DIR}/examples/demo/web/ $/web) 29 | 30 | add_custom_command(TARGET demo PRE_BUILD 31 | COMMAND ${CMAKE_COMMAND} -E copy_directory 32 | ${CMAKE_SOURCE_DIR}/examples/demo/templates/ $/templates) 33 | 34 | TARGET_LINK_LIBRARIES(demo 35 | matador-utils 36 | matador-json 37 | matador-logger 38 | matador-sql 39 | matador-object 40 | matador-orm 41 | matador-net 42 | matador-http 43 | ${CMAKE_DL_LIBS} 44 | ${CMAKE_THREAD_LIBS_INIT} 45 | ${NET_LIBRARIES} 46 | ${SQLite3_LIBRARIES} 47 | ) 48 | -------------------------------------------------------------------------------- /include/matador/utils/cascade_type.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_CASCADE_TYPE_HPP 2 | #define OOS_CASCADE_TYPE_HPP 3 | 4 | namespace matador { 5 | 6 | /** 7 | * @brief Cascade types for database actions 8 | */ 9 | enum class cascade_type 10 | { 11 | NONE = 0, /**< Cascade type none */ 12 | REMOVE = 1, /**< Cascade type remove */ 13 | UPDATE = 2, /**< Cascade type update */ 14 | INSERT = 4, /**< Cascade type insert */ 15 | ALL = REMOVE | UPDATE | INSERT /**< Cascade type all */ 16 | }; 17 | 18 | inline cascade_type operator~ (cascade_type a) { return (cascade_type)~(int)a; } 19 | inline cascade_type operator| (cascade_type a, cascade_type b) { return (cascade_type)((int)a | (int)b); } 20 | inline cascade_type operator& (cascade_type a, cascade_type b) { return (cascade_type)((int)a & (int)b); } 21 | inline cascade_type operator^ (cascade_type a, cascade_type b) { return (cascade_type)((int)a ^ (int)b); } 22 | inline cascade_type& operator|= (cascade_type& a, cascade_type b) { return (cascade_type&)((int&)a |= (int)b); } 23 | inline cascade_type& operator&= (cascade_type& a, cascade_type b) { return (cascade_type&)((int&)a &= (int)b); } 24 | inline cascade_type& operator^= (cascade_type& a, cascade_type b) { return (cascade_type&)((int&)a ^= (int)b); } 25 | 26 | } 27 | #endif //OOS_CASCADE_TYPE_HPP 28 | -------------------------------------------------------------------------------- /include/matador/http/detail/template_filter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MATADOR_TEMPLATE_FILTER_HPP 2 | #define MATADOR_TEMPLATE_FILTER_HPP 3 | 4 | #include "matador/http/export.hpp" 5 | 6 | #include "matador/json/json.hpp" 7 | 8 | #include 9 | #include 10 | 11 | namespace matador { 12 | namespace http { 13 | namespace detail { 14 | 15 | /// @cond MATADOR_DEV 16 | 17 | class OOS_HTTP_API template_filter 18 | { 19 | public: 20 | virtual ~template_filter() = default; 21 | 22 | json apply(const json &data); 23 | void append(const std::shared_ptr &filter); 24 | 25 | protected: 26 | virtual json evaluate(const json &data) = 0; 27 | 28 | private: 29 | std::shared_ptr next_; 30 | }; 31 | 32 | class OOS_HTTP_API escape_filter : public template_filter 33 | { 34 | public: 35 | json evaluate(const json &data) override; 36 | }; 37 | 38 | class OOS_HTTP_API capfirst_filter : public template_filter 39 | { 40 | public: 41 | json evaluate(const json &data) override; 42 | }; 43 | 44 | class OOS_HTTP_API upper_filter : public template_filter 45 | { 46 | public: 47 | json evaluate(const json &data) override; 48 | }; 49 | 50 | class OOS_HTTP_API lower_filter : public template_filter 51 | { 52 | public: 53 | json evaluate(const json &data) override; 54 | }; 55 | 56 | /// @endcond 57 | 58 | } 59 | } 60 | } 61 | #endif //MATADOR_TEMPLATE_FILTER_HPP 62 | -------------------------------------------------------------------------------- /src/sql/database_error.cpp: -------------------------------------------------------------------------------- 1 | #include "matador/sql/database_error.hpp" 2 | 3 | #include 4 | 5 | namespace matador { 6 | 7 | database_error::database_error(const char *what, std::string source, long ec, std::string sql) 8 | : std::runtime_error(what) 9 | , source_(std::move(source)) 10 | , error_code_(ec) 11 | , sql_stmt_(std::move(sql)) 12 | {} 13 | 14 | database_error::database_error(const char *what, std::string source, std::string sqlstate, long ec, 15 | std::string sql) 16 | : std::runtime_error(what) 17 | , source_(std::move(source)) 18 | , error_code_(ec) 19 | , sqlstate_(std::move(sqlstate)) 20 | , sql_stmt_(std::move(sql)) 21 | {} 22 | 23 | database_error::database_error(const char *what, std::string source, std::string sqlstate, std::string sql) 24 | : std::runtime_error(what) 25 | , source_(std::move(source)) 26 | , sqlstate_(std::move(sqlstate)) 27 | , sql_stmt_(std::move(sql)) 28 | {} 29 | 30 | const char *database_error::source() const noexcept 31 | { 32 | return source_.c_str(); 33 | } 34 | 35 | long database_error::error_code() const noexcept 36 | { 37 | return error_code_; 38 | } 39 | 40 | const char *database_error::sql_state() const noexcept 41 | { 42 | return sqlstate_.c_str(); 43 | } 44 | 45 | const char *database_error::sql_statement() const noexcept 46 | { 47 | return sql_stmt_.c_str(); 48 | } 49 | } -------------------------------------------------------------------------------- /include/matador/object/update_action.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OOS_UPDATE_ACTION_HPP 2 | #define OOS_UPDATE_ACTION_HPP 3 | 4 | #include "matador/object/action.hpp" 5 | #include "matador/object/delete_action.hpp" 6 | 7 | #include 8 | 9 | namespace matador { 10 | 11 | class object_proxy; 12 | 13 | /// @cond MATADOR_DEV 14 | 15 | /** 16 | * @internal 17 | * @class update_action 18 | * @brief Action when updating an serializable. 19 | * 20 | * This action is used when an objected 21 | * is updated on the database. 22 | */ 23 | class MATADOR_OBJECT_API update_action : public action 24 | { 25 | public: 26 | /** 27 | * Creates an update_action. 28 | * 29 | * @param o The updated serializable. 30 | */ 31 | explicit update_action(object_proxy *proxy); 32 | 33 | void accept(action_visitor *av) override; 34 | 35 | /** 36 | * The serializable of the action. 37 | */ 38 | object_proxy* proxy(); 39 | 40 | /** 41 | * The serializable of the action. 42 | */ 43 | const object_proxy* proxy() const; 44 | 45 | void backup(byte_buffer &buffer) override; 46 | 47 | void restore(byte_buffer &buffer, object_store *store) override; 48 | 49 | delete_action* release_delete_action(); 50 | 51 | private: 52 | object_proxy *proxy_; 53 | std::unique_ptr delete_action_; 54 | }; 55 | 56 | /// @endcond 57 | 58 | } 59 | 60 | #endif //OOS_UPDATE_ACTION_HPP 61 | -------------------------------------------------------------------------------- /include/matador/orm/persistence_observer.tpp: -------------------------------------------------------------------------------- 1 | #include "matador/orm/persistence_observer.hpp" 2 | #include "matador/orm/persistence.hpp" 3 | #include "matador/orm/table.hpp" 4 | 5 | namespace matador { 6 | 7 | template < class T > 8 | void persistence_observer::on_attach(prototype_node &node, T&) 9 | { 10 | if (node.is_abstract()) { 11 | return; 12 | } 13 | if (persistence_.tables_.find(node.type()) != persistence_.tables_.end()) { 14 | return; 15 | } 16 | persistence_.tables_.insert(std::make_pair(node.type(), std::make_shared>(node, persistence_))); 17 | } 18 | 19 | template < class T > 20 | void persistence_observer::on_detach(prototype_node &node, T&) 21 | { 22 | if (node.is_abstract()) { 23 | return; 24 | } 25 | auto i = persistence_.tables_.find(node.type()); 26 | if (i == persistence_.tables_.end()) { 27 | return; 28 | } 29 | persistence_.tables_.erase(i); 30 | } 31 | 32 | template 33 | void persistence_observer::on_insert(object_proxy &proxy) 34 | { 35 | persistence_.register_proxy_insert(proxy); 36 | } 37 | 38 | template 39 | void persistence_observer::on_update(object_proxy &proxy) 40 | { 41 | persistence_.register_proxy_update(proxy); 42 | } 43 | 44 | template 45 | void persistence_observer::on_delete(object_proxy &proxy) 46 | { 47 | persistence_.register_proxy_delete(proxy); 48 | } 49 | 50 | } --------------------------------------------------------------------------------