SharedPtr.hpp

Go to the documentation of this file.

#pragma once

#ifndef GEODE_SHAREDPTR_H_
#define GEODE_SHAREDPTR_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 "SharedBase.hpp"
#include "Assert.hpp"
#include "TypeHelper.hpp"
#include <typeinfo>
#include "SharedPtrHelper.hpp"

namespace apache {
namespace geode {
namespace client {

#if GF_DEVEL_ASSERTS == 1
#define GF_CHECK_NPE(x)                                          \
  if (x != NULL) {                                               \
  } else                                                         \
    apache::geode::client::SPEHelper::throwNullPointerException( \
        typeid(*this).name())
#else
#define GF_CHECK_NPE(x)
#endif

class MapEntry;
class MapEntryImpl;

template <class Target>
class SharedPtr {
 public:
  inline SharedPtr() : m_ptr(NULL) {}

  inline SharedPtr(const NullSharedBase* ptr) : m_ptr(NULL) {}

  inline explicit SharedPtr(const Target* ptr)
      : m_ptr(const_cast<Target*>(ptr)) {
    if (NULL != m_ptr) getSB(m_ptr)->preserveSB();
  }

  inline SharedPtr(const SharedPtr& other) : m_ptr(other.m_ptr) {
    if (NULL != m_ptr) getSB(m_ptr)->preserveSB();
  }

  template <class Other>
  inline SharedPtr(const SharedPtr<Other>& other)
      : m_ptr(getTarget<Target>(other.ptr())) {
    if (NULL != m_ptr) getSB(m_ptr)->preserveSB();
  }

  inline ~SharedPtr() {
    if (NULL != m_ptr) getSB(m_ptr)->releaseSB();

    m_ptr = NULL;
  }

  inline Target* operator->() const {
    GF_CHECK_NPE(m_ptr);
    GF_DEV_ASSERT(getSB(m_ptr)->refCount() > 0);

    return m_ptr;
  }

  inline Target& operator*() const {
    GF_CHECK_NPE(m_ptr);
    return *m_ptr;
  }

  inline SharedPtr& operator=(Target* other) {
    if (NULL != other) getSB(other)->preserveSB();

    if (NULL != m_ptr) getSB(m_ptr)->releaseSB();

    m_ptr = other;

    return *this;
  }

  inline SharedPtr& operator=(const SharedPtr& other) {
    Target* otherPtr = other.m_ptr;

    if (NULL != otherPtr) {
      getSB(otherPtr)->preserveSB();
    }
    if (NULL != m_ptr) {
      getSB(m_ptr)->releaseSB();
    }
    m_ptr = otherPtr;

    GF_DEV_ASSERT(otherPtr == other.m_ptr);

    return *this;
  }

  template <class Other>
  inline SharedPtr& operator=(const SharedPtr<Other>& other) {
    Other* otherPtr = other.ptr();

    Target* otherTargetPtr = getTarget<Target>(otherPtr);

    if (NULL != otherPtr) {
      getSB(otherPtr)->preserveSB();
    }
    if (NULL != m_ptr) {
      getSB(m_ptr)->releaseSB();
    }
    m_ptr = otherTargetPtr;

    GF_DEV_ASSERT(otherPtr == other.ptr());

    return *this;
  }

  inline SharedPtr& operator=(const NullSharedBase* nullOther) {
    if (m_ptr != NULL) {
      getSB(m_ptr)->releaseSB();
    }
    m_ptr = NULL;
    return *this;
  }

  template <class Other>
  inline SharedPtr& operator=(Other* other) {
    Target* otherTargetPtr = getTarget<Target>(other);

    if (NULL != other) {
      getSB(other)->preserveSB();
    }
    if (NULL != m_ptr) {
      getSB(m_ptr)->releaseSB();
    }
    m_ptr = otherTargetPtr;

    return *this;
  }

  inline bool operator==(const Target* other) const { return m_ptr == other; }

  inline bool operator!=(const Target* other) const { return m_ptr != other; }

  inline bool operator==(const NullSharedBase* nullOther) const {
    return m_ptr == NULL;
  }

  inline bool operator!=(const NullSharedBase* nullOther) const {
    return m_ptr != NULL;
  }

  inline bool operator==(const SharedPtr& other) const {
    return m_ptr == other.m_ptr;
  }

  inline bool operator!=(const SharedPtr& other) const {
    return m_ptr != other.m_ptr;
  }

  template <class Other>
  inline bool operator==(const SharedPtr<Other>& other) {
    return ((const void*)m_ptr) == ((const void*)other.ptr());
  }

  template <class Other>
  inline bool operator!=(const SharedPtr<Other>& other) {
    return !operator==(other);
  }

  inline Target* ptr() const { return m_ptr; }

 private:
  inline explicit SharedPtr(bool noInit) {}

  Target* m_ptr;

  friend class MapEntry;
  friend class MapEntryImpl;
};

typedef SharedPtr<SharedBase> SharedBasePtr;

template <class TargetSP, class Other>
TargetSP staticCast(const SharedPtr<Other>& other) {
  GF_D_ASSERT((other.ptr() == NULL) ||
              (dynamic_cast<GF_UNWRAP_SP(TargetSP)*>(other.ptr()) != NULL));

  return TargetSP(static_cast<GF_UNWRAP_SP(TargetSP)*>(other.ptr()));
}

template <class TargetSP, class Other>
TargetSP dynCast(const SharedPtr<Other>& other) {
  GF_UNWRAP_SP(TargetSP) * otherPtr;

  if ((other.ptr() == NULL)) {
    return NULLPTR;
  } else if ((otherPtr = dynamic_cast<GF_UNWRAP_SP(TargetSP)*>(other.ptr())) !=
             NULL) {
    return TargetSP(otherPtr);
  } else {
    SPEHelper::throwClassCastException(
        "dynCast: cast failed", typeid(other).name(), typeid(TargetSP).name());
    return NULLPTR;
  }
}

template <class TargetSP, class Other>
bool instanceOf(const SharedPtr<Other>& other) {
  return (dynamic_cast<GF_UNWRAP_SP(TargetSP)*>(other.ptr()) != NULL);
}
}  // namespace client
}  // namespace geode
}  // namespace apache

#endif  // GEODE_SHAREDPTR_H_