RecoveryPoint.hpp

//
// Copyright (c) 2010-2020 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 _RECOVERYPOINT_H_
#define _RECOVERYPOINT_H_

#include <BookmarkStore.hpp>
#include <Field.hpp>
#include <util.hpp>

namespace AMPS
{

class RecoveryPoint;

class RecoveryPointImpl : public RefBody
{
public:
    virtual ~RecoveryPointImpl() { }
    virtual const Field& getSubId() const = 0;
    virtual const Field& getBookmark() const = 0;
    virtual RecoveryPointImpl* deepCopy() = 0;
    virtual RecoveryPointImpl* deepCopy(const RecoveryPointImpl& original_) = 0;
    virtual void clear() = 0;
};

class RecoveryPoint
{
public:
    RecoveryPoint() : _body() { }

    RecoveryPoint(RecoveryPointImpl* body_)
    : _body(body_)
    { }

    RecoveryPoint(const RecoveryPoint& rhs_)
    : _body(rhs_._body)
    { }

    ~RecoveryPoint() { }

    const Field& getSubId() const
    {
        return _body.get().getSubId();
    }

    const Field& getBookmark() const
    {
        return _body.get().getBookmark();
    }

    RecoveryPoint deepCopy()
    {
        return _body.get().deepCopy();
    }

    RecoveryPoint deepCopy(const RecoveryPoint& original_)
    {
        return _body.get().deepCopy(original_._body.get());
    }

    void clear()
    {
        return _body.get().clear();
    }
private:
    RefHandle<RecoveryPointImpl> _body;
};

typedef RecoveryPoint (*RecoveryPointFactory)(const Field& subId_,
                                              const Field& bookmark_);

class FixedRecoveryPoint : public RecoveryPointImpl
{
public:
    static RecoveryPoint create(const Field& subId_, const Field& bookmark_)
    {
        return RecoveryPoint(new FixedRecoveryPoint(subId_, bookmark_));
    }

    FixedRecoveryPoint() : RecoveryPointImpl(), _owner(false) { }

    FixedRecoveryPoint(const Field& subId_, const Field& bookmark_)
    : _subId(subId_), _bookmark(bookmark_), _owner(false)
    {
    }

    FixedRecoveryPoint(const Field& subId_, const Field& bookmark_,
                       bool deepCopy_)
    : _owner(deepCopy_)
    {
        if (_owner)
        {
            _subId.deepCopy(subId_);
            _bookmark.deepCopy(bookmark_);
        }
        else
        {
            _subId = subId_;
            _bookmark = bookmark_;
        }
    }

    virtual ~FixedRecoveryPoint()
    {
        if (_owner)
        {
            _subId.clear();
            _bookmark.clear();
        }
    }

    virtual const Field& getSubId() const
    {
        return _subId;
    }

    virtual const Field& getBookmark() const
    {
        return _bookmark;
    }

    virtual RecoveryPointImpl* deepCopy()
    {
        return new FixedRecoveryPoint(_subId, _bookmark, true);
    }

    virtual RecoveryPointImpl* deepCopy(const RecoveryPointImpl& original_)
    {
        if (!_owner)
        {
            // deepCopy calls clear() so need to avoid that
            _subId = Field();
            _bookmark = Field();
        }
        _owner = true;
        _subId.deepCopy(original_.getSubId());
        _bookmark.deepCopy(original_.getBookmark());
        return this;
    }

    virtual void clear()
    {
        if (_owner)
        {
            _subId.clear();
            _bookmark.clear();
            _owner = false;
        }
        else
        {
            _subId = Field();
            _bookmark = Field();
        }
    }

private:
    Field _subId;
    Field _bookmark;
    bool  _owner;
};

class DynamicRecoveryPoint : public RecoveryPointImpl
{
public:
    static RecoveryPoint create(const Field& subId_, const Field&,
                                const BookmarkStore& store_)
    {
        return RecoveryPoint(new DynamicRecoveryPoint(subId_, store_));
    }

    DynamicRecoveryPoint(const Field& subId_,
                         const BookmarkStore& store_,
                         bool owner_ = false)
    : RecoveryPointImpl(), _subId(subId_), _store(store_), _owner(owner_)
    {
        if (_owner) _subId.deepCopy(subId_);
    }

    virtual ~DynamicRecoveryPoint()
    {
        if (_owner)
        {
            _subId.clear();
        }
    }

    virtual const Field& getSubId() const
    {
        return _subId;
    }

    virtual const Field& getBookmark() const
    {
        _bookmark = _store.getMostRecent(_subId);
        return _bookmark;
    }

    virtual RecoveryPointImpl* deepCopy()
    {
        return new DynamicRecoveryPoint(_subId, _store, true);
    }

    virtual RecoveryPointImpl* deepCopy(const RecoveryPointImpl& original_)
    {
        if (!_owner)
        {
            // deepCopy calls clear() so need to avoid that
            _subId = Field();
        }
        _owner = true;
        _subId.deepCopy(original_.getSubId());
        if (typeid(*this) == typeid(original_))
        {
            _store = ((DynamicRecoveryPoint*)&original_)->_store;
        }
        return this;
    }

    virtual void clear()
    {
        if (_owner)
        {
            _subId.clear();
            _owner = false;
        }
        else
        {
            _subId = Field();
        }
    }

private:
    Field _subId;
    mutable Field _bookmark;
    mutable BookmarkStore _store;
    bool  _owner;

    DynamicRecoveryPoint();
};

}

#endif //_RECOVERYPOINT_H_