EntryEvent.h

/*
 * Copyright (c) 2008-2019, 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.
 */
//
// Created by ihsan demir on 9/9/15.
// Copyright (c) 2015 hazelcast. All rights reserved.

#ifndef HAZELCAST_ENTRY_EVENT
#define HAZELCAST_ENTRY_EVENT

#include <memory>
#include "hazelcast/client/Member.h"
#include "hazelcast/client/TypedData.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_API EntryEventType {
        public:
            enum Type {
                UNDEFINED = 0 ,
                ADDED =  1,
                REMOVED = 1 << 1,
                UPDATED = 1 << 2,
                EVICTED = 1 << 3 ,
                EVICT_ALL = 1 << 4 ,
                CLEAR_ALL = 1 << 5 ,
                MERGED = 1 << 6 ,
                EXPIRED = 1 << 7,
                INVALIDATION = 1 << 8,
                ALL = 0xFF
            };
            Type value;

            EntryEventType();

            EntryEventType(Type value);

            operator int() const;

            void operator = (int i);
        };

        template <typename K, typename V>
        class EntryEvent {
        public:
            EntryEvent(const std::string &name, const Member &member, EntryEventType eventType,
                        std::auto_ptr<K> key, std::auto_ptr<V> value)
            : name(name)
            , member(member)
            , eventType(eventType)
            , key(key)
            , value(value) {
            }

            EntryEvent(const std::string &name, const Member &member, EntryEventType eventType,
                           std::auto_ptr<K> key, std::auto_ptr<V> value,
                            std::auto_ptr<V> oldValue, std::auto_ptr<V> mergingValue)
            : name(name)
            , member(member)
            , eventType(eventType)
            , key(key)
            , value(value)
            , oldValue(oldValue)
            , mergingValue(mergingValue) {
            }

            EntryEvent(const std::string &name, const Member &member, EntryEventType eventType)
                    : name(name)
                    , member(member)
                    , eventType(eventType) {
            }

            virtual ~EntryEvent() {}

            virtual const K *getKeyObject() const {
                return key.get();
            }

            std::auto_ptr<K> releaseKey() {
                return key;
            }

            const K &getKey() const {
                return *getKeyObject();
            }

            virtual const V *getOldValueObject() const {
                return oldValue.get();
            }

            std::auto_ptr<V> releaseOldValue() {
                return oldValue;
            }

            const V &getOldValue() const {
                return *getOldValueObject();
            }

            virtual const V *getValueObject() const {
                return value.get();
            }

            std::auto_ptr<V> releaseValue() {
                return value;
            }

            const V &getValue() const {
                return *getValueObject();
            }

            virtual const V *getMergingValueObject() const {
                return mergingValue.get();
            }

            std::auto_ptr<V> releaseMergingValue() const {
                return mergingValue;
            }

            const V &getMergingValue() const {
                return *getMergingValueObject();
            }

            const Member &getMember() const {
                return member;
            };

            EntryEventType getEventType() const {
                return eventType;
            };

            const std::string &getName() const {
                return name;
            };

            std::ostream &operator<< (std::ostream &out) const {
                out << "EntryEvent{entryEventType=" << eventType <<
                    ", member=" << member << ", name='" << name << "', key=" << *key;
                if (value.get()) {
                    out << ", value=" << *value;
                }
                if (oldValue.get()) {
                    out << ", oldValue=" << *oldValue;
                }
                if (mergingValue.get()) {
                    out << ", mergingValue=" << *mergingValue;
                }
                return out;
            }
        protected:
            std::string name;
            Member member;
            EntryEventType eventType;
            std::auto_ptr<K> key;
            std::auto_ptr<V> value;
            std::auto_ptr<V> oldValue;
            std::auto_ptr<V> mergingValue;

        };

        namespace mixedtype {
            class HAZELCAST_API MixedEntryEvent {
            public:
                MixedEntryEvent(const std::string &name, const Member &member, EntryEventType eventType,
                                TypedData key, TypedData value)
                        : name(name)
                        , member(member)
                        , eventType(eventType)
                        , key(key)
                        , value(value) {
                }

                MixedEntryEvent(const std::string &name, const Member &member, EntryEventType eventType,
                                TypedData key, TypedData value,
                                TypedData oldValue, TypedData mergingValue)
                        : name(name)
                        , member(member)
                        , eventType(eventType)
                        , key(key)
                        , value(value)
                        , oldValue(new TypedData(oldValue))
                        , mergingValue(new TypedData(mergingValue)) {
                }

                const TypedData &getKey() const {
                    return key;
                }

                const TypedData *getOldValue() const {
                    return oldValue.get();
                }

                const TypedData &getValue() const {
                    return value;
                }

                const TypedData *getMergingValue() const {
                    return mergingValue.get();
                }

                const Member &getMember() const {
                    return member;
                };

                EntryEventType getEventType() const {
                    return eventType;
                };

                const std::string &getName() const {
                    return name;
                };

                std::ostream &operator<< (std::ostream &out) const {
                    out << "EntryEvent{entryEventType=" << eventType.value << eventType <<
                        ", member=" << member << ", name='" << name;
                    return out;
                }
            private:
                std::string name;
                Member member;
                EntryEventType eventType;
                TypedData key;
                TypedData value;
                std::auto_ptr<TypedData> oldValue;
                std::auto_ptr<TypedData> mergingValue;
            };
        }
    }
}


template <typename K, typename V>
std::ostream &operator<<(std::ostream &out, const hazelcast::client::EntryEvent<K, V> &event) {
    event.operator<<(out);
    return out;
}

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

#endif //__EntryEvent_H_