Commit 7f5baec5 authored by Robert Maynard's avatar Robert Maynard Committed by Kitware Robot

Merge topic 'replace_boost_ctypes_with_cxx11_types'

2c3aab64 Replace boost::int64_t with std::int64_t
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Reviewed-by: T.J. Corona's avatarT.J. Corona <tj.corona@kitware.com>
Merge-request: !357
parents 6d605449 2c3aab64
......@@ -96,8 +96,8 @@ namespace
{
// functions to shunt past data transfer if input and output types match
void constructNewArrayIfNecessary(vtkIdType*&, vtkIdType*&, boost::int64_t) {}
void transferDataIfNecessary(vtkIdType*& in, vtkIdType*& out, boost::int64_t)
void constructNewArrayIfNecessary(vtkIdType*&, vtkIdType*&, std::int64_t) {}
void transferDataIfNecessary(vtkIdType*& in, vtkIdType*& out, std::int64_t)
{
out = in;
}
......@@ -106,15 +106,15 @@ void deleteOldArrayIfNecessary(vtkIdType*&, vtkIdType*&) {}
// functions for allocation, transfer and deallocation when there is a type
// mismatch
template <typename T>
void constructNewArrayIfNecessary(T*&, vtkIdType*& out, boost::int64_t len)
void constructNewArrayIfNecessary(T*&, vtkIdType*& out, std::int64_t len)
{
out = new vtkIdType[len];
}
template <typename T>
void transferDataIfNecessary(T*& in, vtkIdType*& out, boost::int64_t len)
void transferDataIfNecessary(T*& in, vtkIdType*& out, std::int64_t len)
{
for (boost::int64_t i=0;i<len;i++)
for (std::int64_t i=0;i<len;i++)
{
out[i] = in[i];
}
......@@ -151,9 +151,9 @@ void ExportVTKData::operator()(const smtk::mesh::MeshSet& meshset,
smtk::mesh::CellSet cellset =
meshset.cells(static_cast<smtk::mesh::DimensionType>(dimension));
boost::int64_t connectivityLength= -1;
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t connectivityLength= -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
//determine the allocation lengths
smtk::mesh::PreAllocatedTessellation::determineAllocationLengths(
......@@ -166,8 +166,8 @@ void ExportVTKData::operator()(const smtk::mesh::MeshSet& meshset,
//create raw data buffers to hold our data
double* pointsData = new double[3*numberOfPoints];
unsigned char* cellTypesData = new unsigned char[numberOfCells];
boost::int64_t* cellLocationsData_ = new boost::int64_t[numberOfCells];
boost::int64_t* connectivityData_ = new boost::int64_t[connectivityLength];
std::int64_t* cellLocationsData_ = new std::int64_t[numberOfCells];
std::int64_t* connectivityData_ = new std::int64_t[connectivityLength];
//extract tessellation information
smtk::mesh::PreAllocatedTessellation tess(connectivityData_,
......@@ -232,8 +232,8 @@ void ExportVTKData::operator()(const smtk::mesh::MeshSet& meshset,
if (!domainPropertyName.empty())
{
boost::int64_t* cellData_ = new boost::int64_t[numberOfCells];
boost::int64_t* pointData_ = new boost::int64_t[numberOfPoints];
std::int64_t* cellData_ = new std::int64_t[numberOfCells];
std::int64_t* pointData_ = new std::int64_t[numberOfPoints];
//extract field information
smtk::mesh::PreAllocatedField field(cellData_, pointData_);
......@@ -272,9 +272,9 @@ void ExportVTKData::operator()(const smtk::mesh::MeshSet& meshset,
vtkUnstructuredGrid* ug,
std::string domainPropertyName) const
{
boost::int64_t connectivityLength= -1;
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t connectivityLength= -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
//determine the allocation lengths
smtk::mesh::PreAllocatedTessellation::determineAllocationLengths(
......@@ -287,8 +287,8 @@ void ExportVTKData::operator()(const smtk::mesh::MeshSet& meshset,
//create raw data buffers to hold our data
double* pointsData = new double[3*numberOfPoints];
unsigned char* cellTypesData = new unsigned char[numberOfCells];
boost::int64_t* cellLocationsData_ = new boost::int64_t[numberOfCells];
boost::int64_t* connectivityData_ = new boost::int64_t[connectivityLength];
std::int64_t* cellLocationsData_ = new std::int64_t[numberOfCells];
std::int64_t* connectivityData_ = new std::int64_t[connectivityLength];
//extract tessellation information
smtk::mesh::PreAllocatedTessellation tess(connectivityData_,
......@@ -343,8 +343,8 @@ void ExportVTKData::operator()(const smtk::mesh::MeshSet& meshset,
if (!domainPropertyName.empty())
{
boost::int64_t* cellData_ = new boost::int64_t[numberOfCells];
boost::int64_t* pointData_ = new boost::int64_t[numberOfPoints];
std::int64_t* cellData_ = new std::int64_t[numberOfCells];
std::int64_t* pointData_ = new std::int64_t[numberOfPoints];
//extract field information
smtk::mesh::PreAllocatedField field(cellData_, pointData_);
......
......@@ -189,9 +189,9 @@ static void internal_AddBlockInfo(
static void convert_smtkMesh_singleDimCells_to_vtkPolyData(const smtk::mesh::CellSet& cells,
vtkPoints* pts, vtkPolyData* pd)
{
boost::int64_t connectivityLength= -1;
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t connectivityLength= -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
//query for all cells
smtk::mesh::PreAllocatedTessellation::determineAllocationLengths(cells,
......@@ -199,8 +199,8 @@ static void convert_smtkMesh_singleDimCells_to_vtkPolyData(const smtk::mesh::Cel
numberOfCells,
numberOfPoints);
// std::vector<boost::int64_t> conn( connectivityLength + numberOfCells );
// std::vector<boost::int64_t> locations( numberOfCells );
// std::vector<std::int64_t> conn( connectivityLength + numberOfCells );
// std::vector<std::int64_t> locations( numberOfCells );
// std::vector<unsigned char> types( numberOfCells );
// std::vector<double> dpoints( numberOfPoints * 3 );
......@@ -226,7 +226,7 @@ static void convert_smtkMesh_singleDimCells_to_vtkPolyData(const smtk::mesh::Cel
double *rawPoints = static_cast<double*>(pts->GetVoidPointer(0));
cellarray->Allocate(connectivityLength + numberOfCells);
boost::int64_t* cellconn = reinterpret_cast<boost::int64_t *>(
std::int64_t* cellconn = reinterpret_cast<std::int64_t *>(
cellarray->WritePointer(numberOfCells, connectivityLength + numberOfCells));
smtk::mesh::PreAllocatedTessellation tess(cellconn,
rawPoints);
......@@ -342,7 +342,7 @@ void vtkMeshMultiBlockSource::GenerateRepresentationForSingleMesh(
toRender.append(twoD);
toRender.append(oneD);
toRender.append(zeroD);
convert_smtkMesh_to_vtkPolyData(toRender, pts.GetPointer(), pd);
// std::cout << "Number of points: " << pd->GetNumberOfPoints() << std::endl;
this->GenerateNormals(pd, entityref, genNormals);
......
......@@ -213,8 +213,8 @@ public:
//Use the extractTessellation helpers to convert the connectivity
//to map properly to the PointSet that represents ALL points we are
//using, not just the points these cells are using
boost::int64_t connectivityLen = cells.pointConnectivity().size();
std::vector<boost::int64_t> conn(connectivityLen);
std::int64_t connectivityLen = cells.pointConnectivity().size();
std::vector<std::int64_t> conn(connectivityLen);
smtk::mesh::PreAllocatedTessellation connectivityInfo(&conn[0]);
connectivityInfo.disableVTKStyleConnectivity(true);
......@@ -242,10 +242,10 @@ public:
//Use the extractTessellation helpers to convert the connectivity
//to map properly to the PointSet that represents ALL points we are
//using, not just the points these cells are using
boost::int64_t connectivityLen = cells.pointConnectivity().size();
boost::int64_t pointLen = this->m_PointSet.size() * 3;
std::int64_t connectivityLen = cells.pointConnectivity().size();
std::int64_t pointLen = this->m_PointSet.size() * 3;
std::vector<boost::int64_t> conn(connectivityLen);
std::vector<std::int64_t> conn(connectivityLen);
std::vector<double> points(pointLen);
smtk::mesh::PreAllocatedTessellation connectivityInfo(&conn[0], &points[0]);
......
......@@ -33,10 +33,10 @@ namespace mesh {
//----------------------------------------------------------------------------
void PreAllocatedField::determineAllocationLengths(
const smtk::mesh::MeshSet& ms,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints)
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints)
{
boost::int64_t connectivityLength;
std::int64_t connectivityLength;
PreAllocatedTessellation::determineAllocationLengths(ms.cells(),
connectivityLength,
numberOfCells,
......@@ -44,8 +44,8 @@ void PreAllocatedField::determineAllocationLengths(
}
//----------------------------------------------------------------------------
PreAllocatedField::PreAllocatedField(boost::int64_t* cellField,
boost::int64_t* pointField):
PreAllocatedField::PreAllocatedField(std::int64_t* cellField,
std::int64_t* pointField):
m_cellField(cellField),
m_pointField(pointField)
{
......@@ -58,8 +58,8 @@ void Field::extract( const smtk::mesh::MeshSet& ms,
const smtk::mesh::PointSet& ps )
{
//determine the lengths
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
PreAllocatedField::determineAllocationLengths(ms,
numberOfCells,
......
......@@ -11,7 +11,7 @@
#ifndef __smtk_mesh_ExtractField_h
#define __smtk_mesh_ExtractField_h
#include <boost/cstdint.hpp>
#include <cstdint>
#include "smtk/mesh/CellSet.h"
#include "smtk/mesh/MeshSet.h"
......@@ -25,11 +25,11 @@ class SMTKCORE_EXPORT PreAllocatedField
public:
static void determineAllocationLengths(const smtk::mesh::MeshSet& ms,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints);
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints);
PreAllocatedField( boost::int64_t* cellField,
boost::int64_t* pointField );
PreAllocatedField( std::int64_t* cellField,
std::int64_t* pointField );
private:
template <typename QueryTag>
......@@ -37,8 +37,8 @@ friend SMTKCORE_EXPORT void extractField( const smtk::mesh::MeshSet&,
const smtk::mesh::PointSet&,
PreAllocatedField& );
boost::int64_t* m_cellField;
boost::int64_t* m_pointField;
std::int64_t* m_cellField;
std::int64_t* m_pointField;
};
class SMTKCORE_EXPORT Field
......@@ -60,9 +60,9 @@ public:
const smtk::mesh::PointSet& ps );
//use these methods to gain access to the field after extraction
const std::vector<boost::int64_t>& cellData() const
const std::vector<std::int64_t>& cellData() const
{ return this->m_cellData; }
const std::vector<boost::int64_t>& pointData() const
const std::vector<std::int64_t>& pointData() const
{ return this->m_pointData; }
private:
......@@ -70,8 +70,8 @@ private:
void extract( const smtk::mesh::MeshSet& ms,
const smtk::mesh::PointSet& ps );
std::vector<boost::int64_t> m_cellData;
std::vector<boost::int64_t> m_pointData;
std::vector<std::int64_t> m_cellData;
std::vector<std::int64_t> m_pointData;
};
//Don't wrap these for python, instead python should use the Field class and
......
......@@ -90,7 +90,7 @@ std::size_t smtkToVTKLocation(const std::size_t& location, int numPts)
}
inline
std::size_t smtkToSMTKConn(boost::int64_t&, std::size_t index, int)
std::size_t smtkToSMTKConn(std::int64_t&, std::size_t index, int)
{
//do nothing as we aren't storing the length of each cell in the connectivity
//array
......@@ -98,7 +98,7 @@ std::size_t smtkToSMTKConn(boost::int64_t&, std::size_t index, int)
}
inline
std::size_t smtkToVTKConn(boost::int64_t& conn, std::size_t index, int numPts)
std::size_t smtkToVTKConn(std::int64_t& conn, std::size_t index, int numPts)
{
//store the length of the cell in the connectivity array
conn = numPts;
......@@ -109,9 +109,9 @@ std::size_t smtkToVTKConn(boost::int64_t& conn, std::size_t index, int numPts)
//----------------------------------------------------------------------------
void PreAllocatedTessellation::determineAllocationLengths(const smtk::mesh::MeshSet& ms,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints)
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints)
{
determineAllocationLengths(ms.cells(),
......@@ -122,9 +122,9 @@ void PreAllocatedTessellation::determineAllocationLengths(const smtk::mesh::Mesh
//----------------------------------------------------------------------------
void PreAllocatedTessellation::determineAllocationLengths(const smtk::mesh::CellSet& cs,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints)
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints)
{
connectivityLength = cs.pointConnectivity().size();
......@@ -135,9 +135,9 @@ void PreAllocatedTessellation::determineAllocationLengths(const smtk::mesh::Cell
//----------------------------------------------------------------------------
void PreAllocatedTessellation::determineAllocationLengths(const smtk::model::EntityRef& eRef,
const smtk::mesh::CollectionPtr& c,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints)
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints)
{
determineAllocationLengths(c->findAssociatedCells(eRef),
......@@ -149,9 +149,9 @@ void PreAllocatedTessellation::determineAllocationLengths(const smtk::model::Ent
//----------------------------------------------------------------------------
void PreAllocatedTessellation::determineAllocationLengths(const smtk::model::Loop& loop,
const smtk::mesh::CollectionPtr& c,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints)
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints)
{
smtk::mesh::HandleRange cellRange;
......@@ -174,7 +174,7 @@ void PreAllocatedTessellation::determineAllocationLengths(const smtk::model::Loo
}
//----------------------------------------------------------------------------
PreAllocatedTessellation::PreAllocatedTessellation( boost::int64_t* connectivity ):
PreAllocatedTessellation::PreAllocatedTessellation( std::int64_t* connectivity ):
m_connectivity(connectivity),
m_cellLocations(NULL),
m_cellTypes(NULL),
......@@ -187,7 +187,7 @@ PreAllocatedTessellation::PreAllocatedTessellation( boost::int64_t* connectivity
}
//----------------------------------------------------------------------------
PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
PreAllocatedTessellation::PreAllocatedTessellation(std::int64_t* connectivity,
float* points):
m_connectivity(connectivity),
m_cellLocations(NULL),
......@@ -201,7 +201,7 @@ PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
}
//----------------------------------------------------------------------------
PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
PreAllocatedTessellation::PreAllocatedTessellation(std::int64_t* connectivity,
double* points):
m_connectivity(connectivity),
m_cellLocations(NULL),
......@@ -215,8 +215,8 @@ PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
}
//----------------------------------------------------------------------------
PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
boost::int64_t* cellLocations,
PreAllocatedTessellation::PreAllocatedTessellation(std::int64_t* connectivity,
std::int64_t* cellLocations,
unsigned char* cellTypes):
m_connectivity(connectivity),
m_cellLocations(cellLocations),
......@@ -230,8 +230,8 @@ PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
}
//----------------------------------------------------------------------------
PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
boost::int64_t* cellLocations,
PreAllocatedTessellation::PreAllocatedTessellation(std::int64_t* connectivity,
std::int64_t* cellLocations,
unsigned char* cellTypes,
float* points):
m_connectivity(connectivity),
......@@ -246,8 +246,8 @@ PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
}
//----------------------------------------------------------------------------
PreAllocatedTessellation::PreAllocatedTessellation(boost::int64_t* connectivity,
boost::int64_t* cellLocations,
PreAllocatedTessellation::PreAllocatedTessellation(std::int64_t* connectivity,
std::int64_t* cellLocations,
unsigned char* cellTypes,
double* points):
m_connectivity(connectivity),
......@@ -310,9 +310,9 @@ void Tessellation::extract( const smtk::mesh::CellSet& cs,
const smtk::mesh::PointSet& ps )
{
//determine the lengths
boost::int64_t connectivityLength= -1;
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t connectivityLength= -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
PreAllocatedTessellation::determineAllocationLengths(cs,
connectivityLength,
......@@ -404,7 +404,7 @@ void extractTessellationInternal( PointConnectivity& pc,
//we are using VTK style connectivity or a compacted connectivity format.
//determine the function pointer to use for the connectivity array
std::size_t (*addCellLen)(boost::int64_t& conn, std::size_t index, int numPts) = detail::smtkToSMTKConn;
std::size_t (*addCellLen)(std::int64_t& conn, std::size_t index, int numPts) = detail::smtkToSMTKConn;
if(tess.m_useVTKConnectivity)
{
addCellLen = detail::smtkToVTKConn;
......
......@@ -11,7 +11,7 @@
#ifndef __smtk_mesh_ExtractTessellation_h
#define __smtk_mesh_ExtractTessellation_h
#include <boost/cstdint.hpp>
#include <cstdint>
#include "smtk/mesh/CellSet.h"
#include "smtk/mesh/MeshSet.h"
......@@ -22,61 +22,60 @@ namespace mesh {
class SMTKCORE_EXPORT PreAllocatedTessellation
{
public:
// Todo: Document that connectivityLength is just pure lenght of connectivity
// Todo: Document that connectivityLength is just pure length of connectivity
// if you are enabling vtk length you need to allocate for connectivityLength
// + numberOfCells
static void determineAllocationLengths(const smtk::mesh::MeshSet& ms,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints);
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints);
static void determineAllocationLengths(const smtk::mesh::CellSet& cs,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints);
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints);
static void determineAllocationLengths(const smtk::model::EntityRef& eRef,
const smtk::mesh::CollectionPtr& c,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints);
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints);
static void determineAllocationLengths(const smtk::model::Loop& loop,
const smtk::mesh::CollectionPtr& c,
boost::int64_t& connectivityLength,
boost::int64_t& numberOfCells,
boost::int64_t& numberOfPoints);
std::int64_t& connectivityLength,
std::int64_t& numberOfCells,
std::int64_t& numberOfPoints);
//Only converts connectivity. The following properties will not be
//converted: cellLocations, cellTypes, and Points
PreAllocatedTessellation( boost::int64_t* connectivity );
PreAllocatedTessellation( std::int64_t* connectivity );
//Converts connectivity and store the points as floats. The following properties will not be
//converted: cellLocations, and cellTypes.
PreAllocatedTessellation( boost::int64_t* connectivity,
PreAllocatedTessellation( std::int64_t* connectivity,
float* points);
//Converts connectivityand store the points as doubles. The following properties will not be
//converted: cellLocations, and cellTypes.
PreAllocatedTessellation( boost::int64_t* connectivity,
PreAllocatedTessellation( std::int64_t* connectivity,
double* points);
//Converts everything but Points.
PreAllocatedTessellation( boost::int64_t* connectivity,
boost::int64_t* cellLocations,
PreAllocatedTessellation( std::int64_t* connectivity,
std::int64_t* cellLocations,
unsigned char* cellTypes);
//Converts everything and stores the points as floats
PreAllocatedTessellation( boost::int64_t* connectivity,
boost::int64_t* cellLocations,
PreAllocatedTessellation( std::int64_t* connectivity,
std::int64_t* cellLocations,
unsigned char* cellTypes,
float* points);
//Converts everything and stores the points as doubles
PreAllocatedTessellation( boost::int64_t* connectivity,
boost::int64_t* cellLocations,
PreAllocatedTessellation( std::int64_t* connectivity,
std::int64_t* cellLocations,
unsigned char* cellTypes,
double* points);
......@@ -107,8 +106,8 @@ private:
extractTessellationInternal( PointConnectivity&,
const smtk::mesh::PointSet&,
PreAllocatedTessellation& );
boost::int64_t* m_connectivity;
boost::int64_t* m_cellLocations;
std::int64_t* m_connectivity;
std::int64_t* m_cellLocations;
unsigned char* m_cellTypes;
double* m_dpoints;
......@@ -140,14 +139,14 @@ public:
void extract( const smtk::mesh::CellSet& cs, const smtk::mesh::PointSet& ps );
//use these methods to gain access to the tessellation after
const std::vector<boost::int64_t>& connectivity() const {return this->m_connectivity;}
const std::vector<boost::int64_t>& cellLocations() const {return this->m_cellLocations;}
const std::vector<std::int64_t>& connectivity() const {return this->m_connectivity;}
const std::vector<std::int64_t>& cellLocations() const {return this->m_cellLocations;}
const std::vector<unsigned char>& cellTypes() const {return this->m_cellTypes;}
const std::vector<double>& points() const {return this->m_points;}
private:
std::vector<boost::int64_t> m_connectivity;
std::vector<boost::int64_t> m_cellLocations;
std::vector<std::int64_t> m_connectivity;
std::vector<std::int64_t> m_cellLocations;
std::vector<unsigned char> m_cellTypes;
std::vector<double> m_points;
......
......@@ -11,7 +11,7 @@
#include "smtk/mesh/Handle.h"
#include "cJSON.h"
#include <boost/cstdint.hpp>
#include <cstdint>
#include <iostream>
#include <sstream>
......
......@@ -18,7 +18,7 @@
#include "smtk/mesh/moab/Allocator.h"
#include "smtk/mesh/moab/Interface.h"
#include <boost/cstdint.hpp>
#include <cstdint>
#include <cassert>
......@@ -65,14 +65,14 @@ private:
template <typename IntegerType>
bool addCell(smtk::mesh::CellType ctype,
IntegerType* pointIds,
boost::int64_t nCoordinates);
std::int64_t nCoordinates);
::moab::EntityHandle m_firstCoordinate;
std::size_t m_nCoordinates;
std::vector<double*> m_coordinateMemory;
smtk::mesh::CellType m_activeCellType;
int m_nCoords;
std::vector<boost::int64_t> m_localConnectivity;
std::vector<std::int64_t> m_localConnectivity;
::moab::Range m_cells;
};
......@@ -80,7 +80,7 @@ private:
template <typename IntegerType>
bool BufferedCellAllocator::addCell(smtk::mesh::CellType ctype,
IntegerType* pointIds,
boost::int64_t nCoordinates)
std::int64_t nCoordinates)
{
if (!this->m_validState) { return false; }
......@@ -96,7 +96,7 @@ bool BufferedCellAllocator::addCell(smtk::mesh::CellType ctype,
assert(this->m_activeCellType != smtk::mesh::CellType_MAX);
assert(this->m_nCoords > 0);
for (boost::int64_t i = 0; i < this->m_nCoords; i++)
for (std::int64_t i = 0; i < this->m_nCoords; i++)
{
this->m_localConnectivity.push_back(pointIds[i]);
}
......
......@@ -61,7 +61,7 @@ class ValidateCells : public smtk::mesh::CellForEach
public:
ValidateCells(const std::vector<smtk::mesh::CellSet>& cellsByDomain,
const std::vector<smtk::mesh::Domain>& domains,
const boost::int64_t* domainAssignments,
const std::int64_t* domainAssignments,
const smtk::mesh::HandleRange cellRange) :
smtk::mesh::CellForEach(),
m_cellsByDomain(cellsByDomain),
......@@ -76,7 +76,7 @@ public:
smtk::mesh::CellType, int)
{
// default to the value for unlabeled domains
boost::int64_t domainValue = -1;
std::int64_t domainValue = -1;
for (std::size_t i = 0; i < this->m_cellsByDomain.size(); ++i)
{
......@@ -93,7 +93,7 @@ public:
const std::vector<smtk::mesh::CellSet>& m_cellsByDomain;
const std::vector<smtk::mesh::Domain>& m_domains;
const boost::int64_t* m_domainAssignments;
const std::int64_t* m_domainAssignments;
const smtk::mesh::HandleRange m_cellRange;
std::size_t m_index;
};
......@@ -104,7 +104,7 @@ class ValidatePoints : public smtk::mesh::PointForEach
public:
ValidatePoints(const std::vector<smtk::mesh::PointSet>& pointsByDomain,
const std::vector<smtk::mesh::Domain>& domains,
const boost::int64_t* domainAssignments,
const std::int64_t* domainAssignments,
const smtk::mesh::HandleRange pointRange) :
smtk::mesh::PointForEach(),
m_pointsByDomain(pointsByDomain),
......@@ -121,7 +121,7 @@ public:
for (auto point = pointIds.begin(); point != pointIds.end(); ++point)
{
// default to the value for unlabeled domains
boost::int64_t domainValue = -1;
std::int64_t domainValue = -1;
for (std::size_t i = 0; i < this->m_pointsByDomain.size(); ++i)
{
......@@ -138,7 +138,7 @@ public:
const std::vector<smtk::mesh::PointSet>& m_pointsByDomain;
const std::vector<smtk::mesh::Domain>& m_domains;
const boost::int64_t* m_domainAssignments;
const std::int64_t* m_domainAssignments;
const smtk::mesh::HandleRange m_pointRange;
std::size_t m_index;
};
......@@ -162,15 +162,15 @@ void verify_extract_domain()
SubdivideMesh subdivideMesh(order);
smtk::mesh::for_each( meshes, subdivideMesh );
boost::int64_t numberOfCells;
boost::int64_t numberOfPoints;
std::int64_t numberOfCells;
std::int64_t numberOfPoints;
smtk::mesh::PreAllocatedField::determineAllocationLengths(meshes,
numberOfCells,
numberOfPoints);
boost::int64_t* cells = new boost::int64_t[numberOfCells];
boost::int64_t* points = new boost::int64_t[numberOfPoints];
std::int64_t* cells = new std::int64_t[numberOfCells];
std::int64_t* points = new std::int64_t[numberOfPoints];
smtk::mesh::PreAllocatedField field(cells, points);
smtk::mesh::extractDomainField(meshes, field);
......
......@@ -162,15 +162,15 @@ int UnitTestExtractOrderedTessellation(int, char** const)
smtk::model::Loop exteriorLoop = exteriorLoops[0];
boost::int64_t connectivityLength= -1;
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t connectivityLength= -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
//query for all cells
smtk::mesh::PreAllocatedTessellation::determineAllocationLengths(
exteriorLoop, c, connectivityLength, numberOfCells, numberOfPoints);
std::vector<boost::int64_t> conn( connectivityLength );
std::vector<std::int64_t> conn( connectivityLength );
std::vector<float> fpoints(numberOfPoints * 3);
smtk::mesh::PreAllocatedTessellation ftess(&conn[0], &fpoints[0]);
......@@ -186,15 +186,15 @@ int UnitTestExtractOrderedTessellation(int, char** const)
for (auto& edge : edges)
{
boost::int64_t connectivityLength= -1;
boost::int64_t numberOfCells = -1;
boost::int64_t numberOfPoints = -1;
std::int64_t connectivityLength= -1;
std::int64_t numberOfCells = -1;
std::int64_t numberOfPoints = -1;
//query for all cells
smtk::mesh::PreAllocatedTessellation::determineAllocationLengths(
edge, c, connectivityLength, numberOfCells, numberOfPoints);
std::vector<boost::int64_t> conn( connectivityLength );
std::vector<std::int64_t> conn( connectivityLength );
std::vector<float> fpoints(numberOfPoints * 3);