OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0024805: Eliminate unused static functions and methods: ShallowDump(), ShallowCopy(), STANDARD_TYPE(...)

Browse Source 
Implementation of global functions STANDARD_TYPE() for types not inheriting Standard_Transient or Standard_Persistent are eliminated.

Global functions and class methods ShallowCopy() are removed; also removed unused classes Visual3d_PickPath and Visual3d_PickDescriptor.

Global functions and class methods ShallowDump() are removed, except for classes Standard_GUID, TopLoc_Datum, and TopLoc_Location as the latter are still used in some Debug printouts.
This commit is contained in:
abv 2014-04-11 13:59:41 +04:00 committed by apn
parent c5751993f2
commit 2cb4424136
143 changed files with 16 additions and 2825 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/Aspect/Aspect_CLayer2d.cxx
View File

@ -1,20 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Aspect_CLayer2d.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_CLayer2d)
{
static Handle(Standard_Type) _atype = new Standard_Type ("Aspect_CLayer2d", sizeof (Aspect_CLayer2d));
return _atype;
}

8
src/Aspect/Aspect_CLayer2d.hxx
View File

@ -24,12 +24,4 @@
#include <InterfaceGraphic_Aspect.hxx>
typedef CALL_DEF_LAYER Aspect_CLayer2d;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& TYPE(Aspect_CLayer2d) ;
/*============================================================================*/
#endif
#endif /*Aspect_CLayer2d_HeaderFile*/

12
src/Aspect/Aspect_Display.hxx
View File

@ -21,16 +21,6 @@
#ifndef _Aspect_Display_HeaderFile
#define _Aspect_Display_HeaderFile
typedef void* Aspect_Display; /* Display* under UNIX */
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Macro.hxx>
class Handle(Standard_Type);
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_Display);
/*============================================================================*/
#endif
typedef void* Aspect_Display; /* Display* under UNIX */
#endif /* _Aspect_Display_HeaderFile */

10
src/Aspect/Aspect_Drawable.hxx
View File

@ -27,14 +27,4 @@
typedef unsigned long Aspect_Drawable; /* Window or Pixmap under UNIX */
#endif /* WNT */
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Macro.hxx>
class Handle(Standard_Type);
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_Drawable);
/*============================================================================*/
#endif
#endif /* _Aspect_Drawable_HeaderFile */

24
src/Aspect/Aspect_FStream.cxx
View File

@ -1,24 +0,0 @@
// Created on: 1994-08-24
// Created by: Modelistation
// Copyright (c) 1994-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Aspect_FStream.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_FStream)
{
static Handle(Standard_Type) _atype =
new Standard_Type("Aspect_FStream",sizeof(Aspect_FStream));
return _atype;
}

3
src/Aspect/Aspect_FStream.hxx
View File

@ -19,7 +19,4 @@
typedef ofstream* Aspect_FStream;
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_FStream);
#endif

3
src/Aspect/Aspect_GraphicCallbackProc.hxx
View File

@ -46,7 +46,4 @@ typedef int (*Aspect_GraphicCallbackProc) (Aspect_Drawable theWind
void* theUserData,
Aspect_GraphicCallbackStruct* theCallData);
class Handle(Standard_Type);
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_GraphicCallbackProc);
#endif /* _Aspect_GraphicCallbackProc_HeaderFile */

21
src/Aspect/Aspect_Handle.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Aspect_Handle.hxx>
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_Handle)
{
static Handle(Standard_Type) _atype = new Standard_Type ("Aspect_Handle", sizeof (Aspect_Handle));
return _atype;
}

10
src/Aspect/Aspect_Handle.hxx
View File

@ -28,14 +28,4 @@
typedef unsigned long Aspect_Handle;
#endif /* WNT */
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Macro.hxx>
class Handle(Standard_Type);
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_Handle);
/*============================================================================*/
#endif
#endif /* _Aspect_Handle_HeaderFile */

23
src/Aspect/Aspect_IFStream.cxx
View File

@ -1,23 +0,0 @@
// Created on: 2001-01-26
// Created by: SPK
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Aspect_IFStream.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_IFStream)
{
static Handle(Standard_Type) _atype =
new Standard_Type("Aspect_IFStream", sizeof(Aspect_IFStream));
return _atype;
}

5
src/Aspect/Aspect_IFStream.hxx
View File

@ -18,9 +18,6 @@
#include <Standard_Stream.hxx>
typedef ifstream* Aspect_IFStream;
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_IFStream);
typedef std::ifstream* Aspect_IFStream;
#endif

24
src/Aspect/Aspect_RGBPixel.cxx
View File

@ -1,24 +0,0 @@
// Created on: 1998-10-28
// Created by: DCB
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Aspect_RGBPixel.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_RGBPixel)
{
static Handle(Standard_Type) _atype =
new Standard_Type("Aspect_RGBPixel",sizeof(Aspect_RGBPixel));
return _atype;
}

3
src/Aspect/Aspect_RGBPixel.hxx
View File

@ -14,13 +14,10 @@
#ifndef _Aspect_RGBPixel_HeaderFile
#define _Aspect_RGBPixel_HeaderFile
#include <Standard_Type.hxx>
typedef struct {
float red;
float green;
float blue;
} Aspect_RGBPixel;
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_RGBPixel);
#endif

10
src/Aspect/Aspect_RenderingContext.hxx
View File

@ -24,14 +24,4 @@
typedef void* Aspect_RenderingContext; /* GLXContext under UNIX */
/* HGLRC under WNT */
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Macro.hxx>
class Handle(Standard_Type);
const Handle(Standard_Type)& STANDARD_TYPE(Aspect_RenderingContext);
/*============================================================================*/
#endif
#endif /* _Aspect_RenderingContext_HeaderFile */

5
src/Aspect/FILES
View File

@ -2,14 +2,9 @@ EXTERNLIB
Aspect_WOKSteps.edl
Aspect_CMPLRS.edl
Aspect_FStream.hxx
Aspect_FStream.cxx
Aspect_IFStream.hxx
Aspect_IFStream.cxx
Aspect_CLayer2d.hxx
Aspect_CLayer2d.cxx
Aspect_RGBPixel.hxx
Aspect_RGBPixel.cxx
Aspect_Handle.cxx
Aspect_Handle.hxx
Aspect_XWD.hxx
Aspect_Units.hxx

9
src/DBC/DBC_BaseArray.cdl
View File

@ -52,15 +52,6 @@ is
Unlock (me) is static;
---Purpose: unlocks the array <me> from memory
ShallowDump (me; S: in out OStream)
--Purpose: Prints the contents at the first level of <me> on
-- the stream <s>. The Root version of ShallowDump prints
-- the name of the class <me> is an instance of,
-- followed by its memory address.
---C++: function call
is redefined;
fields
mySize : Integer is protected;

12
src/DBC/DBC_BaseArray.cxx
View File

@ -79,18 +79,6 @@ static PStandard_ArrayNode DBC_tmpItem;
// Last revision : January 1996 JMS/CLE
// portage OBJY 3.8
// --------------------------------------------------------------------
// ShallowDump
// --------------------------------------------------------------------
//void DBC_BaseArray::ShallowDump( Standard_OStream& S) const
void DBC_BaseArray::ShallowDump( Standard_OStream& ) const
{
}
// --------------------------------------------------------------------
// Constructor
// --------------------------------------------------------------------

21
src/DBC/DBC_BaseArray_objs.hxx
View File

@ -33,8 +33,6 @@ class Standard_DimensionMismatch;
#endif
#endif
Handle_Standard_Type& DBC_BaseArray_Type_();
class Standard_EXPORT DBC_BaseArray :
public os_virtual_behavior /* New */ {
@ -49,21 +47,12 @@ DBC_BaseArray(const DBC_BaseArray& BaseArray);
Standard_Integer Upper() const;
Standard_Address Lock() const;
void Unlock() const;
virtual void ShallowDump(Standard_OStream& S) const;
void Destroy() ;
~DBC_BaseArray()
{
Destroy();
}
// Type management
//
friend Handle_Standard_Type& DBC_BaseArray_Type_();
protected:
// Methods PROTECTED
@ -91,14 +80,4 @@ private:
#include <DBC_BaseArray.lxx>
// other Inline functions and methods (like "C++: function call" methods)
//
void ShallowDump(const DBC_BaseArray& me,Standard_OStream& S) {
me.ShallowDump(S);
}
#endif

2
src/DDataStd/DDataStd_BasicCommands.cxx
View File

@ -374,8 +374,6 @@ static Standard_Integer DDataStd_GetUAttribute (Draw_Interpretor& di,
di << "No UAttribute Attribute on label" << "\n";
}
else {
// UA->ID().ShallowDump(cout);
// cout << endl;
char *aStrGUID = new char[37];
UA->ID().ToCString(aStrGUID);
di << aStrGUID;

12
src/Graphic3d/FILES
View File

@ -5,27 +5,16 @@ Graphic3d_CAspectText.hxx
Graphic3d_CStructure.cxx
Graphic3d_CStructure.hxx
Graphic3d_CStructure_Handle.hxx
Graphic3d_CBitFields16.cxx
Graphic3d_CBitFields16.hxx
Graphic3d_CBitFields20.cxx
Graphic3d_CBitFields20.hxx
Graphic3d_CBitFields8.cxx
Graphic3d_CBitFields8.hxx
Graphic3d_CBitFields4.cxx
Graphic3d_CBitFields4.hxx
Graphic3d_CTexture.cxx
Graphic3d_CTexture.hxx
Graphic3d_CLight.cxx
Graphic3d_CLight.hxx
Graphic3d_CPick.cxx
Graphic3d_CPick.hxx
Graphic3d_CBounds.cxx
Graphic3d_CBounds.hxx
Graphic3d_CUserDraw.cxx
Graphic3d_CUserDraw.hxx
Graphic3d_CView.cxx
Graphic3d_CView.hxx
Graphic3d_CGraduatedTrihedron.cxx
Graphic3d_CGraduatedTrihedron.hxx
Graphic3d_Structure.lxx
Graphic3d_Structure.pxx
@ -48,7 +37,6 @@ Graphic3d_WOKSteps.edl
Graphic3d_PrimitiveArray.hxx
Graphic3d_TransModeFlags.hxx
Graphic3d_CTransPersStruct.hxx
Graphic3d_CTransPersStruct.cxx
Graphic3d_NListOfHAsciiString.hxx
Graphic3d_AspectText3d.cxx
Graphic3d_PtrFrameBuffer.hxx

22
src/Graphic3d/Graphic3d_CBitFields16.cxx
View File

@ -1,22 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CBitFields16.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields16)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CBitFields16", sizeof (Graphic3d_CBitFields16));
return _atype;
}

7
src/Graphic3d/Graphic3d_CBitFields16.hxx
View File

@ -46,11 +46,4 @@ typedef struct {
} Graphic3d_CBitFields16;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields16);
/*============================================================================*/
#endif
#endif /*Graphic3d_CBitFields16_HeaderFile*/

22
src/Graphic3d/Graphic3d_CBitFields20.cxx
View File

@ -1,22 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CBitFields20.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields20)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CBitFields20", sizeof (Graphic3d_CBitFields20));
return _atype;
}

7
src/Graphic3d/Graphic3d_CBitFields20.hxx
View File

@ -51,11 +51,4 @@ typedef struct {
} Graphic3d_CBitFields20;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields20);
/*============================================================================*/
#endif
#endif /*Graphic3d_CBitFields20_HeaderFile*/

22
src/Graphic3d/Graphic3d_CBitFields4.cxx
View File

@ -1,22 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CBitFields4.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields4)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CBitFields4", sizeof (Graphic3d_CBitFields4));
return _atype;
}

7
src/Graphic3d/Graphic3d_CBitFields4.hxx
View File

@ -31,11 +31,4 @@ typedef struct {
} Graphic3d_CBitFields4;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields4);
/*============================================================================*/
#endif
#endif /*Graphic3d_CBitFields4_HeaderFile*/

22
src/Graphic3d/Graphic3d_CBitFields8.cxx
View File

@ -1,22 +0,0 @@
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CBitFields8.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields8)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CBitFields8", sizeof (Graphic3d_CBitFields8));
return _atype;
}

7
src/Graphic3d/Graphic3d_CBitFields8.hxx
View File

@ -36,11 +36,4 @@ typedef struct {
} Graphic3d_CBitFields8;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& STANDARD_TYPE(Graphic3d_CBitFields8);
/*============================================================================*/
#endif
#endif /*Graphic3d_CBitFields8_HeaderFile*/

21
src/Graphic3d/Graphic3d_CBounds.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CBounds.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CBounds)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CBounds", sizeof (Graphic3d_CBounds));
return _atype;
}

7
src/Graphic3d/Graphic3d_CBounds.hxx
View File

@ -24,11 +24,4 @@
#include <InterfaceGraphic_Graphic3d.hxx>
typedef CALL_DEF_BOUNDS Graphic3d_CBounds;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CBounds) ;
/*============================================================================*/
#endif
#endif /*Graphic3d_CBounds_HeaderFile*/

23
src/Graphic3d/Graphic3d_CGraduatedTrihedron.cxx
View File

@ -1,23 +0,0 @@
// Created on: 2011-03-06
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CGraduatedTrihedron.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CGraduatedTrihedron)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CGraduatedTrihedron", sizeof (Graphic3d_CGraduatedTrihedron));
return _atype;
}

3
src/Graphic3d/Graphic3d_CGraduatedTrihedron.hxx
View File

@ -18,7 +18,6 @@
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
#include <Quantity_Color.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
@ -101,6 +100,4 @@ public:
Visual3d_View* ptrVisual3dView;
};
const Handle(Standard_Type)& TYPE(Graphic3d_CGraduatedTrihedron);
#endif /*Graphic3d_CGraduatedTrihedron_HeaderFile*/

21
src/Graphic3d/Graphic3d_CLight.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CLight.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CLight)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CLight", sizeof (Graphic3d_CLight));
return _atype;
}

1
src/Graphic3d/Graphic3d_CLight.hxx
View File

@ -17,7 +17,6 @@
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_Vec.hxx>
#include <Standard_Type.hxx>
//! Light definition
struct Graphic3d_CLight

21
src/Graphic3d/Graphic3d_CPick.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CPick.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CPick)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CPick", sizeof (Graphic3d_CPick));
return _atype;
}

8
src/Graphic3d/Graphic3d_CPick.hxx
View File

@ -25,12 +25,4 @@
#include <InterfaceGraphic_Visual3d.hxx>
typedef CALL_DEF_PICK Graphic3d_CPick;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CPick);
/*============================================================================*/
#endif
#endif /*Graphic3d_CPick_HeaderFile*/

21
src/Graphic3d/Graphic3d_CTexture.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CTexture.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CTexture)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CTexture", sizeof (Graphic3d_CTexture));
return _atype;
}

3
src/Graphic3d/Graphic3d_CTexture.hxx
View File

@ -15,7 +15,6 @@
#define _Graphic3d_CTexture_HeaderFile
#include <Graphic3d_TextureMap.hxx>
#include <Standard_Type.hxx>
class Graphic3d_CTexture
{
@ -35,6 +34,4 @@ public:
};
const Handle(Standard_Type)& TYPE(Graphic3d_CTexture);
#endif // Graphic3d_CTexture_HeaderFile

21
src/Graphic3d/Graphic3d_CTransPersStruct.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CTransPersStruct.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CTransPersStruct)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CTransPersStruct", sizeof (Graphic3d_CTransPersStruct));
return _atype;
}

7
src/Graphic3d/Graphic3d_CTransPersStruct.hxx
View File

@ -24,11 +24,4 @@
#include <InterfaceGraphic_Graphic3d.hxx>
typedef CALL_DEF_TRANSFORM_PERSISTENCE Graphic3d_CTransPersStruct;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CTransPersStruct);
/*============================================================================*/
#endif
#endif /*_Graphic3d_CTransPersStruct_HeaderFile*/

21
src/Graphic3d/Graphic3d_CUserDraw.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CUserDraw.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CUserDraw)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CUserDraw", sizeof (Graphic3d_CUserDraw));
return _atype;
}

7
src/Graphic3d/Graphic3d_CUserDraw.hxx
View File

@ -24,11 +24,4 @@
#include <InterfaceGraphic_Graphic3d.hxx>
typedef CALL_DEF_USERDRAW Graphic3d_CUserDraw;
#if defined(__cplusplus) || defined(c_plusplus)
/*==== Definition de Type ====================================================*/
#include <Standard_Type.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CUserDraw) ;
/*============================================================================*/
#endif
#endif /*Graphic3d_CUserDraw_HeaderFile*/

21
src/Graphic3d/Graphic3d_CView.cxx
View File

@ -1,21 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_CView.hxx>
const Handle(Standard_Type)& TYPE(Graphic3d_CView)
{
static Handle(Standard_Type) _atype =
new Standard_Type ("Graphic3d_CView", sizeof (Graphic3d_CView));
return _atype;
}

3
src/Graphic3d/Graphic3d_CView.hxx
View File

@ -19,7 +19,6 @@
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_Camera.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_CLight.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
@ -149,6 +148,4 @@ public:
};
const Handle(Standard_Type)& TYPE(Graphic3d_CView);
#endif // Graphic3d_CView_HeaderFile

1
src/IFSelect/FILES
View File

@ -1,2 +1 @@
IFSelect_ActFunc.hxx
IFSelect_ActFunc.cxx

30
src/IFSelect/IFSelect_ActFunc.cxx
View File

@ -1,30 +0,0 @@
// Created on: 2000-02-29
// Created by: data exchange team
// Copyright (c) 2000-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <IFSelect_ActFunc.hxx>
//=======================================================================
//function : IFSelect_ActFunc_Type_
//purpose :
//=======================================================================
Handle(Standard_Type)& STANDARD_TYPE(IFSelect_ActFunc)
{
static Handle(Standard_Type) _aType =
new Standard_Type("IFSelect_ActFunc", sizeof(IFSelect_ActFunc), 0, NULL);
return _aType;
}

3
src/IFSelect/IFSelect_ActFunc.hxx
View File

@ -16,12 +16,9 @@
#ifndef _IFSelect_ActFunc_HeaderFile
#define _IFSelect_ActFunc_HeaderFile
#include <Standard_Type.hxx>
#include <IFSelect_SessionPilot.hxx>
#include <IFSelect_ReturnStatus.hxx>
typedef IFSelect_ReturnStatus (*IFSelect_ActFunc) (const Handle(IFSelect_SessionPilot)&);
Standard_EXPORT Handle(Standard_Type)& STANDARD_TYPE(IFSelect_ActFunc);
#endif

2
src/MoniTool/FILES
View File

@ -1,5 +1,3 @@
MoniTool_ValueInterpret.hxx
MoniTool_ValueInterpret.cxx
MoniTool_ValueSatisfies.hxx
MoniTool_ValueSatisfies.cxx
MoniTool_Macros.hxx

30
src/MoniTool/MoniTool_ValueInterpret.cxx
View File

@ -1,30 +0,0 @@
// Created on: 2000-02-28
// Created by: data exchange team
// Copyright (c) 2000-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MoniTool_ValueInterpret.hxx>
//=======================================================================
//function : MoniTool_ValueInterpret_Type_
//purpose :
//=======================================================================
Handle(Standard_Type)& STANDARD_TYPE(MoniTool_ValueInterpret)
{
static Handle(Standard_Type) _aType =
new Standard_Type("MoniTool_ValueInterpret", sizeof(MoniTool_ValueInterpret), 0, NULL);
return _aType;
}

3
src/MoniTool/MoniTool_ValueInterpret.hxx
View File

@ -16,7 +16,6 @@
#ifndef MoniTool_ValueInterpret_HeaderFile
#define MoniTool_ValueInterpret_HeaderFile
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
class Handle(MoniTool_TypedValue);
@ -25,6 +24,4 @@ typedef Handle(TCollection_HAsciiString) (*MoniTool_ValueInterpret) (const Hand
const Handle(TCollection_HAsciiString)& val,
const Standard_Boolean native);
Standard_EXPORT Handle(Standard_Type)& STANDARD_TYPE(MoniTool_ValueInterpret);
#endif

30
src/MoniTool/MoniTool_ValueSatisfies.cxx
View File

@ -1,30 +0,0 @@
// Created on: 2000-02-28
// Created by: data exchange team
// Copyright (c) 2000-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MoniTool_ValueSatisfies.hxx>
//=======================================================================
//function : MoniTool_ValueSatisfies_Type_
//purpose :
//=======================================================================
Handle(Standard_Type)& STANDARD_TYPE(MoniTool_ValueSatisfies)
{
static Handle(Standard_Type) _aType =
new Standard_Type("MoniTool_ValueSatisfies", sizeof(MoniTool_ValueSatisfies), 0, NULL);
return _aType;
}

3
src/MoniTool/MoniTool_ValueSatisfies.hxx
View File

@ -16,11 +16,8 @@
#ifndef MoniTool_ValueSatisfies_HeaderFile
#define MoniTool_ValueSatisfies_HeaderFile
#include <Standard_Type.hxx>
#include <TCollection_HAsciiString.hxx>
typedef Standard_Boolean (*MoniTool_ValueSatisfies) (const Handle(TCollection_HAsciiString)& val);
Standard_EXPORT Handle(Standard_Type)& STANDARD_TYPE(MoniTool_ValueSatisfies);
#endif

6
src/NCollection/NCollection_UtfString.hxx
View File

@ -20,7 +20,7 @@
#include <Standard.hxx>
#include <string>
#include <cstring>
#include <cstdlib>
//! This template class represent constant UTF-* string.
@ -240,7 +240,7 @@ private: //! @name low-level methods
const Standard_Byte* theStrSrc,
const Standard_Integer theSizeBytes)
{
::memcpy (theStrDst, theStrSrc, (Standard_Size )theSizeBytes);
std::memcpy (theStrDst, theStrSrc, (Standard_Size )theSizeBytes);
}
//! Compare two Unicode strings per-byte.
@ -250,7 +250,7 @@ private: //! @name low-level methods
const Standard_Integer theSizeBytes2)
{
return (theSizeBytes1 == theSizeBytes2)
&& (::memcmp (theString1, theString2, (Standard_Size )theSizeBytes1) == 0);
&& (std::memcmp (theString1, theString2, (Standard_Size )theSizeBytes1) == 0);
}
private: //! @name private fields

1
src/OSD/FILES
View File

@ -1,6 +1,5 @@
EXTERNLIB
OSD_CMPLRS.edl
OSD_Function.cxx
OSD_Function.hxx
OSD_ErrorList.hxx
OSD_WNT.cxx

23
src/OSD/OSD_Function.cxx
View File

@ -1,23 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OSD_Function.hxx>
const Handle_Standard_Type& OSD_Function_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("OSD_Function",sizeof(OSD_Function));
return _aType;
}

3
src/OSD/OSD_Function.hxx
View File

@ -15,9 +15,6 @@
#ifndef OSD_Function_HeaderFile
#define OSD_Function_HeaderFile
#include <Standard_Type.hxx>
const Handle_Standard_Type& OSD_Function_Type_();
typedef int (* OSD_Function)(...);
#endif

1
src/OSD/OSD_MAllocHook.cxx
View File

@ -25,6 +25,7 @@
#include <set>
#include <map>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#ifndef SIZE_MAX

12
src/PCollection/PCollection_HArray1.cdl
View File

@ -96,18 +96,6 @@ is
-- Exceptions
-- Standard_OutOfRange if Index is not within the bounds of this array.
ShallowCopy(me)
returns mutable like me
is redefined;
---Purpose: Returns a new array containing a copy
-- of the values (of the elements) in this array.
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
Field (me)returns FieldOfHArray1
---Level: Internal
is private;

24
src/PCollection/PCollection_HArray1.gxx
View File

@ -75,30 +75,6 @@ void PCollection_HArray1::~PCollection_HArray1 ()
*/
// ----------------------------------------------------------------------
// ShallowCopy
// ----------------------------------------------------------------------
Handle(Standard_Persistent) PCollection_HArray1::ShallowCopy() const
{
PCollection_HArray1* TheCopy = new PCollection_HArray1(*this);
// PCollection_FieldOfHArray1 DataCopy (Data);
// TheCopy->Data = DataCopy;
return TheCopy;
}
// ----------------------------------------------------------------------
// ShallowDump
// ----------------------------------------------------------------------
void PCollection_HArray1::ShallowDump(Standard_OStream& S) const
{
::ShallowDump(Data,S);
}
/* Anciens INLINE */
// ----------------------------------------------------------------------

12
src/PCollection/PCollection_HArray2.cdl
View File

@ -121,18 +121,6 @@ is
-- Standard_OutOfRange if the index (Row,
-- Column) is not within the bounds of this array.
ShallowCopy(me)
returns mutable like me
is redefined;
---Purpose: Returns a new array containing a copy of the
-- values (of the elements) in this array.
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
Field (me) returns FieldOfHArray2
is private;
---Level: Internal

23
src/PCollection/PCollection_HArray2.gxx
View File

@ -90,29 +90,6 @@ void PCollection_HArray2::~PCollection_HArray2 ()
}
*/
// --------------------------------------------------------------------
// ShallowCopy
// --------------------------------------------------------------------
Handle(Standard_Persistent) PCollection_HArray2::ShallowCopy() const
{
PCollection_HArray2* TheCopy = new PCollection_HArray2(*this);
// PCollection_FieldOfHArray2 DataCopy (Data);
// TheCopy->Data = DataCopy;
return TheCopy;
}
// --------------------------------------------------------------------
// ShallowDump
// --------------------------------------------------------------------
void PCollection_HArray2::ShallowDump(Standard_OStream& S) const
{
::ShallowDump(Data,S);
}
/* Anciens INLINE */
// --------------------------------------------------------------------

5
src/PCollection/PCollection_HAsciiString.cdl
View File

@ -439,11 +439,6 @@ is
---Purpose: Returns the character of index Index of the string
---Example: me = "abcd", Index = 2, Value returns 'b'.
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
Assign(me : mutable ;TheData : VArrayOfCharacter) is private;
---Level: Internal
---Purpose : Assigns the field of the current structure with

10
src/PCollection/PCollection_HAsciiString.cxx
View File

@ -745,13 +745,3 @@ void PCollection_HAsciiString::Assign(const DBC_VArrayOfCharacter& TheField)
{
Data = TheField;
}
//------------------------------------------------------------------------
// ShallowDump
//------------------------------------------------------------------------
void PCollection_HAsciiString::ShallowDump(Standard_OStream& S) const
{
S << "begin class HAsciiString " << endl;
::ShallowDump(Data, S);
S << "end class HAsciiString" << endl;
}

11
src/PCollection/PCollection_HDoubleList.cdl
View File

@ -111,17 +111,6 @@ is
---Level: Public
---Purpose: Modification of the forward pointer
ShallowCopy(me)
returns mutable like me
is redefined;
---Level: Advanced
---C++: function call
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
Destroy(me : mutable);
---C++: alias ~

57
src/PCollection/PCollection_HDoubleList.gxx
View File

@ -50,63 +50,6 @@ Handle(PCollection_HDoubleList)
return L; // C'est L qui est retourne.
}
// -----------------------------------------------------------------------
// - -
// - -
// - -
// -----------------------------------------------------------------------
Handle(Standard_Persistent) PCollection_HDoubleList::ShallowCopy() const
{
Handle(PCollection_HDoubleList) TheList, // Traversal depth of <this>
TheCopy, // The list returned
Pred, // Backward pointer
Succ, // Forward pointer
Last; // Last cell
TheCopy = new PCollection_HDoubleList; // Initialization of the list
// that will be returned
Standard_Boolean FirstTime = Standard_True;
TheList = this; // Start at the beginning
Pred = Succ = TheCopy;
while ( ! TheList->IsEmpty() ) { // Append each item at the
Succ = Succ->Construct(TheList->Value()); // end of the list
if ( FirstTime ){
FirstTime = Standard_False;
TheCopy = Succ;
}
else{
Pred->ChangeForwardPointer(Succ); // Make the link between
Succ->ChangeBackPointer(Pred); // Pred and Succ
}
Pred = Succ;
Succ = Succ->Tail();
TheList = TheList->Tail();
}
return TheCopy; // Returns the header
}
// -----------------------------------------------------------------------
// - -
// - -
// - -
// -----------------------------------------------------------------------
void PCollection_HDoubleList::ShallowDump(Standard_OStream& S) const
{
Handle(PCollection_HDoubleList) TheList;
TheList = this;
S << "begin class HDoubleList " << endl;
while ( ! TheList->IsEmpty() ) {
::ShallowDump(TheList->Value(), S);
TheList = TheList->Tail();
}
S << "end of HDoubleList." << endl;
}
/* Anciens INLINE */

6
src/PCollection/PCollection_HExtendedString.cdl
View File

@ -280,12 +280,6 @@ is
---Purpose: Returns the character of index Index of the string.
---Example: me = "abcd", Index = 2, Value returns 'b'
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
Assign(me : mutable ;TheData : VArrayOfExtCharacter) is private;
---Level: Internal
---Purpose : Assigns the field of the current structure with

11
src/PCollection/PCollection_HExtendedString.cxx
View File

@ -567,17 +567,6 @@ Standard_ExtCharacter PCollection_HExtendedString::Value
return Data(Index-1);
}
//------------------------------------------------------------------------
// ShallowDump
//------------------------------------------------------------------------
void PCollection_HExtendedString::ShallowDump(Standard_OStream& S) const
{
S << "begin class HExtendedString " << endl;
::ShallowDump(Data, S);
S << "end class HExtendedString" << endl;
}
//------------------------------------------------------------------------
// Assign
//------------------------------------------------------------------------

13
src/PCollection/PCollection_HSequence.cdl
View File

@ -401,19 +401,6 @@ is
returns SeqNode
is private;
ShallowCopy(me)
returns mutable like me
is redefined;
---Level: Advanced
---C++: function call
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
Destroy(me : mutable);
---C++: alias ~

46
src/PCollection/PCollection_HSequence.gxx
View File

@ -426,52 +426,6 @@ Item PCollection_HSequence::Last() const
return LastItem->Value();
}
// ----------------------------------------------------
//
// ShallowCopy
//
// ----------------------------------------------------
Handle(Standard_Persistent) PCollection_HSequence::ShallowCopy() const
{
Handle (PCollection_HSequence) TheCopy ;
Handle (PCollection_SeqNode) TheList ;
#ifndef OBJS
TheCopy = new PCollection_HSequence;
#else
TheCopy = new (os_segment::of(this)) PCollection_HSequence;
#endif
TheList = FirstItem;
for (Standard_Integer I = 1; I <= Size; I++) {
TheCopy->Append(TheList->Value());
TheList = TheList->Next();
}
return TheCopy;
}
// ----------------------------------------------------
//
// ShallowDump
// ----------------------------------------------------
void PCollection_HSequence::ShallowDump(Standard_OStream& S) const
{
S << "begin class Sequence "<< endl;
S << "Size : "<< Size << "element(s)." << endl;
Standard_Integer i = 1;
Handle(PCollection_SeqNode) cell = FirstItem;
while ( !cell.IsNull() ) {
S << "Index : "<< i << endl;
// ::ShallowDump(cell->Value(),S);
cell = cell->Next();
++i;
}
S << "end class Sequence" << endl;
}
// IsEmpty : Returns Standard_True if the sequence is empty (i.e. Size = 0)
Standard_Boolean PCollection_HSequence::IsEmpty() const
{

14
src/PCollection/PCollection_HSingleList.cdl
View File

@ -93,20 +93,6 @@ is
---Level: Public
---Purpose: Modification of the node link.
ShallowCopy(me)
returns mutable like me
is redefined;
---Level: Advanced
---C++: function call
ShallowDump (me; s: in out OStream)
is redefined;
---Level: Advanced
---C++: function call
fields
Data : Item;
Next : HSingleList;

62
src/PCollection/PCollection_HSingleList.gxx
View File

@ -59,68 +59,6 @@ Handle(PCollection_HSingleList)
return L;
}
// -------------------------------------------------------------------------
// -
// Shallowcopy : Redefinition of the shallowcopy dump -
// ----------- -
// -
// -------------------------------------------------------------------------
Handle(Standard_Persistent) PCollection_HSingleList::ShallowCopy() const
{
Handle(PCollection_HSingleList) TheList, // Traversal depth of <this>
TheCopy, // The list returned
Pred, // Backward pointer
Succ; // Forward pointer
#ifndef OBJS
TheCopy = new PCollection_HSingleList; // Initialization of the list
#else
TheCopy = new (os_segment::of(this)) PCollection_HSingleList; // Initialization of the list
#endif
// that will be returned
Standard_Boolean FirstTime = Standard_True;
TheList = this; // Start at the beginning
Pred = Succ = TheCopy;
while ( ! TheList->IsEmpty() ) { // Append each item at the
Succ = Succ->Construct(TheList->Value()); // end of the list
if ( FirstTime ){
FirstTime = Standard_False;
TheCopy = Succ;
}
else{
Pred->ChangeForwardPointer(Succ); // Make the link between
} // Pred and Succ
Pred = Succ;
Succ = Succ->Tail();
TheList = TheList->Tail();
}
return TheCopy; // Returns the header
}
// -------------------------------------------------------------------------
// -
// ShallowDump Redefinition of the shallowdump method -
// ----------- -
// -
// -------------------------------------------------------------------------
void PCollection_HSingleList::ShallowDump(Standard_OStream& S) const
{
Handle(PCollection_HSingleList) TheList;
TheList = this;
S << "begin class HSingleList " << endl;
while ( ! TheList->IsEmpty() ) {
::ShallowDump(TheList->Value(), S);
TheList = TheList->Tail();
}
S << "end class HSingleList" << endl;
}
/* Anciens INLINE */
Item PCollection_HSingleList::Value() const {

8
src/PMMgt/PMMgt_PManaged.cxx
View File

@ -15,14 +15,6 @@
#include <PMMgt_PManaged.ixx>
#include <Standard_TypeMismatch.hxx>
#ifdef TRACE
#define PRINT(X) cout X
#define SHALLOWDUMP(X) X.ShallowDump(cout)
#else
#define PRINT(X)
#define SHALLOWDUMP(X)
#endif
PMMgt_PManaged::PMMgt_PManaged()
{
}

2
src/SWDRAW/SWDRAW.cxx
View File

@ -106,11 +106,9 @@ static Standard_Integer LocDump (Draw_Interpretor& di, Standard_Integer argc, co
TopLoc_Location L = a.Location();
di << "Location of shape " << argv[1] << ":" << "\n";
// L.ShallowDump ( di );
di << "Results in:" << "\n";
gp_Trsf T = L.Transformation();
TopLoc_Location l ( T );
//l.ShallowDump ( di );
Standard_SStream aSStream;
l.ShallowDump ( aSStream );
di << aSStream;

1
src/ShapeProcess/FILES
View File

@ -1,3 +1,2 @@
ShapeProcess_OperFunc.hxx
ShapeProcess_OperFunc.cxx

30
src/ShapeProcess/ShapeProcess_OperFunc.cxx
View File

@ -1,30 +0,0 @@
// Created on: 2000-08-22
// Created by: data exchange team
// Copyright (c) 2000-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <ShapeProcess_OperFunc.hxx>
//=======================================================================
//function : MoniFrame_OperFunc_Type_
//purpose :
//=======================================================================
/*
Handle(Standard_Type)& STANDARD_TYPE(ShapeProcess_OperFunc)
{
static Handle(Standard_Type) _aType =
new Standard_Type("MoniFrame_OperFunc", sizeof(ShapeProcess_OperFunc), 0, NULL);
return _aType;
}
*/

3
src/ShapeProcess/ShapeProcess_OperFunc.hxx
View File

@ -16,11 +16,8 @@
#ifndef ShapeProcess_OperFunc_HeaderFile
#define ShapeProcess_OperFunc_HeaderFile
#include <Standard_Type.hxx>
#include <ShapeProcess_Context.hxx>
typedef Standard_Boolean (*ShapeProcess_OperFunc) (const Handle(ShapeProcess_Context)& context);
//Standard_EXPORT Handle(Standard_Type)& STANDARD_TYPE(ShapeProcess_OperFunc);
#endif

10
src/Standard/FILES
View File

@ -15,9 +15,7 @@ Handle_Standard_Persistent.hxx
Handle_Standard_Persistent.cxx
Handle_Standard_Transient.cxx
Handle_Standard_Transient.hxx
Standard_Address.cxx
Standard_Address.hxx
Standard_Boolean.cxx
Standard_Boolean.hxx
Standard_Byte.hxx
Standard_PByte.hxx
@ -25,20 +23,14 @@ Standard_CLocaleSentry.hxx
Standard_CLocaleSentry.cxx
Standard_CString.cxx
Standard_CString.hxx
Standard_Character.cxx
Standard_Character.hxx
Standard_ExtCharacter.cxx
Standard_ExtCharacter.hxx
Standard_ExtString.cxx
Standard_ExtString.hxx
Standard_HashCode.cxx
Standard_IStream.cxx
Standard_IStream.hxx
Standard_Integer.cxx
Standard_Integer.hxx
Standard_Macro.hxx
Standard_OId.hxx
Standard_OStream.cxx
Standard_OStream.hxx
Standard_Persistent_proto.hxx
Standard_PrimitiveTypes.hxx
@ -46,11 +38,9 @@ Standard_Real.cxx
Standard_Real.hxx
Standard_SStream.cxx
Standard_SStream.hxx
Standard_ShallowDump.cxx
Standard_ShortReal.cxx
Standard_ShortReal.hxx
Standard_Stream.hxx
Standard_Time.cxx
Standard_Time.hxx
Standard_Transient.hxx
Standard_Transient_proto.hxx

2
src/Standard/Handle_Standard_Persistent.hxx
View File

@ -92,8 +92,6 @@ class Handle(Standard_Persistent)
Standard_EXPORT ~Handle(Standard_Persistent)();
Standard_EXPORT void ShallowDump(Standard_OStream&) const;
bool operator==(const Handle(Standard_Persistent)& right) const
{
return entity == right.entity;

34
src/Standard/Standard_Address.cxx
View File

@ -1,34 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_Address.hxx>
#include <Standard_Type.hxx>
#ifndef _Standard_OStream_HeaderFile
#include <Standard_OStream.hxx>
#endif
const Handle_Standard_Type& Standard_Address_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_Address", sizeof(Standard_Address),0,NULL);
return _aType;
}
//============================================================================
//==== ShallowDump : Writes a CString value.
//============================================================================
Standard_EXPORT void ShallowDump (const Standard_Address Value, Standard_OStream& s)
{ s << Value << " Standard_Address " << "\n"; }

24
src/Standard/Standard_Address.hxx
View File

@ -12,35 +12,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//============================================================================
//==== Titre: Standard_Address.hxx
//==== Role : The headr file of primitve type "Address" from package "Standard"
//====
//==== Implementation: This is a primitive type implementadef with typedef
//==== typedef char* Address;
//============================================================================
#ifndef _Standard_Address_HeaderFile
#define _Standard_Address_HeaderFile
# include <string.h>
//typedef void* Standard_Address;
#include <Standard_Integer.hxx>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_Address_Type_();
//class Standard_OStream;
//void ShallowDump (const Standard_Address, Standard_OStream& );
//============================================================================
//==== ShallowCopy: Returns a CString
//============================================================================
inline Standard_Address ShallowCopy (const Standard_Address Value)
{
return Value;
}
//============================================================================
//==== HashCode : Returns a HashCode CString
//============================================================================

51
src/Standard/Standard_Boolean.cxx
View File

@ -1,51 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_Boolean.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Stream.hxx>
#include <Standard_OStream.hxx>
const Handle_Standard_Type& Standard_Boolean_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_Boolean",sizeof(Standard_Boolean),0,NULL);
return _aType;
}
// ------------------------------------------------------------------
// Hascode : Computes a hascoding value for a given Integer
// ------------------------------------------------------------------
//Standard_Integer HashCode(const Standard_Boolean me
// ,const Standard_Integer Upper)
//{
// if (Upper < 1){
// Standard_RangeError::
// Raise("Try to apply HashCode method with negative or null argument.");
// }
// return (me % Upper) + 1;
//}
// ----------------------------------------
// ShallowCopy : Makes a copy of a boolean
// ----------------------------------------
Standard_Boolean ShallowCopy (const Standard_Boolean me)
{ return me; }
// ------------------------------------------------------------------
// ShallowDump : Writes a boolean value
// ------------------------------------------------------------------
Standard_EXPORT void ShallowDump (const Standard_Boolean Value, Standard_OStream& s)
{ s << Value << " Standard_Boolean" << "\n"; }

57
src/Standard/Standard_Boolean.hxx
View File

@ -12,64 +12,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//============================================================================
//==== Titre: Standard_Boolean.hxx
//==== Role : The headr file of primitve type "Boolean" from package "Standard"
//====
//==== Implementation: This is a primitive type implementadef with typedef
//==== typedef int Standard_Boolean
//==== #define Standard_False 0
//==== #define Standard_True 1
//============================================================================
#ifndef _Standard_Boolean_HeaderFile
#define _Standard_Boolean_HeaderFile
//typedef unsigned int Standard_Boolean;
#ifndef _Standard_TypeDef_HeaderFile
//typedef unsigned integer Standard_Boolean;
#include <Standard_TypeDef.hxx>
#endif
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_Boolean_Type_();
//class Standard_OStream;
//void ShallowDump (const Standard_Boolean, Standard_OStream& );
// ===============================================
// Methods from Standard_Entity class which are redefined:
// - Hascode
// - IsEqual
// - IsSimilar
// - Shallowcopy
// - ShallowDump
// ===============================================
// ==================================
// Method implemented in Standard_Boolean.cxx
// ==================================
__Standard_API Standard_Boolean ShallowCopy (const Standard_Boolean);
//__Standard_API Standard_Integer HashCode (const Standard_Boolean, const Standard_Integer);
// ===============
// inline methods
// ===============
// ------------------------------------------------------------------
// IsEqual : Returns Standard_True if two booleans have the same value
// ------------------------------------------------------------------
//inline Standard_Boolean IsEqual(const Standard_Boolean One
// ,const Standard_Boolean Two)
//{ return One == Two; }
// ------------------------------------------------------------------
// IsSimilar : Returns Standard_True if two booleans have the same value
// ------------------------------------------------------------------
inline Standard_Boolean IsSimilar(const Standard_Boolean One
,const Standard_Boolean Two)
{ return One == Two; }
#endif

17
src/Standard/Standard_CString.cxx
View File

@ -27,23 +27,6 @@
#include <string.h>
#include <stdarg.h>
//============================================================================
//====
//============================================================================
const Handle_Standard_Type& Standard_CString_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_CString",sizeof(Standard_CString),0,NULL);
return _aType;
}
//============================================================================
//==== ShallowDump : Writes a CString value.
//============================================================================
Standard_EXPORT void ShallowDump (const Standard_CString Value, Standard_OStream& s)
{ s << Value << " Standard_CString " << "\n"; }
//============================================================================
//==== HashCode of a CString
//============================================================================

12
src/Standard/Standard_CString.hxx
View File

@ -41,11 +41,7 @@
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_CString_Type_();
inline Standard_Integer Abs (const Standard_Integer);
inline Standard_CString ShallowCopy (const Standard_CString Value);
inline Standard_Boolean IsSimilar(const Standard_CString One
,const Standard_CString Two);
__Standard_API Standard_Integer HashCode (const Standard_CString,
@ -67,14 +63,6 @@ __Standard_API int Printf (const char* theFormat, ...);
__Standard_API int Fprintf (FILE* theFile, const char* theFormat, ...);
__Standard_API int Sprintf (char* theBuffer, const char* theFormat, ...);
//============================================================================
//==== ShallowCopy: Returns a CString
//============================================================================
inline Standard_CString ShallowCopy (const Standard_CString Value)
{
return Value;
}
//============================================================================
//==== IsSimilar : Returns Standard_True if two booleans have the same value
//============================================================================

58
src/Standard/Standard_Character.cxx
View File

@ -1,58 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//============================================================================
//==== Titre: Standard_Character.cxx
//==== Role : the methodes which raise the exceptions are implemented in
//==== this file.
//============================================================================
#include <stdlib.h>
#include <Standard_Character.hxx>
#include <Standard_Integer.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Stream.hxx>
#include <Standard_OStream.hxx>
#include <Standard_Type.hxx>
const Handle_Standard_Type& Standard_Character_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_Character",sizeof(Standard_Character),0,NULL);
return _aType;
}
// ------------------------------------------------------------------
// Hascode : Computes a hascoding value for a given Character
// ------------------------------------------------------------------
Standard_Integer HashCode(const Standard_Character me,
const Standard_Integer Upper)
{
if (Upper < 1){
Standard_RangeError::
Raise("Try to apply HashCode method with negative or null argument.");
}
Standard_Character S[2];
S[0] = me;
S[1] = 0;
return HashCode( atoi(S) , Upper ) ;
}
// ------------------------------------------------------------------
// ShallowDump : Writes a character
// ------------------------------------------------------------------
Standard_EXPORT void ShallowDump (const Standard_Character Value, Standard_OStream& s)
{
s << Value << " Standard_Character" << endl;
}

30
src/Standard/Standard_Character.hxx
View File

@ -29,30 +29,6 @@
#include <string.h>
#include <cctype>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_Character_Type_();
//class Standard_OStream;
//void ShallowDump (const Standard_Character, Standard_OStream& );
// =====================================
// Method implemented in Standard_Character.cxx
// =====================================
__Standard_API Standard_Integer HashCode(const Standard_Character, const Standard_Integer);
// ===============================================
// Methods from Standard_Entity class which are redefined:
// - Hascode
// - IsEqual
// - IsSimilar
// - Shallowcopy
// - ShallowDump
// ===============================================
// ===============
// inline methods
// ===============
// ------------------------------------------------------------------
// IsEqual : Returns Standard_True if two characters have the same value
// ------------------------------------------------------------------
@ -162,10 +138,4 @@ inline Standard_Character LowerCase(const Standard_Character me)
inline Standard_Character UpperCase(const Standard_Character me)
{ return (Standard_Character)(unsigned char)std::toupper(me); }
// ------------------------------------------------------------------
// ShallowCopy : Make a copy of one Character
// ------------------------------------------------------------------
inline Standard_Character ShallowCopy (const Standard_Character me)
{ return me; }
#endif

59
src/Standard/Standard_ExtCharacter.cxx
View File

@ -1,59 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//============================================================================
//==== Titre: Standard_ExtCharacter.cxx
//==== Role : the methodes which raise the exceptions are implemented in
//==== this file.
//============================================================================
#include <stdlib.h>
#include <Standard_ExtCharacter.hxx>
#include <Standard_Integer.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Type.hxx>
#include <Standard_Stream.hxx>
#include <Standard_OStream.hxx>
const Handle_Standard_Type& Standard_ExtCharacter_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_ExtCharacter",sizeof(Standard_ExtCharacter),
0,NULL);
return _aType;
}
// ------------------------------------------------------------------
// Hascode : Computes a hascoding value for a given ExtCharacter
// ------------------------------------------------------------------
Standard_Integer HashCode(const Standard_ExtCharacter me,
const Standard_Integer Upper)
{
if (Upper < 1){
Standard_RangeError::
Raise("Try to apply HashCode method with negative or null argument.");
}
Standard_Integer aCode = me;
return ( aCode % Upper) + 1;
}
// ------------------------------------------------------------------
// ShallowDump : Writes a character
// ------------------------------------------------------------------
Standard_EXPORT void ShallowDump (const Standard_ExtCharacter Value
,Standard_OStream& s)
{
s << hex << Value << " Standard_ExtCharacter" << endl;
}

40
src/Standard/Standard_ExtCharacter.hxx
View File

@ -29,25 +29,6 @@
#include <string.h>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_ExtCharacter_Type_();
//class Standard_OStream;
//void ShallowDump (const Standard_ExtCharacter, Standard_OStream& );
// =====================================
// Method implemented in Standard_ExtCharacter.cxx
// =====================================
__Standard_API Standard_Integer HashCode(const Standard_ExtCharacter, const Standard_Integer);
// ===============================================
// Methods from Standard_Entity class which are redefined:
// - Hascode
// - IsEqual
// - IsSimilar
// - Shallowcopy
// - ShallowDump
// ===============================================
// ===============
// inline methods
// ===============
@ -92,25 +73,4 @@ inline Standard_Boolean IsSimilar(const Standard_ExtCharacter One,
const Standard_ExtCharacter Two)
{ return One == Two; }
// ------------------------------------------------------------------
// ShallowCopy : Make a copy of one Character
// ------------------------------------------------------------------
inline Standard_ExtCharacter ShallowCopy (const Standard_ExtCharacter me)
{ return me; }
#endif

18
src/Standard/Standard_ExtString.cxx
View File

@ -18,25 +18,7 @@
#include <Standard_ExtString.hxx>
#include <Standard_Type.hxx>
#ifndef _Standard_OStream_HeaderFile
#include <Standard_OStream.hxx>
#endif
//============================================================================
//==== ShallowDump : Writes a ExtString value.
//============================================================================
Standard_EXPORT void ShallowDump (const Standard_ExtString Value, Standard_OStream& s)
{
s << hex << Value << " Standard_ExtString " << endl;
}
const Handle_Standard_Type& Standard_ExtString_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_ExtString",sizeof(Standard_ExtString),0,NULL);
return _aType;
}
Standard_Integer HashCode (const Standard_ExtString Value,
const Standard_Integer Upper)

13
src/Standard/Standard_ExtString.hxx
View File

@ -24,19 +24,6 @@
#include <Standard_TypeDef.hxx>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_ExtString_Type_();
//class Standard_OStream;
//void ShallowDump (const Standard_ExtString, Standard_OStream& );
//============================================================================
//==== ShallowCopy: Returns a CString
//============================================================================
inline Standard_ExtString ShallowCopy (const Standard_ExtString Value)
{
return Value;
}
//============================================================================
//==== HashCode : Returns a HashCode ExtString
//============================================================================

2
src/Standard/Standard_GUID.cdl
View File

@ -85,7 +85,7 @@ is
Assign(me : out; uid : UUID from Standard);
---C++: alias operator =
ShallowDump(me; aStream : in out OStream from Standard) is redefined;
ShallowDump(me; aStream : in out OStream from Standard);
---Purpose: Display the GUID with the following format:
--
-- "00000000-0000-0000-0000-000000000000"

25
src/Standard/Standard_IStream.cxx
View File

@ -1,25 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_IStream.hxx>
#include <Standard_Type.hxx>
const Handle_Standard_Type& Standard_IStream_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_IStream", sizeof(Standard_IStream));
return _aType;
}

6
src/Standard/Standard_IStream.hxx
View File

@ -18,10 +18,6 @@
#include <Standard_Macro.hxx>
#include <Standard_Stream.hxx>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_IStream_Type_();
#define Standard_IStream istream
typedef std::istream Standard_IStream;
#endif

227
src/Standard/Standard_Integer.cxx
View File

@ -1,227 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <stdlib.h>
#include <Standard_Integer.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_Stream.hxx>
#include <Standard_OStream.hxx>
// ------------------------------------------------------------------
// CharToInt : Converts a character in an integer value
// ------------------------------------------------------------------
const Handle_Standard_Type& Standard_Integer_Type_()
{
static Handle_Standard_Type _aType = new
Standard_Type("Standard_Integer",sizeof(Standard_Integer),0,NULL);
return _aType;
}
Standard_Integer CharToInt(const Standard_Character me)
{
if (!IsDigit(me)) {
Standard_ConstructionError::Raise();
}
Standard_Character S[2];
S[0] = me;
S[1] = 0;
return atoi(S);
}
// ------------------------------------------------------------------
// CharToInt : Converts a string in an integer value
// ------------------------------------------------------------------
Standard_Integer CharToInt(const Standard_CString me)
{
const Standard_Size Len = strlen(me);
for (Standard_Size I = 0; I < Len; I++)
if (!IsDigit(me[I])) {
Standard_ConstructionError::Raise();
}
return atoi(me);
}
// ------------------------------------------------------------------
// ShallowCopy : Copy of an integer
// ------------------------------------------------------------------
Standard_Integer ShallowCopy (const Standard_Integer me)
{ return me; }
// ------------------------------------------------------------------
// ShallowDump : Writes an integer value
// ------------------------------------------------------------------
Standard_EXPORT void ShallowDump (const Standard_Integer Value, Standard_OStream& s)
{ s << Value << " Standard_Integer" << "\n"; }
// ------------------------------------------------------------------
// NextPrime : Compute the first prime number greater or equal than an integer
// ------------------------------------------------------------------
#define VALUESNBR 4
long NextPrime (const long me )
{
struct svalue {int signiaib ;
int nbr ;} ;
struct svalue values[VALUESNBR] ;
long ia ;
long maxia ;
long ib[4] ;
int n[4] ;
// int signiaib[4] = { -1 , +1 , +1 , -1 } ;
int signiaib[4];
signiaib[0] = -1;
signiaib[1] = 1;
signiaib[2] = 1;
signiaib[3] = -1;
long remain ;
int nbvalues ;
int loop ;
int nindd ;
long minn ;
long maxvn ;
long premret = 0 ;
if (me < 0 || me >
#if defined (__alpha) || defined(DECOSF1)
127149130704178201
#else
2147483647
#endif
){
Standard_RangeError::
Raise("Try to apply NextPrime method with negative, null or too large value.");
}
if ( me <= 7 ) {
if ( me <= 1 )
return 1 ;
else if ( me <= 2 )
return 2 ;
else if ( me <= 3 )
return 3 ;
else if ( me <= 5 )
return 5 ;
else if ( me <= 7 )
return 7 ;
}
minn = ( me - 1 ) / 6 ; // n minimum
while ( 6*minn+1 < me ) {
minn += 1 ;
}
maxia = long( sqrt((double ) me ) / 6 + 1 ) ;
maxvn = minn + VALUESNBR ;
nbvalues = 0 ;
for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
if ( 6*(nindd+minn)-1 < me ) {
values[nindd].nbr = 1 ;
values[nindd].signiaib = -1 ;
nbvalues += 1 ;
}
else {
values[nindd].nbr = 0 ;
values[nindd].signiaib = 0 ;
}
}
for ( ia = 1 ; ia <= maxia ; ia++ ) {
if ( nbvalues == VALUESNBR*2 ) {
break ;
}
remain = -VALUESNBR ;
ib[0] = ( minn + ia - remain ) / (6*ia - 1) ;
n[0] = int ( 6*ia*ib[0] - ia - ib[0] - minn ) ;
ib[1] = ( minn - ia - remain ) / (6*ia - 1) ;
n[1] = int ( 6*ia*ib[1] + ia - ib[1] - minn ) ;
ib[2] = ( minn + ia - remain ) / (6*ia + 1) ;
n[2] = int ( 6*ia*ib[2] - ia + ib[2] - minn ) ;
ib[3] = ( minn - ia - remain ) / (6*ia + 1) ;
n[3] = int ( 6*ia*ib[3] + ia + ib[3] - minn ) ;
for ( loop = 0 ; loop < 4 ; loop++ ) {
if ( n[loop] >= 0 && n[loop] < VALUESNBR ) {
if ( ( values[n[loop]].nbr == 0 ) ||
( values[n[loop]].signiaib == signiaib[loop] ) ) {
values[n[loop]].signiaib = -signiaib[loop] ;
values[n[loop]].nbr += 1 ;
if ( values[n[loop]].nbr <= 2 )
nbvalues += 1 ;
}
}
}
}
for ( nindd = 0 ; nindd < VALUESNBR ; nindd++ ) {
if ( values[nindd].nbr == 0 ) {
if ( me <= 6*(nindd+minn)-1 ) {
premret = 6*(nindd+minn)-1 ;
break ;
}
else if ( me <= 6*(nindd+minn)+1 ) {
premret = 6*(nindd+minn)+1 ;
break ;
}
}
else if ( values[nindd].nbr == 1 ) {
if ( values[nindd].signiaib > 0 ) {
if ( me <= 6*(nindd+minn)-1 ) {
premret = 6*(nindd+minn)-1 ;
break ;
}
}
else {
if ( me <= 6*(nindd+minn)+1 ) {
premret = 6*(nindd+minn)+1 ;
break ;
}
}
}
}
if ( premret != 0 ) {
return premret ;
}
return NextPrime ( 6*(maxvn-1)+2) ;
}
static const Standard_Integer Primes[] = {
101, 1009, 2003, 3001, 4001, 5003, 6007, 7001, 8009, 9001,
10007, 12007, 14009, 16007, 18013,
20011, 23003, 26003, 29009,
33013, 37003,
41011, 46021,
51001, 57037,
65003,
100019}; // catch the biggest
const Standard_Integer NbPrimes = 26; // does not include the biggest
Standard_Integer NextPrimeForMap(const Standard_Integer N)
{
Standard_Integer i;
for (i = 0; i < NbPrimes; i++)
if (Primes[i] > N) break;
return Primes[i];
}

23
src/Standard/Standard_Integer.hxx
View File

@ -16,28 +16,7 @@
#define _Standard_Integer_HeaderFile
#include <Standard_TypeDef.hxx>
# include <Standard_values.h>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_Integer_Type_();
// ===============================================
// Methods from Standard_Entity class which are redefined:
// - Hascode
// - IsEqual
// - IsSimilar
// - Shallowcopy
// - ShallowDump
// ===============================================
// ==================================
// Methods implemeted in Standard_Integer.cxx
// ==================================
__Standard_API Standard_Integer NextPrimeForMap(const Standard_Integer anInt ) ;
__Standard_API long NextPrime (const long me);
__Standard_API Standard_Integer CharToInt (const Standard_Character me);
__Standard_API Standard_Integer CharToInt (const Standard_CString me);
__Standard_API Standard_Integer ShallowCopy (const Standard_Integer me);
#include <Standard_values.h>
// ===============
// Inline methods

31
src/Standard/Standard_OId.hxx
View File

@ -1,31 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Standard_OId_HeaderFile
#define _Standard_OId_HeaderFile
#include <Standard_Integer.hxx>
#include <Standard_OStream.hxx>
class Standard_Persistent;
typedef Standard_Persistent* Standard_OId;
extern Standard_OId ShallowCopy (const Standard_OId me) ;
extern Standard_Integer HashCode(const Standard_OId me,
const Standard_Integer Upper);
//extern void ShallowDump (const Standard_OId Value, Standard_OStream& s);
const Handle_Standard_Type& Standard_OId_Type_();
#endif

26
src/Standard/Standard_OStream.cxx
View File

@ -1,26 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_OStream.hxx>
#include <Standard_Type.hxx>
const Handle_Standard_Type& Standard_OStream_Type_()
{
static Handle_Standard_Type _aType =
new Standard_Type("Standard_OStream", sizeof(Standard_OStream));
return _aType;
}

19
src/Standard/Standard_OStream.hxx
View File

@ -18,24 +18,7 @@
#include <Standard_TypeDef.hxx>
#include <Standard_Stream.hxx>
class Handle_Standard_Type;
__Standard_API const Handle_Standard_Type& Standard_OStream_Type_();
typedef ostream Standard_OStream;
__Standard_API void ShallowDump(const Standard_Boolean, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_CString, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_Character, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_ExtCharacter, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_ExtString, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_Integer, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_Real, Standard_OStream& );
__Standard_API void ShallowDump(const Standard_ShortReal, Standard_OStream& );
class Handle(Standard_Transient);
__Standard_API void ShallowDump(const Handle(Standard_Transient)&, Standard_OStream& );
class Handle(Standard_Persistent);
__Standard_API void ShallowDump(const Handle(Standard_Persistent)&, Standard_OStream& );
typedef std::ostream Standard_OStream;
#endif

7
src/Standard/Standard_Persistent.cdl
View File

@ -59,13 +59,6 @@ uses
is
ShallowCopy (me) returns mutable like me is deferred;
---Purpose: Returns a copy at the first level of <me>.
-- The objects referenced are not copied.
-- Entities copied by ShallowCopy are equal.
---C++: function call
---Level: Advanced
Delete (me: mutable) is redefined;
---Purpose: Deletes this object.

28
src/Standard/Standard_Persistent.cxx
View File

@ -49,33 +49,12 @@ Handle_Standard_Persistent Standard_Persistent::This() const
return aHand;
}
// The Method ShallowCopy
//
Handle_Standard_Persistent Standard_Persistent::ShallowCopy() const
{
//the method must be redefined in the every subclass that is expected to use it
Standard_NotImplemented::Raise ("The ShallowCopy() method must be redefined in the subclass");
return This(); // for compilation only
}
// Empty Constructor
//
// Standard_Persistent::Standard_Persistent()
// {
// }
// Empty Destructor
//
Standard_Persistent::~Standard_Persistent()
{
}
// Constructor from a Standard_Persistent
//
// Standard_Persistent::Standard_Persistent(const Standard_Persistent& )
// {
// }
// Operator= with a Standard_Persistent
//
Standard_Persistent& Standard_Persistent::operator=(const Standard_Persistent& )
@ -106,13 +85,6 @@ Standard_Boolean Standard_Persistent::IsKind (const Handle(Standard_Type)& aType
// return (aType == STANDARD_TYPE(Standard_Persistent));
}
void Standard_Persistent::ShallowDump(Standard_OStream& AStream) const
{
Handle(Standard_Persistent) me = this;
::ShallowDump(me, AStream);
}
void Standard_Persistent::Delete() const
{
delete((Standard_Persistent *)this);

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