change_stream.hpp

// Copyright 2018-present MongoDB 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 <memory>

#include <bsoncxx/document/view.hpp>
#include <bsoncxx/stdx/optional.hpp>

#include <mongocxx/config/prelude.hpp>

namespace mongocxx {
MONGOCXX_INLINE_NAMESPACE_BEGIN

class client;
class collection;
class database;

class MONGOCXX_API change_stream {
   public:
    class MONGOCXX_API iterator;

    change_stream(change_stream&& other) noexcept;

    change_stream& operator=(change_stream&& other) noexcept;

    ~change_stream();

    iterator begin() const;

    iterator end() const;

    bsoncxx::stdx::optional<bsoncxx::document::view> get_resume_token() const;

   private:
    friend class client;
    friend class collection;
    friend class database;
    friend class change_stream::iterator;

    MONGOCXX_PRIVATE change_stream(void* change_stream_ptr);

    class MONGOCXX_PRIVATE impl;
    std::unique_ptr<impl> _impl;
};

class MONGOCXX_API change_stream::iterator {
   public:
    // Support input-iterator (caveat of post-increment returning void)
    using difference_type = std::int64_t;
    using value_type = const bsoncxx::document::view;
    using pointer = std::add_pointer<value_type>::type;
    using reference = std::add_lvalue_reference<value_type>::type;
    using iterator_category = std::input_iterator_tag;

    iterator();

    const bsoncxx::document::view& operator*() const;

    const bsoncxx::document::view* operator->() const;

    iterator& operator++();

    void operator++(int);

   private:
    friend class change_stream;
    enum class iter_type { k_tracking, k_default_constructed, k_end };

    MONGOCXX_PRIVATE explicit iterator(iter_type type, const change_stream* change_stream);

    friend MONGOCXX_API bool MONGOCXX_CALL operator==(const change_stream::iterator&,
                                                      const change_stream::iterator&) noexcept;

    friend MONGOCXX_API bool MONGOCXX_CALL operator!=(const change_stream::iterator&,
                                                      const change_stream::iterator&) noexcept;

    MONGOCXX_PRIVATE bool is_exhausted() const;

    // iter_type==k_default_constructed is equivalent to _change_stream==nullptr
    iter_type _type;
    const change_stream* _change_stream;
};

MONGOCXX_INLINE_NAMESPACE_END
}  // namespace mongocxx

#include <mongocxx/config/postlude.hpp>