[occt.git] / src / PCDM / PCDM_ReadWriter_1.cxx

// Created on: 1997-12-09
// Created by: Jean-Louis Frenkel
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.


#include <CDM_Document.hxx>
#include <CDM_MessageDriver.hxx>
#include <CDM_MetaData.hxx>
#include <CDM_ReferenceIterator.hxx>
#include <OSD_Path.hxx>
#include <PCDM.hxx>
#include <PCDM_BaseDriverPointer.hxx>
#include <PCDM_ReadWriter_1.hxx>
#include <PCDM_Reference.hxx>
#include <PCDM_TypeOfFileDriver.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Type.hxx>
#include <Storage_Data.hxx>
#include <Storage_HeaderData.hxx>
#include <Storage_Schema.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <UTL.hxx>

IMPLEMENT_STANDARD_RTTIEXT(PCDM_ReadWriter_1,PCDM_ReadWriter)

#define START_REF "START_REF"
#define END_REF "END_REF"
#define START_EXT "START_EXT"
#define END_EXT "END_EXT"
#define MODIFICATION_COUNTER "MODIFICATION_COUNTER: "
#define REFERENCE_COUNTER "REFERENCE_COUNTER: "

//=======================================================================
//function : PCDM_ReadWriter_1
//purpose  : 
//=======================================================================

PCDM_ReadWriter_1::PCDM_ReadWriter_1() {}
static Standard_Integer RemoveExtraSeparator(TCollection_AsciiString& aString) {

  Standard_Integer i, j, len ;

  len = aString.Length() ;
#ifdef _WIN32
  // Case of network path, such as \\MACHINE\dir
  for (i = j = 2 ; j <= len ; i++,j++) {
#else
  for (i = j = 1 ; j <= len ; i++,j++) {
#endif
      Standard_Character c = aString.Value(j) ;
      aString.SetValue(i,c) ;
      if (c == '/')
          while(j < len && aString.Value(j+1) == '/') j++ ;
  }
  len = i-1 ;
  if (aString.Value(len) == '/') len-- ;  
  aString.Trunc(len) ;
  return len ;
}
static TCollection_AsciiString AbsolutePath(
                            const TCollection_AsciiString& aDirPath,
                            const TCollection_AsciiString& aRelFilePath)
{
  TCollection_AsciiString EmptyString = "" ;
#ifdef _WIN32
  if (aRelFilePath.Search(":") == 2 ||
      (aRelFilePath.Search("\\") == 1 && aRelFilePath.Value(2) == '\\'))
#else
  if(aRelFilePath.Search("/") == 1)
#endif
    return aRelFilePath ;
  
  TCollection_AsciiString DirPath = aDirPath, RelFilePath = aRelFilePath  ;
  Standard_Integer i,len ;
  
#ifdef _WIN32
  if(DirPath.Search(":") != 2 &&
     (DirPath.Search("\\") != 1 || DirPath.Value(2) != '\\'))
#else
  if (DirPath.Search("/") != 1 )
#endif
    return EmptyString ;

#ifdef _WIN32
  DirPath.ChangeAll('\\','/') ;
  RelFilePath.ChangeAll('\\','/') ;      
#endif
  
  RemoveExtraSeparator(DirPath) ;
  len = RemoveExtraSeparator(RelFilePath) ;
  
  while (RelFilePath.Search("../") == 1) {
      if (len == 3)
	  return EmptyString ;
      RelFilePath = RelFilePath.SubString(4,len) ;
      len -= 3 ;
      if (DirPath.IsEmpty())
	  return EmptyString ;
      i = DirPath.SearchFromEnd("/") ;
      if (i < 0)
          return EmptyString ;
      DirPath.Trunc(i-1) ;
  }  
  TCollection_AsciiString retx;
  retx= DirPath;
  retx+= "/";
  retx+=RelFilePath ;
  return retx;
}

static TCollection_AsciiString GetDirFromFile(const TCollection_ExtendedString& aFileName) {
  TCollection_AsciiString theCFile(aFileName);
  TCollection_AsciiString theDirectory;
  Standard_Integer i=theCFile.SearchFromEnd("/");
#ifdef _WIN32    
//    if(i==-1) i=theCFile.SearchFromEnd("\\");
  if(theCFile.SearchFromEnd("\\") > i)
    i=theCFile.SearchFromEnd("\\");
#endif
  if(i!=-1) theDirectory=theCFile.SubString(1,i);
  return theDirectory;
}
//=======================================================================
//function : Version
//purpose  : 
//=======================================================================

TCollection_AsciiString PCDM_ReadWriter_1::Version() const {
  return "PCDM_ReadWriter_1";
}
//=======================================================================
//function : WriteReferenceCounter
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::WriteReferenceCounter(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument) const { 
  TCollection_AsciiString ligne(REFERENCE_COUNTER);
  ligne+=aDocument->ReferenceCounter();
  aData->AddToUserInfo(ligne);
}
//=======================================================================
//function : WriteReferences
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::WriteReferences(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument,const TCollection_ExtendedString& theReferencerFileName) const {  

  Standard_Integer theNumber = aDocument->ToReferencesNumber();
  if(theNumber > 0) {

    aData->AddToUserInfo(START_REF);

    CDM_ReferenceIterator it(aDocument);

    TCollection_ExtendedString ligne;

    TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(theReferencerFileName);

    for (;it.More();it.Next()) {
      ligne = TCollection_ExtendedString(it.ReferenceIdentifier());
      ligne += " ";
      ligne += TCollection_ExtendedString(it.Document()->Modifications());
      ligne += " ";

      TCollection_AsciiString thePath(it.Document()->MetaData()->FileName());
      TCollection_AsciiString theRelativePath;
      if(!theAbsoluteDirectory.IsEmpty()) {
	theRelativePath=OSD_Path::RelativePath(theAbsoluteDirectory,thePath);
	if(!theRelativePath.IsEmpty()) thePath=theRelativePath;
      }
      ligne +=  TCollection_ExtendedString(thePath);
      UTL::AddToUserInfo(aData,ligne);
    }
    aData->AddToUserInfo(END_REF);
  }
}

//=======================================================================
//function : WriteExtensions
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::WriteExtensions(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument) const {  

  TColStd_SequenceOfExtendedString theExtensions;
  aDocument->Extensions(theExtensions);
  Standard_Integer theNumber = theExtensions.Length();
  if(theNumber > 0) {

    aData->AddToUserInfo(START_EXT);
    for (Standard_Integer i=1; i<=theNumber; i++) {
      UTL::AddToUserInfo(aData,theExtensions(i));
    }
    aData->AddToUserInfo(END_EXT);
  }
}
//=======================================================================
//function : WriteVersion
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::WriteVersion(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument) const { 
  TCollection_AsciiString ligne(MODIFICATION_COUNTER);
  ligne+=aDocument->Modifications();
  aData->AddToUserInfo(ligne);
}
//=======================================================================
//function : ReadReferenceCounter
//purpose  : 
//=======================================================================

Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) const {

  static Standard_Integer theReferencesCounter ;
  theReferencesCounter=0;
  static Standard_Integer i ;

  PCDM_BaseDriverPointer theFileDriver;
  TCollection_AsciiString aFileNameU(aFileName);
  if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
    return theReferencesCounter;
  
  static Standard_Boolean theFileIsOpen ;
  theFileIsOpen=Standard_False;

  try {
    OCC_CATCH_SIGNALS
    PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
    theFileIsOpen=Standard_True;
   
    Handle(Storage_Schema) s = new Storage_Schema;
    Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
    const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
    
    for ( i =1; i<=  refUserInfo.Length() ; i++) {
      if(refUserInfo(i).Search(REFERENCE_COUNTER) != -1) {
	try { OCC_CATCH_SIGNALS theReferencesCounter=refUserInfo(i).Token(" ",2).IntegerValue();}
	catch (Standard_Failure) { 
//	  cout << "warning: could not read the reference counter in " << aFileName << endl;
	  TCollection_ExtendedString aMsg("Warning: ");
	  aMsg = aMsg.Cat("could not read the reference counter in ").Cat(aFileName).Cat("\0");
	  if(!theMsgDriver.IsNull()) 
	    theMsgDriver->Write(aMsg.ToExtString());
	}
      }
    }
    
  }
  catch (Standard_Failure) {}

  if(theFileIsOpen)  theFileDriver->Close();

  delete theFileDriver;
  return theReferencesCounter;
}
  
//=======================================================================
//function : ReadReferences
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::ReadReferences(const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) const  {

  TColStd_SequenceOfExtendedString ReadReferences;
  
  ReadUserInfo(aFileName,START_REF,END_REF,ReadReferences, theMsgDriver);

  Standard_Integer theReferenceIdentifier;
  TCollection_ExtendedString theFileName;
  Standard_Integer theDocumentVersion;

  TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(aFileName);

  for (Standard_Integer i=1; i<=ReadReferences.Length(); i++) {
    Standard_Integer pos=ReadReferences(i).Search(" ");
    if(pos != -1) {
      TCollection_ExtendedString theRest=ReadReferences(i).Split(pos);
      theReferenceIdentifier=UTL::IntegerValue(ReadReferences(i));
    
      Standard_Integer pos2=theRest.Search(" ");
      
      theFileName=theRest.Split(pos2);
      theDocumentVersion=UTL::IntegerValue(theRest);
      
      TCollection_AsciiString thePath(theFileName);
      TCollection_AsciiString theAbsolutePath;
      if(!theAbsoluteDirectory.IsEmpty()) {
	theAbsolutePath=AbsolutePath(theAbsoluteDirectory,thePath);
	if(!theAbsolutePath.IsEmpty()) thePath=theAbsolutePath;
      }
      if(!theMsgDriver.IsNull()) {
//      cout << "reference found; ReferenceIdentifier: " << theReferenceIdentifier << "; File:" << thePath << ", version:" << theDocumentVersion;
	TCollection_ExtendedString aMsg("Warning: ");
	aMsg = aMsg.Cat("reference found; ReferenceIdentifier:  ").Cat(theReferenceIdentifier).Cat("; File:").Cat(thePath).Cat(", version:").Cat(theDocumentVersion).Cat("\0");
	theMsgDriver->Write(aMsg.ToExtString());
      }
      TCollection_ExtendedString aPathW(thePath);
      theReferences.Append(PCDM_Reference (theReferenceIdentifier,aPathW,theDocumentVersion));
    
    }
  }

}

//=======================================================================
//function : ReadExtensions
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::ReadExtensions(const TCollection_ExtendedString& aFileName, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) const {
  
  ReadUserInfo(aFileName,START_EXT,END_EXT,theExtensions, theMsgDriver);
}


//=======================================================================
//function : ReadUserInfo
//purpose  : 
//=======================================================================

void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName,
                                     const TCollection_AsciiString& Start,
                                     const TCollection_AsciiString& End,
                                     TColStd_SequenceOfExtendedString& theUserInfo,
                                     const Handle(CDM_MessageDriver)&) {

  static Standard_Integer i ;
  PCDM_BaseDriverPointer theFileDriver;
  TCollection_AsciiString aFileNameU(aFileName);
  if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
    return;

  PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
  Handle(Storage_Schema) s = new Storage_Schema;
  Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
  const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();

  Standard_Integer debut=0,fin=0;
  
  for ( i =1; i<=  refUserInfo.Length() ; i++) {
    TCollection_ExtendedString theLine=refUserInfo(i);
    if(refUserInfo(i)== Start) debut=i;
    if(refUserInfo(i)== End) fin=i;
  }
  if(debut != 0) {
    for (i=debut+1 ; i<fin; i++) {
      TCollection_ExtendedString aInfoW(refUserInfo(i));
      theUserInfo.Append(aInfoW);
    }
  }
  theFileDriver->Close();
  delete theFileDriver;
}

//=======================================================================
//function : ReadDocumentVersion
//purpose  : 
//=======================================================================

Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) const {

  static Standard_Integer theVersion ;
  theVersion=-1;

  PCDM_BaseDriverPointer theFileDriver;
  TCollection_AsciiString aFileNameU(aFileName);
  if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
    return theVersion;

  static Standard_Boolean theFileIsOpen ;
  theFileIsOpen =Standard_False;

  try {
    OCC_CATCH_SIGNALS
    PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
    theFileIsOpen=Standard_True;
    Handle(Storage_Schema) s = new Storage_Schema;
    Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
    const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();

    static Standard_Integer i ;
    for ( i =1; i<=  refUserInfo.Length() ; i++) {
      if(refUserInfo(i).Search(MODIFICATION_COUNTER) != -1) {
	try { OCC_CATCH_SIGNALS theVersion=refUserInfo(i).Token(" ",2).IntegerValue();}
	catch (Standard_Failure) { 
//	  cout << "warning: could not read the version in " << aFileName << endl;
	  TCollection_ExtendedString aMsg("Warning: ");
	  aMsg = aMsg.Cat("could not read the version in ").Cat(aFileName).Cat("\0");
	  if(!theMsgDriver.IsNull()) 
	    theMsgDriver->Write(aMsg.ToExtString());
	}

      }
    }
  }

  catch (Standard_Failure) {}

  if(theFileIsOpen) theFileDriver->Close();
  delete theFileDriver;
  return theVersion;
}
Commit	Line	Data
b311480e	1	// Created on: 1997-12-09
	2	// Created by: Jean-Louis Frenkel
	3	// Copyright (c) 1997-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
42cf5bc1	17
7fd59977	18	#include <CDM_Document.hxx>
42cf5bc1	19	#include <CDM_MessageDriver.hxx>
7fd59977	20	#include <CDM_MetaData.hxx>
42cf5bc1	21	#include <CDM_ReferenceIterator.hxx>
7fd59977	22	#include <OSD_Path.hxx>
7fd59977	23	#include <PCDM.hxx>
42cf5bc1	24	#include <PCDM_BaseDriverPointer.hxx>
	25	#include <PCDM_ReadWriter_1.hxx>
	26	#include <PCDM_Reference.hxx>
7fd59977	27	#include <PCDM_TypeOfFileDriver.hxx>
42cf5bc1	28	#include <Standard_ErrorHandler.hxx>
	29	#include <Standard_Type.hxx>
	30	#include <Storage_Data.hxx>
	31	#include <Storage_HeaderData.hxx>
	32	#include <Storage_Schema.hxx>
	33	#include <TCollection_AsciiString.hxx>
	34	#include <TCollection_ExtendedString.hxx>
	35	#include <TColStd_SequenceOfAsciiString.hxx>
	36	#include <TColStd_SequenceOfExtendedString.hxx>
	37	#include <UTL.hxx>
7fd59977	38
92efcf78	39	IMPLEMENT_STANDARD_RTTIEXT(PCDM_ReadWriter_1,PCDM_ReadWriter)
92efcf78	40
7fd59977	41	#define START_REF "START_REF"
	42	#define END_REF "END_REF"
	43	#define START_EXT "START_EXT"
	44	#define END_EXT "END_EXT"
	45	#define MODIFICATION_COUNTER "MODIFICATION_COUNTER: "
	46	#define REFERENCE_COUNTER "REFERENCE_COUNTER: "
	47
	48	//=======================================================================
	49	//function : PCDM_ReadWriter_1
	50	//purpose :
	51	//=======================================================================
	52
	53	PCDM_ReadWriter_1::PCDM_ReadWriter_1() {}
	54	static Standard_Integer RemoveExtraSeparator(TCollection_AsciiString& aString) {
	55
	56	Standard_Integer i, j, len ;
	57
	58	len = aString.Length() ;
57c28b61	59	#ifdef _WIN32
7fd59977	60	// Case of network path, such as \\MACHINE\dir
	61	for (i = j = 2 ; j <= len ; i++,j++) {
	62	#else
	63	for (i = j = 1 ; j <= len ; i++,j++) {
	64	#endif
	65	Standard_Character c = aString.Value(j) ;
	66	aString.SetValue(i,c) ;
	67	if (c == '/')
	68	while(j < len && aString.Value(j+1) == '/') j++ ;
	69	}
	70	len = i-1 ;
	71	if (aString.Value(len) == '/') len-- ;
	72	aString.Trunc(len) ;
	73	return len ;
	74	}
	75	static TCollection_AsciiString AbsolutePath(
	76	const TCollection_AsciiString& aDirPath,
	77	const TCollection_AsciiString& aRelFilePath)
	78	{
	79	TCollection_AsciiString EmptyString = "" ;
57c28b61	80	#ifdef _WIN32
7fd59977	81	if (aRelFilePath.Search(":") == 2 \|\|
	82	(aRelFilePath.Search("\\") == 1 && aRelFilePath.Value(2) == '\\'))
	83	#else
	84	if(aRelFilePath.Search("/") == 1)
	85	#endif
	86	return aRelFilePath ;
	87
	88	TCollection_AsciiString DirPath = aDirPath, RelFilePath = aRelFilePath ;
	89	Standard_Integer i,len ;
	90
57c28b61	91	#ifdef _WIN32
7fd59977	92	if(DirPath.Search(":") != 2 &&
	93	(DirPath.Search("\\") != 1 \|\| DirPath.Value(2) != '\\'))
	94	#else
	95	if (DirPath.Search("/") != 1 )
	96	#endif
	97	return EmptyString ;
	98
57c28b61	99	#ifdef _WIN32
7fd59977	100	DirPath.ChangeAll('\\','/') ;
	101	RelFilePath.ChangeAll('\\','/') ;
	102	#endif
	103
	104	RemoveExtraSeparator(DirPath) ;
	105	len = RemoveExtraSeparator(RelFilePath) ;
	106
	107	while (RelFilePath.Search("../") == 1) {
	108	if (len == 3)
	109	return EmptyString ;
	110	RelFilePath = RelFilePath.SubString(4,len) ;
	111	len -= 3 ;
	112	if (DirPath.IsEmpty())
	113	return EmptyString ;
	114	i = DirPath.SearchFromEnd("/") ;
	115	if (i < 0)
	116	return EmptyString ;
	117	DirPath.Trunc(i-1) ;
	118	}
	119	TCollection_AsciiString retx;
	120	retx= DirPath;
	121	retx+= "/";
	122	retx+=RelFilePath ;
	123	return retx;
	124	}
	125
	126	static TCollection_AsciiString GetDirFromFile(const TCollection_ExtendedString& aFileName) {
d9ff84e8	127	TCollection_AsciiString theCFile(aFileName);
7fd59977	128	TCollection_AsciiString theDirectory;
7fd59977	129	Standard_Integer i=theCFile.SearchFromEnd("/");
57c28b61	130	#ifdef _WIN32
7fd59977	131	// if(i==-1) i=theCFile.SearchFromEnd("\\");
	132	if(theCFile.SearchFromEnd("\\") > i)
	133	i=theCFile.SearchFromEnd("\\");
	134	#endif
	135	if(i!=-1) theDirectory=theCFile.SubString(1,i);
	136	return theDirectory;
	137	}
	138	//=======================================================================
	139	//function : Version
	140	//purpose :
	141	//=======================================================================
	142
	143	TCollection_AsciiString PCDM_ReadWriter_1::Version() const {
	144	return "PCDM_ReadWriter_1";
	145	}
	146	//=======================================================================
	147	//function : WriteReferenceCounter
	148	//purpose :
	149	//=======================================================================
	150
	151	void PCDM_ReadWriter_1::WriteReferenceCounter(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument) const {
	152	TCollection_AsciiString ligne(REFERENCE_COUNTER);
	153	ligne+=aDocument->ReferenceCounter();
	154	aData->AddToUserInfo(ligne);
	155	}
	156	//=======================================================================
	157	//function : WriteReferences
	158	//purpose :
	159	//=======================================================================
	160
	161	void PCDM_ReadWriter_1::WriteReferences(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument,const TCollection_ExtendedString& theReferencerFileName) const {
	162
	163	Standard_Integer theNumber = aDocument->ToReferencesNumber();
	164	if(theNumber > 0) {
	165
	166	aData->AddToUserInfo(START_REF);
	167
	168	CDM_ReferenceIterator it(aDocument);
	169
	170	TCollection_ExtendedString ligne;
	171
	172	TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(theReferencerFileName);
	173
	174	for (;it.More();it.Next()) {
	175	ligne = TCollection_ExtendedString(it.ReferenceIdentifier());
	176	ligne += " ";
	177	ligne += TCollection_ExtendedString(it.Document()->Modifications());
	178	ligne += " ";
	179
d9ff84e8	180	TCollection_AsciiString thePath(it.Document()->MetaData()->FileName());
7fd59977	181	TCollection_AsciiString theRelativePath;
	182	if(!theAbsoluteDirectory.IsEmpty()) {
	183	theRelativePath=OSD_Path::RelativePath(theAbsoluteDirectory,thePath);
	184	if(!theRelativePath.IsEmpty()) thePath=theRelativePath;
	185	}
d9ff84e8	186	ligne += TCollection_ExtendedString(thePath);
7fd59977	187	UTL::AddToUserInfo(aData,ligne);
	188	}
	189	aData->AddToUserInfo(END_REF);
	190	}
	191	}
	192
	193	//=======================================================================
	194	//function : WriteExtensions
	195	//purpose :
	196	//=======================================================================
	197
	198	void PCDM_ReadWriter_1::WriteExtensions(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument) const {
	199
	200	TColStd_SequenceOfExtendedString theExtensions;
	201	aDocument->Extensions(theExtensions);
	202	Standard_Integer theNumber = theExtensions.Length();
	203	if(theNumber > 0) {
	204
	205	aData->AddToUserInfo(START_EXT);
	206	for (Standard_Integer i=1; i<=theNumber; i++) {
	207	UTL::AddToUserInfo(aData,theExtensions(i));
	208	}
	209	aData->AddToUserInfo(END_EXT);
	210	}
	211	}
	212	//=======================================================================
	213	//function : WriteVersion
	214	//purpose :
	215	//=======================================================================
	216
	217	void PCDM_ReadWriter_1::WriteVersion(const Handle(Storage_Data)& aData, const Handle(CDM_Document)& aDocument) const {
	218	TCollection_AsciiString ligne(MODIFICATION_COUNTER);
	219	ligne+=aDocument->Modifications();
	220	aData->AddToUserInfo(ligne);
	221	}
	222	//=======================================================================
	223	//function : ReadReferenceCounter
	224	//purpose :
	225	//=======================================================================
	226
	227	Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) const {
	228
	229	static Standard_Integer theReferencesCounter ;
	230	theReferencesCounter=0;
	231	static Standard_Integer i ;
	232
	233	PCDM_BaseDriverPointer theFileDriver;
d9ff84e8	234	TCollection_AsciiString aFileNameU(aFileName);
	235	if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
	236	return theReferencesCounter;
7fd59977	237
	238	static Standard_Boolean theFileIsOpen ;
	239	theFileIsOpen=Standard_False;
	240
	241	try {
	242	OCC_CATCH_SIGNALS
	243	PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
	244	theFileIsOpen=Standard_True;
	245
	246	Handle(Storage_Schema) s = new Storage_Schema;
	247	Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
	248	const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
	249
	250	for ( i =1; i<= refUserInfo.Length() ; i++) {
	251	if(refUserInfo(i).Search(REFERENCE_COUNTER) != -1) {
	252	try { OCC_CATCH_SIGNALS theReferencesCounter=refUserInfo(i).Token(" ",2).IntegerValue();}
	253	catch (Standard_Failure) {
	254	// cout << "warning: could not read the reference counter in " << aFileName << endl;
	255	TCollection_ExtendedString aMsg("Warning: ");
	256	aMsg = aMsg.Cat("could not read the reference counter in ").Cat(aFileName).Cat("\0");
	257	if(!theMsgDriver.IsNull())
	258	theMsgDriver->Write(aMsg.ToExtString());
	259	}
	260	}
	261	}
	262
	263	}
	264	catch (Standard_Failure) {}
	265
	266	if(theFileIsOpen) theFileDriver->Close();
	267
	268	delete theFileDriver;
	269	return theReferencesCounter;
	270	}
	271
	272	//=======================================================================
	273	//function : ReadReferences
	274	//purpose :
	275	//=======================================================================
	276
	277	void PCDM_ReadWriter_1::ReadReferences(const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) const {
	278
	279	TColStd_SequenceOfExtendedString ReadReferences;
	280
	281	ReadUserInfo(aFileName,START_REF,END_REF,ReadReferences, theMsgDriver);
	282
	283	Standard_Integer theReferenceIdentifier;
	284	TCollection_ExtendedString theFileName;
	285	Standard_Integer theDocumentVersion;
	286
	287	TCollection_AsciiString theAbsoluteDirectory=GetDirFromFile(aFileName);
	288
	289	for (Standard_Integer i=1; i<=ReadReferences.Length(); i++) {
	290	Standard_Integer pos=ReadReferences(i).Search(" ");
	291	if(pos != -1) {
	292	TCollection_ExtendedString theRest=ReadReferences(i).Split(pos);
	293	theReferenceIdentifier=UTL::IntegerValue(ReadReferences(i));
	294
	295	Standard_Integer pos2=theRest.Search(" ");
	296
	297	theFileName=theRest.Split(pos2);
	298	theDocumentVersion=UTL::IntegerValue(theRest);
	299
d9ff84e8	300	TCollection_AsciiString thePath(theFileName);
7fd59977	301	TCollection_AsciiString theAbsolutePath;
	302	if(!theAbsoluteDirectory.IsEmpty()) {
	303	theAbsolutePath=AbsolutePath(theAbsoluteDirectory,thePath);
	304	if(!theAbsolutePath.IsEmpty()) thePath=theAbsolutePath;
	305	}
	306	if(!theMsgDriver.IsNull()) {
	307	// cout << "reference found; ReferenceIdentifier: " << theReferenceIdentifier << "; File:" << thePath << ", version:" << theDocumentVersion;
	308	TCollection_ExtendedString aMsg("Warning: ");
	309	aMsg = aMsg.Cat("reference found; ReferenceIdentifier: ").Cat(theReferenceIdentifier).Cat("; File:").Cat(thePath).Cat(", version:").Cat(theDocumentVersion).Cat("\0");
	310	theMsgDriver->Write(aMsg.ToExtString());
	311	}
d9ff84e8	312	TCollection_ExtendedString aPathW(thePath);
d9ff84e8	313	theReferences.Append(PCDM_Reference (theReferenceIdentifier,aPathW,theDocumentVersion));
7fd59977	314
	315	}
	316	}
	317
	318	}
	319
	320	//=======================================================================
	321	//function : ReadExtensions
	322	//purpose :
	323	//=======================================================================
	324
	325	void PCDM_ReadWriter_1::ReadExtensions(const TCollection_ExtendedString& aFileName, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) const {
	326
	327	ReadUserInfo(aFileName,START_EXT,END_EXT,theExtensions, theMsgDriver);
	328	}
	329
	330
	331	//=======================================================================
	332	//function : ReadUserInfo
	333	//purpose :
	334	//=======================================================================
	335
	336	void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName,
	337	const TCollection_AsciiString& Start,
	338	const TCollection_AsciiString& End,
	339	TColStd_SequenceOfExtendedString& theUserInfo,
	340	const Handle(CDM_MessageDriver)&) {
	341
	342	static Standard_Integer i ;
	343	PCDM_BaseDriverPointer theFileDriver;
d9ff84e8	344	TCollection_AsciiString aFileNameU(aFileName);
	345	if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
	346	return;
7fd59977	347
	348	PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
	349	Handle(Storage_Schema) s = new Storage_Schema;
	350	Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
	351	const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
	352
	353	Standard_Integer debut=0,fin=0;
	354
	355	for ( i =1; i<= refUserInfo.Length() ; i++) {
	356	TCollection_ExtendedString theLine=refUserInfo(i);
	357	if(refUserInfo(i)== Start) debut=i;
	358	if(refUserInfo(i)== End) fin=i;
	359	}
	360	if(debut != 0) {
	361	for (i=debut+1 ; i<fin; i++) {
d9ff84e8	362	TCollection_ExtendedString aInfoW(refUserInfo(i));
d9ff84e8	363	theUserInfo.Append(aInfoW);
7fd59977	364	}
	365	}
	366	theFileDriver->Close();
	367	delete theFileDriver;
	368	}
	369
	370	//=======================================================================
	371	//function : ReadDocumentVersion
	372	//purpose :
	373	//=======================================================================
	374
	375	Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) const {
	376
	377	static Standard_Integer theVersion ;
	378	theVersion=-1;
	379
	380	PCDM_BaseDriverPointer theFileDriver;
d9ff84e8	381	TCollection_AsciiString aFileNameU(aFileName);
	382	if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
	383	return theVersion;
7fd59977	384
	385	static Standard_Boolean theFileIsOpen ;
	386	theFileIsOpen =Standard_False;
	387
	388	try {
	389	OCC_CATCH_SIGNALS
	390	PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
	391	theFileIsOpen=Standard_True;
	392	Handle(Storage_Schema) s = new Storage_Schema;
	393	Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
	394	const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
	395
	396	static Standard_Integer i ;
	397	for ( i =1; i<= refUserInfo.Length() ; i++) {
	398	if(refUserInfo(i).Search(MODIFICATION_COUNTER) != -1) {
	399	try { OCC_CATCH_SIGNALS theVersion=refUserInfo(i).Token(" ",2).IntegerValue();}
	400	catch (Standard_Failure) {
	401	// cout << "warning: could not read the version in " << aFileName << endl;
	402	TCollection_ExtendedString aMsg("Warning: ");
	403	aMsg = aMsg.Cat("could not read the version in ").Cat(aFileName).Cat("\0");
	404	if(!theMsgDriver.IsNull())
	405	theMsgDriver->Write(aMsg.ToExtString());
	406	}
	407
	408	}
	409	}
	410	}
	411
	412	catch (Standard_Failure) {}
	413
	414	if(theFileIsOpen) theFileDriver->Close();
	415	delete theFileDriver;
	416	return theVersion;
	417	}