predicates.h

/*
 * Copyright (c) 2008-2022, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include "hazelcast/client/serialization/serialization.h"
 
#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable: 4251) //for dll export
#endif
 
namespace hazelcast {
    namespace client {
        class hazelcast_client;
 
        namespace query {
            struct HAZELCAST_API query_constants {
                static const char * const KEY_ATTRIBUTE_NAME;
                static const char * const THIS_ATTRIBUTE_NAME;
            };
 
            class HAZELCAST_API predicate {
            };
 
            struct HAZELCAST_API base_predicate : public predicate {
                explicit base_predicate(hazelcast_client &client);
 
                serialization::object_data_output out_stream;
            };
 
            class HAZELCAST_API named_predicate : public base_predicate {
            protected:
                explicit named_predicate(hazelcast_client &client, const std::string &attribute_name);
            };
 
            class multi_predicate : public base_predicate {
            public:
                template<typename ...Args>
                multi_predicate(hazelcast_client &client, const Args &...values) : base_predicate(client) {
                    out_stream.write<int32_t>(static_cast<int32_t>(sizeof...(values)));
                    out_stream.write_objects(values...);
                }
 
                template<typename ...Args>
                multi_predicate(const std::string attribute_name, hazelcast_client &client, const Args &...values) : base_predicate(client) {
                    out_stream.write(attribute_name);
                    out_stream.write<int32_t>(static_cast<int32_t>(sizeof...(values)));
                    out_stream.write_objects(values...);
                }
 
                template<typename T>
                multi_predicate(const std::string attribute_name, hazelcast_client &client, const std::vector<T> &values) : base_predicate(client) {
                    out_stream.write(attribute_name);
                    out_stream.write<int32_t>(static_cast<int32_t>(values.size()));
                    for (const T &value : values) {
                        out_stream.write_object(value);
                    }
                }
            };
 
            enum struct predicate_data_serializer_hook {
                F_ID = -20,
 
                SQL_PREDICATE = 0,
 
                AND_PREDICATE = 1,
 
                BETWEEN_PREDICATE = 2,
 
                EQUAL_PREDICATE = 3,
 
                GREATERLESS_PREDICATE = 4,
 
                LIKE_PREDICATE = 5,
 
                ILIKE_PREDICATE = 6,
 
                IN_PREDICATE = 7,
 
                INSTANCEOF_PREDICATE = 8,
 
                NOTEQUAL_PREDICATE = 9,
 
                NOT_PREDICATE = 10,
 
                OR_PREDICATE = 11,
 
                REGEX_PREDICATE = 12,
 
                FALSE_PREDICATE = 13,
 
                TRUE_PREDICATE = 14,
 
                PAGING_PREDICATE = 15
            };
 
            class equal_predicate : public named_predicate {
            public:
                template<typename T>
                equal_predicate(hazelcast_client &client, const std::string &attribute_name, const T &value)
                        : named_predicate(client, attribute_name) {
                    out_stream.write_object(value);
                }
            };
 
            class not_equal_predicate : public named_predicate {
            public:
                template<typename T>
                not_equal_predicate(hazelcast_client &client, const std::string &attribute_name, const T &value)
                        : named_predicate(client, attribute_name) {
                    out_stream.write_object(value);
                }
            };
 
            class greater_less_predicate : public named_predicate {
            public:
                template<typename T>
                greater_less_predicate(hazelcast_client &client, const std::string &attribute_name, const T &value,
                                       bool is_equal, bool is_less)
                        : named_predicate(client, attribute_name) {
                    out_stream.write_object(value);
                    out_stream.write(is_equal);
                    out_stream.write(is_less);
                }
            };
 
            class between_predicate : public named_predicate {
            public:
                template<typename FROM_TYPE, typename TO_TYPE>
                between_predicate(hazelcast_client &client, const std::string &attribute_name, const FROM_TYPE &from,
                                  const TO_TYPE &to)
                        : named_predicate(client, attribute_name) {
                    out_stream.write_object(to);
                    out_stream.write_object(from);
                }
            };
 
            class HAZELCAST_API false_predicate : public base_predicate {
            public:
                false_predicate(hazelcast_client &client);
            };
 
            class HAZELCAST_API true_predicate : public base_predicate {
            public:
                true_predicate(hazelcast_client &client);
            };
 
            class HAZELCAST_API instance_of_predicate : public base_predicate {
            public:
                instance_of_predicate(hazelcast_client &client, const std::string &java_class_name);
            };
 
            class HAZELCAST_API sql_predicate : public base_predicate {
            public:
                sql_predicate(hazelcast_client &client, const std::string &sql);
            };
 
            class HAZELCAST_API like_predicate : public named_predicate {
            public:
                like_predicate(hazelcast_client &client, const std::string &attribute, const std::string &expression);
            };
 
            class HAZELCAST_API ilike_predicate : public named_predicate {
            public:
                ilike_predicate(hazelcast_client &client, const std::string &attribute, const std::string &expression);
            };
 
            class HAZELCAST_API regex_predicate : public named_predicate {
            public:
                regex_predicate(hazelcast_client &client, const std::string &attribute, const std::string &expression);
            };
 
            class in_predicate : public multi_predicate {
            public:
                template<typename ...Args>
                in_predicate(hazelcast_client &client, const std::string &attribute_name, const Args &...values)
                        : multi_predicate(attribute_name, client, values...) {}
 
                template<typename T>
                in_predicate(hazelcast_client &client, const std::string &attribute_name, const std::vector<T> &values)
                        : multi_predicate(attribute_name, client, values) {}
            };
 
            class and_predicate : public multi_predicate {
            public:
                template<typename ...Args>
                and_predicate(hazelcast_client &client, const Args &...values) : multi_predicate(client, values...) {}
            };
 
            class or_predicate : public multi_predicate {
            public:
                template<typename ...PredicateTypes>
                or_predicate(hazelcast_client &client, const PredicateTypes &...values) : multi_predicate(client, values...) {}
            };
 
            class not_predicate : public base_predicate {
            public:
                template<typename T>
                not_predicate(hazelcast_client &client, const T &predicate) : base_predicate(client) {
                    out_stream.write_object(predicate);
                }
            };
        }
 
        namespace serialization {
            template<typename T>
            struct BasePredicateSerializer : public identified_data_serializer {
                static constexpr int32_t get_factory_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::F_ID);
                }
 
                static void write_data(const T &object, object_data_output &out) {
                    out.append_bytes(object.out_stream.to_byte_array());
                }
 
                static T read_data(object_data_input &in) {
                    // Not need to read at the client side
                    BOOST_THROW_EXCEPTION(exception::hazelcast_serialization("readData",
                                                                                       "Client should not need to use readdata method!!!"));
                }
            };
 
            template<>
            struct hz_serializer<query::between_predicate> : public BasePredicateSerializer<query::between_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::BETWEEN_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::equal_predicate> : public BasePredicateSerializer<query::equal_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::EQUAL_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::not_equal_predicate> : public BasePredicateSerializer<query::not_equal_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::NOTEQUAL_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::greater_less_predicate>
                    : public BasePredicateSerializer<query::greater_less_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::GREATERLESS_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::false_predicate> : public BasePredicateSerializer<query::false_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::FALSE_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::true_predicate> : public BasePredicateSerializer<query::true_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::TRUE_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::like_predicate> : public BasePredicateSerializer<query::like_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::LIKE_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::instance_of_predicate>
                    : public BasePredicateSerializer<query::instance_of_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::INSTANCEOF_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::sql_predicate>
                    : public BasePredicateSerializer<query::sql_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::SQL_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::ilike_predicate> : public BasePredicateSerializer<query::ilike_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::ILIKE_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::regex_predicate> : public BasePredicateSerializer<query::regex_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::REGEX_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::in_predicate> : public BasePredicateSerializer<query::in_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::IN_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::and_predicate> : public BasePredicateSerializer<query::and_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::AND_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::or_predicate> : public BasePredicateSerializer<query::or_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::OR_PREDICATE);
                }
            };
 
            template<>
            struct hz_serializer<query::not_predicate> : public BasePredicateSerializer<query::not_predicate> {
                static constexpr int32_t get_class_id() noexcept {
                    return static_cast<int32_t>(query::predicate_data_serializer_hook::NOT_PREDICATE);
                }
            };
        };
    }
}
 
#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif