TypeHelper.hpp

#pragma once

#ifndef GEODE_TYPEHELPER_H_
#define GEODE_TYPEHELPER_H_

/*
 * 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.
 */

#include "geode_globals.hpp"

namespace apache {
namespace geode {
namespace client {
// Forward declaration of SharedPtr<T>
template <typename Target>
class SharedPtr;

// Forward declaration of SharedArrayPtr<T, ID>
template <typename Target, int8_t TYPEID>
class SharedArrayPtr;

// Forward declaration of CacheableArrayType<T, ID>
template <typename Target, int8_t TYPEID>
class CacheableArrayType;

namespace TypeHelper {
typedef uint8_t yes_type;
typedef uint32_t no_type;

template <typename TBase, typename TDerived>
struct BDHelper {
  template <typename T>
  static yes_type check_sig(TDerived const volatile*, T);
  static no_type check_sig(TBase const volatile*, int);
};

template <typename TBase, typename TDerived>
struct SuperSubclass {
 private:
  struct Host {
    operator TBase const volatile*() const;
    operator TDerived const volatile*();
  };

 public:
  static const bool result = sizeof(BDHelper<TBase, TDerived>::check_sig(
                                 Host(), 0)) == sizeof(yes_type);
};

template <typename TBase>
struct SuperSubclass<TBase, TBase> {
  static const bool result = true;
};

template <bool getType = true>
struct YesNoType {
  static const yes_type value = 0;
};

template <>
struct YesNoType<false> {
  static const no_type value = 0;
};

template <class T>
struct UnwrapSharedPtr {};

template <class T>
struct UnwrapSharedPtr<SharedPtr<T> > {
  typedef T type;
};

template <class T, int8_t ID>
struct UnwrapSharedPtr<SharedArrayPtr<T, ID> > {
  typedef CacheableArrayType<T, ID> type;
};
}  // namespace TypeHelper
}  // namespace client
}  // namespace geode
}  // namespace apache

#define GF_UNWRAP_SP(T) \
  typename apache::geode::client::TypeHelper::UnwrapSharedPtr<T>::type

#define GF_TYPE_IS_SERIALIZABLE(T)                  \
  apache::geode::client::TypeHelper::SuperSubclass< \
      apache::geode::client::Serializable, T>::result

#define GF_TYPE_IS_SERIALIZABLE_TYPE(T)                                 \
  apache::geode::client::TypeHelper::YesNoType<GF_TYPE_IS_SERIALIZABLE( \
      T)>::value

#define GF_SRC_IS_TARGET_TYPE(TARGET, SRC)                     \
  apache::geode::client::TypeHelper::YesNoType<                \
      apache::geode::client::TypeHelper::SuperSubclass<TARGET, \
                                                       SRC>::result>::value

#endif  // GEODE_TYPEHELPER_H_