mirror of
https://github.com/mcneel/opennurbs.git
synced 2026-03-03 04:57:01 +08:00
453 lines
14 KiB
C++
453 lines
14 KiB
C++
/* $NoKeywords: $ */
|
|
/*
|
|
//
|
|
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
|
|
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
|
|
// McNeel & Associates.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
|
|
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
|
|
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
|
|
//
|
|
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
|
|
//
|
|
////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
#if !defined(OPENNURBS_WORKSPACE_INC_)
|
|
#define OPENNURBS_WORKSPACE_INC_
|
|
|
|
/*
|
|
Description:
|
|
Use ON_Workspace classes on the stack to efficiently get
|
|
and automatically clean up workspace memory and scratch
|
|
files.
|
|
*/
|
|
class ON_CLASS ON_Workspace
|
|
{
|
|
public:
|
|
/*
|
|
Description:
|
|
ON_Workspace classes should be on the stack
|
|
or as members on classes that are never copied.
|
|
The destructor frees memory that was allocated by
|
|
ON_Workspace::GetMemory and closes files that were
|
|
opened with ON_Workspace::OpenFile.
|
|
*/
|
|
ON_Workspace();
|
|
|
|
/*
|
|
Description:
|
|
The destructor frees memory that was allocated by
|
|
ON_Workspace::GetMemory and closes files that were
|
|
opened with ON_Workspace::OpenFile.
|
|
*/
|
|
~ON_Workspace();
|
|
|
|
/*
|
|
Description:
|
|
The destructor frees memory that was allocated by
|
|
ON_Workspace::GetMemory and closes files that were
|
|
opened with ON_Workspace::OpenFile. The workspace
|
|
can be used again after calling destroy.
|
|
*/
|
|
void Destroy();
|
|
|
|
/*
|
|
Description:
|
|
Gets a block of heap memory that will be freed by
|
|
~ON_Workspace. The intent of ON_Workspace::GetMemory
|
|
is to provide an easy way to get blocks of scratch
|
|
memory without having to worry about cleaning up
|
|
before returning.
|
|
Parameters:
|
|
sz - [in] (>0) size of memory block in bytes.
|
|
If sz <= 0, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the memory block.
|
|
Remarks.
|
|
onmalloc() is used to get the block of memory.
|
|
Do NOT free the pointer returned by GetMemory().
|
|
~ON_Workspace() will free the memory. If you decide
|
|
you want to keep the memory block, pass the pointer
|
|
to KeepMemory before ~ON_Workspace is called.
|
|
See Also:
|
|
ON_Workspace::::~ON_Workspace
|
|
ON_Workspace::KeepMemory
|
|
ON_Workspace::GrowMemory
|
|
ON_Workspace::GetIntMemory
|
|
ON_Workspace::GetDoubleMemory
|
|
ON_Workspace::GetPointMemory
|
|
ON_Workspace::GetVectorMemory
|
|
*/
|
|
void* GetMemory( size_t sz );
|
|
|
|
/*
|
|
Description:
|
|
Gets an array of integers that will be freed by ~ON_Workspace.
|
|
The intent of ON_Workspace::GetIntMemory is to provide
|
|
an easy way to get scratch integer arrays without
|
|
having to worry about cleaning up before returning.
|
|
Parameters:
|
|
count - [in] (>0) number of integers in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the array of integers.
|
|
Remarks.
|
|
This is a simple helper function so you don't have to
|
|
mess around with (int*) casts and sizeof(int)s in a call
|
|
to GetMemory(). It is exactly like calling
|
|
(int*)GetMemory(count*sizeof(int));
|
|
See Also:
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepMemory
|
|
ON_Workspace::GrowIntMemory
|
|
*/
|
|
int* GetIntMemory( size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Gets an matrix of integers
|
|
Parameters:
|
|
row_count - [in] (>0) number of rows
|
|
col_count - [in] (>0) number of columns
|
|
Returns:
|
|
A pointer p so that p[i][j] is an integer when
|
|
0 <= i < row_count and 0 <= j < col_count.
|
|
Remarks.
|
|
This is a simple helper function so you don't have to
|
|
mess around building the 2d array.
|
|
See Also:
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
int** GetIntMemory( size_t row_count, size_t col_count );
|
|
|
|
/*
|
|
Description:
|
|
Gets an array of doubles that will be freed by ~ON_Workspace.
|
|
The intent of ON_Workspace::GetDoubleMemory is to provide
|
|
an easy way to get scratch double arrays without
|
|
having to worry about cleaning up before returning.
|
|
Parameters:
|
|
count - [in] (>0) number of doubles in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the array of doubles.
|
|
Remarks.
|
|
This is a simple helper function so you don't have to
|
|
mess around with (double*) casts and sizeof(double)s
|
|
in a call to GetMemory(). It is exactly like calling
|
|
(double*)GetMemory(count*sizeof(double));
|
|
See Also:
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepMemory
|
|
ON_Workspace::GrowIntMemory
|
|
*/
|
|
double* GetDoubleMemory( size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Gets an matrix of doubles
|
|
Parameters:
|
|
row_count - [in] (>0) number of rows
|
|
col_count - [in] (>0) number of columns
|
|
Returns:
|
|
A pointer p so that p[i][j] is an double when
|
|
0 <= i < row_count and 0 <= j < col_count.
|
|
Remarks.
|
|
This is a simple helper function so you don't have to
|
|
mess around building the 2d array.
|
|
See Also:
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
double** GetDoubleMemory( size_t row_count, size_t col_count );
|
|
|
|
/*
|
|
Description:
|
|
Gets an array of ON_3dPoints that will be freed by ~ON_Workspace.
|
|
The intent of ON_Workspace::GetPointMemory is to
|
|
provide an easy way to get scratch point arrays without
|
|
having to worry about cleaning up before returning.
|
|
Parameters:
|
|
count - [in] (>0) number of points in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the memory block.
|
|
Remarks.
|
|
This is a simple helper function so you don't have to
|
|
mess around with (ON_3dPoint*) casts and sizeof(ON_3dPoint)s
|
|
in a call to GetMemory(). It is exactly like calling
|
|
(ON_3dPoint*)GetMemory(count*sizeof(ON_3dPoint));
|
|
See Also:
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepMemory
|
|
ON_Workspace::GrowIntMemory
|
|
*/
|
|
ON_3dPoint* GetPointMemory( size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Gets an array of ON_3dVectors that will be freed by ~ON_Workspace.
|
|
The intent of ON_Workspace::GetVectorMemory is to
|
|
provide an easy way to get scratch Vector arrays without
|
|
having to worry about cleaning up before returning.
|
|
Parameters:
|
|
count - [in] (>0) number of Vectors in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the memory block.
|
|
Remarks.
|
|
This is a simple helper function so you don't have to
|
|
mess around with (ON_3dVector*) casts and sizeof(ON_3dVector)s
|
|
in a call to GetMemory(). It is exactly like calling
|
|
(ON_3dVector*)GetMemory(count*sizeof(ON_3dVector));
|
|
See Also:
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepMemory
|
|
ON_Workspace::GrowIntMemory
|
|
*/
|
|
ON_3dVector* GetVectorMemory( size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Grows a block of heap memory that was allocated by
|
|
ON_Workspace::GetMemory.
|
|
Parameters:
|
|
ptr - [in] pointer returned by an earlier call to
|
|
GetMemory or GrowMemory.
|
|
sz - [in] (>0) size of memory block in bytes.
|
|
If sz <= 0, then nullptr is returned.
|
|
If ptr is not nullptr and was not allocated by an
|
|
earlier call to GetMemory or GrowMemory, then
|
|
nullptr is returned.
|
|
Returns:
|
|
A pointer to the memory block.
|
|
Remarks.
|
|
onrealloc() is used to grow the block of memory.
|
|
Do NOT free the pointer returned by GrowMemory().
|
|
~ON_Workspace() will free the memory. If you decide
|
|
you want to keep the memory block, pass the pointer
|
|
to KeepMemory before ~ON_Workspace is called.
|
|
See Also:
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepMemory
|
|
ON_Workspace::GrowIntMemory
|
|
ON_Workspace::GrowDoubleMemory
|
|
ON_Workspace::GrowPointMemory
|
|
ON_Workspace::GrowVectorMemory
|
|
*/
|
|
void* GrowMemory( void* ptr, size_t sz );
|
|
|
|
/*
|
|
Description:
|
|
Grows the array of integers that was allocated by
|
|
GetIntMemory or GrowIntMemory.
|
|
Parameters:
|
|
ptr - [in] pointer returned by an earlier call to
|
|
GetIntMemory or GrowIntMemory.
|
|
count - [in] (>0) number of integers in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
If ptr was not allocated by this ON_Workspace
|
|
class, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the integer array.
|
|
Remarks.
|
|
onrealloc() is used to grow the block of memory.
|
|
Do NOT free the pointer returned by GrowIntMemory().
|
|
~ON_Workspace() will free the memory. If you decide
|
|
you want to keep the memory block, pass the pointer
|
|
to KeepMemory before ~ON_Workspace is called.
|
|
See Also:
|
|
ON_Workspace::GetIntMemory
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
int* GrowIntMemory( int* ptr, size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Grows the array of doubles that was allocated by
|
|
GetDoubleMemory or GrowDoubleMemory.
|
|
Parameters:
|
|
ptr - [in] pointer returned by an earlier call to
|
|
GetDoubleMemory or GrowDoubleMemory.
|
|
count - [in] (>0) number of doubles in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
If ptr was not allocated by this ON_Workspace
|
|
class, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the double array.
|
|
Remarks.
|
|
onrealloc() is used to grow the block of memory.
|
|
Do NOT free the pointer returned by GrowDoubleMemory().
|
|
~ON_Workspace() will free the memory. If you decide
|
|
you want to keep the memory block, pass the pointer
|
|
to KeepMemory before ~ON_Workspace is called.
|
|
See Also:
|
|
ON_Workspace::GetDoubleMemory
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
double* GrowDoubleMemory( double* ptr, size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Grows the array of points that was allocated by
|
|
GetPointMemory or GrowPointMemory.
|
|
Parameters:
|
|
ptr - [in] pointer returned by an earlier call to
|
|
GetPointMemory or GrowPointMemory.
|
|
count - [in] (>0) number of points in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
If ptr was not allocated by this ON_Workspace
|
|
class, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the point array.
|
|
Remarks.
|
|
onrealloc() is used to grow the block of memory.
|
|
Do NOT free the pointer returned by GrowMemory().
|
|
~ON_Workspace() will free the memory. If you decide
|
|
you want to keep the memory block, pass the pointer
|
|
to KeepMemory before ~ON_Workspace is called.
|
|
See Also:
|
|
ON_Workspace::GetPointMemory
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
ON_3dPoint* GrowPointMemory( ON_3dPoint* ptr, size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Grows the array of vectors that was allocated by
|
|
GetVectorMemory or GrowVectorMemory.
|
|
Parameters:
|
|
ptr - [in] pointer returned by an earlier call to
|
|
GetVectorMemory or GrowVectorMemory.
|
|
count - [in] (>0) number of vectors in memory block.
|
|
If count <= 0, then nullptr is returned.
|
|
If ptr was not allocated by this ON_Workspace
|
|
class, then nullptr is returned.
|
|
Returns:
|
|
A pointer to the vector array.
|
|
Remarks.
|
|
onrealloc() is used to grow the block of memory.
|
|
Do NOT free the pointer returned by GrowMemory().
|
|
~ON_Workspace() will free the memory. If you decide
|
|
you want to keep the memory block, pass the pointer
|
|
to KeepMemory before ~ON_Workspace is called.
|
|
See Also:
|
|
ON_Workspace::GetVectorMemory
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
ON_3dVector* GrowVectorMemory( ON_3dVector* ptr, size_t count );
|
|
|
|
/*
|
|
Description:
|
|
Calling the KeepMemory() function with a pointer
|
|
returned from one of the Get...() or Grow...() calls
|
|
keeps the workspace destructor from freeing the memory.
|
|
After calling KeepMemory(), you can no longer use
|
|
Grow...() on the pointer. The caller is responsible
|
|
for using onfree() to release the memory when it is no
|
|
longer needed.
|
|
Parameters:
|
|
ptr - [in] pointer returned by a Get...() or Grow()
|
|
call to this ON_Workspace.
|
|
Returns:
|
|
True if the pointer was successfully found and removed
|
|
from this ON_Workspace.
|
|
See Also:
|
|
ON_Workspace::~ON_Workspace
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepAllMemory
|
|
*/
|
|
bool KeepMemory( void* ptr );
|
|
|
|
/*
|
|
Description:
|
|
Calling KeepAllMemory() has the same effect as calling
|
|
KeepMemory(p) for every active allocation in the workspace.
|
|
After calling KeepAllMemory(), you can no longer use
|
|
Grow...() on the pointers and you are responsible
|
|
for using onfree() to release the memory when it is no
|
|
longer needed.
|
|
See Also:
|
|
ON_Workspace::~ON_Workspace
|
|
ON_Workspace::GetMemory
|
|
ON_Workspace::KeepMemory
|
|
*/
|
|
void KeepAllMemory();
|
|
|
|
/*
|
|
Description:
|
|
Uses ON::OpenFile to open a file. ~ON_Workspace will
|
|
close the file.
|
|
Parameters:
|
|
filename - [in] name of file
|
|
filemode - [in] open mode (just like second argument to fopen).
|
|
Returns:
|
|
Pointer to opened file.
|
|
Remarks:
|
|
~ON_Workspace will close the file.
|
|
See Also:
|
|
ON_Workspace::~ON_Workspace
|
|
ON_Workspace::KeepFile
|
|
ON::OpenFile
|
|
*/
|
|
FILE* OpenFile(
|
|
const char* filename,
|
|
const char* filemode
|
|
);
|
|
|
|
/*
|
|
Description:
|
|
Uses ON::OpenFile to open a file. ~ON_Workspace will
|
|
close the file.
|
|
Parameters:
|
|
filename - [in] name of file
|
|
filemode - [in] open mode (just like second argument to _wfopen).
|
|
Returns:
|
|
Pointer to opened file.
|
|
Remarks:
|
|
~ON_Workspace will close the file.
|
|
See Also:
|
|
ON_Workspace::~ON_Workspace
|
|
ON_Workspace::KeepFile
|
|
ON::OpenFile
|
|
*/
|
|
FILE* OpenFile(
|
|
const wchar_t* filename,
|
|
const wchar_t* filemode
|
|
);
|
|
|
|
/*
|
|
Description:
|
|
If you want to prevent ~ON_Workspace from closing a file
|
|
that was opened with ON_Workspace::OpenFile, then pass
|
|
the returned FILE pointer to KeepFile. After calling
|
|
KeepFile, the caller is responsible for calling
|
|
ON::CloseFile to close the file.
|
|
Parameters:
|
|
fileptr - [in] pointer returned by OpenFile.
|
|
Returns:
|
|
True if file was successfully closed.
|
|
See Also:
|
|
ON_Workspace::~ON_Workspace
|
|
ON_Workspace::OpenFile
|
|
ON::OpenFile
|
|
ON::CloseFile
|
|
*/
|
|
bool KeepFile(FILE* fileptr);
|
|
|
|
private:
|
|
struct ON_Workspace_FBLK * m_pFileBlk;
|
|
struct ON_Workspace_MBLK * m_pMemBlk;
|
|
|
|
private:
|
|
// There is no implementation of the following to prevent use.
|
|
// ON_Workspaces should never be copied, or you will get
|
|
// multiple attempts to free the same pointer.
|
|
ON_Workspace( const ON_Workspace& ) = delete;
|
|
ON_Workspace& operator=( const ON_Workspace& ) = delete;
|
|
};
|
|
|
|
|
|
#endif
|