return Standard_True;
}
-//===========================================================================
-// function : WireIN
-// purpose : to solve WIREIN name
-//=======================================================================
+//=================================================================================================
+
static Standard_Boolean WireIN(const TDF_Label& L,
const TDF_LabelMap& Valid,
const TNaming_ListOfNamedShape& Args,
return TCollection_ExtendedString();
}
-//=======================================================================
-// function : GetInteger
-// purpose : Conversion to Integer
-//=======================================================================
+//=================================================================================================
Standard_Boolean LDOMBasicString::GetInteger(Standard_Integer& aResult) const
{
myLength = -1;
}
-//=======================================================================
-// function : getLength
-// purpose : query the data length
-//=======================================================================
+//=================================================================================================
Standard_Integer LDOM_CharacterData::getLength() const
{
void TDF_Attribute::References(const Handle(TDF_DataSet)& /*aDataSet*/) const {}
-//=======================================================================
-// function : DeltaOnAddition
-// purpose : Creates such a delta.
-//=======================================================================
+//=================================================================================================
Handle(TDF_DeltaOnAddition) TDF_Attribute::DeltaOnAddition() const
{
return new TDF_DeltaOnAddition(this);
}
-//=======================================================================
-// function : DeltaOnForget
-// purpose : Creates such a delta.
-//=======================================================================
+//=================================================================================================
Handle(TDF_DeltaOnForget) TDF_Attribute::DeltaOnForget() const
{
return new TDF_DeltaOnForget(this);
}
-//=======================================================================
-// function : DeltaOnResume
-// purpose : Creates such a delta.
-//=======================================================================
+//=================================================================================================
Handle(TDF_DeltaOnResume) TDF_Attribute::DeltaOnResume() const
{
return new TDF_DeltaOnResume(this);
}
-//=======================================================================
-// function : DeltaOnModification
-// purpose : Creates such a delta.
-//=======================================================================
+//=================================================================================================
Handle(TDF_DeltaOnModification) TDF_Attribute::DeltaOnModification(
const Handle(TDF_Attribute)& anOldAttribute) const
return new TDF_DefaultDeltaOnModification(anOldAttribute);
}
-//=======================================================================
-// function : DeltaOnModification
-// purpose : Applies such a delta.
-//=======================================================================
+//=================================================================================================
void TDF_Attribute::DeltaOnModification(const Handle(TDF_DeltaOnModification)& aDelta)
{
Restore(aDelta->Attribute());
}
-//=======================================================================
-// function : DeltaOnRemoval
-// purpose : Creates such a delta.
-//=======================================================================
+//=================================================================================================
Handle(TDF_DeltaOnRemoval) TDF_Attribute::DeltaOnRemoval() const
{
myIDMap.Add(anID);
}
-//=======================================================================
-// function : Ignore
-// purpose : Ignores a list of ID.
-//=======================================================================
+//=================================================================================================
void TDF_IDFilter::Ignore(const TDF_IDList& anIDList)
{
TDF_Tool::ExtendedDeepDump(anOS, aDF->Root(), aFilter);
}
-//=======================================================================
-// function : DeepDump
-// purpose : Deep dump of a label.
-//=======================================================================
+//=================================================================================================
void TDF_Tool::DeepDump(Standard_OStream& anOS, const TDF_Label& aLabel)
{
}
}
-//=======================================================================
-// function : GetValid
-// purpose : Returns valid labels.
-//=======================================================================
+//=================================================================================================
void TFunction_Logbook::GetValid(TDF_LabelMap& Ls) const
{
return new TFunction_Logbook();
}
-//=======================================================================
-// function : Dump
-// purpose : Dump of modifications
-//=======================================================================
+//=================================================================================================
Standard_OStream& TFunction_Logbook::Dump(Standard_OStream& stream) const
{
return (aNbShapes > 0);
}
-//=======================================================================
-// function : readAnnotationPlane
-// purpose : read annotation plane
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean readAnnotationPlane(const Handle(StepVisual_AnnotationPlane)& theAnnotationPlane,
gp_Ax2& thePlane,
const StepData_Factors& theLocalFactors)
IMPLEMENT_STANDARD_RTTIEXT(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx,
StepRepr_RepresentationContext)
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
+
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx()
{
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Init(
const Handle(TCollection_HAsciiString)& aContextIdentifier,
StepRepr_RepresentationContext::Init(aContextIdentifier, aContextType);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Init(
const Handle(TCollection_HAsciiString)& aContextIdentifier,
globalUncertaintyAssignedContext->Init(aContextIdentifier, aContextType, anUncertainty);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::
SetGeometricRepresentationContext(
geometricRepresentationContext = aGeometricRepresentationContext;
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepGeom_GeometricRepresentationContext)
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::GeometricRepresentationContext()
return geometricRepresentationContext;
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetGlobalUnitAssignedContext(
const Handle(StepRepr_GlobalUnitAssignedContext)& aGlobalUnitAssignedContext)
globalUnitAssignedContext = aGlobalUnitAssignedContext;
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepRepr_GlobalUnitAssignedContext)
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::GlobalUnitAssignedContext()
return globalUnitAssignedContext;
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::
SetGlobalUncertaintyAssignedContext(
globalUncertaintyAssignedContext = aGlobalUncertaintyAssignedCtx;
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepRepr_GlobalUncertaintyAssignedContext)
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::
//--- Specific Methods for AND classe field access : GeometricRepresentationContext ---
//-------------------------------------------------------------------------------------
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetCoordinateSpaceDimension(
const Standard_Integer aCoordinateSpaceDimension)
geometricRepresentationContext->SetCoordinateSpaceDimension(aCoordinateSpaceDimension);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Standard_Integer StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::
CoordinateSpaceDimension() const
//--- Specific Methods for AND classe field access : GlobalUnitAssignedContext ---
//---------------------------------------------------------------------------------
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetUnits(
const Handle(StepBasic_HArray1OfNamedUnit)& aUnits)
globalUnitAssignedContext->SetUnits(aUnits);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepBasic_HArray1OfNamedUnit)
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Units() const
return globalUnitAssignedContext->Units();
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepBasic_NamedUnit) StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::
UnitsValue(const Standard_Integer num) const
return globalUnitAssignedContext->UnitsValue(num);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Standard_Integer StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::NbUnits() const
{
//--- Specific Methods for AND classe field access : GlobalUncertaintyAssignedContext ---
//----------------------------------------------------------------------------------------
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
void StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::SetUncertainty(
const Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit)& aUncertainty)
globalUncertaintyAssignedContext->SetUncertainty(aUncertainty);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepBasic_HArray1OfUncertaintyMeasureWithUnit)
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::Uncertainty() const
return globalUncertaintyAssignedContext->Uncertainty();
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Handle(StepBasic_UncertaintyMeasureWithUnit)
StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::UncertaintyValue(
return globalUncertaintyAssignedContext->UncertaintyValue(num);
}
-// --------------------------------------------------------------------------------------------------
-// Method :
-// Purpose :
-// --------------------------------------------------------------------------------------------------
+//=================================================================================================
Standard_Integer StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx::NbUncertainty()
const
return Standard_True;
}
-//=======================================================================
-// function : Value
-// purpose : return resulting wire
-//=======================================================================
+//=================================================================================================
const TopoDS_Wire& StepToTopoDS_TranslateCompositeCurve::Value() const
{
#include <ShapeAnalysis_Curve.hxx>
// Processing of non-manifold topology (ssv; 11.11.2010)
-// ----------------------------------------------------------------------------
-// Constructors
-// ----------------------------------------------------------------------------
+
+//=================================================================================================
+
TopoDSToStep_MakeStepEdge::TopoDSToStep_MakeStepEdge()
: myError(TopoDSToStep_EdgeOther)
{
Init(E, T, FP, theLocalFactors);
}
-// ----------------------------------------------------------------------------
-// Method : Init
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
void TopoDSToStep_MakeStepEdge::Init(const TopoDS_Edge& aEdge,
TopoDSToStep_Tool& aTool,
return;
}
-// ----------------------------------------------------------------------------
-// Method : Value
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
const Handle(StepShape_TopologicalRepresentationItem)& TopoDSToStep_MakeStepEdge::Value() const
{
return myResult;
}
-// ----------------------------------------------------------------------------
-// Method : Error
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
TopoDSToStep_MakeEdgeError TopoDSToStep_MakeStepEdge::Error() const
{
#include <GeomConvert_Units.hxx>
// Processing of non-manifold topology (ssv; 10.11.2010)
-// ----------------------------------------------------------------------------
-// Constructors
-// ----------------------------------------------------------------------------
+
+//=================================================================================================
+
TopoDSToStep_MakeStepFace::TopoDSToStep_MakeStepFace()
: myError(TopoDSToStep_FaceOther)
{
Init(F, T, FP, theLocalFactors);
}
-// ----------------------------------------------------------------------------
-// Method : Init
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TopoDSToStep_MakeStepFace::Init(const TopoDS_Face& aFace,
TopoDSToStep_Tool& aTool,
const Handle(Transfer_FinderProcess)& FP,
}
}
-// ----------------------------------------------------------------------------
-// Method : Value
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
const Handle(StepShape_TopologicalRepresentationItem)& TopoDSToStep_MakeStepFace::Value() const
{
return myResult;
}
-// ----------------------------------------------------------------------------
-// Method : Error
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
TopoDSToStep_MakeFaceError TopoDSToStep_MakeStepFace::Error() const
{
#include <TransferBRep_ShapeMapper.hxx>
// Processing of non-manifold topology (ssv; 11.11.2010)
-// ----------------------------------------------------------------------------
-// Constructors
-// ----------------------------------------------------------------------------
+
+//=================================================================================================
+
TopoDSToStep_MakeStepVertex::TopoDSToStep_MakeStepVertex()
: myError(TopoDSToStep_VertexOther)
{
Init(V, T, FP, theLocalFactors);
}
-// ----------------------------------------------------------------------------
-// Method : Init
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
void TopoDSToStep_MakeStepVertex::Init(const TopoDS_Vertex& aVertex,
TopoDSToStep_Tool& aTool,
myResult = Vpms;
}
-// ----------------------------------------------------------------------------
-// Method : Value
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
const Handle(StepShape_TopologicalRepresentationItem)& TopoDSToStep_MakeStepVertex::Value() const
{
return myResult;
}
-// ----------------------------------------------------------------------------
-// Method : Error
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
TopoDSToStep_MakeVertexError TopoDSToStep_MakeStepVertex::Error() const
{
#include <Transfer_FinderProcess.hxx>
#include <TransferBRep_ShapeMapper.hxx>
-// ----------------------------------------------------------------------------
-// Constructors
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TopoDSToStep_MakeStepWire::TopoDSToStep_MakeStepWire()
: myError(TopoDSToStep_WireOther)
{
Init(W, T, FP, theLocalFactors);
}
-// ----------------------------------------------------------------------------
-// Method : Init
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
void TopoDSToStep_MakeStepWire::Init(const TopoDS_Wire& aWire,
TopoDSToStep_Tool& aTool,
}
}
-// ----------------------------------------------------------------------------
-// Method : Value
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
const Handle(StepShape_TopologicalRepresentationItem)& TopoDSToStep_MakeStepWire::Value() const
{
return myResult;
}
-// ----------------------------------------------------------------------------
-// Method : Error
-// Purpose :
-// ----------------------------------------------------------------------------
+//=================================================================================================
TopoDSToStep_MakeWireError TopoDSToStep_MakeStepWire::Error() const
{
ostr << buff << std::endl;
}
-//=======================================================================
-// function : Dictionary
-// purpose : Return DataMapOfTimer
-//=======================================================================
+//=================================================================================================
MoniTool_DataMapOfTimer& MoniTool_Timer::Dictionary()
{
return 0;
}
-//=======================================================================
-// function : CommitTran
-// purpose : Commits a transaction
-//=======================================================================
+//=================================================================================================
static Standard_Integer CommitTran(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
return 0;
}
-//=======================================================================
-// TreeNode : ChildNodeNextBrother
-// purpose : ChildNodeNext Brother
-//=======================================================================
+//=================================================================================================
static Standard_Integer DDataStd_ChildNodeNextBrother(Draw_Interpretor& /*di*/,
Standard_Integer /*n*/,
return 0;
}
-//=======================================================================
-// function : mtmOpenTransaction
-// purpose : opens new transaction
-//=======================================================================
+//=================================================================================================
static int mtmOpenTransaction(Draw_Interpretor& di, int /*n*/, const char** /*a*/)
{
return aFirstFun;
}
-//=======================================================================
-// function : GetLastFunction
-// purpose : Returns Last function
-//=======================================================================
+//=================================================================================================
+
Handle(TFunction_Function) DNaming::GetLastFunction(const Handle(TDataStd_UAttribute)& theObject)
{
Handle(TFunction_Function) aLastFun;
save.close();
}
#endif
-//=======================================================================
-// function : Execute
-// purpose : Executes the function
-//=======================================================================
+
+//=================================================================================================
+
Standard_Integer DNaming_PrismDriver::Execute(Handle(TFunction_Logbook)& theLog) const
{
Handle(TFunction_Function) aFunction;
return Standard_True;
}
-//=======================================================================
-// function : Execute
-// purpose : Executes the function
-//=======================================================================
+//=================================================================================================
+
Standard_Integer DNaming_RevolutionDriver::Execute(Handle(TFunction_Logbook)& theLog) const
{
Handle(TFunction_Function) aFunction;
return Standard_True;
}
-//=======================================================================
-// function : Execute
-// purpose : Executes the function
-//=======================================================================
+//=================================================================================================
+
Standard_Integer DNaming_SphereDriver::Execute(Handle(TFunction_Logbook)& theLog) const
{
Handle(TFunction_Function) aFunction;
#include <TDF_Label.hxx>
#include <XCAFPrs_Driver.hxx>
-//------------------------------------------------------------------------------------------
-// name : OCC363
-// Purpose :
-//------------------------------------------------------------------------------------------
+//=================================================================================================
+
static Standard_Integer OCC363(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
try
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <Message.hxx>
-//-----------------------------------------------------------------------
-// suppressarg : suppress a[d],modifie na--
-//-----------------------------------------------------------------------
+//=================================================================================================
+
static void suppressarg(Standard_Integer& na, const char** a, const Standard_Integer d)
{
for (Standard_Integer i = d; i < na; i++)
return 0;
}
-//=======================================================================
-// function : noteTimestamp
-// purpose : gets a note timestamp
-//=======================================================================
+//=================================================================================================
+
static const cmd XNoteTimestamp = {"XNoteTimestamp", 3, "XNoteTimestamp Doc note"};
static Standard_Integer noteTimestamp(Draw_Interpretor& di,
PLib::GetPoles(newpoles, NewPoles);
}
-//--------------------------------------------------------------------------
-// ELEMENTARY COMPUTATIONS
-//--------------------------------------------------------------------------
+//=================================================================================================
+
//
// All the following methods are methods of low level used in BSplCLib
// but also in BSplSLib (but not in Geom)
return Standard::AllocateOptimal(theSize);
}
-//=======================================================================
-// function : Free
-// purpose : Standard deallocation
-//=======================================================================
+//=================================================================================================
+
void NCollection_BaseAllocator::Free(void* theAddress)
{
Standard::Free(theAddress);
fDel(p, myAllocator);
}
-//=======================================================================
-// function : Remove
-// purpose : remove a set of items
-//=======================================================================
+//=================================================================================================
void NCollection_BaseSequence::RemoveSeq(const Standard_Integer From,
const Standard_Integer To,
OSD_Environment::OSD_Environment() {}
-// ----------------------------------------------------------------------
-// Constructor
-// ----------------------------------------------------------------------
+//=================================================================================================
OSD_Environment::OSD_Environment(const TCollection_AsciiString& Name)
{
myName = Name;
}
-// ----------------------------------------------------------------------
-// Create an environment variable and initialize it
-// ----------------------------------------------------------------------
+//=================================================================================================
OSD_Environment::OSD_Environment(const TCollection_AsciiString& Name,
const TCollection_AsciiString& Value)
myValue = Value;
}
-// ----------------------------------------------------------------------
-// Returns the name of the symbol
-// ----------------------------------------------------------------------
+//=================================================================================================
TCollection_AsciiString OSD_Environment::Name() const
{
return myName;
}
-// ----------------------------------------------------------------------
-// Set new value for environment variable
-// ----------------------------------------------------------------------
+//=================================================================================================
void OSD_Environment::SetName(const TCollection_AsciiString& Name)
{
myName = Name;
}
-// ----------------------------------------------------------------------
-// Change value
-// ----------------------------------------------------------------------
+//=================================================================================================
void OSD_Environment::SetValue(const TCollection_AsciiString& Value)
{
myValue = Value;
}
-// ----------------------------------------------------------------------
-// Get environment variable physically
-// ----------------------------------------------------------------------
+//=================================================================================================
TCollection_AsciiString OSD_Environment::Value()
{
return myValue;
}
-// ----------------------------------------------------------------------
-// Sets physically the environment variable
-// ----------------------------------------------------------------------
+//=================================================================================================
void OSD_Environment::Build()
{
myError.SetValue(errno, Iam, "Set Environment");
}
-// ----------------------------------------------------------------------
-// Remove physically the environment variable
-// ----------------------------------------------------------------------
+//=================================================================================================
void OSD_Environment::Remove()
{
return (char*)dlerror();
}
-// ----------------------------------------------------------------------------
-// Destroy
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void OSD_SharedLibrary::Destroy()
{
if (myName != NULL)
}
}
-//=======================================================================
-// function : Difference
-// purpose : Boolean operation XOR
-//=======================================================================
+//=================================================================================================
void TColStd_PackedMapOfInteger::Difference(const TColStd_PackedMapOfInteger& theMap1,
const TColStd_PackedMapOfInteger& theMap2)
}
}
-//=======================================================================
-// function : Differ
-// purpose : Boolean operation XOR
-//=======================================================================
+//=================================================================================================
Standard_Boolean TColStd_PackedMapOfInteger::Differ(const TColStd_PackedMapOfInteger& theMap)
{
}
} // namespace
-// ----------------------------------------------------------------------------
-// Create an empty AsciiString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString()
{
allocate(0);
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from a Standard_CString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_CString theString)
{
if (theString == NULL)
memcpy(mystring, theString, mylength);
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from a Standard_CString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_CString theString,
const Standard_Integer theLen)
{
memcpy(mystring, theString, mylength);
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from a Standard_Character
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_Character aChar)
{
if (aChar != '\0')
}
}
-// ----------------------------------------------------------------------------
-// Create an AsciiString from a filler
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_Integer length,
const Standard_Character filler)
{
memset(mystring, filler, length);
}
-// ----------------------------------------------------------------------------
-// Create an AsciiString from an Integer
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_Integer aValue)
{
char t[13];
memcpy(mystring, t, mylength);
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from a real
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_Real aValue)
{
char t[50];
memcpy(mystring, t, mylength);
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from an asciistring
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const TCollection_AsciiString& theString)
{
allocate(theString.mylength);
theOther.mystring = THE_DEFAULT_CHAR_STRING;
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from a character
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const TCollection_AsciiString& theString,
const Standard_Character theChar)
{
mystring[mylength - 1] = theChar;
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from an asciistring
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const TCollection_AsciiString& theString1,
const Standard_CString theString2)
{
}
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from an asciistring
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const TCollection_AsciiString& theString1,
const TCollection_AsciiString& theString2)
{
}
}
-//---------------------------------------------------------------------------
-// Create an asciistring from an ExtendedString
-//---------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const TCollection_ExtendedString& astring,
const Standard_Character replaceNonAscii)
{
}
}
-//---------------------------------------------------------------------------
-// Create an TCollection_AsciiString from a Standard_WideChar
-//---------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::TCollection_AsciiString(const Standard_WideChar* theStringUtf)
{
int aLength = 0;
}
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::AssignCat(const Standard_Integer other)
{
AssignCat(TCollection_AsciiString(other));
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::AssignCat(const Standard_Real other)
{
AssignCat(TCollection_AsciiString(other));
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::AssignCat(const Standard_Character other)
{
if (other != '\0')
}
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::AssignCat(const Standard_CString theOther)
{
if (theOther == NULL)
}
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::AssignCat(const TCollection_AsciiString& theOther)
{
if (theOther.mylength != 0)
}
}
-// ---------------------------------------------------------------------------
-// Capitalize
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Capitalize()
{
if (mylength)
mystring[i] = ::LowerCase(mystring[i]);
}
-// ---------------------------------------------------------------------------
-// Center
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Center(const Standard_Integer Width, const Standard_Character Filler)
{
if (Width > mylength)
}
}
-// ----------------------------------------------------------------------------
-// ChangeAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::ChangeAll(const Standard_Character aChar,
const Standard_Character NewChar,
const Standard_Boolean CaseSensitive)
}
}
-// ----------------------------------------------------------------------------
-// Clear
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Clear()
{
deallocate();
}
-// ----------------------------------------------------------------------------
-// Copy
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Copy(const Standard_CString fromwhere)
{
if (fromwhere == mystring)
}
}
-// ----------------------------------------------------------------------------
-// Copy
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Copy(const TCollection_AsciiString& fromwhere)
{
if (&fromwhere == this)
theOther.mylength = 0;
}
-// ----------------------------------------------------------------------------
-// Swap
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Swap(TCollection_AsciiString& theOther)
{
if (&theOther == this)
std::swap(mylength, theOther.mylength);
}
-// ----------------------------------------------------------------------------
-// Destroy
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString::~TCollection_AsciiString()
{
deallocate();
}
-// ----------------------------------------------------------------------------
-// FirstLocationInSet
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::FirstLocationInSet(const TCollection_AsciiString& Set,
const Standard_Integer FromIndex,
const Standard_Integer ToIndex) const
throw Standard_OutOfRange();
}
-// ----------------------------------------------------------------------------
-// FirstLocationNotInSet
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::FirstLocationNotInSet(
const TCollection_AsciiString& Set,
const Standard_Integer FromIndex,
throw Standard_OutOfRange();
}
-//----------------------------------------------------------------------------
-// Insert a character before 'where'th character
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Insert(const Standard_Integer where, const Standard_Character what)
{
if (where > mylength + 1)
mystring[where - 1] = what;
}
-// ----------------------------------------------------------------------------
-// Insert
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Insert(const Standard_Integer where, const Standard_CString what)
{
if (where <= mylength + 1 && where > 0)
}
}
-// ----------------------------------------------------------------------------
-// Insert
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Insert(const Standard_Integer where,
const TCollection_AsciiString& what)
{
}
}
-//------------------------------------------------------------------------
-// InsertAfter
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::InsertAfter(const Standard_Integer Index,
const TCollection_AsciiString& what)
{
Insert(Index + 1, what);
}
-//------------------------------------------------------------------------
-// InsertBefore
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::InsertBefore(const Standard_Integer Index,
const TCollection_AsciiString& what)
{
Insert(Index, what);
}
-// ----------------------------------------------------------------------------
-// IsEqual
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsEqual(const Standard_CString other) const
{
if (other)
"Parameter 'other'");
}
-// ----------------------------------------------------------------------------
-// IsEqual
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsEqual(const TCollection_AsciiString& other) const
{
if (mylength != other.mylength)
return (strncmp(other.mystring, mystring, mylength) == 0);
}
-// ----------------------------------------------------------------------------
-// IsSameString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsSameString(const TCollection_AsciiString& theString1,
const TCollection_AsciiString& theString2,
const Standard_Boolean theIsCaseSensitive)
return Standard_True;
}
-// ----------------------------------------------------------------------------
-// IsDifferent
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsDifferent(const Standard_CString other) const
{
if (other)
"Parameter 'other'");
}
-// ----------------------------------------------------------------------------
-// IsDifferent
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsDifferent(const TCollection_AsciiString& other) const
{
return (strncmp(other.mystring, mystring, mylength) != 0);
}
-// ----------------------------------------------------------------------------
-// IsLess
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsLess(const Standard_CString other) const
{
if (other)
"Parameter 'other'");
}
-// ----------------------------------------------------------------------------
-// IsLess
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsLess(const TCollection_AsciiString& other) const
{
return (strncmp(mystring, other.mystring, mylength + 1) < 0);
}
-// ----------------------------------------------------------------------------
-// IsGreater
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsGreater(const Standard_CString other) const
{
if (other)
"Parameter 'other'");
}
-// ----------------------------------------------------------------------------
-// IsGreater
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsGreater(const TCollection_AsciiString& other) const
{
return (strncmp(mystring, other.mystring, mylength + 1) > 0);
}
-// ----------------------------------------------------------------------------
-// StartsWith
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::StartsWith(
const TCollection_AsciiString& theStartString) const
{
&& strncmp(theStartString.mystring, mystring, theStartString.mylength) == 0;
}
-// ----------------------------------------------------------------------------
-// EndsWith
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::EndsWith(
const TCollection_AsciiString& theEndString) const
{
== 0;
}
-// ----------------------------------------------------------------------------
-// IntegerValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::IntegerValue() const
{
char* ptr;
throw Standard_NumericError("TCollection_AsciiString::IntegerValue");
}
-// ----------------------------------------------------------------------------
-// IsIntegerValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsIntegerValue() const
{
char* ptr;
return Standard_False;
}
-// ----------------------------------------------------------------------------
-// IsRealValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsRealValue(Standard_Boolean theToCheckFull) const
{
char* ptr;
}
}
-// ----------------------------------------------------------------------------
-// IsAscii
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_AsciiString::IsAscii() const
{
// LD : Debuggee le 26/11/98
return Standard_True;
}
-//------------------------------------------------------------------------
-// LeftAdjust
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::LeftAdjust()
{
Standard_Integer i;
Remove(1, i);
}
-//------------------------------------------------------------------------
-// LeftJustify
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::LeftJustify(const Standard_Integer Width,
const Standard_Character Filler)
{
}
}
-//------------------------------------------------------------------------
-// Location
-//------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::Location(const Standard_Integer N,
const Standard_Character C,
const Standard_Integer FromIndex,
throw Standard_OutOfRange();
}
-//------------------------------------------------------------------------
-// Location
-//------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::Location(const TCollection_AsciiString& what,
const Standard_Integer FromIndex,
const Standard_Integer ToIndex) const
throw Standard_OutOfRange();
}
-// ----------------------------------------------------------------------------
-// LowerCase
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::LowerCase()
{
for (int i = 0; i < mylength; i++)
mystring[i] = ::LowerCase(mystring[i]);
}
-//------------------------------------------------------------------------
-// Prepend
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Prepend(const TCollection_AsciiString& what)
{
Insert(1, what);
}
-// ----------------------------------------------------------------------------
-// RealValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Real TCollection_AsciiString::RealValue() const
{
char* ptr;
throw Standard_NumericError("TCollection_AsciiString::RealValue");
}
-// ----------------------------------------------------------------------------
-// Read
-//--------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Read(Standard_IStream& astream)
{
// get characters from astream
return astream;
}
-// ----------------------------------------------------------------------------
-// Print
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Print(Standard_OStream& astream) const
{
if (mystring)
return astream;
}
-// ----------------------------------------------------------------------------
-// RemoveAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::RemoveAll(const Standard_Character what,
const Standard_Boolean CaseSensitive)
{
mystring[mylength] = '\0';
}
-// ----------------------------------------------------------------------------
-// RemoveAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::RemoveAll(const Standard_Character what)
{
RemoveAll(what, Standard_True);
}
-// ----------------------------------------------------------------------------
-// Remove
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Remove(const Standard_Integer where, const Standard_Integer ahowmany)
{
if (where + ahowmany <= mylength + 1)
}
}
-//------------------------------------------------------------------------
-// RightAdjust
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::RightAdjust()
{
Standard_Integer i;
Remove(i + 2, mylength - (i + 2) + 1);
}
-//------------------------------------------------------------------------
-// RightJustify
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::RightJustify(const Standard_Integer Width,
const Standard_Character Filler)
{
}
}
-// ----------------------------------------------------------------------------
-// Search
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::Search(const Standard_CString what) const
{
Standard_Integer size = Standard_Integer(what ? strlen(what) : 0);
return -1;
}
-// ----------------------------------------------------------------------------
-// Search
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::Search(const TCollection_AsciiString& what) const
{
Standard_Integer size = what.mylength;
return -1;
}
-// ----------------------------------------------------------------------------
-// SearchFromEnd
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::SearchFromEnd(const Standard_CString what) const
{
Standard_Integer size = Standard_Integer(what ? strlen(what) : 0);
return -1;
}
-// ----------------------------------------------------------------------------
-// SearchFromEnd
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::SearchFromEnd(const TCollection_AsciiString& what) const
{
int size = what.mylength;
return -1;
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::SetValue(const Standard_Integer theWhere,
const Standard_Character theWhat)
{
mystring[theWhere - 1] = theWhat;
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::SetValue(const Standard_Integer where, const Standard_CString what)
{
if (where > 0 && where <= mylength + 1)
}
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::SetValue(const Standard_Integer where,
const TCollection_AsciiString& what)
{
}
}
-// ----------------------------------------------------------------------------
-// Split
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString TCollection_AsciiString::Split(const Standard_Integer where)
{
if (where >= 0 && where <= mylength)
throw Standard_OutOfRange("TCollection_AsciiString::Split index");
}
-// ----------------------------------------------------------------------------
-// Token
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_AsciiString TCollection_AsciiString::Token(const Standard_CString separators,
const Standard_Integer whichone) const
{
return TCollection_AsciiString(&mystring[BeginIndex - 1], EndIndex - BeginIndex + 1);
}
-// ----------------------------------------------------------------------------
-// Trunc
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::Trunc(const Standard_Integer ahowmany)
{
if (ahowmany < 0 || ahowmany > mylength)
mystring[mylength] = '\0';
}
-// ----------------------------------------------------------------------------
-// UpperCase
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_AsciiString::UpperCase()
{
for (int i = 0; i < mylength; i++)
mystring[i] = ::UpperCase(mystring[i]);
}
-//------------------------------------------------------------------------
-// UsefullLength
-//------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_AsciiString::UsefullLength() const
{
Standard_Integer i;
return i + 1;
}
-// ----------------------------------------------------------------------------
-// Value
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Character TCollection_AsciiString::Value(const Standard_Integer where) const
{
if (where > 0 && where <= mylength)
};
} // namespace std
-//------------------------------------------------------------------------
-// IsEqual
-//------------------------------------------------------------------------
+//=================================================================================================
+
inline Standard_Boolean IsEqual(const TCollection_AsciiString& string1,
const TCollection_AsciiString& string2)
{
return TCollection_AsciiString::IsEqual(string1, string2);
}
-// ----------------------------------------------------------------------------
-// ToCString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
inline Standard_CString TCollection_AsciiString::ToCString() const
{
return mystring;
return opencascade::hashBytes(mystring, mylength);
}
-//------------------------------------------------------------------------
-// IsEqual
-//------------------------------------------------------------------------
+//=================================================================================================
+
inline Standard_Boolean TCollection_AsciiString::IsEqual(const TCollection_AsciiString& string1,
const TCollection_AsciiString& string2)
{
return string1.IsEqual(string2);
}
-//------------------------------------------------------------------------
-// IsEqual
-//------------------------------------------------------------------------
+//=================================================================================================
+
inline Standard_Boolean TCollection_AsciiString::IsEqual(const TCollection_AsciiString& string1,
const Standard_CString string2)
{
return string1.IsEqual(string2);
}
-// ----------------------------------------------------------------------------
-// SubString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
inline TCollection_AsciiString TCollection_AsciiString::SubString(
const Standard_Integer FromIndex,
const Standard_Integer ToIndex) const
} // namespace
-//-----------------------------------------------------------------------------
-// Create an empty ExtendedString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString()
{
allocate(0);
}
-//----------------------------------------------------------------------------
-// Create an ExtendedString from a Standard_CString
-//----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_CString theString,
const Standard_Boolean isMultiByte)
{
}
}
-//---------------------------------------------------------------------------
-// Create an ExtendedString from an ExtString
-//--------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_ExtString theString)
{
if (theString == NULL)
memcpy(mystring, theString, mylength * sizeof(Standard_ExtCharacter));
}
-// ----------------------------------------------------------------------------
-// TCollection_ExtendedString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_WideChar* theStringUtf)
{
if (theStringUtf == NULL)
mystring = fromWideString<sizeof(Standard_WideChar)>(theStringUtf, mylength);
}
-// ----------------------------------------------------------------------------
-// Create an asciistring from a Standard_Character
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Character aChar)
{
if (aChar != '\0')
}
}
-//--------------------------------------------------------------------------
-// Create a string from a ExtCharacter
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_ExtCharacter aChar)
{
allocate(1);
mystring[0] = aChar;
}
-// ----------------------------------------------------------------------------
-// Create an AsciiString from a filler
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Integer length,
const Standard_ExtCharacter filler)
{
mystring[i] = filler;
}
-// ----------------------------------------------------------------------------
-// Create a String from an Integer
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Integer aValue)
{
union {
mystring[i] = ToExtCharacter(CHN.t[i]);
}
-// ----------------------------------------------------------------------------
-// Create a String from a real
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Real aValue)
{
union {
mystring[i] = ToExtCharacter(CHN.t[i]);
}
-//-----------------------------------------------------------------------------
-// create an extendedstring from an extendedstring
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const TCollection_ExtendedString& theOther)
{
allocate(theOther.mylength);
theOther.mylength = 0;
}
-//---------------------------------------------------------------------------
-// Create an extendedstring from an AsciiString
-//---------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::TCollection_ExtendedString(const TCollection_AsciiString& theString,
const Standard_Boolean isMultiByte)
{
}
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::AssignCat(const TCollection_ExtendedString& theOther)
{
if (theOther.mylength == 0)
memcpy(mystring + anOldLength, theOther.mystring, anOtherLength * sizeof(Standard_ExtCharacter));
}
-// ----------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::AssignCat(const Standard_Utf16Char theChar)
{
if (theChar != '\0')
}
}
-// ----------------------------------------------------------------------------
-// Cat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString TCollection_ExtendedString::Cat(
const TCollection_ExtendedString& other) const
{
return res;
}
-// ----------------------------------------------------------------------------
-// ChangeAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::ChangeAll(const Standard_ExtCharacter aChar,
const Standard_ExtCharacter NewChar)
{
mystring[i] = NewChar;
}
-// ----------------------------------------------------------------------------
-// Clear
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Clear()
{
deallocate();
}
-// ----------------------------------------------------------------------------
-// Copy
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Copy(const TCollection_ExtendedString& fromwhere)
{
if (&fromwhere == this)
theOther.mylength = 0;
}
-// ----------------------------------------------------------------------------
-// Swap
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Swap(TCollection_ExtendedString& theOther)
{
if (&theOther == this)
std::swap(mylength, theOther.mylength);
}
-// ----------------------------------------------------------------------------
-// Destroy
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString::~TCollection_ExtendedString()
{
deallocate();
}
-//----------------------------------------------------------------------------
-// Insert a character before 'where'th character
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Insert(const Standard_Integer where,
const Standard_ExtCharacter what)
{
mystring[where - 1] = what;
}
-// ----------------------------------------------------------------------------
-// Insert
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Insert(const Standard_Integer where,
const TCollection_ExtendedString& what)
{
}
}
-// ----------------------------------------------------------------------------
-// ExtStrCmp: strcmp for 16-bit chars
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
static int ExtStrCmp(const Standard_ExtString theStr1, const Standard_ExtString theStr2)
{
const Standard_ExtCharacter* aStr1 = theStr1;
return *aStr1 - *aStr2;
}
-// ----------------------------------------------------------------------------
-// IsEqual
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsEqual(const Standard_ExtString other) const
{
return ExtStrCmp(mystring, other) == 0;
}
-// ----------------------------------------------------------------------------
-// IsEqual
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsEqual(const TCollection_ExtendedString& other) const
{
return mylength == other.mylength
&& memcmp(mystring, other.mystring, (mylength + 1) * sizeof(Standard_ExtCharacter)) == 0;
}
-// ----------------------------------------------------------------------------
-// IsDifferent
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsDifferent(const Standard_ExtString other) const
{
return ExtStrCmp(mystring, other) != 0;
}
-// ----------------------------------------------------------------------------
-// IsDifferent
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsDifferent(
const TCollection_ExtendedString& other) const
{
|| memcmp(mystring, other.mystring, (mylength + 1) * sizeof(Standard_ExtCharacter)) != 0;
}
-// ----------------------------------------------------------------------------
-// IsLess
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsLess(const Standard_ExtString other) const
{
return ExtStrCmp(mystring, other) < 0;
}
-// ----------------------------------------------------------------------------
-// IsLess
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsLess(const TCollection_ExtendedString& other) const
{
return ExtStrCmp(mystring, other.mystring) < 0;
}
-// ----------------------------------------------------------------------------
-// IsGreater
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsGreater(const Standard_ExtString other) const
{
return ExtStrCmp(mystring, other) > 0;
}
-// ----------------------------------------------------------------------------
-// IsGreater
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsGreater(
const TCollection_ExtendedString& other) const
{
return ExtStrCmp(mystring, other.mystring) > 0;
}
-// ----------------------------------------------------------------------------
-// StartsWith
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::StartsWith(
const TCollection_ExtendedString& theStartString) const
{
== 0;
}
-// ----------------------------------------------------------------------------
-// EndsWith
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::EndsWith(
const TCollection_ExtendedString& theEndString) const
{
== 0;
}
-// ----------------------------------------------------------------------------
-// IsAscii
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::IsAscii() const
{
for (Standard_Integer i = 0; i < mylength; i++)
return Standard_True;
}
-//------------------------------------------------------------------------
-// Length
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_ExtendedString::Length() const
{
return mylength;
}
-// ----------------------------------------------------------------------------
-// Print
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Print(Standard_OStream& theStream) const
{
if (mylength > 0)
return astream;
}
-// ----------------------------------------------------------------------------
-// RemoveAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::RemoveAll(const Standard_ExtCharacter what)
{
mystring[mylength] = '\0';
}
-// ----------------------------------------------------------------------------
-// Remove
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Remove(const Standard_Integer where,
const Standard_Integer ahowmany)
{
"invalid starting value.");
}
-// ----------------------------------------------------------------------------
-// Search
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_ExtendedString::Search(const TCollection_ExtendedString& what) const
{
Standard_Integer size = what.mylength;
return -1;
}
-// ----------------------------------------------------------------------------
-// SearchFromEnd
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_ExtendedString::SearchFromEnd(
const TCollection_ExtendedString& what) const
{
return -1;
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::SetValue(const Standard_Integer where,
const Standard_ExtCharacter what)
{
}
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::SetValue(const Standard_Integer where,
const TCollection_ExtendedString& what)
{
"parameter where");
}
-// ----------------------------------------------------------------------------
-// Split
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString TCollection_ExtendedString::Split(const Standard_Integer where)
{
if (where >= 0 && where < mylength)
throw Standard_OutOfRange("TCollection_ExtendedString::Split index");
}
-// ----------------------------------------------------------------------------
-// Token
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_ExtendedString TCollection_ExtendedString::Token(const Standard_ExtString separators,
const Standard_Integer whichone) const
{
return res;
}
-// ----------------------------------------------------------------------------
-// ToExtString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_ExtString TCollection_ExtendedString::ToExtString() const
{
return mystring;
}
-// ----------------------------------------------------------------------------
-// Trunc
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_ExtendedString::Trunc(const Standard_Integer ahowmany)
{
if (ahowmany < 0 || ahowmany > mylength)
mystring[mylength] = '\0';
}
-// ----------------------------------------------------------------------------
-// Value
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_ExtCharacter TCollection_ExtendedString::Value(const Standard_Integer where) const
{
if (where > 0 && where <= mylength)
"parameter where");
}
-//----------------------------------------------------------------------------
-// Convert CString (including multibyte case) to UniCode representation
-//----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_ExtendedString::ConvertToUnicode(const Standard_CString theStringUtf)
{
NCollection_Utf8Iter anIterRead(theStringUtf);
IMPLEMENT_STANDARD_RTTIEXT(TCollection_HAsciiString, Standard_Transient)
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString()
: myString()
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const Standard_CString message)
: myString(message)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const TCollection_AsciiString& astring)
: myString(astring)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const Standard_Character aChar)
: myString(aChar)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const Standard_Integer length,
const Standard_Character filler)
: myString(length, filler)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const Standard_Integer aValue)
: myString(aValue)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const Standard_Real aValue)
: myString(aValue)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(const Handle(TCollection_HAsciiString)& astring)
: myString(astring->String())
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HAsciiString::TCollection_HAsciiString(
const Handle(TCollection_HExtendedString)& astring,
const Standard_Character replaceNonAscii)
{
}
-// ---------------------------------------------------------------------------
-// Capitalize
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Capitalize()
{
myString.Capitalize();
}
-// ---------------------------------------------------------------------------
-// Cat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HAsciiString) TCollection_HAsciiString::Cat(const Standard_CString other) const
{
return new TCollection_HAsciiString(myString.Cat(other));
}
-// ---------------------------------------------------------------------------
-// Cat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HAsciiString) TCollection_HAsciiString::Cat(
const Handle(TCollection_HAsciiString)& other) const
{
return new TCollection_HAsciiString(myString.Cat(other->String()));
}
-// ---------------------------------------------------------------------------
-// Center
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Center(const Standard_Integer Width, const Standard_Character Filler)
{
if (Width < 0)
myString.Center(Width, Filler);
}
-// ----------------------------------------------------------------------------
-// ChangeAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::ChangeAll(const Standard_Character aChar,
const Standard_Character NewChar,
const Standard_Boolean CaseSensitive)
myString.ChangeAll(aChar, NewChar, CaseSensitive);
}
-// ----------------------------------------------------------------------------
-// Clear
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Clear()
{
myString.Clear();
}
-// ----------------------------------------------------------------------------
-// FirstLocationInSet
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::FirstLocationInSet(
const Handle(TCollection_HAsciiString)& Set,
const Standard_Integer FromIndex,
return (myString.FirstLocationInSet(Set->String(), FromIndex, ToIndex));
}
-// ----------------------------------------------------------------------------
-// FirstLocationNotInSet
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::FirstLocationNotInSet(
const Handle(TCollection_HAsciiString)& Set,
const Standard_Integer FromIndex,
return (myString.FirstLocationNotInSet(Set->String(), FromIndex, ToIndex));
}
-// ----------------------------------------------------------------------------
-// Insert a Standard_Character before 'where'th Standard_Character
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Insert(const Standard_Integer where, const Standard_Character what)
{
myString.Insert(where, what);
}
-// ----------------------------------------------------------------------------
-// Insert
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Insert(const Standard_Integer where, const Standard_CString what)
{
myString.Insert(where, what);
}
-// ----------------------------------------------------------------------------
-// Insert
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Insert(const Standard_Integer where,
const Handle(TCollection_HAsciiString)& what)
{
myString.Insert(where, what->String());
}
-//------------------------------------------------------------------------
-// InsertAfter
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::InsertAfter(const Standard_Integer Index,
const Handle(TCollection_HAsciiString)& S)
{
myString.InsertAfter(Index, S->String());
}
-//------------------------------------------------------------------------
-// InsertBefore
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::InsertBefore(const Standard_Integer Index,
const Handle(TCollection_HAsciiString)& S)
{
myString.InsertBefore(Index, S->String());
}
-// ----------------------------------------------------------------------------
-// IsEmpty
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsEmpty() const
{
return (myString.Length() == 0);
}
-// ----------------------------------------------------------------------------
-// IsLess
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsLess(
const Handle(TCollection_HAsciiString)& other) const
{
return myString.IsLess(other->String());
}
-// ----------------------------------------------------------------------------
-// IsGreater
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsGreater(
const Handle(TCollection_HAsciiString)& other) const
{
return myString.IsGreater(other->String());
}
-// ----------------------------------------------------------------------------
-// IntegerValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::IntegerValue() const
{
return myString.IntegerValue();
}
-// ----------------------------------------------------------------------------
-// IsIntegerValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsIntegerValue() const
{
return myString.IsIntegerValue();
}
-// ----------------------------------------------------------------------------
-// IsRealvalue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsRealValue() const
{
return myString.IsRealValue();
}
-// ----------------------------------------------------------------------------
-// IsAscii
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsAscii() const
{
return myString.IsAscii();
}
-// ----------------------------------------------------------------------------
-// IsDifferent
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsDifferent(
const Handle(TCollection_HAsciiString)& S) const
{
return (strncmp(myString.ToCString(), S->ToCString(), myString.Length()) != 0);
}
-// ----------------------------------------------------------------------------
-// IsSameString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsSameString(
const Handle(TCollection_HAsciiString)& S) const
{
return Standard_False;
}
-// ----------------------------------------------------------------------------
-// IsSameString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsSameString(const Handle(TCollection_HAsciiString)& S,
const Standard_Boolean CaseSensitive) const
{
return TCollection_AsciiString::IsSameString(myString, S->myString, CaseSensitive);
}
-//------------------------------------------------------------------------
-// LeftAdjust
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::LeftAdjust()
{
myString.LeftAdjust();
}
-//------------------------------------------------------------------------
-// LeftJustify
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::LeftJustify(const Standard_Integer Width,
const Standard_Character Filler)
{
myString.LeftJustify(Width, Filler);
}
-//------------------------------------------------------------------------
-// Location
-//------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::Location(const Standard_Integer N,
const Standard_Character C,
const Standard_Integer FromIndex,
return myString.Location(N, C, FromIndex, ToIndex);
}
-//------------------------------------------------------------------------
-// Location
-//------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::Location(const Handle(TCollection_HAsciiString)& S,
const Standard_Integer FromIndex,
const Standard_Integer ToIndex) const
return myString.Location(S->String(), FromIndex, ToIndex);
}
-// ----------------------------------------------------------------------------
-// LowerCase
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::LowerCase()
{
myString.LowerCase();
}
-//------------------------------------------------------------------------
-// Prepend
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Prepend(const Handle(TCollection_HAsciiString)& S)
{
myString.Prepend(S->String());
myString.Print(S);
}
-// ----------------------------------------------------------------------------
-// RealValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Real TCollection_HAsciiString::RealValue() const
{
return myString.RealValue();
}
-// ----------------------------------------------------------------------------
-// RemoveAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::RemoveAll(const Standard_Character what,
const Standard_Boolean CaseSensitive)
{
myString.RemoveAll(what, CaseSensitive);
}
-// ----------------------------------------------------------------------------
-// RemoveAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::RemoveAll(const Standard_Character what)
{
myString.RemoveAll(what);
}
-// ----------------------------------------------------------------------------
-// Remove
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Remove(const Standard_Integer where, const Standard_Integer ahowmany)
{
myString.Remove(where, ahowmany);
}
-//------------------------------------------------------------------------
-// RightAdjust
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::RightAdjust()
{
myString.RightAdjust();
}
-//------------------------------------------------------------------------
-// RightJustify
-//------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::RightJustify(const Standard_Integer Width,
const Standard_Character Filler)
{
myString.RightJustify(Width, Filler);
}
-// ----------------------------------------------------------------------------
-// Search
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::Search(const Standard_CString what) const
{
return myString.Search(what);
}
-// ----------------------------------------------------------------------------
-// Search
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::Search(
const Handle(TCollection_HAsciiString)& what) const
{
return myString.Search(what->String());
}
-// ----------------------------------------------------------------------------
-// SearchFromEnd
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::SearchFromEnd(const Standard_CString what) const
{
return myString.SearchFromEnd(what);
}
-// ----------------------------------------------------------------------------
-// SearchFromEnd
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::SearchFromEnd(
const Handle(TCollection_HAsciiString)& what) const
{
return myString.SearchFromEnd(what->String());
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::SetValue(const Standard_Integer where, const Standard_Character what)
{
myString.SetValue(where, what);
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::SetValue(const Standard_Integer where, const Standard_CString what)
{
myString.SetValue(where, what);
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ---------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::SetValue(const Standard_Integer where,
const Handle(TCollection_HAsciiString)& what)
{
myString.SetValue(where, what->String());
}
-// ----------------------------------------------------------------------------
-// Split
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HAsciiString) TCollection_HAsciiString::Split(const Standard_Integer where)
{
return new TCollection_HAsciiString(myString.Split(where));
}
-// ----------------------------------------------------------------------------
-// SubString
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HAsciiString) TCollection_HAsciiString::SubString(
const Standard_Integer FromIndex,
const Standard_Integer ToIndex) const
return new TCollection_HAsciiString(myString.SubString(FromIndex, ToIndex));
}
-// ----------------------------------------------------------------------------
-// Token
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HAsciiString) TCollection_HAsciiString::Token(
const Standard_CString separators,
const Standard_Integer whichone) const
return new TCollection_HAsciiString(myString.Token(separators, whichone));
}
-// ----------------------------------------------------------------------------
-// Trunc
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::Trunc(const Standard_Integer ahowmany)
{
myString.Trunc(ahowmany);
}
-// ----------------------------------------------------------------------------
-// UpperCase
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HAsciiString::UpperCase()
{
myString.UpperCase();
}
-// ----------------------------------------------------------------------------
-// UsefullLength
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HAsciiString::UsefullLength() const
{
return myString.UsefullLength();
}
-// ----------------------------------------------------------------------------
-// Value
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Character TCollection_HAsciiString::Value(const Standard_Integer where) const
{
return myString.Value(where);
}
-// ----------------------------------------------------------------------------
-// IsSameState
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HAsciiString::IsSameState(
const Handle(TCollection_HAsciiString)& other) const
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-// ---------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
inline void TCollection_HAsciiString::AssignCat(const Standard_CString other)
{
myString.AssignCat(other);
}
-// ---------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
inline void TCollection_HAsciiString::AssignCat(const Handle(TCollection_HAsciiString)& other)
{
myString.AssignCat(other->String());
}
-// ----------------------------------------------------------------------------
-// Length
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
inline Standard_Integer TCollection_HAsciiString::Length() const
{
return myString.mylength;
}
-// ----------------------------------------------------------------------------
-// String
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
inline const TCollection_AsciiString& TCollection_HAsciiString::String() const
{
return myString;
IMPLEMENT_STANDARD_RTTIEXT(TCollection_HExtendedString, Standard_Transient)
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString() {}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(const Standard_CString message)
: myString(message)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(const Standard_ExtString message)
: myString(message)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(const Standard_ExtCharacter aChar)
: myString(aChar)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(const Standard_Integer length,
const Standard_ExtCharacter filler)
: myString(length, filler)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(const TCollection_ExtendedString& astring)
: myString(astring)
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(
const Handle(TCollection_HAsciiString)& astring)
: myString(astring->String())
{
}
-// ----------------------------------------------------------------------------
-// Create
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
TCollection_HExtendedString::TCollection_HExtendedString(
const Handle(TCollection_HExtendedString)& astring)
: myString(astring->ChangeString())
{
}
-// ---------------------------------------------------------------------------
-// AssignCat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::AssignCat(const Handle(TCollection_HExtendedString)& other)
{
myString.AssignCat(other->ChangeString());
}
-// ---------------------------------------------------------------------------
-// Cat
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HExtendedString) TCollection_HExtendedString::Cat(
const Handle(TCollection_HExtendedString)& other) const
{
return new TCollection_HExtendedString(myString.Cat(other->ChangeString()));
}
-// ----------------------------------------------------------------------------
-// ChangeAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::ChangeAll(const Standard_ExtCharacter aChar,
const Standard_ExtCharacter NewChar)
{
myString.ChangeAll(aChar, NewChar);
}
-// ----------------------------------------------------------------------------
-// IsEmpty
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HExtendedString::IsEmpty() const
{
return (myString.Length() == 0);
}
-// ----------------------------------------------------------------------------
-// Clear
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::Clear()
{
myString.Clear();
}
-// ----------------------------------------------------------------------------
-// Insert a Standard_ExtCharacter before 'where'th Standard_ExtCharacter
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::Insert(const Standard_Integer where,
const Standard_ExtCharacter what)
{
myString.Insert(where, what);
}
-// ----------------------------------------------------------------------------
-// Insert
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::Insert(const Standard_Integer where,
const Handle(TCollection_HExtendedString)& what)
{
myString.Insert(where, what->ChangeString());
}
-// ----------------------------------------------------------------------------
-// IsLess
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HExtendedString::IsLess(
const Handle(TCollection_HExtendedString)& other) const
{
return myString.IsLess(other->ChangeString());
}
-// ----------------------------------------------------------------------------
-// IsGreater
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HExtendedString::IsGreater(
const Handle(TCollection_HExtendedString)& other) const
{
return myString.IsGreater(other->ChangeString());
}
-// ----------------------------------------------------------------------------
-// IsAscii
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HExtendedString::IsAscii() const
{
return myString.IsAscii();
}
-// ----------------------------------------------------------------------------
-// Length
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HExtendedString::Length() const
{
return myString.Length();
}
-// ----------------------------------------------------------------------------
-// Remove
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::Remove(const Standard_Integer where,
const Standard_Integer ahowmany)
{
myString.Remove(where, ahowmany);
}
-// ----------------------------------------------------------------------------
-// RemoveAll
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::RemoveAll(const Standard_ExtCharacter what)
{
myString.RemoveAll(what);
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::SetValue(const Standard_Integer where,
const Standard_ExtCharacter what)
{
myString.SetValue(where, what);
}
-// ----------------------------------------------------------------------------
-// SetValue
-// ---------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::SetValue(const Standard_Integer where,
const Handle(TCollection_HExtendedString)& what)
{
myString.SetValue(where, what->ChangeString());
}
-// ----------------------------------------------------------------------------
-// Split
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HExtendedString) TCollection_HExtendedString::Split(const Standard_Integer where)
{
return new TCollection_HExtendedString(myString.Split(where));
}
-// ----------------------------------------------------------------------------
-// Search
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HExtendedString::Search(
const Handle(TCollection_HExtendedString)& what) const
{
return myString.Search(what->ChangeString());
}
-// ----------------------------------------------------------------------------
-// SearchFromEnd
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Integer TCollection_HExtendedString::SearchFromEnd(
const Handle(TCollection_HExtendedString)& what) const
{
return myString.SearchFromEnd(what->ChangeString());
}
-// ----------------------------------------------------------------------------
-// Token
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Handle(TCollection_HExtendedString) TCollection_HExtendedString::Token(
const Standard_ExtString separators,
const Standard_Integer whichone) const
return new TCollection_HExtendedString(myString.Token(separators, whichone));
}
-// ----------------------------------------------------------------------------
-// Trunc
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
void TCollection_HExtendedString::Trunc(const Standard_Integer ahowmany)
{
myString.Trunc(ahowmany);
}
-// ----------------------------------------------------------------------------
-// Value
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_ExtCharacter TCollection_HExtendedString::Value(const Standard_Integer where) const
{
return myString.Value(where);
}
-// ----------------------------------------------------------------------------
-// String
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
const TCollection_ExtendedString& TCollection_HExtendedString::String() const
{
return myString;
myString.Print(S);
}
-// ----------------------------------------------------------------------------
-// Issamestate
-// ----------------------------------------------------------------------------
+//=================================================================================================
+
Standard_Boolean TCollection_HExtendedString::IsSameState(
const Handle(TCollection_HExtendedString)& other) const
{
Sewing();
}
-//=======================================================================
-// function : Init
-// purpose : Construction of laws.
-//======================================================================
+//=================================================================================================
+
void BRepFill_Draft::Init(const Handle(Geom_Surface)&,
const Standard_Real Length,
const Bnd_Box& Box)
mySection.Nullify(); // It is required to relocalize sections.
}
-//=======================================================================
-// function : Set
-// purpose : Define a law Constant
-//=======================================================================
+//=================================================================================================
+
void BRepFill_PipeShell::Set(const gp_Ax2& Axe)
{
myTrihedron = GeomFill_IsFixed;
#include <TopOpeBRep_VPointInter.hxx>
#include <TopOpeBRepDS_Transition.hxx>
-//-----------------------------------------------------------------------
-// function : TransitionToOrientation
-// purpose : static
-//-----------------------------------------------------------------------
+//=================================================================================================
static Standard_Boolean TransitionToOrientation(const IntSurf_Transition& T, TopAbs_Orientation& O)
{
return state;
}
-// ----------------------------------------------------------------------
-// Class methods
-// ----------------------------------------------------------------------
+//=================================================================================================
//=======================================================================
// function : Lminmax
myGeomTool.Define(GT);
}
-//-----------------------------------------------------------------------
-// function : MakePCurve
-// purpose :
-//-----------------------------------------------------------------------
+//=================================================================================================
+
Standard_EXPORT Handle(Geom2d_Curve) MakePCurve(const ProjLib_ProjectedCurve& PC)
{
Handle(Geom2d_Curve) C2D;
return Standard_True;
}
-// ----------------------------------------------------------------------
-// projecting point <P> on topologies (edge <E>,face <F>)
-// ----------------------------------------------------------------------
+//=================================================================================================
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_projPonE(const gp_Pnt& P,
FUN_tool_UpdateBnd2d(B2d, newB2d);
}
-// ----------------------------------------------------------------------
-// closing topologies :
-// ----------------------------------------------------------------------
+//=================================================================================================
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_IsClosingE(const TopoDS_Edge& E,
return Standard_False;
}*/
-// ----------------------------------------------------------------------
-// shared topologies :
-// ----------------------------------------------------------------------
+//=================================================================================================
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_inS(const TopoDS_Shape& subshape,
return r;
}
-// ----------------------------------------------------------------------
-// tolerances :
-// ----------------------------------------------------------------------
+//=================================================================================================
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_maxtol(const TopoDS_Shape& S,
return Standard_False;
}
-// ----------------------------------------------------------------------
-// shared geometry :
-// ----------------------------------------------------------------------
+//=================================================================================================
// ----------------------------------------------------------------------
Standard_EXPORT Standard_Boolean FUN_tool_curvesSO(const TopoDS_Edge& E1,
return Standard_False;
}
-// ----------------------------------------------------------------------
-// new topologies :
-// ----------------------------------------------------------------------
+//=================================================================================================
// FUN_ds_* methods are methods of TopOpeBRepDS_BuildTool
// that cannot be called (cyclic dependencies)
#define M_INTERNAL(ori) (ori == TopAbs_INTERNAL)
#define M_EXTERNAL(ori) (ori == TopAbs_EXTERNAL)
-// ----------------------------------------------------------------------
-// oriented vectors :
-// ----------------------------------------------------------------------
+//=================================================================================================
// ----------------------------------------------------------------------
Standard_EXPORT gp_Dir FUN_tool_nCinsideS(const gp_Dir& tgC, const gp_Dir& ngS)
{
}
-//=======================================================================
-// function : Perform
-// purpose : launch the processing
-//=======================================================================
+//=================================================================================================
void BRepBlend_RstRstLineBuilder::Perform(Blend_RstRstFunction& Func,
Blend_SurfCurvFuncInv& Finv1,
Perform(Path, Tol);
}
-//===============================================================
-// Function :Perform
-// Purpose : Recherche automatique
-//===============================================================
+//=================================================================================================
+
void GeomFill_SectionPlacement::Perform(const Handle(Adaptor3d_Curve)& Path,
const Standard_Real Tol)
{
// =========================================================
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
-//-------------------------------------------------------------------------
-// Function : TrierTab, internal Function, does not belong to class
-//-------------------------------------------------------------------------
+//=================================================================================================
+
// Reorder the table of transformations
// After the call of CourbeJointive the order of curves is modified
// Ex : initial order of curves ==> A B C D E F
return Standard_False;
}
-//-------------------------------------------------------------------------
-// Function : ComputeSurfInit
-//-------------------------------------------------------------------------
+//=================================================================================================
+
// Calculate the initial surface either by the method of max flow or by
// the method of the plane of inertia if the contour is not closed or if
// there are point constraints.
return NewPoint;
}
-//==================================================================================
-// function : Perform
-// purpose : base SS Int. function
-//==================================================================================
+//=================================================================================================
+
void IntPatch_PrmPrmIntersection::Perform(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_Surface)& Surf2,
return Standard_False;
}
-//=======================================================================
-// function : Dump
-// purpose : Dump the TangentZone.
-//=======================================================================
+//=================================================================================================
void Intf_TangentZone::Dump(const Standard_Integer /*Indent*/) const
{
}
// modified by NIZNHY-PKV Thu Mar 29 16:53:07 2001f
-//=======================================================================
-// function : Quadric
-// purpose : returns empty Quadric
-//=======================================================================
+
+//=================================================================================================
+
const IntSurf_Quadric& Contap_ArcFunction::Quadric() const
{
return (myQuad);
Builds(TopAbs_IN);
}
-//=======================================================================
-// function : InitAreas
-// purpose : set on the first area
-//=======================================================================
+//=================================================================================================
void HLRBRep_EdgeBuilder::InitAreas()
{
myBuilder.Range(E, P1, P2);
}
-//=======================================================================
-// function : AddWireEdge
-// purpose : Add an Edge to a Wire
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::AddWireEdge(TopoDS_Wire& W,
const TopoDS_Edge& E,
myBuilder.Add(F, W);
}
-//=======================================================================
-// function : AddShellFace
-// purpose : Add a Face to a Shell
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::AddShellFace(TopoDS_Shell& S, const TopoDS_Face& F) const
{
/*********************************************************************************/
-//------------------------------------------------------------------------------
-// function: TRI_SOLUTION
-//------------------------------------------------------------------------------
+//=================================================================================================
+
static Standard_Boolean TRI_SOLUTION(const BRepExtrema_SeqOfSolution& SeqSol, const gp_Pnt& Pt)
{
for (BRepExtrema_SeqOfSolution::iterator anIt = SeqSol.begin(); anIt != SeqSol.end(); anIt++)
return Standard_True;
}
-//------------------------------------------------------------------------------
-// function: MIN_SOLUTION
-//------------------------------------------------------------------------------
+//=================================================================================================
+
static void MIN_SOLUTION(const BRepExtrema_SeqOfSolution& SeqSol1,
const BRepExtrema_SeqOfSolution& SeqSol2,
const Standard_Real DstRef,
}
}
-//------------------------------------------------------------------------------
-// function: TRIM_INFINIT_EDGE
-//------------------------------------------------------------------------------
+//=================================================================================================
+
static void TRIM_INFINIT_EDGE(const TopoDS_Edge& S1,
const TopoDS_Edge& S2,
TopoDS_Edge& aResEdge,
}
}
-//------------------------------------------------------------------------------
-// function: TRIM_INFINIT_FACE
-//------------------------------------------------------------------------------
+//=================================================================================================
+
static void TRIM_INFINIT_FACE(const TopoDS_Shape& S1,
const TopoDS_Shape& S2,
TopoDS_Face& aResFace,
bIsInfinit = Standard_False;
}
-//------------------------------------------------------------------------------
-// static function: PERFORM_C0
-//------------------------------------------------------------------------------
+//=================================================================================================
+
static void PERFORM_C0(const TopoDS_Edge& S1,
const TopoDS_Edge& S2,
BRepExtrema_SeqOfSolution& SeqSol1,
return aMaxCont;
}
-//=======================================================================
-// function : Pnt
-// purpose : Returns the 3d point.
-//=======================================================================
+//=================================================================================================
gp_Pnt BRep_Tool::Pnt(const TopoDS_Vertex& V)
{
#include <StdFail_NotDone.hxx>
#include <TColStd_HArray1OfReal.hxx>
-//----------------------------------------------------------------------------
-// Purpose - to find min index of global variables and define
-//----------------------------------------------------------------------------
+//=================================================================================================
+
static Standard_Integer MinIndex(const Handle(FEmTool_HAssemblyTable)& Table)
{
Standard_Integer dim, el, nvar, Imin;
return Imin;
}
-//----------------------------------------------------------------------------
-// Purpose - to find max index of global variables
-//----------------------------------------------------------------------------
+//=================================================================================================
+
static Standard_Integer MaxIndex(const Handle(FEmTool_HAssemblyTable)& Table)
{
Standard_Integer dim, el, nvar, Imax;
{
}
-//============================================================================
-// Method: Destructor
-// Purpose: Protected destructor.
-//============================================================================
+//=================================================================================================
+
IVtkTools_ShapeObject::~IVtkTools_ShapeObject() {}
//=================================================================================================
//
}
-// =======================================================================
-// function : Update
-// purpose : Updates current state
-// =======================================================================
+//=================================================================================================
+
void OpenGl_ClippingState::Update()
{
myStateStack.Prepend(myIndex);
++myNextIndex;
}
-// =======================================================================
-// function : Revert
-// purpose : Reverts current state
-// =======================================================================
+//=================================================================================================
+
void OpenGl_ClippingState::Revert()
{
if (!myStateStack.IsEmpty())
return aStatus;
}
-//=======================================================================
-// function : Select
-// purpose : Selection by polyline
-//=======================================================================
+//=================================================================================================
+
AIS_StatusOfPick AIS_InteractiveContext::Select(const TColgp_Array1OfPnt2d& thePolyline,
const Handle(V3d_View)& theView,
const Standard_Boolean theToUpdateViewer)
//
}
-//=======================================================================
-// class : Axis
-// function : Compute
-// purpose :
-//=======================================================================
+//=================================================================================================
void AIS_Manipulator::Axis::Compute(const Handle(PrsMgr_PresentationManager)& thePrsMgr,
const Handle(Prs3d_Presentation)& thePrs,
#include <stdio.h>
-//------------------------------------------------------------------------------------------------------------------
-// Returns 1 if C is above of CMin; 0 if C is between CMin and CMax; -1 if C is Below CMax
-//-----------------------------------------------------------------------------------------------------------------
+//=================================================================================================
+
static Standard_Integer AboveInBelowCone(const gp_Circ& CMax, const gp_Circ& CMin, const gp_Circ& C)
{
const Standard_Real D = CMax.Location().Distance(CMin.Location());
SetFlyout(15.0);
}
-//=======================================================================
-// function : Constructor
-// purpose : Dimension of one edge
-//=======================================================================
+//=================================================================================================
+
PrsDim_LengthDimension::PrsDim_LengthDimension(const TopoDS_Edge& theEdge, const gp_Pln& thePlane)
: PrsDim_Dimension(PrsDim_KOD_LENGTH),
myHasCustomDirection(Standard_False)
IMPLEMENT_STANDARD_RTTIEXT(PrsDim_PerpendicularRelation, PrsDim_Relation)
-//=======================================================================
-// function : Constructor
-// purpose : TwoEdgesPerpendicular
-//=======================================================================
+//=================================================================================================
+
PrsDim_PerpendicularRelation::PrsDim_PerpendicularRelation(const TopoDS_Shape& aFShape,
const TopoDS_Shape& aSShape,
const Handle(Geom_Plane)& aPlane)
myPlane = aPlane;
}
-//=======================================================================
-// function : Constructor
-// purpose : TwoFacesPerpendicular
-//=======================================================================
+//=================================================================================================
+
PrsDim_PerpendicularRelation::PrsDim_PerpendicularRelation(const TopoDS_Shape& aFShape,
const TopoDS_Shape& aSShape)
: PrsDim_Relation()
//! Short-cut definition of indexed data map of selectable objects
typedef NCollection_IndexedMap<Handle(SelectMgr_SelectableObject)> ObjectsMap;
-//-------------------------------------------------------------------------------------
-// Adaptor over regular objects subset of SelectMgr_SelectableObjectSet for BVH builder
-//-------------------------------------------------------------------------------------
+//=================================================================================================
//! This class provides direct access to fields of SelectMgr_SelectableObjectSet
//! so the BVH builder could explicitly arrange objects in the map as necessary
mutable Select3D_BndBox3d myBox;
};
-//----------------------------------------------------------------------------------------
-// Adaptor over persistent objects subset of SelectMgr_SelectableObjectSet for BVH builder
-//----------------------------------------------------------------------------------------
+//=================================================================================================
//! This class provides direct access to fields of SelectMgr_SelectableObjectSet
//! so the BVH builder could explicitly arrange objects in the map as necessary
projects / occt.git / commitdiff