TrackedPtr.h

Go to the documentation of this file.

/*
 * Copyright 2020 OmniSci, Inc.
 *
 * 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.
 */

#pragma once

#include "ParserNode.h"

namespace Parser {

template <typename T>
class TrackedPtr {
  static_assert(std::is_same<std::string, T>::value || std::is_same<Node, T>::value);

 public:
  TrackedPtr(const TrackedPtr&) = delete;

  TrackedPtr& operator=(const TrackedPtr&) = delete;

  T* release() {
    if (is_empty_) {
      return nullptr;
    }
    CHECK(!is_released_);
    is_released_ = true;
    return value_.release();
  }

  T* get() {
    if (is_empty_) {
      return nullptr;
    }
    return value_.get();
  }

  template <typename... Args>
  static TrackedPtr<T>* make(std::vector<std::unique_ptr<TrackedPtr<T>>>& tracked_ptrs,
                             Args&&... args) {
    std::unique_ptr<TrackedPtr<T>> tracked_ptr{
        new TrackedPtr<T>(std::forward<Args>(args)...)};
    const auto& ptr = tracked_ptrs.emplace_back(std::move(tracked_ptr));
    return ptr.get();
  }

  static TrackedPtr<T>* makeEmpty() {
    static std::unique_ptr<TrackedPtr<T>> empty_tracked_ptr_ =
        std::unique_ptr<TrackedPtr<T>>(new TrackedPtr<T>());
    return empty_tracked_ptr_.get();
  }

 private:
  std::unique_ptr<T> value_;
  bool is_empty_;
  bool is_released_;

  TrackedPtr() : is_empty_(true), is_released_(false){};

  TrackedPtr(Node* node)
      : value_(std::unique_ptr<Node>(node)), is_empty_(false), is_released_(false) {}

  TrackedPtr(const std::string& str)
      : value_(std::make_unique<std::string>(str))
      , is_empty_(false)
      , is_released_(false) {}

  TrackedPtr(const char* str, size_t len)
      : value_(std::make_unique<std::string>(str, len))
      , is_empty_(false)
      , is_released_(false) {}
};

template <typename T>
class TrackedListPtr {
  static_assert(std::is_same<std::string, T>::value || std::is_same<Node, T>::value);

 public:
  TrackedListPtr(const TrackedListPtr&) = delete;

  TrackedListPtr& operator=(const TrackedListPtr&) = delete;

  std::list<T*>* release() {
    if (is_empty_) {
      return nullptr;
    }
    CHECK(!is_released_);
    is_released_ = true;

    auto result = new std::list<T*>();
    for (auto& ptr : *value_) {
      result->emplace_back(ptr->release());
    }
    return result;
  }

  void push_back(TrackedPtr<T>* item) { value_->emplace_back(item); }

  void push_back(T* item) {
    value_->emplace_back(TrackedPtr<T>::make(owned_ptrs_, item));
  }

  template <typename... Args>
  static TrackedListPtr<T>* make(
      std::vector<std::unique_ptr<TrackedListPtr<T>>>& tracked_ptrs,
      Args&&... args) {
    std::unique_ptr<TrackedListPtr<T>> tracked_ptr{
        new TrackedListPtr<T>(std::forward<Args>(args)...)};
    const auto& ptr = tracked_ptrs.emplace_back(std::move(tracked_ptr));
    return ptr.get();
  }

  static TrackedListPtr<T>* makeEmpty() {
    static std::unique_ptr<TrackedListPtr<T>> empty_tracked_ptr_ =
        std::unique_ptr<TrackedListPtr<T>>(new TrackedListPtr<T>());
    return empty_tracked_ptr_.get();
  }

 private:
  std::unique_ptr<std::list<TrackedPtr<T>*>> value_;
  std::vector<std::unique_ptr<TrackedPtr<T>>> owned_ptrs_{};
  bool is_empty_;
  bool is_released_;

  TrackedListPtr() : is_empty_(true), is_released_(false){};

  TrackedListPtr(size_t n)
      : value_(std::make_unique<std::list<TrackedPtr<T>*>>(n))
      , is_empty_(false)
      , is_released_(false) {}

  TrackedListPtr(size_t n, TrackedPtr<T>* val)
      : value_(std::make_unique<std::list<TrackedPtr<T>*>>(n, val))
      , is_empty_(false)
      , is_released_(false) {}

  TrackedListPtr(size_t n, T* val)
      : value_(std::make_unique<std::list<TrackedPtr<T>*>>(
            n,
            TrackedPtr<T>::make(owned_ptrs_, (T*)val)))
      , is_empty_(false)
      , is_released_(false) {}
};
}  // namespace Parser