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>