ssphys/SSLib/SSItem.cpp

   1 // SSItem.cpp: implementation of the SSItem class.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4
   5 #include "stdafx.h"
   6 #include "SSItem.h"
   7 #include "SSVersion.h"
   8 #include "SSDatabase.h"
   9 #include <SSPhysLib\SSProjectObject.h>
  10
  11 //---------------------------------------------------------------------------
  12 #include "LeakWatcher.h"
  13
  14 #ifdef _DEBUG
  15 #define new DEBUG_NEW
  16 #undef THIS_FILE
  17 static char THIS_FILE[] = __FILE__;
  18 #endif
  19
  20 //////////////////////////////////////////////////////////////////////
  21 // Construction/Destruction
  22 //////////////////////////////////////////////////////////////////////
  23
  24
  25 /*
  26 SSItem::SSItem()
  27   : m_pDatabase (NULL),
  28     m_nVersionNumber(0)
  29 {
  30 }
  31
  32 SSItem::SSItem(SSHistoryFile& rFile, int nVersion)
  33   : m_pDatabase (NULL),
  34     m_nVersionNumber(nVersion)
  35 {
  36 }
  37
  38 SSItem::SSItem(SSDatabase* pDb, const std::string& spec, const std::string& phys)
  39   : m_pDatabase (pDb),
  40     m_MySpec (spec),
  41     m_Phys (phys),
  42     m_nVersionNumber(0)
  43 {
  44 }
  45 */
  46
  47 //SSItem::SSItem(SSDatabase* pDb)
  48 //  : m_pDatabase (pDb),
  49 //    m_pParent (NULL),
  50 //    // m_ItemDescr (project),
  51 //    m_nVersionNumber(0)
  52 //{
  53 //  m_ItemDescr.type = SSITEM_PROJECT;
  54 //  m_ItemDescr.flags = 0;
  55 //  m_ItemDescr.name.flags = 0;
  56 //  strncpy (m_ItemDescr.name.name, "$", 2);
  57 //  m_ItemDescr.name.nsmap = 0;
  58 //  strncpy (m_ItemDescr.phys, "AAAAAAAA", 9);
  59 //}
  60
  61 SSItem::SSItem(SSDatabase* pDb, SSItemPtr pParent, SSProjectObject project, int version)
  62   : m_pDatabase (pDb),
  63     m_pParent (pParent),
  64     m_ItemDescr (project)
  65 {
  66   m_ItemDescr.Pin (version);
  67 }
  68
  69 SSItem::SSItem(SSDatabase* pDb, SSItemPtr pParent, SSProjectObject project)
  70   : m_pDatabase (pDb),
  71     m_pParent (pParent),
  72     m_ItemDescr (project)
  73 {
  74 }
  75
  76 SSItem::~SSItem()
  77 {
  78 }
  79
  80 bool SSItem::GetBinary ()
  81 {
  82   return m_ItemDescr.IsStoreBinaryDiff ();
  83 }
  84
  85 bool SSItem::GetDeleted ()
  86 {
  87   return m_ItemDescr.IsDeleted ();
  88 }
  89
  90 int SSItem::GetType ()
  91 {
  92   return m_ItemDescr.GetType ();
  93 }
  94
  95 std::string SSItem::GetSpec ()
  96 {
  97   // Here is a minor oddity in the naming of the specification
  98   // The spec of the root project is $/, but the name of any subproject is
  99   // $/subproject (note without the slash at the end)
 100
 101   // The encoding of the path specification leads to the small problem, that
 102   // a pinned version of the root project is written in the form $/;10. Chaining
 103   // subproject to that form of the root project specification leads to
 104   // $/;10project;20. To be unambigous in this way, we need to introduce another
 105   // path sperator: $/;10/project;20, even if this looks strange
 106
 107   // Due to the nature ss handles the specification $;10 is valid. It is the version 10
 108   // of the current project.
 109   std::string spec;
 110   SSItemPtr pParent (m_pParent);
 111
 112   spec = GetName ();
 113   if (!pParent)
 114   {
 115     if (spec.size() < 2 && spec.compare(0, 2, "$/") != 0)
 116       throw SSException ("internal error: the root project must start with $/");
 117   }
 118
 119   while (pParent)
 120   {
 121     std::string parentSpec = pParent->GetSpec();
 122
 123     if (*parentSpec.rbegin() != '/')
 124       parentSpec += "/";
 125
 126     spec = parentSpec + spec;
 127     pParent = pParent->GetParent();
 128   }
 129
 130   return spec;
 131 }
 132
 133 std::string SSItem::GetLocalSpec ()
 134 {
 135   return "";
 136 }
 137
 138 std::string SSItem::GetName ()
 139 {
 140   return m_ItemDescr.GetName ();
 141 }
 142
 143 long SSItem::GetVersionNumber ( )
 144 {
 145   int pin = m_ItemDescr.GetPinnedToVersion();
 146   if (pin)
 147     return pin;
 148
 149 //  std::auto_ptr<SSHistoryFile> pFile (m_pDatabase->GetDataFile (m_ItemDescr.GetPhysFile()));
 150 //  if (pFile.get())
 151 //  {
 152 //    pFile->Open ();
 153 //    std::auto_ptr<SSVersionObject> version (pFile->GetLastVersion());
 154 //    return version->GetVersionNumber ();
 155 //  }
 156 //  else
 157 //    throw SSException (std::string ("Could not open File: ") + pFile->GetFileName());
 158
 159   return 0;
 160 }
 161
 162 long SSItem::GetIsCheckedOut ( )
 163 {
 164   return 0;
 165 }
 166
 167 SSItemPtr SSItem::GetParent ()
 168 {
 169   return m_pParent;
 170 }
 171
 172 SSItems* SSItem::GetItems (bool bIncludeDeleted)
 173 {
 174   // valid only for project items
 175   if (GetType () != SSITEM_PROJECT)
 176     return NULL;
 177
 178   // get the correct phys file
 179   std::auto_ptr<SSHistoryFile> pFile (m_pDatabase->GetDataFile (m_ItemDescr.GetPhysFile()));
 180   if (pFile.get())
 181   {
 182     pFile->Open ();
 183     SSProjectFile projectFile (pFile->GetFileName () + pFile->GetLatestExt ());
 184     SSItems* pItems = new SSItems (shared_from_this(), projectFile, true);
 185
 186     // reverse apply the history
 187     SSVersionObject version = pFile->GetLastVersion();
 188     int myVersion = GetVersionNumber ();
 189     while (version && ( (myVersion > 0 && version.GetVersionNumber() > myVersion) )
 190 /*                       || (versionPtr->GetDate() > m_pDatabase->GetVersionDate ()) */)
 191     {
 192       SSAction* pAction = version.GetAction();
 193       if (!pAction->Accept (*pItems))
 194         throw SSException("unsupported action");
 195
 196       version = pFile->GetPrevVersion (version);
 197     }
 198     return pItems;
 199   }
 200   else
 201     throw SSException (std::string ("Could not open File: ") + pFile->GetFileName());
 202
 203   return NULL;
 204 }
 205
 206 SSItemPtr SSItem::GetVersion (std::string version)
 207 {
 208   int v = atoi (version.c_str());
 209   return SSItemPtr (new SSItem (m_pDatabase, m_pParent, m_ItemDescr, v));
 210 }
 211
 212 SSVersions* SSItem::GetVersions (long iFlags)
 213 {
 214   return new SSVersions (shared_from_this(), m_ItemDescr.GetPhysFile(), iFlags);
 215 }
 216
 217 std::string SSItem::GetPhysical()
 218 {
 219   return m_ItemDescr.GetPhysFile();
 220 }
 221
 222
 223 void SSItem::Recover()
 224 {
 225   m_ItemDescr.Recover ();
 226 }
 227
 228 void SSItem::Delete()
 229 {
 230   m_ItemDescr.Delete ();
 231 }
 232
 233 void SSItem::Rename(SSNAME oldName, SSNAME newName)
 234 {
 235   m_ItemDescr.Rename (oldName, newName);
 236 }
 237
 238
 239
 240 SSItems::~SSItems ()
 241 {
 242 }
 243
 244 SSItems::SSItems (SSItemPtr pParentItem, SSProjectFile& rFile, bool bIncludeDeleted)
 245   : m_pParent (pParentItem)
 246 {
 247   BuildList (pParentItem, rFile, bIncludeDeleted);
 248 }
 249
 250 SSItemPtr SSItems::GetItem (long i)
 251 {
 252   assert (i < GetCount ());
 253   if (i<GetCount ())
 254     return m_Items[i];
 255   return static_cast<SSItem*>(NULL);
 256 }
 257
 258 void SSItems::BuildList (SSItemPtr pParentItem, SSProjectFile& rFile, bool bIncludeDeleted)
 259 {
 260   // iterate all records and add the items to the collection
 261   SSRecordPtr recordPtr = rFile.GetFirstRecord ();
 262   while (recordPtr)
 263   {
 264     if (recordPtr->GetType() == eProjectEntry)
 265     {
 266       SSProjectObject project (recordPtr);
 267       if (!project.IsDeleted() || bIncludeDeleted)
 268       {
 269         m_Items.push_back (SSItemPtr(new SSItem (pParentItem->GetDatabase (), pParentItem, project)));
 270       }
 271     }
 272
 273     recordPtr = rFile.GetNextRecord (recordPtr);
 274   }
 275 }
 276
 277 bool SSItems::Apply (const SSLabeledAction& rAction)
 278 {
 279   return true;
 280 }
 281
 282 bool SSItems::Apply (const SSCreatedProjectAction& rAction)
 283 {
 284   return true;
 285 }
 286
 287 bool SSItems::Apply (const SSCreatedFileAction& rAction)
 288 {
 289   return true;
 290 }
 291
 292 bool SSItems::Apply (const SSDestroyedFileAction& rAction)
 293 {
 294   // durch map wahrscheinlich besser zu lösen
 295   if (GetPhysicalItem (rAction.GetPhysical()))
 296     throw SSException ("adding already existing item");
 297
 298   PROJECT_ENTRY pe;
 299 //          pe.flags = ??;
 300   pe.name = rAction.GetSSName ();
 301   strncpy (pe.phys, rAction.GetPhysical().c_str(), 8);
 302   pe.phys[8] = '\0';
 303   pe.pinnedToVersion = 0;
 304 //          pe.type = ??
 305   SSProjectObject pr (pe);
 306   SSItemPtr pItem (new SSItem (m_pParent->GetDatabase(), m_pParent, pr));
 307
 308   m_Items.push_back (pItem);
 309
 310   return true;
 311 }
 312 bool SSItems::Apply (const SSDestroyedProjectAction& rAction)
 313 {
 314   // durch map wahrscheinlich besser zu lösen
 315   if (GetPhysicalItem (rAction.GetPhysical()))
 316     throw SSException ("adding already existing item");
 317
 318   PROJECT_ENTRY pe;
 319 //          pe.flags = ??;
 320   pe.name = rAction.GetSSName ();
 321   strncpy (pe.phys, rAction.GetPhysical().c_str(), 8);
 322   pe.phys[8] = '\0';
 323   pe.pinnedToVersion = 0;
 324 //          pe.type = ??
 325   SSProjectObject pr (pe);
 326   SSItemPtr pItem (new SSItem (m_pParent->GetDatabase(), m_pParent, pr));
 327
 328   m_Items.push_back (pItem);
 329
 330   return true;
 331 }
 332 bool SSItems::Apply (const SSAddedFileAction& rAction)
 333 {
 334   SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 335   std::vector<SSItemPtr>::iterator itor = std::find (m_Items.begin(), m_Items.end(), pItem);
 336
 337   if (itor != m_Items.end())
 338     m_Items.erase(itor);
 339   else
 340     throw SSException ("item not found");
 341
 342   return true;
 343 }
 344 bool SSItems::Apply (const SSAddedProjectAction& rAction)
 345 {
 346   SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 347   std::vector<SSItemPtr>::iterator itor = std::find (m_Items.begin(), m_Items.end(), pItem);
 348
 349   if (itor != m_Items.end())
 350     m_Items.erase(itor);
 351   else
 352     throw SSException ("item not found");
 353
 354   return true;
 355 }
 356
 357 bool SSItems::Apply (const SSDeletedFileAction& rAction)
 358 {
 359   SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 360   if (pItem)
 361     pItem->Recover ();
 362   else
 363     throw SSException ("item not found");
 364
 365   return true;
 366 }
 367 bool SSItems::Apply (const SSDeletedProjectAction& rAction)
 368 {
 369   SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 370   if (pItem)
 371     pItem->Recover ();
 372   else
 373     throw SSException ("item not found");
 374
 375   return true;
 376 }
 377
 378 //bool SSItems::DeleteFile (SSAction& rAction)
 379 //{
 380 //  SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 381 //  if (pItem)
 382 //    pItem->Delete ();
 383 //  else
 384 //    throw SSException ("item not found");
 385 //
 386 //  return true;
 387 //}
 388 //bool SSItems::DeleteProject (SSAction& rAction)
 389 //{
 390 //  return DeleteFile (pAction);
 391 //}
 392
 393 bool SSItems::Apply (const SSRenamedProjectAction& rAction) //, SSNAME oldName, SSNAME newName)
 394 {
 395   SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 396   if (!pItem)
 397     throw SSException ("item not found");
 398
 399   pItem->Rename (rAction.GetSSName(), rAction.GetNewSSName ());
 400   return true;
 401 }
 402
 403 bool SSItems::Apply (const SSRenamedFileAction& rAction) //, SSNAME oldName, SSNAME newName)
 404 {
 405   SSItemPtr pItem = GetPhysicalItem (rAction.GetPhysical());
 406   if (!pItem)
 407     throw SSException ("item not found");
 408
 409   pItem->Rename (rAction.GetSSName(), rAction.GetNewSSName ());
 410   return true;
 411 }
 412
 413 bool SSItems::Apply (const SSCheckedInAction& rAction)
 414 {
 415   return true;
 416 }
 417
 418 SSItemPtr SSItems::GetPhysicalItem (std::string physical)
 419 {
 420 #pragma message ("speed up by using a map and no full search")
 421   std::vector<SSItemPtr>::iterator itor;
 422   std::vector<SSItemPtr>::iterator end = m_Items.end();
 423
 424   SSItemPtr foundItemPtr;
 425   for (itor = m_Items.begin(); itor != end; ++itor)
 426   {
 427     SSItemPtr itemPtr = *itor;
 428 //    std::cout << itemPtr->GetPhysical () << std::endl;
 429     std::string current = itemPtr->GetPhysical ();
 430     if (current == physical)
 431     {
 432       if (foundItemPtr)
 433         throw SSException ("duplicate entry");
 434
 435       foundItemPtr = itemPtr;
 436     }
 437   }
 438
 439   return foundItemPtr;
 440 }
 441
 442 void SSItems::Dump (std::ostream& os) const
 443 {
 444   std::vector<SSItemPtr>::iterator itor;
 445   std::vector<SSItemPtr>::iterator end = m_Items.end();
 446
 447   for (itor = m_Items.begin(); itor != end; ++itor)
 448   {
 449     oss << (*itor)->GetPhysical () << ": "  << (*itor)->GetName () << std::endl;
 450   }
 451 }