RecoveryPoint.hpp

Go to the documentation of this file.

//
// Copyright (c) 2010-2021 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();
 }

 RecoveryPoint& operator=(const RecoveryPoint& rhs_)
 {
 _body = rhs_._body;
 return *this;
 }
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_