OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-04 13:13:25 +03:00
Code Activity

Integration of OCCT 6.5.0 from SVN

Browse Source
This commit is contained in:
bugmaster
2011-03-16 07:30:28 +00:00
committed by bugmaster
parent 4903637061
commit 7fd59977df
16375 changed files with 3882564 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
src/MDataStd/MDataStd.cdl Executable file
View File

@@ -0,0 +1,143 @@
-- File: MDataStd.cdl
-- Created: Thu Aug 7 16:12:08 1997
-- Author: VAUTHIER Jean-Claude
-- modified Sergey Zaritchny
---Copyright: Matra Datavision 1997
package MDataStd
---Purpose: Storage and Retrieval drivers for modelling
-- attributes. Transient attributes are defined in
-- package TDataStd and persistent one are defined in
-- package PDataStd
uses TDF,
PDF,
MDF,
CDM,
TDataStd
is
---Purpose: Storage drivers for TDataStd attributes
-- =======================================
class DirectoryStorageDriver;
class UAttributeStorageDriver;
class NameStorageDriver;
class CommentStorageDriver;
class IntegerStorageDriver;
class IntegerArrayStorageDriver;
class RealStorageDriver;
class RealArrayStorageDriver;
class ExtStringArrayStorageDriver;
class VariableStorageDriver;
class ExpressionStorageDriver;
class RelationStorageDriver;
class NoteBookStorageDriver;
class TreeNodeStorageDriver;
--Extension
class TickStorageDriver;
class IntegerListStorageDriver;
class RealListStorageDriver;
class ExtStringListStorageDriver;
class BooleanListStorageDriver;
class ReferenceListStorageDriver;
class BooleanArrayStorageDriver;
class ReferenceArrayStorageDriver;
class ByteArrayStorageDriver;
class NamedDataStorageDriver;
class AsciiStringStorageDriver;
class IntPackedMapStorageDriver;
---Purpose: Retrieval drivers for PDataStd attributes
-- =========================================
class DirectoryRetrievalDriver;
class UAttributeRetrievalDriver;
class NameRetrievalDriver;
class CommentRetrievalDriver;
class IntegerRetrievalDriver;
class IntegerArrayRetrievalDriver;
class IntegerArrayRetrievalDriver_1;
class RealRetrievalDriver;
class RealArrayRetrievalDriver;
class RealArrayRetrievalDriver_1;
class ExtStringArrayRetrievalDriver;
class ExtStringArrayRetrievalDriver_1;
class VariableRetrievalDriver;
class ExpressionRetrievalDriver;
class RelationRetrievalDriver;
class NoteBookRetrievalDriver;
class TreeNodeRetrievalDriver;
-- Extension
class TickRetrievalDriver;
class IntegerListRetrievalDriver;
class RealListRetrievalDriver;
class ExtStringListRetrievalDriver;
class BooleanListRetrievalDriver;
class ReferenceListRetrievalDriver;
class BooleanArrayRetrievalDriver;
class ReferenceArrayRetrievalDriver;
class ByteArrayRetrievalDriver;
class ByteArrayRetrievalDriver_1;
class NamedDataRetrievalDriver;
class AsciiStringRetrievalDriver;
class IntPackedMapRetrievalDriver;
class IntPackedMapRetrievalDriver_1;
AddStorageDrivers(aDriverSeq : ASDriverHSequence from MDF; theMessageDriver : MessageDriver from CDM);
---Purpose: Adds the attribute storage drivers to <aDriverSeq>.
AddRetrievalDrivers(aDriverSeq : ARDriverHSequence from MDF; theMessageDriver : MessageDriver from CDM);
---Purpose: Adds the attribute retrieval drivers to <aDriverSeq>.
---Purpose: Translation of TDataStd enumerations to integer
-- ===============================================
RealDimensionToInteger (e : RealEnum from TDataStd)
returns Integer from Standard;
IntegerToRealDimension (i : Integer from Standard)
returns RealEnum from TDataStd;
end MDataStd;

207
src/MDataStd/MDataStd.cxx Executable file
View File

@@ -0,0 +1,207 @@
// File: MDataStd.cxx
// ------------
// Author: DAUTRY Philippe
// modified Sergey Zaritchny
// Copyright: Matra Datavision 1997
// Version: 0.0
// History: Version Date Purpose
// 0.0 Aug 4 1997 Creation
#include <MDataStd.ixx>
#include <MDF_ASDriverTable.hxx>
#include <MDF_ARDriverTable.hxx>
#include <CDM_MessageDriver.hxx>
//
// Storage
//
#include <MDataStd_DirectoryStorageDriver.hxx>
#include <MDataStd_UAttributeStorageDriver.hxx>
#include <MDataStd_IntegerArrayStorageDriver.hxx>
#include <MDataStd_RealArrayStorageDriver.hxx>
#include <MDataStd_ExtStringArrayStorageDriver.hxx>
#include <MDataStd_NameStorageDriver.hxx>
#include <MDataStd_CommentStorageDriver.hxx>
#include <MDataStd_IntegerStorageDriver.hxx>
#include <MDataStd_RealStorageDriver.hxx>
#include <MDataStd_VariableStorageDriver.hxx>
#include <MDataStd_ExpressionStorageDriver.hxx>
#include <MDataStd_RelationStorageDriver.hxx>
#include <MDataStd_NoteBookStorageDriver.hxx>
#include <MDataStd_TreeNodeStorageDriver.hxx>
#include <MDataStd_TickStorageDriver.hxx>
#include <MDataStd_IntegerListStorageDriver.hxx>
#include <MDataStd_RealListStorageDriver.hxx>
#include <MDataStd_ExtStringListStorageDriver.hxx>
#include <MDataStd_BooleanListStorageDriver.hxx>
#include <MDataStd_ReferenceListStorageDriver.hxx>
#include <MDataStd_BooleanArrayStorageDriver.hxx>
#include <MDataStd_ReferenceArrayStorageDriver.hxx>
#include <MDataStd_ByteArrayStorageDriver.hxx>
#include <MDataStd_NamedDataStorageDriver.hxx>
#include <MDataStd_AsciiStringStorageDriver.hxx>
#include <MDataStd_IntPackedMapStorageDriver.hxx>
//
// Retrieval
//
#include <MDataStd_DirectoryRetrievalDriver.hxx>
#include <MDataStd_RealArrayRetrievalDriver.hxx>
#include <MDataStd_ExtStringArrayRetrievalDriver.hxx>
#include <MDataStd_UAttributeRetrievalDriver.hxx>
#include <MDataStd_IntegerArrayRetrievalDriver.hxx>
#include <MDataStd_NameRetrievalDriver.hxx>
#include <MDataStd_CommentRetrievalDriver.hxx>
#include <MDataStd_IntegerRetrievalDriver.hxx>
#include <MDataStd_RealRetrievalDriver.hxx>
#include <MDataStd_VariableRetrievalDriver.hxx>
#include <MDataStd_ExpressionRetrievalDriver.hxx>
#include <MDataStd_RelationRetrievalDriver.hxx>
#include <MDataStd_NoteBookRetrievalDriver.hxx>
#include <MDataStd_TreeNodeRetrievalDriver.hxx>
#include <MDataStd_TickRetrievalDriver.hxx>
#include <MDataStd_IntegerListRetrievalDriver.hxx>
#include <MDataStd_RealListRetrievalDriver.hxx>
#include <MDataStd_ExtStringListRetrievalDriver.hxx>
#include <MDataStd_BooleanListRetrievalDriver.hxx>
#include <MDataStd_ReferenceListRetrievalDriver.hxx>
#include <MDataStd_BooleanArrayRetrievalDriver.hxx>
#include <MDataStd_ReferenceArrayRetrievalDriver.hxx>
#include <MDataStd_ByteArrayRetrievalDriver.hxx>
#include <MDataStd_NamedDataRetrievalDriver.hxx>
#include <MDataStd_AsciiStringRetrievalDriver.hxx>
#include <MDataStd_IntPackedMapRetrievalDriver.hxx>
#include <MDataStd_ByteArrayRetrievalDriver_1.hxx>
#include <MDataStd_IntegerArrayRetrievalDriver_1.hxx>
#include <MDataStd_RealArrayRetrievalDriver_1.hxx>
#include <MDataStd_ExtStringArrayRetrievalDriver_1.hxx>
#include <MDataStd_IntPackedMapRetrievalDriver_1.hxx>
//
// enums
//
#include <TDataStd_RealEnum.hxx>
#include <Standard_DomainError.hxx>
//=======================================================================
//function : AddStorageDriver
//purpose :
//=======================================================================
void MDataStd::AddStorageDrivers
(const Handle(MDF_ASDriverHSequence)& aDriverSeq, const Handle(CDM_MessageDriver)& theMsgDriver)
{
aDriverSeq->Append(new MDataStd_DirectoryStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerArrayStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealArrayStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_UAttributeStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_NameStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_CommentStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_VariableStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExpressionStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RelationStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_NoteBookStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_TreeNodeStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExtStringArrayStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_TickStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerListStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealListStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExtStringListStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_BooleanListStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ReferenceListStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_BooleanArrayStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ReferenceArrayStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ByteArrayStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_NamedDataStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_AsciiStringStorageDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntPackedMapStorageDriver(theMsgDriver));
}
//=======================================================================
//function : AddRetrievalDriver
//purpose :
//=======================================================================
void MDataStd::AddRetrievalDrivers
(const Handle(MDF_ARDriverHSequence)& aDriverSeq,const Handle(CDM_MessageDriver)& theMsgDriver)
{
aDriverSeq->Append(new MDataStd_DirectoryRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerArrayRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealArrayRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_UAttributeRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_NameRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_CommentRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_VariableRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExpressionRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RelationRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_NoteBookRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_TreeNodeRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExtStringArrayRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_TickRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerListRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealListRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExtStringListRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_BooleanListRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ReferenceListRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_BooleanArrayRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ReferenceArrayRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ByteArrayRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_NamedDataRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_AsciiStringRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntPackedMapRetrievalDriver(theMsgDriver));
aDriverSeq->Append(new MDataStd_ByteArrayRetrievalDriver_1(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntegerArrayRetrievalDriver_1(theMsgDriver));
aDriverSeq->Append(new MDataStd_RealArrayRetrievalDriver_1(theMsgDriver));
aDriverSeq->Append(new MDataStd_ExtStringArrayRetrievalDriver_1(theMsgDriver));
aDriverSeq->Append(new MDataStd_IntPackedMapRetrievalDriver_1(theMsgDriver));
}
//=======================================================================
//function : RealDimensionToInteger
//purpose :
//=======================================================================
Standard_Integer MDataStd::RealDimensionToInteger(const TDataStd_RealEnum e)
{
switch (e) {
case TDataStd_SCALAR : return 0;
case TDataStd_LENGTH : return 1;
case TDataStd_ANGULAR : return 2;
default:
Standard_DomainError::Raise("TDataStd_RealEnum; enum term unknown");
}
return 0;
}
//=======================================================================
//function : IntegerToRealDimension
//purpose :
//=======================================================================
TDataStd_RealEnum MDataStd::IntegerToRealDimension(const Standard_Integer i)
{
switch(i)
{
// planar constraints
case 0 : return TDataStd_SCALAR;
case 1 : return TDataStd_LENGTH;
case 2 : return TDataStd_ANGULAR;
default :
Standard_DomainError::Raise("TDataStd_RealEnum; enum term unknown ");
}
return TDataStd_SCALAR;
}

38
src/MDataStd/MDataStd_AsciiStringRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_AsciiStringRetrievalDriver.cdl
-- Created: Thu Aug 23 09:55:00 2007
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2007
class AsciiStringRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of AsciiString attribute
uses
RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable AsciiStringRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: AsciiString from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end AsciiStringRetrievalDriver;

59
src/MDataStd/MDataStd_AsciiStringRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,59 @@
// File: MDataStd_AsciiStringRetrievalDriver.cxx
// Created: Thu Aug 23 09:59:19 2007
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2007
#include <MDataStd_AsciiStringRetrievalDriver.ixx>
#include <PDataStd_AsciiString.hxx>
#include <TDataStd_AsciiString.hxx>
#include <TCollection_AsciiString.hxx>
#include <PCollection_HAsciiString.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_AsciiStringRetrievalDriver
//purpose : Constructor
//=======================================================================
MDataStd_AsciiStringRetrievalDriver::MDataStd_AsciiStringRetrievalDriver
(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_AsciiStringRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_AsciiStringRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_AsciiString); }
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_AsciiStringRetrievalDriver::NewEmpty() const
{ return new TDataStd_AsciiString (); }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_AsciiStringRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_AsciiString) S = Handle(PDataStd_AsciiString)::DownCast (Source);
Handle(TDataStd_AsciiString) T = Handle(TDataStd_AsciiString)::DownCast (Target);
if(!S.IsNull() && !T.IsNull()) {
if(!S->Get().IsNull()) {
TCollection_AsciiString aString((S->Get())->Convert ());
T->Set (aString);
}
}
}

38
src/MDataStd/MDataStd_AsciiStringStorageDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_AsciiStringStorageDriver.cdl
-- Created: Wed Aug 22 18:33:31 2007
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2007
class AsciiStringStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose: Storage driver for AsciiString attribute
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM)
returns mutable AsciiStringStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end AsciiStringStorageDriver;

58
src/MDataStd/MDataStd_AsciiStringStorageDriver.cxx Executable file
View File

@@ -0,0 +1,58 @@
// File: MDataStd_AsciiStringStorageDriver.cxx
// Created: Wed Aug 22 18:37:00 2007
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2007
#include <MDataStd_AsciiStringStorageDriver.ixx>
#include <PDataStd_AsciiString.hxx>
#include <TDataStd_AsciiString.hxx>
#include <TCollection_AsciiString.hxx>
#include <PCollection_HAsciiString.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_AsciiStringStorageDriver
//purpose : Constructor
//=======================================================================
MDataStd_AsciiStringStorageDriver::MDataStd_AsciiStringStorageDriver
(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_AsciiStringStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_AsciiStringStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_AsciiString);}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_AsciiStringStorageDriver::NewEmpty() const
{ return new PDataStd_AsciiString; }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_AsciiStringStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_AsciiString) S = Handle(TDataStd_AsciiString)::DownCast (Source);
Handle(PDataStd_AsciiString) T = Handle(PDataStd_AsciiString)::DownCast (Target);
if(!S.IsNull() && !T.IsNull()) {
if(S->Get().Length() != 0) {
Handle(PCollection_HAsciiString) aString = new PCollection_HAsciiString (S->Get());
T->Set (aString);
}
}
}

32
src/MDataStd/MDataStd_BooleanArrayRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,32 @@
-- File: MDataStd_BooleanArrayRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class BooleanArrayRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable BooleanArrayRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end BooleanArrayRetrievalDriver;

76
src/MDataStd/MDataStd_BooleanArrayRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,76 @@
// File: MDataStd_BooleanArrayRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_BooleanArrayRetrievalDriver.ixx>
#include <PDataStd_BooleanArray.hxx>
#include <TDataStd_BooleanArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <PColStd_HArray1OfInteger.hxx>
//=======================================================================
//function : MDataStd_BooleanArrayRetrievalDriver
//purpose :
//=======================================================================
MDataStd_BooleanArrayRetrievalDriver::MDataStd_BooleanArrayRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_BooleanArrayRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_BooleanArrayRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_BooleanArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_BooleanArrayRetrievalDriver::NewEmpty () const
{
return new TDataStd_BooleanArray();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_BooleanArrayRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_BooleanArray) S = Handle(PDataStd_BooleanArray)::DownCast (Source);
Handle(TDataStd_BooleanArray) T = Handle(TDataStd_BooleanArray)::DownCast (Target);
if (S->Upper() >= S->Lower())
{
T->Init(S->Lower(), S->Upper());
const Handle(PColStd_HArray1OfInteger)& pvalues = S->Get();
Handle(TColStd_HArray1OfByte) tvalues = new TColStd_HArray1OfByte(pvalues->Lower(), pvalues->Upper());
Standard_Integer i = pvalues->Lower(), upper = pvalues->Upper();
for (; i <= upper; i++)
{
Standard_Byte pvalue = (Standard_Byte) pvalues->Value(i);
tvalues->SetValue(i, pvalue);
}
T->SetInternalArray(tvalues);
}
}

35
src/MDataStd/MDataStd_BooleanArrayStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_BooleanArrayStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class BooleanArrayStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable BooleanArrayStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end BooleanArrayStorageDriver;

77
src/MDataStd/MDataStd_BooleanArrayStorageDriver.cxx Executable file
View File

@@ -0,0 +1,77 @@
// File: MDataStd_BooleanArrayStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_BooleanArrayStorageDriver.ixx>
#include <PDataStd_BooleanArray.hxx>
#include <TDataStd_BooleanArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <PColStd_HArray1OfInteger.hxx>
//=======================================================================
//function : MDataStd_BooleanArrayStorageDriver
//purpose :
//=======================================================================
MDataStd_BooleanArrayStorageDriver::MDataStd_BooleanArrayStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_BooleanArrayStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_BooleanArrayStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_BooleanArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_BooleanArrayStorageDriver::NewEmpty() const
{
return new PDataStd_BooleanArray();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_BooleanArrayStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_BooleanArray) S = Handle(TDataStd_BooleanArray)::DownCast (Source);
Handle(PDataStd_BooleanArray) T = Handle(PDataStd_BooleanArray)::DownCast (Target);
if (S->Upper() >= S->Lower())
{
T->SetLower(S->Lower());
T->SetUpper(S->Upper());
const Handle(TColStd_HArray1OfByte)& tvalues = S->InternalArray();
Handle(PColStd_HArray1OfInteger) pvalues = new PColStd_HArray1OfInteger(tvalues->Lower(), tvalues->Upper());
Standard_Integer i = tvalues->Lower(), upper = tvalues->Upper();
for (; i <= upper; i++)
{
pvalues->SetValue(i, tvalues->Value(i));
}
T->Set(pvalues);
}
}

32
src/MDataStd/MDataStd_BooleanListRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,32 @@
-- File: MDataStd_BooleanListRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class BooleanListRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable BooleanListRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end BooleanListRetrievalDriver;

66
src/MDataStd/MDataStd_BooleanListRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,66 @@
// File: MDataStd_BooleanListRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_BooleanListRetrievalDriver.ixx>
#include <PDataStd_BooleanList.hxx>
#include <TDataStd_BooleanList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_BooleanListRetrievalDriver
//purpose :
//=======================================================================
MDataStd_BooleanListRetrievalDriver::MDataStd_BooleanListRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_BooleanListRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_BooleanListRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_BooleanList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_BooleanListRetrievalDriver::NewEmpty () const
{
return new TDataStd_BooleanList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_BooleanListRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_BooleanList) S = Handle(PDataStd_BooleanList)::DownCast (Source);
Handle(TDataStd_BooleanList) T = Handle(TDataStd_BooleanList)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
for (i = lower; i <= upper; i++)
{
T->Append(S->Value(i));
}
}

35
src/MDataStd/MDataStd_BooleanListStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_BooleanListStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class BooleanListStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable BooleanListStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end BooleanListStorageDriver;

73
src/MDataStd/MDataStd_BooleanListStorageDriver.cxx Executable file
View File

@@ -0,0 +1,73 @@
// File: MDataStd_BooleanListStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_BooleanListStorageDriver.ixx>
#include <PDataStd_BooleanList.hxx>
#include <TDataStd_BooleanList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TDataStd_ListIteratorOfListOfByte.hxx>
//=======================================================================
//function : MDataStd_BooleanListStorageDriver
//purpose :
//=======================================================================
MDataStd_BooleanListStorageDriver::MDataStd_BooleanListStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_BooleanListStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_BooleanListStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_BooleanList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_BooleanListStorageDriver::NewEmpty() const
{
return new PDataStd_BooleanList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_BooleanListStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_BooleanList) S = Handle(TDataStd_BooleanList)::DownCast (Source);
Handle(PDataStd_BooleanList) T = Handle(PDataStd_BooleanList)::DownCast (Target);
Standard_Integer lower = 1, upper = S->Extent(), i = lower;
if (upper >= lower)
{
T->Init(lower, upper);
TDataStd_ListIteratorOfListOfByte itr(S->List());
for (; itr.More(); itr.Next(), i++)
{
T->SetValue(i, itr.Value());
}
}
}

32
src/MDataStd/MDataStd_ByteArrayRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,32 @@
-- File: MDataStd_ByteArrayRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ByteArrayRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ByteArrayRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ByteArrayRetrievalDriver;

75
src/MDataStd/MDataStd_ByteArrayRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,75 @@
// File: MDataStd_ByteArrayRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ByteArrayRetrievalDriver.ixx>
#include <PDataStd_ByteArray.hxx>
#include <TDataStd_ByteArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <PColStd_HArray1OfInteger.hxx>
//=======================================================================
//function : MDataStd_ByteArrayRetrievalDriver
//purpose :
//=======================================================================
MDataStd_ByteArrayRetrievalDriver::MDataStd_ByteArrayRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ByteArrayRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ByteArrayRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ByteArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ByteArrayRetrievalDriver::NewEmpty () const
{
return new TDataStd_ByteArray();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ByteArrayRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ByteArray) S = Handle(PDataStd_ByteArray)::DownCast (Source);
Handle(TDataStd_ByteArray) T = Handle(TDataStd_ByteArray)::DownCast (Target);
if (!S->Get().IsNull())
{
const Handle(PColStd_HArray1OfInteger)& pvalues = S->Get();
Handle(TColStd_HArray1OfByte) tvalues = new TColStd_HArray1OfByte(pvalues->Lower(), pvalues->Upper());
Standard_Integer i = pvalues->Lower(), upper = pvalues->Upper();
for (; i <= upper; i++)
{
Standard_Byte pvalue = (Standard_Byte) pvalues->Value(i);
tvalues->SetValue(i, pvalue);
}
T->ChangeArray(tvalues, Standard_False);
}
}

37
src/MDataStd/MDataStd_ByteArrayRetrievalDriver_1.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_ByteArrayRetrievalDriver_1.cdl
-- Created: Thu Mar 27 17:45:18 2008
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2008
class ByteArrayRetrievalDriver_1 from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of ByteArray attribute supporting
-- delta mechanism by default
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ByteArrayRetrievalDriver_1 from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ByteArrayRetrievalDriver_1;

78
src/MDataStd/MDataStd_ByteArrayRetrievalDriver_1.cxx Executable file
View File

@@ -0,0 +1,78 @@
// File: MDataStd_ByteArrayRetrievalDriver_1.cxx
// Created: Thu Mar 27 18:41:22 2008
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2008
#include <MDataStd_ByteArrayRetrievalDriver_1.ixx>
#include <PDataStd_ByteArray.hxx>
#include <PDataStd_ByteArray_1.hxx>
#include <TDataStd_ByteArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <PColStd_HArray1OfInteger.hxx>
//=======================================================================
//function : MDataStd_ByteArrayRetrievalDriver_1
//purpose :
//=======================================================================
MDataStd_ByteArrayRetrievalDriver_1::MDataStd_ByteArrayRetrievalDriver_1(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ByteArrayRetrievalDriver_1::VersionNumber() const
{
return 1;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ByteArrayRetrievalDriver_1::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ByteArray_1);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ByteArrayRetrievalDriver_1::NewEmpty () const
{
return new TDataStd_ByteArray();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ByteArrayRetrievalDriver_1::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ByteArray_1) S = Handle(PDataStd_ByteArray_1)::DownCast (Source);
Handle(TDataStd_ByteArray) T = Handle(TDataStd_ByteArray)::DownCast (Target);
if (!S->Get().IsNull()) {
const Handle(PColStd_HArray1OfInteger)& pvalues = S->Get();
Handle(TColStd_HArray1OfByte) tvalues =
new TColStd_HArray1OfByte(pvalues->Lower(), pvalues->Upper());
Standard_Integer i = pvalues->Lower(), upper = pvalues->Upper();
for (; i <= upper; i++) {
Standard_Byte pvalue = (Standard_Byte) pvalues->Value(i);
tvalues->SetValue(i, pvalue);
}
T->ChangeArray(tvalues, Standard_False);
T->SetDelta(S->GetDelta());
}
}

35
src/MDataStd/MDataStd_ByteArrayStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_ByteArrayStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ByteArrayStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ByteArrayStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end ByteArrayStorageDriver;

76
src/MDataStd/MDataStd_ByteArrayStorageDriver.cxx Executable file
View File

@@ -0,0 +1,76 @@
// File: MDataStd_ByteArrayStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ByteArrayStorageDriver.ixx>
#include <PDataStd_ByteArray.hxx>
#include <PDataStd_ByteArray_1.hxx>
#include <TDataStd_ByteArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <PColStd_HArray1OfInteger.hxx>
//=======================================================================
//function : MDataStd_ByteArrayStorageDriver
//purpose :
//=======================================================================
MDataStd_ByteArrayStorageDriver::MDataStd_ByteArrayStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ByteArrayStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ByteArrayStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_ByteArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_ByteArrayStorageDriver::NewEmpty() const
{
return new PDataStd_ByteArray_1();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ByteArrayStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_ByteArray) S = Handle(TDataStd_ByteArray)::DownCast (Source);
Handle(PDataStd_ByteArray_1) T = Handle(PDataStd_ByteArray_1)::DownCast (Target);
const Handle(TColStd_HArray1OfByte)& tvalues = S->InternalArray();
if (tvalues.IsNull())
return;
Handle(PColStd_HArray1OfInteger) pvalues = new PColStd_HArray1OfInteger(tvalues->Lower(), tvalues->Upper());
Standard_Integer i = tvalues->Lower(), upper = tvalues->Upper();
for (; i <= upper; i++)
{
pvalues->SetValue(i, tvalues->Value(i));
}
T->Set(pvalues);
T->SetDelta(S->GetDelta());
}

39
src/MDataStd/MDataStd_CommentRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,39 @@
-- File: MDataStd_CommentRetrievalDriver.cdl
-- Created: Thu Jan 15 11:22:53 1998
-- Author: Denis PASCAL
-- <dp@dingox.paris1.matra-dtv.fr>
---Copyright: Matra Datavision 1998
class CommentRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable CommentRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Comment from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end CommentRetrievalDriver;

36
src/MDataStd/MDataStd_CommentRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,36 @@
// File: MDataStd_CommentRetrievalDriver.cxx
// Created: Thu Jan 15 11:24:15 1998
// Author: Denis PASCAL
// <dp@dingox.paris1.matra-dtv.fr>
#include <MDataStd_CommentRetrievalDriver.ixx>
#include <PDataStd_Comment.hxx>
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_CommentRetrievalDriver::MDataStd_CommentRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_CommentRetrievalDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_CommentRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_Comment); }
Handle(TDF_Attribute) MDataStd_CommentRetrievalDriver::NewEmpty() const
{ return new TDataStd_Comment (); }
//void MDataStd_CommentRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& RelocTable) const
void MDataStd_CommentRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_Comment) S = Handle(PDataStd_Comment)::DownCast (Source);
Handle(TDataStd_Comment) T = Handle(TDataStd_Comment)::DownCast (Target);
TCollection_ExtendedString Comment = (S->Get())->Convert ();
T->Set (Comment);
}

43
src/MDataStd/MDataStd_CommentStorageDriver.cdl Executable file
View File

@@ -0,0 +1,43 @@
-- File: MDataStd_CommentStorageDriver.cdl
-- Created: Thu Jan 15 11:21:00 1998
-- Author: Denis PASCAL
-- <dp@dingox.paris1.matra-dtv.fr>
---Copyright: Matra Datavision 1998
class CommentStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable CommentStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end CommentStorageDriver;

37
src/MDataStd/MDataStd_CommentStorageDriver.cxx Executable file
View File

@@ -0,0 +1,37 @@
// File: MDataStd_CommentStorageDriver.cxx
// Created: Thu Jan 15 11:21:53 1998
// Author: Denis PASCAL
// <dp@dingox.paris1.matra-dtv.fr>
#include <MDataStd_CommentStorageDriver.ixx>
#include <PDataStd_Comment.hxx>
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_CommentStorageDriver::MDataStd_CommentStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_CommentStorageDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_CommentStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_Comment);}
Handle(PDF_Attribute) MDataStd_CommentStorageDriver::NewEmpty() const
{ return new PDataStd_Comment; }
//void MDataStd_CommentStorageDriver::Paste(const Handle(TDF_Attribute)& Source,const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& RelocTable) const
void MDataStd_CommentStorageDriver::Paste(const Handle(TDF_Attribute)& Source,const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_Comment) S = Handle(TDataStd_Comment)::DownCast (Source);
Handle(PDataStd_Comment) T = Handle(PDataStd_Comment)::DownCast (Target);
Handle(PCollection_HExtendedString) Comment = new PCollection_HExtendedString (S->Get());
T->Set (Comment);
}

38
src/MDataStd/MDataStd_DirectoryRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_DirectoryRetrievalDriver.cdl
-- Created: Fri Jun 25 17:19:00 1999
-- Author: Sergey RUIN
---Copyright: Matra Datavision 1999
class DirectoryRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable DirectoryRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Directory from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end DirectoryRetrievalDriver;

21
src/MDataStd/MDataStd_DirectoryRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,21 @@
#include <MDataStd_DirectoryRetrievalDriver.ixx>
#include <PDataStd_Directory.hxx>
#include <TDataStd_Directory.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_DirectoryRetrievalDriver::MDataStd_DirectoryRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
Standard_Integer MDataStd_DirectoryRetrievalDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_DirectoryRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_Directory); }
Handle(TDF_Attribute) MDataStd_DirectoryRetrievalDriver::NewEmpty() const
{ return new TDataStd_Directory; }
void MDataStd_DirectoryRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& RelocTable) const
{
}

39
src/MDataStd/MDataStd_DirectoryStorageDriver.cdl Executable file
View File

@@ -0,0 +1,39 @@
-- File: MDataStd_DirectoryStorageDriver.cdl
-- Created: Fri Jun 25 17:09:27 1999
-- Author: Sergey RUIN
---Copyright: Matra Datavision 1999
class DirectoryStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM)
returns mutable DirectoryStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end DirectoryStorageDriver;

23
src/MDataStd/MDataStd_DirectoryStorageDriver.cxx Executable file
View File

@@ -0,0 +1,23 @@
#include <MDataStd_DirectoryStorageDriver.ixx>
#include <PDataStd_Directory.hxx>
#include <TDataStd_Directory.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_DirectoryStorageDriver::MDataStd_DirectoryStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_DirectoryStorageDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_DirectoryStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_Directory); }
Handle(PDF_Attribute) MDataStd_DirectoryStorageDriver::NewEmpty() const
{ return new PDataStd_Directory; }
//void MDataStd_DirectoryStorageDriver::Paste(const Handle(TDF_Attribute)& Source,const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& RelocTable) const
void MDataStd_DirectoryStorageDriver::Paste(const Handle(TDF_Attribute)& ,const Handle(PDF_Attribute)& ,const Handle(MDF_SRelocationTable)& ) const
{
}

37
src/MDataStd/MDataStd_ExpressionRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_ExpressionRetrievalDriver.cdl
-- Created: Thu Aug 7 17:13:40 1997
-- Author: PASCAL Denis
---Copyright: Matra Datavision 1997
class ExpressionRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable ExpressionRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Expression from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ExpressionRetrievalDriver;

71
src/MDataStd/MDataStd_ExpressionRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,71 @@
#include <MDataStd_ExpressionRetrievalDriver.ixx>
#include <PDataStd_Expression.hxx>
#include <TDataStd_Expression.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TDF_ListIteratorOfAttributeList.hxx>
#include <PDF_HAttributeArray1.hxx>
#include <Standard_NoSuchObject.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_ExpressionRetrievalDriver
//purpose :
//=======================================================================
MDataStd_ExpressionRetrievalDriver::MDataStd_ExpressionRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExpressionRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExpressionRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_Expression); }
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ExpressionRetrievalDriver::NewEmpty() const
{ return new TDataStd_Expression (); }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExpressionRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& RelocTable) const
{
Handle(PDataStd_Expression) S = Handle(PDataStd_Expression)::DownCast (Source);
Handle(TDataStd_Expression) T = Handle(TDataStd_Expression)::DownCast (Target);
TCollection_ExtendedString Expression = (S->GetName())->Convert ();
T->SetExpression (Expression);
Handle(PDF_Attribute) PV;
Handle(TDF_Attribute) TV;
Handle(PDF_HAttributeArray1) PVARS = S->GetVariables ();
if (PVARS.IsNull()) return;
for (Standard_Integer i = 1; i <= PVARS->Length (); i++) {
PV = PVARS->Value (i);
if (!PV.IsNull ()) {
Handle(TDF_Attribute) TV;
if (!RelocTable->HasRelocation (PV, TV)) {
Standard_NoSuchObject::Raise("MDataStd_ConstraintRetrievalDriver::Paste");
}
T->GetVariables().Append(TV);
}
}
}

38
src/MDataStd/MDataStd_ExpressionStorageDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_ExpressionStorageDriver.cdl
-- Created: Thu Aug 7 17:09:27 1997
-- Author: PASCAL Denis
---Copyright: Matra Datavision 1997
class ExpressionStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ExpressionStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me; Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end ExpressionStorageDriver;

75
src/MDataStd/MDataStd_ExpressionStorageDriver.cxx Executable file
View File

@@ -0,0 +1,75 @@
#include <MDataStd_ExpressionStorageDriver.ixx>
#include <PDataStd_Expression.hxx>
#include <TDataStd_Expression.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TDF_ListIteratorOfAttributeList.hxx>
#include <PDF_HAttributeArray1.hxx>
#include <Standard_NoSuchObject.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_ExpressionStorageDriver
//purpose :
//=======================================================================
MDataStd_ExpressionStorageDriver::MDataStd_ExpressionStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExpressionStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExpressionStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_Expression);}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_ExpressionStorageDriver::NewEmpty() const
{ return new PDataStd_Expression; }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExpressionStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_Expression) S = Handle(TDataStd_Expression)::DownCast (Source);
Handle(PDataStd_Expression) T = Handle(PDataStd_Expression)::DownCast (Target);
Handle(PCollection_HExtendedString) Expression = new PCollection_HExtendedString (S->Name());
T->SetName (Expression);
Handle(TDF_Attribute) TV;
Handle(PDF_Attribute) PV;
Standard_Integer nbvar = S->GetVariables().Extent();
if (nbvar <= 0) return;
Handle(PDF_HAttributeArray1) PVARS = new PDF_HAttributeArray1 (1, nbvar);
TDF_ListIteratorOfAttributeList it;
Standard_Integer index = 0;
for (it.Initialize(S->GetVariables());it.More();it.Next()) {
index++;
TV = it.Value();
if(!RelocTable->HasRelocation (TV, PV)) {
Standard_NoSuchObject::Raise("MDataStd_ExpressionStorageDriver::Paste");
}
PVARS->SetValue (index,PV);
}
T->SetVariables (PVARS);
}

37
src/MDataStd/MDataStd_ExtStringArrayRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_ExtStringArrayRetrievalDriver.cdl
-- Created: Mon Sep 27 08:37 2004
-- Author: Pavel TELKOV
---Copyright: Open CASCADE 2004
class ExtStringArrayRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable ExtStringArrayRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: ExtStringArray from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ExtStringArrayRetrievalDriver;

81
src/MDataStd/MDataStd_ExtStringArrayRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,81 @@
// File: MDataStd_ExtStringArrayRetrievalDriver.cxx
// Created: 27.09.04 08:37:09
// Author: Pavel TELKOV
// Copyright: Open CASCADE 2004
#include <MDataStd_ExtStringArrayRetrievalDriver.ixx>
#include <CDM_MessageDriver.hxx>
#include <MDataStd.hxx>
#include <PCollection_HExtendedString.hxx>
#include <PDataStd_ExtStringArray.hxx>
#include <TDataStd_ExtStringArray.hxx>
//=======================================================================
//function : MDataStd_ExtStringArrayRetrievalDriver
//purpose : Constructor
//=======================================================================
MDataStd_ExtStringArrayRetrievalDriver::MDataStd_ExtStringArrayRetrievalDriver
( const Handle(CDM_MessageDriver)& theMsgDriver )
:MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExtStringArrayRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExtStringArrayRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ExtStringArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ExtStringArrayRetrievalDriver::NewEmpty() const
{
return new TDataStd_ExtStringArray ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExtStringArrayRetrievalDriver::Paste
( const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ExtStringArray) S = Handle(PDataStd_ExtStringArray)::DownCast (Source);
Handle(TDataStd_ExtStringArray) T = Handle(TDataStd_ExtStringArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower() , upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++)
{
Handle(PCollection_HExtendedString) aPExtStr = S->Value( i );
if ( !aPExtStr.IsNull() )
T->SetValue( i, aPExtStr->Convert() );
}
}

41
src/MDataStd/MDataStd_ExtStringArrayRetrievalDriver_1.cdl Executable file
View File

@@ -0,0 +1,41 @@
-- File: MDataStd_ExtStringArrayRetrievalDriver_1.cdl
-- Created: Fri Mar 28 11:24:36 2008
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2008
class ExtStringArrayRetrievalDriver_1 from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of ExtStringArray attribute supporting
-- delta mechanism by default
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ExtStringArrayRetrievalDriver_1 from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 1.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: ExtStringArray from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ExtStringArrayRetrievalDriver_1;

86
src/MDataStd/MDataStd_ExtStringArrayRetrievalDriver_1.cxx Executable file
View File

@@ -0,0 +1,86 @@
// File: MDataStd_ExtStringArrayRetrievalDriver_1.cxx
// Created: Fri Mar 28 11:27:04 2008
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2008
#include <MDataStd_ExtStringArrayRetrievalDriver_1.ixx>
#include <CDM_MessageDriver.hxx>
#include <MDataStd.hxx>
#include <PCollection_HExtendedString.hxx>
#include <PDataStd_ExtStringArray.hxx>
#include <PDataStd_ExtStringArray_1.hxx>
#include <TDataStd_ExtStringArray.hxx>
//=======================================================================
//function : MDataStd_ExtStringArrayRetrievalDriver_1
//purpose : Constructor
//=======================================================================
MDataStd_ExtStringArrayRetrievalDriver_1::MDataStd_ExtStringArrayRetrievalDriver_1
( const Handle(CDM_MessageDriver)& theMsgDriver )
:MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExtStringArrayRetrievalDriver_1::VersionNumber() const
{ return 1; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExtStringArrayRetrievalDriver_1::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ExtStringArray_1);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ExtStringArrayRetrievalDriver_1::NewEmpty() const
{
return new TDataStd_ExtStringArray ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExtStringArrayRetrievalDriver_1::Paste
( const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ExtStringArray_1) S =
Handle(PDataStd_ExtStringArray_1)::DownCast (Source);
Handle(TDataStd_ExtStringArray) T =
Handle(TDataStd_ExtStringArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++)
{
Handle(PCollection_HExtendedString) aPExtStr = S->Value( i );
if ( !aPExtStr.IsNull() )
T->SetValue( i, aPExtStr->Convert() );
}
T->SetDelta(S->GetDelta());
}

37
src/MDataStd/MDataStd_ExtStringArrayStorageDriver.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_ExtStringArrayStorageDriver.cdl
-- Created: Mon Sep 27 08:32 2004
-- Author: Pavel TELKOV
---Copyright: Open CASCADE 2004
class ExtStringArrayStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable ExtStringArrayStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: ExtStringArray from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end ExtStringArrayStorageDriver;

83
src/MDataStd/MDataStd_ExtStringArrayStorageDriver.cxx Executable file
View File

@@ -0,0 +1,83 @@
// File: MDataStd_ExtStringArrayStorageDriver.cxx
// Created: 27.09.04 08:32:39
// Author: Pavel TELKOV
// Copyright: Open CASCADE 2004
#include <MDataStd_ExtStringArrayStorageDriver.ixx>
#include <CDM_MessageDriver.hxx>
#include <MDataStd.hxx>
#include <PCollection_HExtendedString.hxx>
#include <PDataStd_ExtStringArray.hxx>
#include <PDataStd_ExtStringArray_1.hxx>
#include <TDataStd_ExtStringArray.hxx>
//=======================================================================
//function : MDataStd_ExtStringArrayStorageDriver
//purpose : Constructor
//=======================================================================
MDataStd_ExtStringArrayStorageDriver::MDataStd_ExtStringArrayStorageDriver
( const Handle(CDM_MessageDriver)& theMsgDriver )
:MDF_ASDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExtStringArrayStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExtStringArrayStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_ExtStringArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_ExtStringArrayStorageDriver::NewEmpty() const
{
return new PDataStd_ExtStringArray_1 ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExtStringArrayStorageDriver::Paste (
const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_ExtStringArray) S =
Handle(TDataStd_ExtStringArray)::DownCast (Source);
Handle(PDataStd_ExtStringArray_1) T =
Handle(PDataStd_ExtStringArray_1)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++)
{
Handle(PCollection_HExtendedString) aPExtStr =
new PCollection_HExtendedString( S->Value( i ) );
T->SetValue( i, aPExtStr );
}
T->SetDelta(S->GetDelta());
}

33
src/MDataStd/MDataStd_ExtStringListRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,33 @@
-- File: MDataStd_ExtStringListRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ExtStringListRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ExtStringListRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ExtStringListRetrievalDriver;

70
src/MDataStd/MDataStd_ExtStringListRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,70 @@
// File: MDataStd_ExtStringListRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ExtStringListRetrievalDriver.ixx>
#include <PDataStd_ExtStringList.hxx>
#include <TDataStd_ExtStringList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
//=======================================================================
//function : MDataStd_ExtStringListRetrievalDriver
//purpose :
//=======================================================================
MDataStd_ExtStringListRetrievalDriver::MDataStd_ExtStringListRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExtStringListRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExtStringListRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ExtStringList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ExtStringListRetrievalDriver::NewEmpty () const
{
return new TDataStd_ExtStringList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExtStringListRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ExtStringList) S = Handle(PDataStd_ExtStringList)::DownCast (Source);
Handle(TDataStd_ExtStringList) T = Handle(TDataStd_ExtStringList)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
for (i = lower; i <= upper; i++)
{
const Handle(PCollection_HExtendedString)& pvalue = S->Value(i);
TCollection_ExtendedString tvalue = pvalue->Convert();
T->Append(tvalue);
}
}

35
src/MDataStd/MDataStd_ExtStringListStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_ExtStringListStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ExtStringListStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ExtStringListStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end ExtStringListStorageDriver;

76
src/MDataStd/MDataStd_ExtStringListStorageDriver.cxx Executable file
View File

@@ -0,0 +1,76 @@
// File: MDataStd_ExtStringListStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ExtStringListStorageDriver.ixx>
#include <PDataStd_ExtStringList.hxx>
#include <TDataStd_ExtStringList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
//=======================================================================
//function : MDataStd_ExtStringListStorageDriver
//purpose :
//=======================================================================
MDataStd_ExtStringListStorageDriver::MDataStd_ExtStringListStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ExtStringListStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ExtStringListStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_ExtStringList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_ExtStringListStorageDriver::NewEmpty() const
{
return new PDataStd_ExtStringList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ExtStringListStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_ExtStringList) S = Handle(TDataStd_ExtStringList)::DownCast (Source);
Handle(PDataStd_ExtStringList) T = Handle(PDataStd_ExtStringList)::DownCast (Target);
Standard_Integer lower = 1, upper = S->Extent(), i = lower;
if (upper >= lower)
{
T->Init(lower, upper);
TDataStd_ListIteratorOfListOfExtendedString itr(S->List());
for (; itr.More(); itr.Next(), i++)
{
const TCollection_ExtendedString& tvalue = itr.Value();
Handle(PCollection_HExtendedString) pvalue = new PCollection_HExtendedString(tvalue);
T->SetValue(i, pvalue);
}
}
}

38
src/MDataStd/MDataStd_IntPackedMapRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_IntPackedMapRetrievalDriver.cdl
-- Created: Thu Aug 23 10:20:22 2007
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2007
class IntPackedMapRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of IntPackedMap attribute
uses
RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable IntPackedMapRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: IntPackedMap from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end IntPackedMapRetrievalDriver;

69
src/MDataStd/MDataStd_IntPackedMapRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,69 @@
// File: MDataStd_IntPackedMapRetrievalDriver.cxx
// Created: Mon Aug 27 11:12:02 2007
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2007
#include <MDataStd_IntPackedMapRetrievalDriver.ixx>
#include <PDataStd_IntPackedMap.hxx>
#include <TDataStd_IntPackedMap.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HPackedMapOfInteger.hxx>
#include <TCollection_ExtendedString.hxx>
//=======================================================================
//function : MDataStd_IntPackedMapRetrievalDriver
//purpose : Constructor
//=======================================================================
MDataStd_IntPackedMapRetrievalDriver::MDataStd_IntPackedMapRetrievalDriver
(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntPackedMapRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntPackedMapRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_IntPackedMap); }
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_IntPackedMapRetrievalDriver::NewEmpty() const
{ return new TDataStd_IntPackedMap (); }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntPackedMapRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_IntPackedMap) aS = Handle(PDataStd_IntPackedMap)::DownCast (Source);
Handle(TDataStd_IntPackedMap) aT = Handle(TDataStd_IntPackedMap)::DownCast (Target);
if(!aS.IsNull() && !aT.IsNull()) {
if(!aS->IsEmpty()) {
Handle(TColStd_HPackedMapOfInteger) aHMap = new TColStd_HPackedMapOfInteger ();
Standard_Integer aKey;
for(Standard_Integer i = aS->Lower(); i<= aS->Upper() ; i++) {
aKey = aS->GetValue(i);
if(!aHMap->ChangeMap().Add( aKey )) {
WriteMessage(
TCollection_ExtendedString("error retrieving integer mamaber of the attribute TDataStd_IntPackedMap"));
return;
}
}
aT->ChangeMap(aHMap);
}
} else
WriteMessage(TCollection_ExtendedString("error retrieving attribute TDataStd_IntPackedMap"));
}

41
src/MDataStd/MDataStd_IntPackedMapRetrievalDriver_1.cdl Executable file
View File

@@ -0,0 +1,41 @@
-- File: MDataStd_IntPackedMapRetrievalDriver_1.cdl
-- Created: Fri Mar 28 11:31:18 2008
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2008
class IntPackedMapRetrievalDriver_1 from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of IntPackedMap attribute supporting
-- delta mechanism by default
uses
RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable IntPackedMapRetrievalDriver_1 from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 1.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: IntPackedMap_1 from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end IntPackedMapRetrievalDriver_1;

75
src/MDataStd/MDataStd_IntPackedMapRetrievalDriver_1.cxx Executable file
View File

@@ -0,0 +1,75 @@
// File: MDataStd_IntPackedMapRetrievalDriver_1.cxx
// Created: Fri Mar 28 11:41:25 2008
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2008
#include <MDataStd_IntPackedMapRetrievalDriver_1.ixx>
#include <PDataStd_IntPackedMap.hxx>
#include <PDataStd_IntPackedMap_1.hxx>
#include <TDataStd_IntPackedMap.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_HPackedMapOfInteger.hxx>
#include <TCollection_ExtendedString.hxx>
//=======================================================================
//function : MDataStd_IntPackedMapRetrievalDriver_1
//purpose : Constructor
//=======================================================================
MDataStd_IntPackedMapRetrievalDriver_1::MDataStd_IntPackedMapRetrievalDriver_1
(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntPackedMapRetrievalDriver_1::VersionNumber() const
{ return 1; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntPackedMapRetrievalDriver_1::SourceType() const
{ return STANDARD_TYPE(PDataStd_IntPackedMap_1); }
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_IntPackedMapRetrievalDriver_1::NewEmpty() const
{ return new TDataStd_IntPackedMap (); }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntPackedMapRetrievalDriver_1::Paste(
const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_IntPackedMap_1) aS =
Handle(PDataStd_IntPackedMap_1)::DownCast (Source);
Handle(TDataStd_IntPackedMap) aT =
Handle(TDataStd_IntPackedMap)::DownCast (Target);
if(!aS.IsNull() && !aT.IsNull()) {
if(!aS->IsEmpty()) {
Handle(TColStd_HPackedMapOfInteger) aHMap = new TColStd_HPackedMapOfInteger ();
Standard_Integer aKey;
for(Standard_Integer i = aS->Lower(); i<= aS->Upper() ; i++) {
aKey = aS->GetValue(i);
if(!aHMap->ChangeMap().Add( aKey )) {
WriteMessage(
TCollection_ExtendedString("error retrieving integer mamaber of the attribute TDataStd_IntPackedMap"));
return;
}
}
aT->ChangeMap(aHMap);
}
aT->SetDelta(aS->GetDelta());
} else
WriteMessage(TCollection_ExtendedString("error retrieving attribute TDataStd_IntPackedMap"));
}

38
src/MDataStd/MDataStd_IntPackedMapStorageDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_IntPackedMapStorageDriver.cdl
-- Created: Thu Aug 23 10:17:07 2007
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2007
class IntPackedMapStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose: Storage driver for IntPackedMap attribute
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM)
returns mutable IntPackedMapStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end IntPackedMapStorageDriver;

68
src/MDataStd/MDataStd_IntPackedMapStorageDriver.cxx Executable file
View File

@@ -0,0 +1,68 @@
// File: MDataStd_IntPackedMapStorageDriver.cxx
// Created: Thu Aug 23 10:40:06 2007
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2007
#include <MDataStd_IntPackedMapStorageDriver.ixx>
#include <PDataStd_IntPackedMap.hxx>
#include <PDataStd_IntPackedMap_1.hxx>
#include <TDataStd_IntPackedMap.hxx>
#include <PColStd_HArray1OfInteger.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
#include <TColStd_PackedMapOfInteger.hxx>
#include <TCollection_ExtendedString.hxx>
//=======================================================================
//function : MDataStd_IntPackedMapStorageDriver
//purpose : Constructor
//=======================================================================
MDataStd_IntPackedMapStorageDriver::MDataStd_IntPackedMapStorageDriver
(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntPackedMapStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntPackedMapStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_IntPackedMap);}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_IntPackedMapStorageDriver::NewEmpty() const
{ return new PDataStd_IntPackedMap_1; }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntPackedMapStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_IntPackedMap) aS =
Handle(TDataStd_IntPackedMap)::DownCast (Source);
Handle(PDataStd_IntPackedMap_1) aT =
Handle(PDataStd_IntPackedMap_1)::DownCast (Target);
if(!aS.IsNull() && !aT.IsNull()) {
Standard_Integer aSize = (aS->IsEmpty()) ? 0 : aS->Extent();
if(aSize) {
aT->Init (1, aSize);
TColStd_MapIteratorOfPackedMapOfInteger anIt(aS->GetMap());
for(Standard_Integer i = 1;anIt.More();anIt.Next(),i++)
aT->SetValue(i, anIt.Key());
}
aT->SetDelta(aS->GetDelta());
} else
WriteMessage(TCollection_ExtendedString ("error storing attribute TDataStd_IntPackedMap"));
}

39
src/MDataStd/MDataStd_IntegerArrayRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,39 @@
-- File: MDataStd_IntegerArrayRetrievalDriver.cdl
-- Created: Tue Jun 15 16:56:00 1999
-- Author: Sergey RUIN
---Copyright: Matra Datavision 1999
class IntegerArrayRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable IntegerArrayRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: IntegerArray from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end IntegerArrayRetrievalDriver;

71
src/MDataStd/MDataStd_IntegerArrayRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,71 @@
// File: MDataStd_UObjectRetrievalDriver.cxx
// Created: Tue Jun 15 16:29:04 1999
// Author: Sergey RUIN
#include <MDataStd_IntegerArrayRetrievalDriver.ixx>
#include <PDataStd_IntegerArray.hxx>
#include <TDataStd_IntegerArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_IntegerArrayRetrievalDriver
//purpose :
//=======================================================================
MDataStd_IntegerArrayRetrievalDriver::MDataStd_IntegerArrayRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerArrayRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerArrayRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_IntegerArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_IntegerArrayRetrievalDriver::NewEmpty () const {
return new TDataStd_IntegerArray ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerArrayRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
// const Handle(MDF_RRelocationTable)& RelocTable) const
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_IntegerArray) S = Handle(PDataStd_IntegerArray)::DownCast (Source);
Handle(TDataStd_IntegerArray) T = Handle(TDataStd_IntegerArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower() , upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++) T->SetValue( i, S->Value(i) );
}

43
src/MDataStd/MDataStd_IntegerArrayRetrievalDriver_1.cdl Executable file
View File

@@ -0,0 +1,43 @@
-- File: MDataStd_IntegerArrayRetrievalDriver_1.cdl
-- Created: Thu Mar 27 18:59:19 2008
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2008
class IntegerArrayRetrievalDriver_1 from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of IntegerArray attribute supporting
-- delta mechanism by default
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable IntegerArrayRetrievalDriver_1 from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 1.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: IntegerArray from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end IntegerArrayRetrievalDriver_1;

74
src/MDataStd/MDataStd_IntegerArrayRetrievalDriver_1.cxx Executable file
View File

@@ -0,0 +1,74 @@
// File: MDataStd_IntegerArrayRetrievalDriver_1.cxx
// Created: Thu Mar 27 19:02:22 2008
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2008
#include <MDataStd_IntegerArrayRetrievalDriver_1.ixx>
#include <PDataStd_IntegerArray.hxx>
#include <PDataStd_IntegerArray_1.hxx>
#include <TDataStd_IntegerArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_IntegerArrayRetrievalDriver_1
//purpose :
//=======================================================================
MDataStd_IntegerArrayRetrievalDriver_1::MDataStd_IntegerArrayRetrievalDriver_1(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerArrayRetrievalDriver_1::VersionNumber() const
{ return 1; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerArrayRetrievalDriver_1::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_IntegerArray_1);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_IntegerArrayRetrievalDriver_1::NewEmpty () const {
return new TDataStd_IntegerArray ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerArrayRetrievalDriver_1::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_IntegerArray_1) S = Handle(PDataStd_IntegerArray_1)::DownCast (Source);
Handle(TDataStd_IntegerArray) T = Handle(TDataStd_IntegerArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower() , upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++) T->SetValue( i, S->Value(i) );
T->SetDelta(S->GetDelta());
}

38
src/MDataStd/MDataStd_IntegerArrayStorageDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_IntegerArrayStorageDriver.cdl
-- Created: Tue Jun 15 16:56:00 1999
-- Author: Sergey RUIN
---Copyright: Matra Datavision 1999
class IntegerArrayStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable IntegerArrayStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: IntegerArray from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end IntegerArrayStorageDriver;

73
src/MDataStd/MDataStd_IntegerArrayStorageDriver.cxx Executable file
View File

@@ -0,0 +1,73 @@
// File: MDataStd_IntegerArrayStorageDriver.cxx
// Created: FriJun 11 16:29:04 1999
// Author: Sergey RUIN
#include <MDataStd_IntegerArrayStorageDriver.ixx>
#include <PDataStd_IntegerArray.hxx>
#include <PDataStd_IntegerArray_1.hxx>
#include <TDataStd_IntegerArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_IntegerArrayStorageDriver
//purpose :
//=======================================================================
MDataStd_IntegerArrayStorageDriver::MDataStd_IntegerArrayStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerArrayStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerArrayStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_IntegerArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_IntegerArrayStorageDriver::NewEmpty () const {
return new PDataStd_IntegerArray_1 ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerArrayStorageDriver::Paste (
const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_IntegerArray) S = Handle(TDataStd_IntegerArray)::DownCast (Source);
Handle(PDataStd_IntegerArray_1) T = Handle(PDataStd_IntegerArray_1)::DownCast (Target);
Standard_Integer i, lower =S->Lower() ,upper = S->Upper() ;
T->Init(lower, upper);
for(i = lower; i<=upper; i++) T->SetValue( i, S->Value(i) );
T->SetDelta(S->GetDelta());
}

33
src/MDataStd/MDataStd_IntegerListRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,33 @@
-- File: MDataStd_IntegerListRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class IntegerListRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable IntegerListRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end IntegerListRetrievalDriver;

66
src/MDataStd/MDataStd_IntegerListRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,66 @@
// File: MDataStd_IntegerListRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_IntegerListRetrievalDriver.ixx>
#include <PDataStd_IntegerList.hxx>
#include <TDataStd_IntegerList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_IntegerListRetrievalDriver
//purpose :
//=======================================================================
MDataStd_IntegerListRetrievalDriver::MDataStd_IntegerListRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerListRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerListRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_IntegerList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_IntegerListRetrievalDriver::NewEmpty () const
{
return new TDataStd_IntegerList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerListRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_IntegerList) S = Handle(PDataStd_IntegerList)::DownCast (Source);
Handle(TDataStd_IntegerList) T = Handle(TDataStd_IntegerList)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
for (i = lower; i <= upper; i++)
{
T->Append(S->Value(i));
}
}

35
src/MDataStd/MDataStd_IntegerListStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_IntegerListStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class IntegerListStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable IntegerListStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end IntegerListStorageDriver;

73
src/MDataStd/MDataStd_IntegerListStorageDriver.cxx Executable file
View File

@@ -0,0 +1,73 @@
// File: MDataStd_IntegerListStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_IntegerListStorageDriver.ixx>
#include <PDataStd_IntegerList.hxx>
#include <TDataStd_IntegerList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
//=======================================================================
//function : MDataStd_IntegerListStorageDriver
//purpose :
//=======================================================================
MDataStd_IntegerListStorageDriver::MDataStd_IntegerListStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerListStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerListStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_IntegerList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_IntegerListStorageDriver::NewEmpty() const
{
return new PDataStd_IntegerList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerListStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_IntegerList) S = Handle(TDataStd_IntegerList)::DownCast (Source);
Handle(PDataStd_IntegerList) T = Handle(PDataStd_IntegerList)::DownCast (Target);
Standard_Integer lower = 1, upper = S->Extent(), i = lower;
if (upper >= lower)
{
T->Init(lower, upper);
TColStd_ListIteratorOfListOfInteger itr(S->List());
for (; itr.More(); itr.Next(), i++)
{
T->SetValue(i, itr.Value());
}
}
}

37
src/MDataStd/MDataStd_IntegerRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_IntegerARDriver.cdl
-- Created: Wed Apr 9 16:52:06 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class IntegerRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses
RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable IntegerRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end IntegerRetrievalDriver;

71
src/MDataStd/MDataStd_IntegerRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,71 @@
// File: MDataStd_IntegerRetrievalDriver.cxx
// Created: Thu Apr 10 16:32:26 1997
// Author: VAUTHIER Jean-Claude
#include <MDataStd_IntegerRetrievalDriver.ixx>
#include <TDataStd_Integer.hxx>
#include <PDataStd_Integer.hxx>
#include <TDF_Label.hxx>
#include <PCollection_HAsciiString.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_IntegerRetrievalDriver
//purpose :
//=======================================================================
MDataStd_IntegerRetrievalDriver::MDataStd_IntegerRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_Integer);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_IntegerRetrievalDriver::NewEmpty () const {
return new TDataStd_Integer ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerRetrievalDriver::Paste (
const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
// const Handle(MDF_RRelocationTable)& RelocTable) const
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_Integer) S = Handle(PDataStd_Integer)::DownCast (Source);
Handle(TDataStd_Integer) T = Handle(TDataStd_Integer)::DownCast (Target);
T->Set (S->Get ());
}

39
src/MDataStd/MDataStd_IntegerStorageDriver.cdl Executable file
View File

@@ -0,0 +1,39 @@
-- File: MDataStd_IntegerStorageDriver.cdl
-- Created: Wed Apr 9 16:53:16 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class IntegerStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable IntegerStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end IntegerStorageDriver;

72
src/MDataStd/MDataStd_IntegerStorageDriver.cxx Executable file
View File

@@ -0,0 +1,72 @@
// File: MDataStd_IntegerStorageDriver.cxx
// Created: Thu Apr 10 16:31:25 1997
// Author: VAUTHIER Jean-Claude
#include <MDataStd_IntegerStorageDriver.ixx>
#include <TDataStd_Integer.hxx>
#include <PDataStd_Integer.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_IntegerStorageDriver
//purpose :
//=======================================================================
MDataStd_IntegerStorageDriver::MDataStd_IntegerStorageDriver (const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_IntegerStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_IntegerStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_Integer);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_IntegerStorageDriver::NewEmpty () const {
return new PDataStd_Integer ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_IntegerStorageDriver::Paste (
const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
// const Handle(MDF_SRelocationTable)& RelocTable) const
const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_Integer) S = Handle(TDataStd_Integer)::DownCast (Source);
Handle(PDataStd_Integer) T = Handle(PDataStd_Integer)::DownCast (Target);
T->Set (S->Get ());
}

36
src/MDataStd/MDataStd_NameRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,36 @@
-- File: MDataStd_NameRetrievalDriver.cdl
-- Created: Thu Aug 7 17:13:40 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class NameRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable NameRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Name from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end NameRetrievalDriver;

42
src/MDataStd/MDataStd_NameRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,42 @@
#include <MDataStd_NameRetrievalDriver.ixx>
#include <PDataStd_Name.hxx>
#include <TDataStd_Name.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <CDM_MessageDriver.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_NameRetrievalDriver::MDataStd_NameRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_NameRetrievalDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_NameRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_Name); }
Handle(TDF_Attribute) MDataStd_NameRetrievalDriver::NewEmpty() const
{ return new TDataStd_Name (); }
#include <TCollection_AsciiString.hxx>
#include <TDF_Tool.hxx>
#include <TDF_Label.hxx>
#define BUGOCC425
void MDataStd_NameRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_Name) S = Handle(PDataStd_Name)::DownCast (Source);
Handle(TDataStd_Name) T = Handle(TDataStd_Name)::DownCast (Target);
#ifdef BUGOCC425
if(!S->Get().IsNull()) {
#endif
TCollection_ExtendedString Name = (S->Get())->Convert ();
T->Set (Name);
#ifdef BUGOCC425
}
#endif
}

39
src/MDataStd/MDataStd_NameStorageDriver.cdl Executable file
View File

@@ -0,0 +1,39 @@
-- File: MDataStd_NameStorageDriver.cdl
-- Created: Thu Aug 7 17:09:27 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class NameStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM)
returns mutable NameStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end NameStorageDriver;

36
src/MDataStd/MDataStd_NameStorageDriver.cxx Executable file
View File

@@ -0,0 +1,36 @@
#include <MDataStd_NameStorageDriver.ixx>
#include <PDataStd_Name.hxx>
#include <TDataStd_Name.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <CDM_MessageDriver.hxx>
#define BUGOCC425
MDataStd_NameStorageDriver::MDataStd_NameStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_NameStorageDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_NameStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_Name);}
Handle(PDF_Attribute) MDataStd_NameStorageDriver::NewEmpty() const
{ return new PDataStd_Name; }
void MDataStd_NameStorageDriver::Paste(const Handle(TDF_Attribute)& Source,const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_Name) S = Handle(TDataStd_Name)::DownCast (Source);
Handle(PDataStd_Name) T = Handle(PDataStd_Name)::DownCast (Target);
#ifdef BUGOCC425
if(S->Get().Length() != 0) {
#endif
Handle(PCollection_HExtendedString) Name = new PCollection_HExtendedString (S->Get());
T->Set (Name);
#ifdef BUGOCC425
}
#endif
}

33
src/MDataStd/MDataStd_NamedDataRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,33 @@
-- File: MDataStd_NamedDataRetrievalDriver.cdl
-- Created: Wed Jun 27 17:19:10 2007
-- Author: Sergey ZARITCHNY
-- <szy@friendox>
---Copyright: Open CASCADE 2007
class NamedDataRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable NamedDataRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end NamedDataRetrievalDriver;

152
src/MDataStd/MDataStd_NamedDataRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,152 @@
// File: MDataStd_NamedDataRetrievalDriver.cxx
// Created: Wed Jun 27 18:37:45 2007
// Author: Sergey ZARITCHNY
// <szy@friendox>
// Copyright: Open CASCADE SA 2007
#include <MDataStd_NamedDataRetrievalDriver.ixx>
#include <PDataStd_NamedData.hxx>
#include <TDataStd_NamedData.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TColStd_DataMapOfStringInteger.hxx>
#include <TDataStd_DataMapOfStringReal.hxx>
#include <TDataStd_DataMapOfStringByte.hxx>
#include <TDataStd_DataMapOfStringString.hxx>
#include <TDataStd_DataMapOfStringHArray1OfInteger.hxx>
#include <TDataStd_DataMapOfStringHArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <PColStd_HArray1OfInteger.hxx>
#include <PColStd_HArray1OfReal.hxx>
//=======================================================================
//function : MDataStd_NamedDataRetrievalDriver
//purpose :
//=======================================================================
MDataStd_NamedDataRetrievalDriver::MDataStd_NamedDataRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_NamedDataRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_NamedDataRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_NamedData);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_NamedDataRetrievalDriver::NewEmpty () const
{
return new TDataStd_NamedData();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_NamedDataRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_NamedData) S = Handle(PDataStd_NamedData)::DownCast (Source);
Handle(TDataStd_NamedData) T = Handle(TDataStd_NamedData)::DownCast (Target);
if(S.IsNull() || T.IsNull()) return;
Standard_Integer i;
#ifdef MDTV_DEB
cout << "Start: " <<S->LowerI() << " " <<S->UpperI()<<"\t"<<S->LowerR() << " " <<S->UpperR();
cout << "\t"<<S->LowerS() << " " <<S->UpperS()<< "\t"<<S->LowerB() << " " <<S->UpperB();
cout << "\t"<<S->LowerAI() << " " <<S->UpperAI()<<"\t"<<S->LowerAR() << " " <<S->UpperAR()<<endl;
#endif
if(S->HasIntegers()) {
TColStd_DataMapOfStringInteger aMap;
for(i=S->LowerI();i<=S->UpperI();i++) {
Handle(PCollection_HExtendedString) aPKey;
Standard_Integer aValue = S->IntDataItemValue(i, aPKey);
const TCollection_ExtendedString& aKey = aPKey->Convert();
aMap.Bind(aKey, aValue);
}
T->ChangeIntegers(aMap);
}
if(S->HasReals()) {
TDataStd_DataMapOfStringReal aMap;
for(i=S->LowerR();i<=S->UpperR();i++) {
Handle(PCollection_HExtendedString) aPKey;
Standard_Real aValue = S->RealDataItemValue(i, aPKey);
const TCollection_ExtendedString& aKey = aPKey->Convert();
aMap.Bind(aKey, aValue);
}
T->ChangeReals(aMap);
}
if(S->HasStrings()) {
TDataStd_DataMapOfStringString aMap;
for(i=S->LowerS();i<=S->UpperS();i++) {
Handle(PCollection_HExtendedString) aPKey;
const Handle(PCollection_HExtendedString)& aPValue = S->StrDataItemValue(i, aPKey);
const TCollection_ExtendedString& aKey = aPKey->Convert();
const TCollection_ExtendedString& aValue = aPValue->Convert();
aMap.Bind(aKey, aValue);
}
T->ChangeStrings(aMap);
}
if(S->HasBytes()) {
TDataStd_DataMapOfStringByte aMap;
for(i=S->LowerB();i<=S->UpperB();i++) {
Handle(PCollection_HExtendedString) aPKey;
Standard_Byte aValue = S->ByteDataItemValue(i, aPKey);
const TCollection_ExtendedString& aKey = aPKey->Convert();
aMap.Bind(aKey, aValue);
}
T->ChangeBytes(aMap);
}
if(S->HasArraysOfIntegers()) {
TDataStd_DataMapOfStringHArray1OfInteger aMap;
for(i=S->LowerAI();i<=S->UpperAI();i++) {
Handle(PCollection_HExtendedString) aPKey;
Handle(PColStd_HArray1OfInteger) aPValue = S->ArrIntDataItemValue(i, aPKey);
const TCollection_ExtendedString& aKey = aPKey->Convert();
Handle(TColStd_HArray1OfInteger) anAr;
if (aPValue.IsNull()) continue;
Standard_Integer lower = aPValue->Lower(), upper = aPValue->Upper();
anAr = new TColStd_HArray1OfInteger(lower, upper);
for (Standard_Integer j = lower; j <= upper; j++)
anAr->SetValue(j, aPValue->Value(j));
aMap.Bind(aKey, anAr);
}
T->ChangeArraysOfIntegers(aMap);
}
if(S->HasArraysOfReals()) {
TDataStd_DataMapOfStringHArray1OfReal aMap;
for(i=S->LowerAR();i<=S->UpperAR();i++) {
Handle(PCollection_HExtendedString) aPKey;
Handle(PColStd_HArray1OfReal) aPValue = S->ArrRealDataItemValue(i, aPKey);
const TCollection_ExtendedString& aKey = aPKey->Convert();
Handle(TColStd_HArray1OfReal) anAr;
if (aPValue.IsNull()) continue;
Standard_Integer lower = aPValue->Lower(), upper = aPValue->Upper();
anAr = new TColStd_HArray1OfReal(lower, upper);
for (Standard_Integer j = lower; j <= upper; j++)
anAr->SetValue(j, aPValue->Value(j));
aMap.Bind(aKey, anAr);
}
T->ChangeArraysOfReals(aMap);
}
}

37
src/MDataStd/MDataStd_NamedDataStorageDriver.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_NamedDataStorageDriver.cdl
-- Created: Wed Jun 27 17:21:55 2007
-- Author: Sergey ZARITCHNY
-- <szy@friendox>
---Copyright: Open CASCADE 2007
class NamedDataStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable NamedDataStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end NamedDataStorageDriver;

171
src/MDataStd/MDataStd_NamedDataStorageDriver.cxx Executable file
View File

@@ -0,0 +1,171 @@
// File: MDataStd_NamedDataStorageDriver.cxx
// Created: Wed Jun 27 17:25:05 2007
// Author: Sergey ZARITCHNY
// <szy@friendox>
// Copyright: Open CASCADE SA 2007
#include <MDataStd_NamedDataStorageDriver.ixx>
#include <CDM_MessageDriver.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TColStd_HArray2OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <PColStd_HArray1OfReal.hxx>
#include <PColStd_HArray1OfInteger.hxx>
#include <PDataStd_NamedData.hxx>
#include <TDataStd_NamedData.hxx>
#include <TColStd_DataMapOfStringInteger.hxx>
#include <TDataStd_DataMapOfStringReal.hxx>
#include <TDataStd_DataMapOfStringString.hxx>
#include <TDataStd_DataMapOfStringByte.hxx>
#include <TDataStd_DataMapOfStringHArray1OfInteger.hxx>
#include <TDataStd_DataMapOfStringHArray1OfReal.hxx>
#include <TColStd_DataMapIteratorOfDataMapOfStringInteger.hxx>
#include <TDataStd_DataMapIteratorOfDataMapOfStringReal.hxx>
#include <TDataStd_DataMapIteratorOfDataMapOfStringString.hxx>
#include <TDataStd_DataMapIteratorOfDataMapOfStringByte.hxx>
#include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger.hxx>
#include <TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal.hxx>
#define ROW_NUMBER 6
//=======================================================================
//function : MDataStd_NamedDataStorageDriver
//purpose :
//=======================================================================
MDataStd_NamedDataStorageDriver::MDataStd_NamedDataStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_NamedDataStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_NamedDataStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_NamedData);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_NamedDataStorageDriver::NewEmpty() const
{
return new PDataStd_NamedData();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_NamedDataStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_NamedData) S = Handle(TDataStd_NamedData)::DownCast (Source);
Handle(PDataStd_NamedData) T = Handle(PDataStd_NamedData)::DownCast (Target);
if(S.IsNull() || T.IsNull()) return;
Standard_Integer i=1;
Handle(TColStd_HArray2OfInteger) aDim = new TColStd_HArray2OfInteger(1,ROW_NUMBER, 1, 2, 0);
if(S->HasIntegers() && !S->GetIntegersContainer().IsEmpty()) {
aDim->SetValue (i,1,1);
aDim->SetValue (i,2,S->GetIntegersContainer().Extent());
}
i++;
if(S->HasReals() && !S->GetRealsContainer().IsEmpty()) {
aDim->SetValue (i,1,1);
aDim->SetValue (i,2,S->GetRealsContainer().Extent());
}
i++;
if(S->HasStrings() && !S->GetStringsContainer().IsEmpty()) {
aDim->SetValue (i,1,1);
aDim->SetValue (i,2,S->GetStringsContainer().Extent());
}
i++;
if(S->HasBytes() && !S->GetBytesContainer().IsEmpty()) {
aDim->SetValue (i,1,1);
aDim->SetValue (i,2,S->GetBytesContainer().Extent());
}
i++;
if(S->HasArraysOfIntegers() && !S->GetArraysOfIntegersContainer().IsEmpty()) {
aDim->SetValue (i,1,1);
aDim->SetValue (i,2,S->GetArraysOfIntegersContainer().Extent());
}
i++;
if(S->HasArraysOfReals() && !S->GetArraysOfRealsContainer().IsEmpty()) {
aDim->SetValue (i,1,1);
aDim->SetValue (i,2,S->GetArraysOfRealsContainer().Extent());
}
T->Init(aDim);
if(S->HasIntegers() && !S->GetIntegersContainer().IsEmpty()) {
TColStd_DataMapIteratorOfDataMapOfStringInteger itr(S->GetIntegersContainer());
for (i=1; itr.More(); itr.Next(),i++) {
Handle(PCollection_HExtendedString) aKey = new PCollection_HExtendedString(itr.Key());
T->SetIntDataItem (i, aKey, itr.Value());
}
}
if(S->HasReals() && !S->GetRealsContainer().IsEmpty()) {
TDataStd_DataMapIteratorOfDataMapOfStringReal itr(S->GetRealsContainer());
for (i=1; itr.More(); itr.Next(),i++) {
Handle(PCollection_HExtendedString) aKey = new PCollection_HExtendedString(itr.Key());
T->SetRealDataItem (i, aKey, itr.Value());
}
}
if(S->HasStrings() && !S->GetStringsContainer().IsEmpty()) {
TDataStd_DataMapIteratorOfDataMapOfStringString itr(S->GetStringsContainer());
for (i=1; itr.More(); itr.Next(),i++) {
Handle(PCollection_HExtendedString) aKey = new PCollection_HExtendedString(itr.Key());
Handle(PCollection_HExtendedString) aValue = new PCollection_HExtendedString(itr.Value());
T->SetStrDataItem (i, aKey, aValue);
}
}
if(S->HasBytes() && !S->GetBytesContainer().IsEmpty()) {
TDataStd_DataMapIteratorOfDataMapOfStringByte itr(S->GetBytesContainer());
for (i=1; itr.More(); itr.Next(),i++) {
Handle(PCollection_HExtendedString) aKey = new PCollection_HExtendedString(itr.Key());
T->SetByteDataItem (i, aKey, itr.Value());
}
}
if(S->HasArraysOfIntegers() && !S->GetArraysOfIntegersContainer().IsEmpty()) {
TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfInteger itr(S->GetArraysOfIntegersContainer());
for (i=1; itr.More(); itr.Next(),i++) {
Handle(PCollection_HExtendedString) aKey = new PCollection_HExtendedString(itr.Key());
const Handle(TColStd_HArray1OfInteger)& anArr1 = itr.Value();
Handle(PColStd_HArray1OfInteger) anArr2 =
new PColStd_HArray1OfInteger(anArr1->Lower(), anArr1->Upper());
for(Standard_Integer j= anArr1->Lower(); j<=anArr1->Upper();j++) {
anArr2->SetValue(j, anArr1->Value(j));
}
T->SetArrIntDataItem (i, aKey, anArr2);
}
}
if(S->HasArraysOfReals() && !S->GetArraysOfRealsContainer().IsEmpty()) {
TDataStd_DataMapIteratorOfDataMapOfStringHArray1OfReal itr(S->GetArraysOfRealsContainer());
for (i=1; itr.More(); itr.Next(),i++) {
Handle(PCollection_HExtendedString) aKey = new PCollection_HExtendedString(itr.Key());
const Handle(TColStd_HArray1OfReal)& anArr1 = itr.Value();
Handle(PColStd_HArray1OfReal) anArr2 =
new PColStd_HArray1OfReal(anArr1->Lower(), anArr1->Upper());
for(Standard_Integer j= anArr1->Lower(); j<=anArr1->Upper();j++) {
anArr2->SetValue(j, anArr1->Value(j));
}
T->SetArrRealDataItem (i, aKey, anArr2);
}
}
}

38
src/MDataStd/MDataStd_NoteBookRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_NoteBookRetrievalDriver.cdl
-- Created: Thu Aug 7 17:18:18 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class NoteBookRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable NoteBookRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: NoteBook from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end NoteBookRetrievalDriver;

23
src/MDataStd/MDataStd_NoteBookRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,23 @@
#include <MDataStd_NoteBookRetrievalDriver.ixx>
#include <PDataStd_NoteBook.hxx>
#include <TDataStd_NoteBook.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_NoteBookRetrievalDriver::MDataStd_NoteBookRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_NoteBookRetrievalDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_NoteBookRetrievalDriver::SourceType() const
{ return STANDARD_TYPE(PDataStd_NoteBook); }
Handle(TDF_Attribute) MDataStd_NoteBookRetrievalDriver::NewEmpty() const
{ return new TDataStd_NoteBook; }
//void MDataStd_NoteBookRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,const Handle(TDF_Attribute)& Target,const Handle(MDF_RRelocationTable)& RelocTable) const
void MDataStd_NoteBookRetrievalDriver::Paste(const Handle(PDF_Attribute)& ,const Handle(TDF_Attribute)& ,const Handle(MDF_RRelocationTable)& ) const
{
}

39
src/MDataStd/MDataStd_NoteBookStorageDriver.cdl Executable file
View File

@@ -0,0 +1,39 @@
-- File: MDataStd_NoteBookStorageDriver.cdl
-- Created: Thu Aug 7 17:09:27 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class NoteBookStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM)
returns mutable NoteBookStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end NoteBookStorageDriver;

23
src/MDataStd/MDataStd_NoteBookStorageDriver.cxx Executable file
View File

@@ -0,0 +1,23 @@
#include <MDataStd_NoteBookStorageDriver.ixx>
#include <PDataStd_NoteBook.hxx>
#include <TDataStd_NoteBook.hxx>
#include <CDM_MessageDriver.hxx>
MDataStd_NoteBookStorageDriver::MDataStd_NoteBookStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
Standard_Integer MDataStd_NoteBookStorageDriver::VersionNumber() const
{ return 0; }
Handle(Standard_Type) MDataStd_NoteBookStorageDriver::SourceType() const
{ return STANDARD_TYPE (TDataStd_NoteBook); }
Handle(PDF_Attribute) MDataStd_NoteBookStorageDriver::NewEmpty() const
{ return new PDataStd_NoteBook(); }
//void MDataStd_NoteBookStorageDriver::Paste(const Handle(TDF_Attribute)& Source,const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& RelocTable) const
void MDataStd_NoteBookStorageDriver::Paste(const Handle(TDF_Attribute)& ,const Handle(PDF_Attribute)& ,const Handle(MDF_SRelocationTable)& ) const
{
}

38
src/MDataStd/MDataStd_RealArrayRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_RealArrayRetrievalDriver.cdl
-- Created: Tue Jun 15 16:56:00 1999
-- Author: Sergey RUIN
---Copyright: Matra Datavision 1999
class RealArrayRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable RealArrayRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: RealArray from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end RealArrayRetrievalDriver;

71
src/MDataStd/MDataStd_RealArrayRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,71 @@
// File: MDataStd_UObjectRetrievalDriver.cxx
// Created: Tue Jun 15 16:29:04 1999
// Author: Sergey RUIN
#include <MDataStd_RealArrayRetrievalDriver.ixx>
#include <PDataStd_RealArray.hxx>
#include <TDataStd_RealArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RealArrayRetrievalDriver
//purpose :
//=======================================================================
MDataStd_RealArrayRetrievalDriver::MDataStd_RealArrayRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealArrayRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealArrayRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_RealArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_RealArrayRetrievalDriver::NewEmpty () const {
return new TDataStd_RealArray ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealArrayRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
// const Handle(MDF_RRelocationTable)& RelocTable) const
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_RealArray) S = Handle(PDataStd_RealArray)::DownCast (Source);
Handle(TDataStd_RealArray) T = Handle(TDataStd_RealArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower() , upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++) T->SetValue( i, S->Value(i) );
}

42
src/MDataStd/MDataStd_RealArrayRetrievalDriver_1.cdl Executable file
View File

@@ -0,0 +1,42 @@
-- File: MDataStd_RealArrayRetrievalDriver_1.cdl
-- Created: Fri Mar 28 11:05:56 2008
-- Author: Sergey ZARITCHNY
-- <sergey.zaritchny@opencascade.com>
---Copyright: Open CasCade SA 2008
class RealArrayRetrievalDriver_1 from MDataStd inherits ARDriver from MDF
---Purpose: Retrieval driver of RealArray attribute supporting
-- delta mechanism by default
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable RealArrayRetrievalDriver_1 from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 1.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: RealArray from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end RealArrayRetrievalDriver_1;

76
src/MDataStd/MDataStd_RealArrayRetrievalDriver_1.cxx Executable file
View File

@@ -0,0 +1,76 @@
// File: MDataStd_RealArrayRetrievalDriver_1.cxx
// Created: Fri Mar 28 11:08:47 2008
// Author: Sergey ZARITCHNY
// <sergey.zaritchny@opencascade.com>
// Copyright: Open CASCADE SA 2008
#include <MDataStd_RealArrayRetrievalDriver_1.ixx>
#include <PDataStd_RealArray.hxx>
#include <PDataStd_RealArray_1.hxx>
#include <TDataStd_RealArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RealArrayRetrievalDriver_1
//purpose :
//=======================================================================
MDataStd_RealArrayRetrievalDriver_1::MDataStd_RealArrayRetrievalDriver_1
(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealArrayRetrievalDriver_1::VersionNumber() const
{ return 1; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealArrayRetrievalDriver_1::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_RealArray_1);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_RealArrayRetrievalDriver_1::NewEmpty () const {
return new TDataStd_RealArray ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealArrayRetrievalDriver_1::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_RealArray_1) S = Handle(PDataStd_RealArray_1)::DownCast (Source);
Handle(TDataStd_RealArray) T = Handle(TDataStd_RealArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower() , upper = S->Upper();
T->Init(lower, upper);
for(i = lower; i<=upper; i++) T->SetValue( i, S->Value(i) );
T->SetDelta(S->GetDelta());
}

38
src/MDataStd/MDataStd_RealArrayStorageDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_RealArrayStorageDriver.cdl
-- Created: Tue Jun 15 16:56:00 1999
-- Author: Sergey RUIN
---Copyright: Matra Datavision 1999
class RealArrayStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable RealArrayStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: RealArray from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end RealArrayStorageDriver;

72
src/MDataStd/MDataStd_RealArrayStorageDriver.cxx Executable file
View File

@@ -0,0 +1,72 @@
// File: MDataStd_RealArrayStorageDriver.cxx
// Created: FriJun 11 16:29:04 1999
// Author: Sergey RUIN
#include <MDataStd_RealArrayStorageDriver.ixx>
#include <PDataStd_RealArray.hxx>
#include <PDataStd_RealArray_1.hxx>
#include <TDataStd_RealArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RealArrayStorageDriver
//purpose :
//=======================================================================
MDataStd_RealArrayStorageDriver::MDataStd_RealArrayStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealArrayStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealArrayStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_RealArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_RealArrayStorageDriver::NewEmpty () const {
return new PDataStd_RealArray_1 ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealArrayStorageDriver::Paste (
const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_RealArray) S = Handle(TDataStd_RealArray)::DownCast (Source);
Handle(PDataStd_RealArray_1) T = Handle(PDataStd_RealArray_1)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper() ;
T->Init(lower, upper);
for(i = lower; i<=upper; i++) T->SetValue( i, S->Value(i) );
T->SetDelta(S->GetDelta());
}

33
src/MDataStd/MDataStd_RealListRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,33 @@
-- File: MDataStd_RealListRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class RealListRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable RealListRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end RealListRetrievalDriver;

66
src/MDataStd/MDataStd_RealListRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,66 @@
// File: MDataStd_RealListRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_RealListRetrievalDriver.ixx>
#include <PDataStd_RealList.hxx>
#include <TDataStd_RealList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RealListRetrievalDriver
//purpose :
//=======================================================================
MDataStd_RealListRetrievalDriver::MDataStd_RealListRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealListRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealListRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_RealList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_RealListRetrievalDriver::NewEmpty () const
{
return new TDataStd_RealList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealListRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_RealList) S = Handle(PDataStd_RealList)::DownCast (Source);
Handle(TDataStd_RealList) T = Handle(TDataStd_RealList)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
for (i = lower; i <= upper; i++)
{
T->Append(S->Value(i));
}
}

35
src/MDataStd/MDataStd_RealListStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_RealListStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class RealListStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable RealListStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end RealListStorageDriver;

73
src/MDataStd/MDataStd_RealListStorageDriver.cxx Executable file
View File

@@ -0,0 +1,73 @@
// File: MDataStd_RealListStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_RealListStorageDriver.ixx>
#include <PDataStd_RealList.hxx>
#include <TDataStd_RealList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TColStd_ListIteratorOfListOfReal.hxx>
//=======================================================================
//function : MDataStd_RealListStorageDriver
//purpose :
//=======================================================================
MDataStd_RealListStorageDriver::MDataStd_RealListStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealListStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealListStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_RealList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_RealListStorageDriver::NewEmpty() const
{
return new PDataStd_RealList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealListStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_RealList) S = Handle(TDataStd_RealList)::DownCast (Source);
Handle(PDataStd_RealList) T = Handle(PDataStd_RealList)::DownCast (Target);
Standard_Integer lower = 1, upper = S->Extent(), i = lower;
if (upper >= lower)
{
T->Init(lower, upper);
TColStd_ListIteratorOfListOfReal itr(S->List());
for (; itr.More(); itr.Next(), i++)
{
T->SetValue(i, itr.Value());
}
}
}

38
src/MDataStd/MDataStd_RealRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_RealRetrievalDriver.cdl
-- Created: Wed Apr 9 16:55:12 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class RealRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable RealRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Real from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end RealRetrievalDriver;

71
src/MDataStd/MDataStd_RealRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,71 @@
// File: MDataStd_RealRetrievalDriver.cxx
// Created: Thu Apr 10 16:30:18 1997
// Author: VAUTHIER Jean-Claude
#include <MDataStd_RealRetrievalDriver.ixx>
#include <TDataStd_Real.hxx>
#include <PDataStd_Real.hxx>
#include <MDataStd.hxx>
#include <TDataStd_RealEnum.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RealRetrievalDriver
//purpose :
//=======================================================================
MDataStd_RealRetrievalDriver::MDataStd_RealRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_Real);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_RealRetrievalDriver::NewEmpty () const {
return new TDataStd_Real ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealRetrievalDriver::Paste
(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
// const Handle(MDF_RRelocationTable)& RelocTable) const
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_Real) S = Handle(PDataStd_Real)::DownCast (Source);
Handle(TDataStd_Real) T = Handle(TDataStd_Real)::DownCast (Target);
T->Set (S->Get ());
T->SetDimension(MDataStd::IntegerToRealDimension(S->GetDimension()));
}

38
src/MDataStd/MDataStd_RealStorageDriver.cdl Executable file
View File

@@ -0,0 +1,38 @@
-- File: MDataStd_RealStorageDriver.cdl
-- Created: Wed Apr 9 16:56:00 1997
-- Author: VAUTHIER Jean-Claude
---Copyright: Matra Datavision 1997
class RealStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable RealStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Real from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end RealStorageDriver;

71
src/MDataStd/MDataStd_RealStorageDriver.cxx Executable file
View File

@@ -0,0 +1,71 @@
// File: MDataStd_RealStorageDriver.cxx
// Created: Thu Apr 10 16:29:04 1997
// Author: VAUTHIER Jean-Claude
#include <MDataStd_RealStorageDriver.ixx>
#include <PDataStd_Real.hxx>
#include <TDataStd_Real.hxx>
#include <MDataStd.hxx>
#include <TDataStd_RealEnum.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RealStorageDriver
//purpose :
//=======================================================================
MDataStd_RealStorageDriver::MDataStd_RealStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RealStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RealStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_Real);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_RealStorageDriver::NewEmpty () const {
return new PDataStd_Real ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RealStorageDriver::Paste (
const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
// const Handle(MDF_SRelocationTable)& RelocTable) const
const Handle(MDF_SRelocationTable)& ) const
{
Handle(TDataStd_Real) S = Handle(TDataStd_Real)::DownCast (Source);
Handle(PDataStd_Real) T = Handle(PDataStd_Real)::DownCast (Target);
T->Set (S->Get ());
T->SetDimension (MDataStd::RealDimensionToInteger(S->GetDimension()));
}

33
src/MDataStd/MDataStd_ReferenceArrayRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,33 @@
-- File: MDataStd_ReferenceArrayRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ReferenceArrayRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ReferenceArrayRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ReferenceArrayRetrievalDriver;

81
src/MDataStd/MDataStd_ReferenceArrayRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,81 @@
// File: MDataStd_ReferenceArrayRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ReferenceArrayRetrievalDriver.ixx>
#include <PDataStd_ReferenceArray.hxx>
#include <TDataStd_ReferenceArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TDF_Label.hxx>
#include <TCollection_AsciiString.hxx>
#include <TDF_Tool.hxx>
//=======================================================================
//function : MDataStd_ReferenceArrayRetrievalDriver
//purpose :
//=======================================================================
MDataStd_ReferenceArrayRetrievalDriver::MDataStd_ReferenceArrayRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ReferenceArrayRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ReferenceArrayRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ReferenceArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ReferenceArrayRetrievalDriver::NewEmpty () const
{
return new TDataStd_ReferenceArray();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ReferenceArrayRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ReferenceArray) S = Handle(PDataStd_ReferenceArray)::DownCast (Source);
Handle(TDataStd_ReferenceArray) T = Handle(TDataStd_ReferenceArray)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
T->Init(lower, upper);
for (i = lower; i <= upper; i++)
{
const Handle(PCollection_HExtendedString)& pvalue = S->Value(i);
if (!pvalue.IsNull())
{
TDF_Label L;
TCollection_AsciiString tvalue = pvalue->Convert();
TDF_Tool::Label(T->Label().Data(), tvalue, L, Standard_True);
if (!L.IsNull())
{
T->SetValue(i, L);
}
}
}
}

35
src/MDataStd/MDataStd_ReferenceArrayStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_ReferenceArrayStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ReferenceArrayStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ReferenceArrayStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end ReferenceArrayStorageDriver;

80
src/MDataStd/MDataStd_ReferenceArrayStorageDriver.cxx Executable file
View File

@@ -0,0 +1,80 @@
// File: MDataStd_ReferenceArrayStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ReferenceArrayStorageDriver.ixx>
#include <PDataStd_ReferenceArray.hxx>
#include <TDataStd_ReferenceArray.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TDF_Tool.hxx>
#include <TDF_Label.hxx>
#include <PCollection_HExtendedString.hxx>
//=======================================================================
//function : MDataStd_ReferenceArrayStorageDriver
//purpose :
//=======================================================================
MDataStd_ReferenceArrayStorageDriver::MDataStd_ReferenceArrayStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ReferenceArrayStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ReferenceArrayStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_ReferenceArray);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_ReferenceArrayStorageDriver::NewEmpty() const
{
return new PDataStd_ReferenceArray();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ReferenceArrayStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_ReferenceArray) S = Handle(TDataStd_ReferenceArray)::DownCast (Source);
Handle(PDataStd_ReferenceArray) T = Handle(PDataStd_ReferenceArray)::DownCast (Target);
Standard_Integer lower = S->Lower(), upper = S->Upper(), i = lower;
if (upper >= lower)
{
T->Init(lower, upper);
for (; i <= upper; i++)
{
TDF_Label L = S->Value(i);
if (!L.IsNull())
{
TCollection_AsciiString tvalue;
TDF_Tool::Entry(L, tvalue);
Handle(PCollection_HExtendedString) pvalue = new PCollection_HExtendedString(tvalue);
T->SetValue(i, pvalue);
}
}
}
}

33
src/MDataStd/MDataStd_ReferenceListRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,33 @@
-- File: MDataStd_ReferenceListRetrievalDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ReferenceListRetrievalDriver from MDataStd inherits ARDriver from MDF
uses
RRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ReferenceListRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
SourceType(me) returns Type from Standard;
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me;
Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end ReferenceListRetrievalDriver;

80
src/MDataStd/MDataStd_ReferenceListRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,80 @@
// File: MDataStd_ReferenceListRetrievalDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ReferenceListRetrievalDriver.ixx>
#include <PDataStd_ReferenceList.hxx>
#include <TDataStd_ReferenceList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TDF_Label.hxx>
#include <TCollection_AsciiString.hxx>
#include <TDF_Tool.hxx>
//=======================================================================
//function : MDataStd_ReferenceListRetrievalDriver
//purpose :
//=======================================================================
MDataStd_ReferenceListRetrievalDriver::MDataStd_ReferenceListRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ReferenceListRetrievalDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ReferenceListRetrievalDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(PDataStd_ReferenceList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_ReferenceListRetrievalDriver::NewEmpty () const
{
return new TDataStd_ReferenceList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ReferenceListRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& ) const
{
Handle(PDataStd_ReferenceList) S = Handle(PDataStd_ReferenceList)::DownCast (Source);
Handle(TDataStd_ReferenceList) T = Handle(TDataStd_ReferenceList)::DownCast (Target);
Standard_Integer i, lower = S->Lower(), upper = S->Upper();
for (i = lower; i <= upper; i++)
{
const Handle(PCollection_HExtendedString)& pvalue = S->Value(i);
if (!pvalue.IsNull())
{
TDF_Label L;
TCollection_AsciiString tvalue = pvalue->Convert();
TDF_Tool::Label(T->Label().Data(), tvalue, L, Standard_True);
if (!L.IsNull())
{
T->Append(L);
}
}
}
}

35
src/MDataStd/MDataStd_ReferenceListStorageDriver.cdl Executable file
View File

@@ -0,0 +1,35 @@
-- File: MDataStd_ReferenceListStorageDriver.cdl
-- Created: May 29 11:40:00 2007
-- Author: Vlad Romashko
-- <vladislav.romashko@opencascade.com>
-- Copyright: Open CASCADE
class ReferenceListStorageDriver from MDataStd inherits ASDriver from MDF
uses
SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM)
returns mutable ReferenceListStorageDriver from MDataStd;
VersionNumber(me)
returns Integer from Standard;
SourceType(me)
returns Type from Standard;
NewEmpty (me)
returns mutable Attribute from PDF;
Paste(me;
Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end ReferenceListStorageDriver;

83
src/MDataStd/MDataStd_ReferenceListStorageDriver.cxx Executable file
View File

@@ -0,0 +1,83 @@
// File: MDataStd_ReferenceListStorageDriver.cxx
// Created: May 29 11:40:00 2007
// Author: Vlad Romashko
// <vladislav.romashko@opencascade.com>
// Copyright: Open CASCADE
#include <MDataStd_ReferenceListStorageDriver.ixx>
#include <PDataStd_ReferenceList.hxx>
#include <TDataStd_ReferenceList.hxx>
#include <MDataStd.hxx>
#include <CDM_MessageDriver.hxx>
#include <TDF_ListIteratorOfLabelList.hxx>
#include <TDF_Tool.hxx>
#include <TDF_Label.hxx>
#include <PCollection_HExtendedString.hxx>
//=======================================================================
//function : MDataStd_ReferenceListStorageDriver
//purpose :
//=======================================================================
MDataStd_ReferenceListStorageDriver::MDataStd_ReferenceListStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_ReferenceListStorageDriver::VersionNumber() const
{
return 0;
}
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_ReferenceListStorageDriver::SourceType() const
{
static Handle(Standard_Type) sourceType = STANDARD_TYPE(TDataStd_ReferenceList);
return sourceType;
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_ReferenceListStorageDriver::NewEmpty() const
{
return new PDataStd_ReferenceList();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_ReferenceListStorageDriver::Paste(const Handle(TDF_Attribute)& Source,
const Handle(PDF_Attribute)& Target,
const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_ReferenceList) S = Handle(TDataStd_ReferenceList)::DownCast (Source);
Handle(PDataStd_ReferenceList) T = Handle(PDataStd_ReferenceList)::DownCast (Target);
Standard_Integer lower = 1, upper = S->Extent(), i = lower;
if (upper >= lower)
{
T->Init(lower, upper);
TDF_ListIteratorOfLabelList itr(S->List());
for (; itr.More(); itr.Next(), i++)
{
TDF_Label L = itr.Value();
if (!L.IsNull())
{
TCollection_AsciiString tvalue;
TDF_Tool::Entry(L, tvalue);
Handle(PCollection_HExtendedString) pvalue = new PCollection_HExtendedString(tvalue);
T->SetValue(i, pvalue);
}
}
}
}

36
src/MDataStd/MDataStd_RelationRetrievalDriver.cdl Executable file
View File

@@ -0,0 +1,36 @@
-- File: MDataStd_RelationRetrievalDriver.cdl
-- Created: Thu Aug 7 17:13:40 1997
-- Author: PASCAL Denis
---Copyright: Matra Datavision 1997
class RelationRetrievalDriver from MDataStd inherits ARDriver from MDF
---Purpose:
uses RRelocationTable from MDF,
Attribute from PDF,
Attribute from TDF,
MessageDriver from CDM
is
Create(theMessageDriver : MessageDriver from CDM) -- Version 0
returns mutable RelationRetrievalDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Relation from PDataStd.
NewEmpty (me) returns mutable Attribute from TDF;
Paste(me; Source : Attribute from PDF;
Target : mutable Attribute from TDF;
RelocTable : RRelocationTable from MDF);
end RelationRetrievalDriver;

78
src/MDataStd/MDataStd_RelationRetrievalDriver.cxx Executable file
View File

@@ -0,0 +1,78 @@
#include <MDataStd_RelationRetrievalDriver.ixx>
#include <PDataStd_Relation.hxx>
#include <TDataStd_Relation.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TDF_ListIteratorOfAttributeList.hxx>
#include <PDF_HAttributeArray1.hxx>
#include <Standard_NoSuchObject.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RelationRetrievalDriver
//purpose :
//=======================================================================
MDataStd_RelationRetrievalDriver::MDataStd_RelationRetrievalDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ARDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RelationRetrievalDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RelationRetrievalDriver::SourceType() const
{
return STANDARD_TYPE(PDataStd_Relation);
}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(TDF_Attribute) MDataStd_RelationRetrievalDriver::NewEmpty() const
{
return new TDataStd_Relation ();
}
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RelationRetrievalDriver::Paste(const Handle(PDF_Attribute)& Source,
const Handle(TDF_Attribute)& Target,
const Handle(MDF_RRelocationTable)& RelocTable) const
{
Handle(PDataStd_Relation) S = Handle(PDataStd_Relation)::DownCast (Source);
Handle(TDataStd_Relation) T = Handle(TDataStd_Relation)::DownCast (Target);
TCollection_ExtendedString Relation = (S->GetName())->Convert ();
T->SetRelation (Relation);
Handle(PDF_Attribute) PV;
Handle(TDF_Attribute) TV;
Handle(PDF_HAttributeArray1) PVARS = S->GetVariables ();
if (PVARS.IsNull()) return;
for (Standard_Integer i = 1; i <= PVARS->Length (); i++) {
PV = PVARS->Value (i);
if (!PV.IsNull ()) {
if (!RelocTable->HasRelocation (PV, TV)) {
Standard_NoSuchObject::Raise("MDataStd_ConstraintRetrievalDriver::Paste");
}
T->GetVariables().Append(TV);
}
}
}

37
src/MDataStd/MDataStd_RelationStorageDriver.cdl Executable file
View File

@@ -0,0 +1,37 @@
-- File: MDataStd_RelationStorageDriver.cdl
-- Created: Thu Aug 7 17:09:27 1997
-- Author: PASCAL Denis
---Copyright: Matra Datavision 1997
class RelationStorageDriver from MDataStd inherits ASDriver from MDF
---Purpose:
uses SRelocationTable from MDF,
Attribute from TDF,
Attribute from PDF,
MessageDriver from CDM
is
Create (theMessageDriver : MessageDriver from CDM)
returns mutable RelationStorageDriver from MDataStd;
VersionNumber(me) returns Integer from Standard;
---Purpose: Returns the version number from which the driver
-- is available: 0.
SourceType(me) returns Type from Standard;
---Purpose: Returns the type: Integer from TDataStd.
NewEmpty (me) returns mutable Attribute from PDF;
Paste(me; Source : Attribute from TDF;
Target : mutable Attribute from PDF;
RelocTable : SRelocationTable from MDF);
end RelationStorageDriver;

73
src/MDataStd/MDataStd_RelationStorageDriver.cxx Executable file
View File

@@ -0,0 +1,73 @@
#include <MDataStd_RelationStorageDriver.ixx>
#include <PDataStd_Relation.hxx>
#include <TDataStd_Relation.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCollection_HExtendedString.hxx>
#include <TDF_ListIteratorOfAttributeList.hxx>
#include <PDF_HAttributeArray1.hxx>
#include <Standard_NoSuchObject.hxx>
#include <CDM_MessageDriver.hxx>
//=======================================================================
//function : MDataStd_RelationStorageDriver
//purpose :
//=======================================================================
MDataStd_RelationStorageDriver::MDataStd_RelationStorageDriver(const Handle(CDM_MessageDriver)& theMsgDriver):MDF_ASDriver(theMsgDriver)
{
}
//=======================================================================
//function : VersionNumber
//purpose :
//=======================================================================
Standard_Integer MDataStd_RelationStorageDriver::VersionNumber() const
{ return 0; }
//=======================================================================
//function : SourceType
//purpose :
//=======================================================================
Handle(Standard_Type) MDataStd_RelationStorageDriver::SourceType() const
{ return STANDARD_TYPE(TDataStd_Relation);}
//=======================================================================
//function : NewEmpty
//purpose :
//=======================================================================
Handle(PDF_Attribute) MDataStd_RelationStorageDriver::NewEmpty() const
{ return new PDataStd_Relation; }
//=======================================================================
//function : Paste
//purpose :
//=======================================================================
void MDataStd_RelationStorageDriver::Paste(const Handle(TDF_Attribute)& Source,const Handle(PDF_Attribute)& Target,const Handle(MDF_SRelocationTable)& RelocTable) const
{
Handle(TDataStd_Relation) S = Handle(TDataStd_Relation)::DownCast (Source);
Handle(PDataStd_Relation) T = Handle(PDataStd_Relation)::DownCast (Target);
Handle(PCollection_HExtendedString) Relation = new PCollection_HExtendedString (S->Name());
T->SetName (Relation);
Handle(TDF_Attribute) TV;
Handle(PDF_Attribute) PV;
Standard_Integer nbvar = S->GetVariables().Extent();
if (nbvar <= 0) return;
Handle(PDF_HAttributeArray1) PVARS = new PDF_HAttributeArray1 (1, nbvar);
TDF_ListIteratorOfAttributeList it;
Standard_Integer index = 0;
for (it.Initialize(S->GetVariables());it.More();it.Next()) {
index++;
TV = it.Value();
if(!RelocTable->HasRelocation (TV, PV)) {
Standard_NoSuchObject::Raise("MDataStd_ExpressionStorageDriver::Paste");
}
PVARS->SetValue (index,PV);
}
T->SetVariables (PVARS);
}

Some files were not shown because too many files have changed in this diff Show More