BookmarkStore.hpp

//
// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
//
// This computer software is owned by 60East Technologies Inc. and is
// protected by U.S. copyright laws and other laws and by international
// treaties.  This computer software is furnished by 60East Technologies
// Inc. pursuant to a written license agreement and may be used, copied,
// transmitted, and stored only in accordance with the terms of such
// license agreement and with the inclusion of the above copyright notice.
// This computer software or any other copies thereof may not be provided
// or otherwise made available to any other person.
//
// U.S. Government Restricted Rights.  This computer software: (a) was
// developed at private expense and is in all respects the proprietary
// information of 60East Technologies Inc.; (b) was not developed with
// government funds; (c) is a trade secret of 60East Technologies Inc.
// for all purposes of the Freedom of Information Act; and (d) is a
// commercial item and thus, pursuant to Section 12.212 of the Federal
// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
// Government's use, duplication or disclosure of the computer software
// is subject to the restrictions set forth by 60East Technologies Inc..
//
#ifndef _BOOKMARKSTORE_H_
#define _BOOKMARKSTORE_H_
#include <string>
#include "amps/Message.hpp"
#include "amps/util.hpp"

namespace AMPS
{

#define AMPS_BOOKMARK_RECENT "recent"

#define AMPS_BOOKMARK_EPOCH "0"

#define AMPS_BOOKMARK_NOW "0|1|"

  /* @}  */

  class BookmarkStore;

  typedef bool (*BookmarkStoreResizeHandler)(BookmarkStore store_,
                                             const Message::Field& subId_,
                                             size_t size_,
                                             void* userData_);

  class BookmarkStoreImpl : public RefBody
  {
  public:
    BookmarkStoreImpl()
      : _resizeHandler(NULL)
      , _resizeHandlerData(NULL)
      , _maxSubIdLength(AMPS_MAX_SUBID_LEN)
    {;}

    virtual ~BookmarkStoreImpl() {;}

    virtual size_t log(Message& message_) = 0;

    virtual void discard(const Message::Field& subId_,
                         size_t bookmarkSeqNo_) = 0;

    virtual void discard(const Message& message_) = 0;

    virtual Message::Field getMostRecent(const Message::Field& subId_) = 0;

    virtual bool isDiscarded(Message& message_) = 0;

    virtual void purge() = 0;

    virtual void purge(const Message::Field& subId_) = 0;

    virtual size_t getOldestBookmarkSeq(const Message::Field& subId_) = 0;

    virtual void setResizeHandler(BookmarkStoreResizeHandler handler_, void* userData_)
    {
      _resizeHandler = handler_;
      _resizeHandlerData = userData_;
    }

    virtual void persisted(const Message::Field& subId_,
                           const Message::Field& bookmark_) = 0;

    virtual Message::Field persisted(const Message::Field& subId_, size_t bookmark_) = 0;

    virtual void setServerVersion(size_t version_) = 0;

    virtual void setServerVersion(const VersionInfo& version_) = 0;

    bool callResizeHandler(const Message::Field& subId_, size_t newSize_);

    inline void prune(const std::string& tmpFileName_ = std::string())
    {
      _prune(tmpFileName_);
    }

    virtual void _prune(const std::string&)
    {
      return;
    }

    size_t getMaxSubIdLength() const
    {
      return _maxSubIdLength;
    }

    void setMaxSubIdLength(size_t maxSubIdLength_)
    {
      _maxSubIdLength = maxSubIdLength_;
    }

  private:
    BookmarkStoreResizeHandler  _resizeHandler;
    void*                       _resizeHandlerData;
    size_t                      _maxSubIdLength;
  };

  class BookmarkStore
  {
    RefHandle<BookmarkStoreImpl> _body;
  public:
    BookmarkStore() {;}

    BookmarkStore(BookmarkStoreImpl* impl_) : _body(impl_) {;}

    BookmarkStore(const BookmarkStore& rhs) : _body(rhs._body) {;}

    BookmarkStore& operator=(const BookmarkStore& rhs)
    {
      _body = rhs._body;
      return *this;
    }

    ~BookmarkStore() {;}

    void setImplementation(BookmarkStoreImpl* impl_)
    {
      _body = impl_;
    }

    bool isValid() const
    {
      return _body.isValid();
    }

    size_t log(Message& message_)
    {
      if (_body.isValid())
      {
        return _body.get().log(message_);
      }
      return Message::BOOKMARK_NONE;
    }

    void discard(const Message::Field& subId_, size_t bookmarkSeqNo_)
    {
      if (_body.isValid())
      {
        _body.get().discard(subId_, bookmarkSeqNo_);
      }
    }

    void discard(const Message& message_)
    {
      if (_body.isValid())
      {
        _body.get().discard(message_);
      }
    }

    Message::Field getMostRecent(const Message::Field& subId_)
    {
      if (_body.isValid())
      {
        return _body.get().getMostRecent(subId_);
      }
      return Message::Field(AMPS_BOOKMARK_EPOCH);
    }

    bool isDiscarded(Message& message_)
    {
      if (_body.isValid())
      {
        return _body.get().isDiscarded(message_);
      }
      return false;
    }

    void purge()
    {
      if (_body.isValid())
      {
        _body.get().purge();
      }
    }

    void purge(const Message::Field& subId_)
    {
      if (_body.isValid())
      {
        _body.get().purge(subId_);
      }
    }

    void setResizeHandler(BookmarkStoreResizeHandler handler_, void* userData_)
    {
      if (_body.isValid())
      {
        _body.get().setResizeHandler(handler_, userData_);
      }
    }

    size_t getOldestBookmarkSeq(const std::string& subId_)
    {
      if (_body.isValid())
        return _body.get().getOldestBookmarkSeq(Message::Field(subId_.c_str(),
                                                               subId_.length()));
      return AMPS_UNSET_INDEX;
    }

    size_t getOldestBookmarkSeq(const Message::Field& subId_)
    {
      if (_body.isValid())
      {
        return _body.get().getOldestBookmarkSeq(subId_);
      }
      return AMPS_UNSET_INDEX;
    }

    void persisted(const Message::Field& subId_, const Message::Field& bookmark_)
    {
      if (_body.isValid())
      {
        _body.get().persisted(subId_, bookmark_);
      }
    }

    void persisted(const Message::Field& subId_, size_t bookmark_)
    {
      if (_body.isValid())
      {
        _body.get().persisted(subId_, bookmark_);
      }
    }

    void setServerVersion(size_t version_)
    {
      if (_body.isValid())
      {
        _body.get().setServerVersion(version_);
      }
    }

    void setServerVersion(const VersionInfo& version_)
    {
      if (_body.isValid())
      {
        _body.get().setServerVersion(version_);
      }
    }

    void prune(const std::string& tmpFileName_ = "")
    {
      if (_body.isValid())
      {
        _body.get().prune(tmpFileName_);
      }
    }

    BookmarkStoreImpl* get()
    {
      if (_body.isValid())
      {
        return &_body.get();
      }
      else
      {
        return NULL;
      }
    }

    size_t getMaxSubIdLength() const
    {
      if (_body.isValid())
      {
        return _body.get().getMaxSubIdLength();
      }
      else
      {
        return 0;
      }
    }

    void setMaxSubIdLength(size_t maxSubIdLength_)
    {
      if (_body.isValid())
      {
        _body.get().setMaxSubIdLength(maxSubIdLength_);
      }
    }

  };

  inline bool BookmarkStoreImpl::callResizeHandler(const Message::Field& subId_,
                                                   size_t newSize_)
  {
    if (_resizeHandler)
    {
      return _resizeHandler(BookmarkStore(this), subId_, newSize_, _resizeHandlerData);
    }
    return true;
  }

  inline bool ThrowawayBookmarkResizeHandler(BookmarkStore store_,
                                             const Message::Field& subId_,
                                             size_t newSize_, void* data_)
  {
    size_t* maxSizep = (size_t*)data_;
    if (newSize_ > *maxSizep)
    {
      size_t discardSeq = store_.getOldestBookmarkSeq(subId_);
      store_.discard(subId_, discardSeq);
      store_.persisted(subId_, discardSeq);
      return false;
    }
    return true;
  }

}

#endif //_BOOKMARKSTORE_H_