ssphys/SSPhysLib/SSVersionObject.cpp

   1 // SSVersionObject.cpp: implementation of the SSVersionObject class.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4
   5 #include "stdafx.h"
   6 #include "SSVersionObject.h"
   7 #include "SSFiles.h"
   8 #include "SSName.h"
   9
  10 //---------------------------------------------------------------------------
  11 #include "LeakWatcher.h"
  12
  13 #ifdef _DEBUG
  14 #define new DEBUG_NEW
  15 #undef THIS_FILE
  16 static char THIS_FILE[] = __FILE__;
  17 #endif
  18
  19
  20 //////////////////////////////////////////////////////////////////////
  21 // Construction/Destruction
  22 //////////////////////////////////////////////////////////////////////
  23 SSVersionObject::SSVersionObject (SSRecordPtr pRecord)
  24   : SSObject (pRecord, eHistoryRecord),
  25     m_pAction (NULL)
  26 {
  27   if (pRecord)
  28   {
  29     if (pRecord->GetLen() < sizeof (VERSION_RECORD))
  30       throw SSRecordException ("not enough data for version object");
  31
  32     m_pAction = SSAction::MakeAction (pRecord);
  33   }
  34 }
  35
  36 SSVersionObject::~SSVersionObject ()
  37 {
  38   delete m_pAction;
  39 }
  40
  41 SSVersionObject::SSVersionObject (SSVersionObject& object)
  42   : SSObject (object),
  43     m_pAction (NULL)
  44 {
  45   m_pAction = SSAction::MakeAction (GetRecord());
  46 }
  47
  48 SSVersionObject& SSVersionObject::operator= (SSVersionObject const & object)
  49 {
  50   if (&object != this)
  51   {
  52     *(SSObject*)this = object;
  53     m_pAction = SSAction::MakeAction (GetRecord());
  54   }
  55   return *this;
  56 }
  57
  58 std::string SSVersionObject::GetComment () const
  59 {
  60   if (GetOffsetToNextRecordOrComment() && GetLengthComment())
  61   {
  62     SSCommentObject comment (GetFile ()->GetRecord (GetOffsetToNextRecordOrComment()));
  63     return comment.GetComment();
  64   }
  65   return "";
  66 }
  67
  68 //std::string SSVersionObject::GetLabel () const
  69 //{
  70 //  const SSLabeledAction* pLabeledAction = dynamic_cast<const SSLabeledAction*> (m_pAction);
  71 //  return pLabeledAction ? pLabeledAction->GetLabel () : "";
  72 //}
  73 std::string SSVersionObject::GetLabelComment () const
  74 {
  75   const SSLabeledAction* pLabeledAction = dynamic_cast<const SSLabeledAction*> (m_pAction);
  76   return pLabeledAction ? pLabeledAction->GetLabelComment () : "";
  77 }
  78
  79 SSVersionObject SSVersionObject::GetPreviousObject () const
  80 {
  81   if (GetPrevious () == 0)
  82     return SSVersionObject (SSRecordPtr());
  83
  84   return SSVersionObject (GetFile ()->GetRecord (GetPrevious ()));
  85 }
  86
  87 bool SSVersionObject::Validate ()
  88 {
  89   bool retval = true;
  90
  91   SSRecordPtr pLabelCommentRecord;
  92   SSRecordPtr pNext;
  93   SSRecordPtr pPrevious;
  94
  95   const VERSION_RECORD* pVersion = GetData ();
  96   if (pVersion->OffsetToLabelComment)
  97     pLabelCommentRecord = GetFile ()->GetRecord (pVersion->OffsetToLabelComment);
  98   if (pVersion->OffsetToNextRecordOrComment)
  99     pNext = GetFile ()->GetRecord (pVersion->OffsetToNextRecordOrComment);
 100   if (pVersion->Previous)
 101     pPrevious = GetFile ()->GetRecord (pVersion->Previous);
 102
 103   if (   (pVersion->LengthLabelComment == 0 && pVersion->OffsetToLabelComment != 0)
 104       || (pVersion->LengthLabelComment != 0 && pVersion->OffsetToLabelComment == 0) )
 105   {
 106     Warning ("invalid length and offset combination");
 107     retval &= false;
 108   }
 109
 110   if (pVersion->LengthLabelComment)
 111   {
 112     retval &= warn_with_msg_if (!pLabelCommentRecord, "the expected comment record is invalid")
 113
 114     retval &= warn_with_msg_if (pLabelCommentRecord->GetType () != eCommentRecord,
 115                                 "the record pointed to by offsetToLabelComment is expected to be a comment record");
 116     return false;
 117   }
 118
 119   if (pVersion->LengthComment)
 120   {
 121     retval &= warn_with_msg_if (!pNext, "the expected comment record is invalid");
 122
 123     retval &= warn_with_msg_if (pNext->GetType () != eCommentRecord,
 124                                 "the record pointed to by offsetToNextRecordOrComment is expected to be a comment record");
 125   }
 126
 127   if (pVersion->Previous && !pPrevious)
 128   {
 129     Warning ("a previous record is specified, but the record could not be read");
 130     retval &= false;
 131   }
 132
 133   if (pPrevious)
 134   {
 135     retval = warn_with_msg_if (pPrevious->GetType () != eHistoryRecord,
 136                                "the record pointed to by previous is expected to be a history record");
 137   }
 138
 139   return retval;
 140 }
 141   // ---------------------------------------------------------------
 142   class ActionNode : public XMLNode
 143   {
 144   public:
 145     ActionNode (XMLNode* pParent, eAction actionid)
 146       : XMLNode (pParent, "Action", ToAttribMap(actionid))
 147     {
 148     }
 149
 150     static AttribMap ToAttribMap (eAction actionid)
 151     {
 152       std::string actionString = CAction::ActionToString (actionid);
 153       actionString.erase (std::remove (actionString.begin (), actionString.end (), ' '));
 154
 155       return ToAttribMap (actionString);
 156     }
 157     static AttribMap ToAttribMap (std::string actionString)
 158     {
 159       AttribMap map;
 160       map["ActionId"] = actionString;
 161       return map;
 162     }
 163   };
 164
 165
 166 void SSVersionObject::ToXml (XMLNode* pParent) const
 167 {
 168   XMLElement versionNumber (pParent, "VersionNumber", GetVersionNumber());
 169   XMLElement useName (pParent, "UserName", GetUsername());
 170   XMLElement date (pParent, "Date", GetDate());
 171   if (!GetComment ().empty ())
 172   {
 173     XMLElement date (pParent, "Comment", GetComment());
 174   }
 175
 176   if (GetAction ())
 177   {
 178     SSAction* pAction = GetAction ();
 179     ActionNode node (pParent, pAction->GetActionID());
 180
 181     pAction->ToXml (&node);
 182   }
 183 }
 184
 185 void SSVersionObject::Dump (std::ostream& os) const
 186 {
 187   SSRecordPtr pLabelCommentRecord;
 188   SSRecordPtr pNext;
 189   const VERSION_RECORD* pVersion = GetData ();
 190
 191   if (pVersion->OffsetToLabelComment)
 192     pLabelCommentRecord = GetFile ()->GetRecord (pVersion->OffsetToLabelComment);
 193   if (pVersion->OffsetToNextRecordOrComment)
 194     pNext = GetFile ()->GetRecord (pVersion->OffsetToNextRecordOrComment);
 195
 196   // dump basic information
 197   SSObject::Dump (os);
 198
 199   SSVersionObject previous = GetPreviousObject ();
 200   os << "Previous: ";
 201   if (previous)
 202   {
 203     os << "Type " << SSRecord::TypeToString (previous.GetType ()) << ", ";
 204     os << "Offset 0x" << std::hex << previous.GetOffset () << std::dec;
 205     os << std::endl;
 206   }
 207   else
 208     os << "NULL" << std::endl;
 209
 210   os << "Action " << GetActionID() << " : " << CAction::ActionToString (GetActionID())  << std::endl;
 211   os << "ActionStr: " << GetActionString ()  << std::endl;
 212   os << "Version:  " << GetVersionNumber () << std::endl;
 213 //  os << "Date" << std::endl;
 214   os << "User:     " << GetUsername () << std::endl;
 215   os << "Comment:  " << GetComment () << std::endl;
 216
 217   os << "Comment Offset      0x" << std::hex << pVersion->OffsetToNextRecordOrComment << std::dec << ", Length " << pVersion->LengthComment;
 218   if (pNext)
 219       os << ", Type " << pNext->GetRecordType ();
 220   os << std::endl;
 221
 222   os << "LabelComment Offset 0x" << std::hex << pVersion->OffsetToLabelComment << std::dec << ", Length " << pVersion->LengthLabelComment;
 223   if (pLabelCommentRecord)
 224       os << ", Type " << pLabelCommentRecord->GetRecordType ();
 225   os << std::endl;
 226
 227     SSAction* pAction = GetAction ();
 228     if (pAction)
 229       pAction->Dump (os);
 230 }
 231
 232 //---------------------------------------------------------------------------
 233 SSAction::SSAction (SSRecordPtr pRecord)
 234 {
 235   const VERSION_RECORD* pVersion = GetHistoryRecordPtr (pRecord);
 236
 237   m_ActionId = static_cast <eAction> (pVersion->ActionID);
 238 }
 239
 240 SSAction::~SSAction ()
 241 {
 242 }
 243
 244 SSAction* SSAction::MakeAction (SSRecordPtr pRecord)
 245 {
 246   if (!pRecord)
 247     return NULL;
 248
 249   if (pRecord->GetLen () < sizeof (VERSION_RECORD))
 250     throw SSException ("not enough bytes for Version Header in record");
 251
 252   const VERSION_RECORD* pVersion = reinterpret_cast<const VERSION_RECORD*> (pRecord->GetBuffer ());
 253
 254   if (pVersion->ActionID == Labeled)
 255     return new SSLabeledAction (pRecord);
 256   else if (pVersion->ActionID == Created_Project)
 257     return new SSCreatedProjectAction (pRecord);
 258   else if (pVersion->ActionID == Added_Project)
 259     return new SSAddedProjectAction (pRecord);
 260   else if (pVersion->ActionID == Added_File)
 261     return new SSAddedFileAction (pRecord);
 262   else if (pVersion->ActionID == Destroyed_Project)
 263     return new SSDestroyedProjectAction(pRecord);
 264   else if (pVersion->ActionID == Destroyed_File)
 265     return new SSDestroyedFileAction (pRecord);
 266   else if (pVersion->ActionID == Deleted_Project)
 267     return new SSDeletedProjectAction (pRecord);
 268   else if (pVersion->ActionID == Deleted_File)
 269     return new SSDeletedFileAction (pRecord);
 270   else if (pVersion->ActionID == Recovered_Project)
 271     return new SSRecoveredProjectAction (pRecord);
 272   else if (pVersion->ActionID == Recovered_File)
 273     return new SSRecoveredFileAction (pRecord);
 274   else if (pVersion->ActionID == Renamed_Project)
 275     return new SSRenamedProjectAction (pRecord);
 276   else if (pVersion->ActionID == Renamed_File)
 277     return new SSRenamedFileAction (pRecord);
 278 //  else if (pVersion->ActionID == missing action 12)
 279 //    return new SSVersionObject (pRecord);
 280 //  else if (pVersion->ActionID == missing action 13)
 281 //    return new SSVersionObject (pRecord);
 282   else if (pVersion->ActionID == Shared_File)
 283     return new SSSharedAction (pRecord);
 284   else if (pVersion->ActionID == Branch_File)
 285     return new SSRollbackAction (pRecord);
 286   else if (pVersion->ActionID == Created_File)
 287     return new SSCreatedFileAction (pRecord);
 288   else if (pVersion->ActionID == Checked_in)
 289     return new SSCheckedInAction (pRecord);
 290 //  else if (pVersion->ActionID == // missing action 18)
 291 //    return new SSVersionObject (pRecord);
 292   else if (pVersion->ActionID == RollBack)
 293     return new SSRollbackAction (pRecord);
 294   else
 295     throw SSUnknownActionException (pVersion->ActionID, pRecord);
 296
 297   return NULL;
 298 }
 299
 300 const VERSION_RECORD* SSAction::GetHistoryRecordPtr (SSRecordPtr pRecord) const
 301 {
 302   assert (pRecord->GetBuffer ());
 303   return reinterpret_cast<const VERSION_RECORD*> (pRecord->GetBuffer ());
 304 }
 305
 306 void SSAction::Dump (std::ostream& os) const
 307 {
 308 }
 309
 310 //---------------------------------------------------------------------------
 311 SSLabeledAction::SSLabeledAction (SSRecordPtr pRecord)
 312   : SSActionEx<SSLabeledAction> (pRecord)
 313 {
 314   const VERSION_RECORD* pVersion = GetHistoryRecordPtr (pRecord);
 315
 316   m_Label = std::string (pVersion->Label);
 317
 318   if (pVersion->OffsetToLabelComment && pVersion->LengthLabelComment > 0)
 319   {
 320     try {
 321       SSCommentObject commentObject (pRecord->GetFileImp ()->GetRecord (pVersion->OffsetToLabelComment));
 322       m_LabelComment = commentObject.GetComment();
 323     }
 324     catch (SSRecordException&)
 325     {
 326     }
 327   }
 328 }
 329
 330 SSLabeledAction::~SSLabeledAction ()
 331 {
 332 }
 333
 334 std::string SSLabeledAction::FormatActionString ()
 335 {
 336   return "Labeled " + m_Label;
 337 }
 338
 339 void SSLabeledAction::ToXml (XMLNode* pParent) const
 340 {
 341   XMLElement label   (pParent, "Label", GetLabel());
 342   XMLElement comment (pParent, "LabelComment", GetLabelComment());
 343
 344 }
 345
 346 void SSLabeledAction::Dump (std::ostream& os) const
 347 {
 348   SSActionEx<SSLabeledAction>::Dump (os);
 349 }
 350
 351 //---------------------------------------------------------------------------
 352 template <class ACTION, class STRUCT>
 353 SSItemAction<ACTION, STRUCT>::SSItemAction (SSRecordPtr pRecord, std::string actionString)
 354   : SSActionEx<ACTION> (pRecord),
 355     m_ActionString (actionString)
 356 {
 357   memcpy (&m_Action, pRecord->GetBuffer()+sizeof(VERSION_RECORD), sizeof(STRUCT));
 358 }
 359
 360 template <class T, class ACTION>
 361 std::string SSItemAction<T, ACTION>::FormatActionString ()
 362 {
 363   return m_ActionString + GetName ();
 364 }
 365
 366 template <class T, class ACTION>
 367 void SSItemAction<T, ACTION>::ToXml (XMLNode* pParent) const
 368 {
 369   XMLElement physical (pParent, "Physical", GetPhysical());
 370   GetSSName().ToXml (pParent);
 371 }
 372
 373 template <class T, class ACTION>
 374 void SSItemAction<T, ACTION>::Dump (std::ostream& os) const
 375 {
 376   SSActionEx<T>::Dump (os);
 377 }
 378
 379 //---------------------------------------------------------------------------
 380 template <class ACTION>
 381 SSDestroyedAction<ACTION>::SSDestroyedAction (SSRecordPtr pRecord, std::string prefix)
 382   : SSItemAction<ACTION, DESTROYED_ACTION> (pRecord, ""),
 383     m_Prefix (prefix)
 384 {
 385 }
 386
 387 template <class ACTION>
 388 std::string SSDestroyedAction<ACTION>::FormatActionString ()
 389 {
 390   std::string action (m_Prefix);
 391   action += GetName () + " Destroyed";
 392   return action;
 393 }
 394
 395 //---------------------------------------------------------------------------
 396 template <class ACTION>
 397 SSRenamedAction<ACTION>::SSRenamedAction (SSRecordPtr pRecord, std::string prefix)
 398   : SSItemAction<ACTION, RENAMED_ACTION> (pRecord, ""),
 399     m_Prefix (prefix)
 400 {
 401 }
 402
 403 template <class ACTION>
 404 std::string SSRenamedAction<ACTION>::FormatActionString ()
 405 {
 406   SSName ssOldName (GetSSName ());
 407   SSName ssNewName (m_Action.newName);
 408   std::string action (m_Prefix);
 409   action += ssOldName.GetFullName ();
 410   action += " renamedto " + m_Prefix;
 411   action += ssNewName.GetFullName ();
 412   return action;
 413 }
 414
 415 template <class ACTION>
 416 void SSRenamedAction<ACTION>::ToXml (XMLNode* pParent) const
 417 {
 418   SSItemAction<ACTION,RENAMED_ACTION>::ToXml (pParent);
 419
 420   GetNewSSName().ToXml (pParent, "NewSSName");
 421 }
 422
 423 template <class ACTION>
 424 void SSRenamedAction<ACTION>::Dump (std::ostream& os) const
 425 {
 426   SSItemAction<ACTION, RENAMED_ACTION>::Dump (os);
 427 }
 428
 429 //---------------------------------------------------------------------------
 430 SSCheckedInAction::SSCheckedInAction (SSRecordPtr pRecord)
 431   : SSActionEx<SSCheckedInAction> (pRecord),
 432     m_FilePtr (pRecord->GetFileImp ())
 433 {
 434   memcpy (&m_Action, pRecord->GetBuffer()+sizeof(VERSION_RECORD), sizeof(CHECKED_IN_ACTION));
 435 }
 436
 437 SSCheckedInAction::~SSCheckedInAction ()
 438 {
 439 }
 440
 441 std::string SSCheckedInAction::FormatActionString ()
 442 {
 443   std::string action = "Checked In ";
 444   action += std::string (m_Action.checkInSpec);
 445   return action;
 446 }
 447
 448 SSRecordPtr SSCheckedInAction::GetFileDelta () const
 449 {
 450   if (!m_pFileDelta && m_Action.offsetFileDelta)
 451   {
 452     m_pFileDelta = m_FilePtr->GetRecord (m_Action.offsetFileDelta);
 453   }
 454
 455   return m_pFileDelta;
 456 }
 457
 458 void SSCheckedInAction::ToXml (XMLNode* pParent) const
 459 {
 460   XMLElement checkInNode (pParent, "CheckInSpec", GetFileSepc());
 461   XMLElement offsetNode  (pParent, "Offset", GetOffset());
 462 }
 463
 464 void SSCheckedInAction::Dump (std::ostream& os) const
 465 {
 466   SSActionEx<SSCheckedInAction>::Dump (os);
 467 }
 468
 469 //---------------------------------------------------------------------------
 470 SSSharedAction::SSSharedAction (SSRecordPtr pRecord)
 471   : SSItemAction<SSSharedAction, SHARED_FILE_ACTION> (pRecord, "")
 472 {
 473 }
 474
 475 SSSharedAction::~SSSharedAction ()
 476 {
 477 }
 478
 479 std::string SSSharedAction::FormatActionString ()
 480 {
 481   std::ostringstream str;
 482   SSName name (m_Action.name);
 483   if (m_Action.pinnedToVersion == -1)
 484     str << m_Action.srcPathSpec << "/" << name.GetFullName() << ";" << m_Action.version << " shared";
 485   else if (m_Action.pinnedToVersion == 0)
 486     str << m_Action.srcPathSpec << "/" << name.GetFullName() << " pinned to version " << m_Action.version;
 487   else if (m_Action.version == 0)
 488     str << m_Action.srcPathSpec << "/" << name.GetFullName() << " unpinned";
 489   else
 490     throw SSException ("bad share/pin/unpin action: version should be 0");
 491
 492   return str.str();
 493 }
 494
 495
 496 void SSSharedAction::ToXml (XMLNode* pParent) const
 497 {
 498   SSItemAction<SSSharedAction, SHARED_FILE_ACTION>::ToXml(pParent);
 499
 500   XMLElement srcPathNode (pParent, "SrcPath", GetSrcPathSpec ());
 501   XMLElement pinnedNode  (pParent, "PinnedToVersion", GetPinnedToVersion ());
 502   XMLElement versionNode (pParent, "Version", GetVersion ());
 503 }
 504
 505 void SSSharedAction::Dump (std::ostream& os) const
 506 {
 507   SSItemAction<SSSharedAction, SHARED_FILE_ACTION>::Dump(os);
 508 }
 509
 510 //---------------------------------------------------------------------------
 511 void SSRollbackAction::ToXml (XMLNode* pParent) const
 512 {
 513   SSItemAction<SSRollbackAction, ROLLBACK_ACTION>::ToXml (pParent);
 514
 515   XMLElement parentNode (pParent, "Parent", GetParent());
 516 }
 517
 518 void SSRollbackAction::Dump (std::ostream& os) const
 519 {
 520   SSItemAction<SSRollbackAction, ROLLBACK_ACTION>::Dump (os);
 521 }