TfRevisionControl.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
#ifndef _TFREVISIONCONTROL_H_INCLUDED_
#define _TFREVISIONCONTROL_H_INCLUDED_
 
#include "TfSchemaManager.h"
#include "DbObjectIterator.h"
#include "ThreadsCounter.h"
 
#define STL_USING_MAP
#include "OdaSTL.h"
 
#include <stdexcept>

struct TFDLL_EXPORT OdTfDigest
{
  char data[20];

  void write(OdStreamBuf* pBuf) const { pBuf->putBytes(data, 20); }

  void read(OdStreamBuf* pBuf) { pBuf->getBytes(data, 20); }

  bool operator < (const OdTfDigest& other) const
  {
    return memcmp(data, other.data, 20) < 0;
  }

  bool operator == (const OdTfDigest& other) const
  {
    return memcmp(data, other.data, 20) == 0;
  }

  bool operator != (const OdTfDigest& other) const
  {
    return memcmp(data, other.data, 20) != 0;
  }

  static OdTfDigest kNull()
  {
    OdTfDigest res;
    memset(res.data, 0, 20);
    return res;
  }

  bool isNull() const
  {
    char test[20] = { 0 };
    return memcmp(test, data, 20) == 0;
  }

  OdTfDigest()
  {
    memset(data, 0, 20);
  }
};

typedef OdArray<OdTfDigest, OdMemoryAllocator<OdTfDigest> > OdTfDigestArray;

namespace OdTfRevisionControl
{
  typedef std::map<OdString, OdTfDigest> ReferenceList;

  enum ChangeType
  {
    kObjectUnmodified = 0,
    kObjectAdded = 1, 
    kObjectDeleted,   
    kObjectModified    
  };

  typedef std::map<OdDbHandle, ChangeType> ChangeList;

  enum MergeFlags {
    kMergeFlagBase = 0,
    kMergeFlagMine = 1,
    kMergeFlagTheirs = 2,
    kMergeFlagFull = 4,
 
    kMergeMaskMineTheirs = kMergeFlagMine | kMergeFlagTheirs,
    kMergeMaskResolution = kMergeMaskMineTheirs | kMergeFlagFull,
  };

  enum MergeResolution {
    kMergeRevertFull = kMergeFlagBase | kMergeFlagFull,
    kMergeMineConflict = kMergeFlagMine,
    kMergeMineFull = kMergeFlagMine | kMergeFlagFull,
    kMergeTheirsConflict = kMergeFlagTheirs,
    kMergeTheirsFull = kMergeFlagTheirs | kMergeFlagFull,

    kMergePostpone = kMergeMineFull,

    kMergeNoResolution = 0,
  };

  bool inline isConflict(ChangeType myChange, ChangeType theirChange)
  {
    return myChange != kObjectUnmodified
      && theirChange != kObjectUnmodified
      && !(myChange == kObjectDeleted && theirChange == kObjectDeleted);
  }
};
 
 

struct TFDLL_EXPORT OdTfCommitAnnotation
{
  OdString author;      
  OdString message;     
  OdTimeStamp date;     
  OdStreamBufPtr userData; 

  OdTfCommitAnnotation(
    const OdString& author = OdString::kEmpty,
    const OdString& message = OdString::kEmpty,
    const OdTimeStamp& date = OdTimeStamp(OdTimeStamp::kInitUniversalTime),
    OdStreamBuf* arbitraryUserData = 0);
};

struct TFDLL_EXPORT OdTfCommitInfo
{
  OdTfDigest hash;              
  OdTfDigestArray parents; 
  OdTfDigest revision;          
  OdTfCommitAnnotation annotation;

  OdTfCommitInfo(const OdString& author = OdString::kEmpty, const OdString& message = OdString::kEmpty, const OdTimeStamp& date = OdTimeStamp(OdTimeStamp::kInitUniversalTime), OdStreamBuf* arbitraryUserData = 0)
    :annotation(author, message, date, arbitraryUserData) {}
};

struct OdTfMergeHandler
{
  virtual ~OdTfMergeHandler() {}
  virtual OdTfRevisionControl::MergeResolution operator()(const OdDbHandle& h,
    OdTfRevisionControl::ChangeType myChange,
    OdTfRevisionControl::ChangeType theirChange,
    OdTfRevisionControl::MergeResolution autoResolution) = 0;
};

template<OdTfRevisionControl::MergeResolution conflictResolution = OdTfRevisionControl::kMergeTheirsConflict>
struct OdTfFixedMergeHandler : public OdTfMergeHandler
{
  OdTfFixedMergeHandler(){};
 
  OdTfRevisionControl::MergeResolution operator()(const OdDbHandle& h,
    OdTfRevisionControl::ChangeType myChange,
    OdTfRevisionControl::ChangeType theirChange,
    OdTfRevisionControl::MergeResolution autoResolution) override
  {
    return autoResolution ? autoResolution : conflictResolution;
  }
};

struct OdTfPostponeMergeHandler : public OdTfMergeHandler
{
  struct Conflict
  {
    OdDbHandle handle;
    OdTfRevisionControl::ChangeType myChange;
    OdTfRevisionControl::ChangeType theirChange;
    Conflict(const OdDbHandle& handle,
      OdTfRevisionControl::ChangeType myChange,
      OdTfRevisionControl::ChangeType theirChange)
      : handle(handle), myChange(myChange), theirChange(theirChange) {}
  };
  typedef OdArray<Conflict> Conflicts;
 
  Conflicts const& conflicts() const { return m_conflicts; }
  Conflicts& conflicts() { return m_conflicts; }
 
  OdTfRevisionControl::MergeResolution operator()(const OdDbHandle& h,
    OdTfRevisionControl::ChangeType myChange,
    OdTfRevisionControl::ChangeType theirChange,
    OdTfRevisionControl::MergeResolution autoResolution) override
  {
    if (autoResolution)
      return autoResolution;
    m_conflicts.append(Conflict(h, myChange, theirChange));
    return OdTfRevisionControl::kMergePostpone;
  }
 
private:
  Conflicts m_conflicts;
};
 
class OdTfRepository;

typedef OdSmartPtr<OdTfRepository> OdTfRepositoryPtr;
 
 
struct OdTfStorage;

typedef OdSmartPtr<OdTfStorage> OdTfStoragePtr;
struct OdTfStorageImpl;
 
namespace OdTfRevisionControl
{
  TFDLL_EXPORT OdTfRepository* getRepository(OdDbDatabase* pDb);

  TFDLL_EXPORT OdTfRepositoryPtr detachRepository(OdDbDatabase* pDb);

  TFDLL_EXPORT OdTfDigest commit(OdDbDatabase* pDb, const OdTfCommitAnnotation& message, const OdDbObjectIdArray* objectsToSave = 0);

  TFDLL_EXPORT bool dryMerge(const OdDbDatabase* pDb, const OdTfDigest& sha,
    OdTfMergeHandler& mergeHandler);
  TFDLL_EXPORT bool dryMerge(const OdDbDatabase* pDb, const OdString& reference,
    OdTfMergeHandler& mergeHandler);

  TFDLL_EXPORT bool merge(OdDbDatabase* pDb, const OdTfDigest& sha,
    OdTfMergeHandler& mergeHandler, bool noFastForward = false);
  TFDLL_EXPORT bool merge(OdDbDatabase* pDb, const OdString& reference,
    OdTfMergeHandler& mergeHandler, bool noFastForward = false);

  TFDLL_EXPORT OdString getLocalBranch(OdDbDatabase* pDb, OdTfDigest* head = 0);

  TFDLL_EXPORT void switchBranch(OdDbDatabase* pDb, const OdString& branch, bool hard = true);

  TFDLL_EXPORT OdDbObjectIdArray getLocalChanges(OdDbDatabase* pDb);

  TFDLL_EXPORT OdStreamBufPtr compressData(OdDbDatabase* pDb);

  TFDLL_EXPORT void loadObjects(OdDbDatabase* pDb, OdDbObjectIterator* pObjects, OdMTLoadReactor* pReactor = 0);

  TFDLL_EXPORT void beginPartialImport(OdStreamBufPtr pStream, OdDbDatabase* pDb);

  TFDLL_EXPORT void writeObjectPartial(OdDbObjectId id, bool pageObjectToDisk = true);

  TFDLL_EXPORT void endPartialImport(OdDbDatabase* pDb);

  TFDLL_EXPORT void getRevisionDifference(OdDbDatabase* pDb, const OdTfDigest& newRevision, const OdTfDigest& oldRevision, ChangeList& result);

  TFDLL_EXPORT bool getCommonAncestor(OdDbDatabase* pDb, const OdTfDigest& theirSha, OdTfDigest& ancestor);
}

struct TFDLL_EXPORT OdTfStorage : public OdRxObject
{
  OdTfStorage();
  ~OdTfStorage();

  //static OdTfStoragePtr createObject(OdStreamBuf* pStream, OdDbHostAppServices* pHostApp);

  OdTfDigest store(OdDbDatabase* pDb, const OdDbObjectIdArray* objectsToSave = 0);

  OdDbDatabasePtr retrieve(const OdTfDigest& sha, bool partial = false) const;
  bool isSchemePresent(const OdTfDigest& sha) const;
  OdStreamBufPtr makeSchemePatch(const OdTfDigest& sha) const;

  OdTfDigest applySchemePatch(OdStreamBufPtr& schemePatch) const;

  void dryMerge(
    const OdTfDigest& mine, const OdTfDigest& theirs, const OdTfDigest& base,
    OdTfMergeHandler& mergeHandler) const;
  void dryMerge(
    const OdDbDatabase *pDb, const OdTfDigest& theirs, const OdTfDigest& base,
    OdTfMergeHandler& mergeHandler) const;

  OdDbDatabasePtr merge(
    const OdTfDigest& mine, const OdTfDigest& theirs, const OdTfDigest& base,
    OdTfMergeHandler& mergeHandler) const;

  void merge(
    OdDbDatabase *pDb, const OdTfDigest& theirs, const OdTfDigest& base,
    OdTfMergeHandler& mergeHandler) const;

  OdStreamBufPtr makePatch(
    const OdTfDigestArray& from, const OdTfDigestArray& to,
    const OdTfRevisionControl::ReferenceList& refs = OdTfRevisionControl::ReferenceList()) const;

  void applyPatch(OdStreamBuf* s,
    OdTfDigestArray& roots, OdTfRevisionControl::ReferenceList& refs);

  void getRevisionDifference(const OdTfDigest& newRevision,
    const OdTfDigest& oldRevision, OdTfRevisionControl::ChangeList& result) const;

  void getRevisionDifference(OdDbDatabase* pDb,
    const OdTfDigest& revision, OdTfRevisionControl::ChangeList& result) const;

  OdStreamBufPtr getStorageStream() const; 

  void setReference(const OdString& refName, const OdTfDigest& sha);

  void setReference(const OdTfRevisionControl::ReferenceList& branches);

  bool getReference(const OdString& refName, OdTfDigest& sha) const;

  void getReferences(OdTfRevisionControl::ReferenceList& refs) const;
 
protected:
  // Internal implementation not writing a header section. To be used in derived
  // makePatch() implementations.
  void makePatch(OdStreamBuf* s,
    const OdTfDigestArray& from, const OdTfDigestArray& to,
    const OdTfRevisionControl::ReferenceList& refs) const;
 
  protected:
    friend struct OdTfStorageImpl;
    friend void OdTfRevisionControl::beginPartialImport(OdStreamBufPtr pStream, OdDbDatabase* pDb);
    OdTfStorageImpl* m_pImpl;
};

class TFDLL_EXPORT OdTfRepository : public OdTfStorage
{
public:
  static OdTfRepositoryPtr createObject(OdStreamBufPtr pStream, OdDbHostAppServices* pHostApp);

  void init(const bool isNewStorage);

  OdTfDigest commit(OdDbDatabase* pDb, const OdTfDigestArray& parents,
    const OdTfCommitAnnotation& message = OdTfCommitAnnotation(),
    const OdDbObjectIdArray* objectsToSave = 0);

  OdTfDigest import(OdDbDatabase* pDb, const OdString& localbranch);

  OdDbDatabasePtr checkout(const OdTfDigest& sha, const OdString& localBranch,
    bool partial = false);

  OdDbDatabasePtr checkout(const OdString& reference, const OdString& localBranch, bool partial = false);

  OdDbDatabasePtr checkout(const OdString& branch, bool partial = false);

  OdStreamBufPtr makePatch(
    const OdTfDigestArray& from, const OdTfDigestArray& to,
    const OdTfRevisionControl::ReferenceList& refs = OdTfRevisionControl::ReferenceList()) const;

  OdStreamBufPtr makePatch(
    const OdTfDigestArray& from, const OdTfDigest& to,
    const OdTfRevisionControl::ReferenceList& refs = OdTfRevisionControl::ReferenceList()) const;

  OdTfCommitInfo getCommitInfo(const OdTfDigest& sha) const;

  OdTfDigest writeCommitInfo(OdTfCommitInfo& commitInfo);
};
 
 
#endif //_TFREVISIONCONTROL_H_INCLUDED_