binary_type.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

#ifndef _IGNITE_BINARY_TYPE
#define _IGNITE_BINARY_TYPE

#include <stdint.h>

#include <ignite/common/common.h>

#include "ignite/ignite_error.h"

#define IGNITE_BINARY_TYPE_START(T) \
template<> \
struct BinaryType<T> \
{

#define IGNITE_BINARY_TYPE_END \
};

#define IGNITE_BINARY_GET_TYPE_ID_AS_CONST(id) \
int32_t GetTypeId() \
{ \
    return id; \
}

#define IGNITE_BINARY_GET_TYPE_ID_AS_HASH(typeName) \
int32_t GetTypeId() \
{ \
    return GetBinaryStringHashCode(#typeName); \
}

#define IGNITE_BINARY_GET_TYPE_NAME_AS_IS(typeName) \
std::string GetTypeName() \
{ \
    return #typeName; \
}

#define IGNITE_BINARY_GET_FIELD_ID_AS_HASH \
int32_t GetFieldId(const char* name) \
{ \
    return GetBinaryStringHashCode(name); \
}

#define IGNITE_BINARY_GET_HASH_CODE_ZERO(T) \
int32_t GetHashCode(const T& obj) \
{ \
    return 0; \
}

#define IGNITE_BINARY_IS_NULL_FALSE(T) \
bool IsNull(const T& obj) \
{ \
    return false; \
}

#define IGNITE_BINARY_IS_NULL_IF_NULLPTR(T) \
bool IsNull(const T& obj) \
{ \
    return obj; \
}

#define IGNITE_BINARY_GET_NULL_DEFAULT_CTOR(T) \
T GetNull() \
{ \
    return T(); \
}

#define IGNITE_BINARY_GET_NULL_NULLPTR(T) \
T GetNull() \
{ \
    return NULL; \
}

namespace ignite
{
    namespace binary
    {
        class BinaryWriter;
        class BinaryReader;

        IGNITE_IMPORT_EXPORT int32_t GetBinaryStringHashCode(const char* val);

        template<typename T>
        struct IGNITE_IMPORT_EXPORT BinaryType
        {
            int32_t GetTypeId()
            {
                IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "GetTypeId function is not defined for binary type.");
            }

            std::string GetTypeName() 
            {
                IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "GetTypeName function is not defined for binary type.");
            }

            int32_t GetFieldId(const char* name)
            {
                return GetBinaryStringHashCode(name);
            }

            int32_t GetHashCode(const T& obj)
            {
                return 0;
            }

            void Write(BinaryWriter& writer, const T& obj)
            {
                IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Write function is not defined for binary type.");
            }

            T Read(BinaryReader& reader)
            {
                IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Read function is not defined for binary type.");
            }

            bool IsNull(const T& obj)
            {
                return false;
            }

            T GetNull()
            {
                IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "GetNull function is not defined for binary type.");
            }
        };

        template <typename T>
        struct IGNITE_IMPORT_EXPORT BinaryType<T*>
        {
            BinaryType<T> typ;

            BinaryType()
            {
                typ = BinaryType<T>();
            }

            int32_t GetTypeId()
            {
                return typ.GetTypeId();
            }

            std::string GetTypeName()
            {
                return typ.GetTypeName();
            }

            int32_t GetFieldId(const char* name)
            {
                return typ.GetFieldId(name);
            }

            int32_t GetHashCode(T* const& obj)
            {
                return typ.GetHashCode(*obj);
            }

            void Write(BinaryWriter& writer, T* const& obj)
            {
                typ.Write(writer, *obj);
            }

            T* Read(BinaryReader& reader)
            {
                T* res = new T();

                *res = typ.Read(reader);

                return res;
            }

            bool IsNull(T* const& obj)
            {
                return !obj || typ.IsNull(*obj);
            }

            T* GetNull()
            {
                return NULL;
            }
        };
    }
}

#endif