index_config.h

/*
 * Copyright (c) 2008-2021, 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 <string>

#include "hazelcast/util/export.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 {
        namespace config {
            struct HAZELCAST_API index_config {
                struct HAZELCAST_API bitmap_index_options {
                    enum unique_key_transformation {
                        OBJECT,

                        LONG,

                        RAW
                    };

                    std::string key;
                    unique_key_transformation transformation;

                    static const std::string DEFAULT_KEY;

                    static const unique_key_transformation DEFAULT_TRANSFORMATION;

                    bitmap_index_options();
                };

                enum index_type {
                    SORTED,

                    HASH,

                    BITMAP
                };

                boost::optional<std::string> name;

                index_type type;

                std::vector<std::string> attributes;

                boost::optional<bitmap_index_options> options;

                static const index_type DEFAULT_TYPE;

                index_config();

                index_config(index_type type);

                 template<typename ...T>
                 index_config(index_type t, T... attrs) : type(t) {
                    add_attributes(std::forward<T>(attrs)...);
                 }

            private:
                template<typename ...T>
                void add_attributes(std::string attribute, T... attrs) {
                    attributes.emplace_back(std::move(attribute));
                    add_attributes(attrs...);
                }

                void add_attributes();
            };
        }
    }
}

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif