core/include/ignite/cache/event/cache_entry_event.h

Go to the documentation of this file.

/*
 * Copyright 2019 GridGain Systems, Inc. and Contributors.
 *
 * Licensed under the GridGain Community Edition License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.gridgain.com/products/software/community-edition/gridgain-community-edition-license
 *
 * 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.
 */
 
#ifndef _IGNITE_CACHE_EVENT_CACHE_ENTRY_EVENT
#define _IGNITE_CACHE_EVENT_CACHE_ENTRY_EVENT
 
#include <ignite/binary/binary_raw_reader.h>
#include <ignite/cache/cache_entry.h>
 
namespace ignite
{
    namespace cache
    {
        struct CacheEntryEventType
        {
            enum T
            {
                CREATE = 0,
 
                UPDATE = 1,
 
                REMOVE = 2,
            };
 
            static T FromInt8(int8_t val)
            {
                switch (val)
                {
                    case CREATE:
                    case UPDATE:
                    case REMOVE:
                        return static_cast<T>(val);
 
                    default:
                    {
                        IGNITE_ERROR_FORMATTED_1(IgniteError::IGNITE_ERR_BINARY,
                            "Unsupported CacheEntryEventType", "val", val);
                    }
                }
            }
        };
 
        template<typename K, typename V>
        class CacheEntryEvent : public CacheEntry<K, V>
        {
        public:
            CacheEntryEvent() :
                CacheEntry<K, V>(),
                oldVal(),
                hasOldValue(false),
                eventType(CacheEntryEventType::CREATE)
            {
                // No-op.
            }
 
            CacheEntryEvent(const CacheEntryEvent<K, V>& other) :
                CacheEntry<K, V>(other),
                oldVal(other.oldVal),
                hasOldValue(other.hasOldValue),
                eventType(other.eventType)
            {
                // No-op.
            }
 
            virtual ~CacheEntryEvent()
            {
                // No-op.
            }
 
            CacheEntryEvent& operator=(const CacheEntryEvent<K, V>& other)
            {
                if (this != &other)
                {
                    CacheEntry<K, V>::operator=(other);
 
                    oldVal = other.oldVal;
                    hasOldValue = other.hasOldValue;
                    eventType = other.eventType;
                }
 
                return *this;
            }
 
            const V& GetOldValue() const
            {
                return oldVal;
            }
 
            bool HasOldValue() const
            {
                return hasOldValue;
            }
 
            CacheEntryEventType::T GetEventType() const
            {
                return eventType;
            }
 
            void Read(binary::BinaryRawReader& reader)
            {
                this->key = reader.ReadObject<K>();
 
                this->hasOldValue = reader.TryReadObject(this->oldVal);
                this->hasValue = reader.TryReadObject(this->val);
 
                int8_t eventTypeByte = reader.ReadInt8();
                this->eventType = CacheEntryEventType::FromInt8(eventTypeByte);
            }
 
        private:
            V oldVal;
 
            bool hasOldValue;
 
            CacheEntryEventType::T eventType;
        };
    }
}
 
#endif //_IGNITE_CACHE_EVENT_CACHE_ENTRY_EVENT