void ParsedDRICmd::SetParams(const QStringList ¶ms)
{
if (CDebugMode) std::cout << "params: " << params.join(";").toStdString() << std::endl;
m_params.clear(); // ?!
// check and set params
for (int i = 0; i < params.size(); ++i)
{
QString pm( params.at(i) );
if ( pm.isEmpty() )
{
ThrowErrorMsg( "Missing method's parameter", params.join(CParamSep) );
}
// pm can also be unquoted path: obj1.obj11
if ( (!ValidateObjName(pm) )
&&( ContainsUnquotedSystemSymbols(pm) ) )
{
QString err = "Parameter contains unquoted system symbol \'" + pm + "\'";
ThrowErrorMsg(err, params.join(CParamSep));
}
pm = DriUtils::UnquoteString(pm, CStringChar);
m_params.push_back(pm);
}
}
void ParsedDRICmd::FillNameAndPath(const QString &data)
{
if (CDebugMode) std::cout << "FillNameAndPath" << std::endl;
QString tmp(data);
if ( tmp.startsWith(CPathSep) )
{
m_isRelativePath = true;
tmp = tmp.remove(0, 1);
}
// check name validation
if ( ( tmp.isEmpty() ) || ( tmp.endsWith(CPathSep) ) )
{
ThrowErrorMsg("No method's or property's name found", tmp);
}
QStringList nameAndPath = tmp.split(CPathSep, QString::KeepEmptyParts);
// check syntax
for (int i = 0; i < nameAndPath.size(); ++i)
{
QString name( nameAndPath.at(i) );
if ( ( name.isEmpty() ) || ( !ValidateObjName(name) ) )
{
ThrowErrorMsg("Invalid method's or property's name or path", tmp);
}
}
m_methodOrPropertyName = nameAndPath.last();
nameAndPath.removeLast();
m_fullObjectName = nameAndPath;
}
bool field_data_valid( const FieldBase & f ,
const Bucket & k ,
unsigned ord ,
const char * required_by )
{
const MetaData * const k_mesh_meta_data = & MetaData::get(k);
const MetaData * const f_mesh_meta_data = & MetaData::get(f);
const bool ok_mesh_meta_data = k_mesh_meta_data == f_mesh_meta_data ;
const bool ok_ord = ord < k.size() ;
const bool exists = ok_mesh_meta_data && ok_ord &&
NULL != field_data( f , k.begin() );
if ( required_by && ! exists ) {
std::ostringstream msg_begin ;
msg_begin << "For args: " ;
msg_begin << f << " , " ;
msg_begin << k << " , " ;
msg_begin << ord << " , " ;
msg_begin << required_by ;
msg_begin << "; operation FAILED with " ;
ThrowErrorMsgIf( ! ok_mesh_meta_data,
msg_begin.str() << " different MetaData");
ThrowErrorMsgIf( ! ok_ord, msg_begin.str() <<
" Ordinal " << ord << " >= " << " size " << k.size());
ThrowErrorMsg( msg_begin.str() << " no data");
}
return exists ;
}
void ParsedDRICmd::CutNameAndPath()
{
QStringList res;
if (CDebugMode) std::cout << "CutNameAndPath" << std::endl;
// 1) try split using CMethodInitBegin
SplitWithQuotesConsideration(m_cmd, CMethodInitBegin, res);
if (res.size() > 2) ThrowSepErrorMsg("Extra", CMethodInitBegin);
if (res.size() == 1)
{
// 2) try split using COptInit
SplitWithQuotesConsideration(m_cmd, COptInit, res);
if (res.size() > 2) ThrowSepErrorMsg("Extra", COptInit);
if (res.size() == 1)
{
// 3) try split using CSep
SplitWithQuotesConsideration(m_cmd, CSep, res);
}
}
// fill fields
if (res.size() < 1) ThrowErrorMsg("No method's or property's name found", m_cmd);
QString nameAndPath = res.at(0).trimmed();
FillNameAndPath(nameAndPath);
// cut
m_cmd = m_cmd.remove( 0, nameAndPath.size() );
}
void ParsedDRICmd::MakeParamList()
{
// [ ][(]param[,] param2[)]
// [ ][=]param
if (CDebugMode) std::cout << "MakeParamList" << std::endl;
m_cmd = m_cmd.trimmed();
QStringList params;
// if it's option's parameter, which starts with COptInit
if ( m_cmd.startsWith(COptInit) )
{
m_cmd = m_cmd.remove(0, 1).trimmed();
if ( m_cmd.isEmpty() ) ThrowSepErrorMsg("Missing property's parameter after",
COptInit);
// even is there is too many params will be syntax exception
SetParams( QStringList(m_cmd) );
m_actType = PropertyWrite;
return;
}
// if there are method's parameters,
// which start with CMethodInitBegin and end with CMethodInitEnd
if ( m_cmd.startsWith(CMethodInitBegin) )
{
if ( !m_cmd.endsWith(CMethodInitEnd) )
{
ThrowSepErrorMsg("Parameter's list does not end with", CMethodInitEnd);
}
// remove separators
m_cmd = m_cmd.mid(1, m_cmd.size() - 2);
m_actType = MethodCall;
}
// try split with using CParamSep
if ( m_cmd.trimmed().endsWith(CParamSep) )
{
ThrowErrorMsg("Missing property's parameter after", CParamSep);
}
SplitWithQuotesConsideration(m_cmd, CParamSep, params, false);
if (params.size() > 1)
{
SetParams(params);
m_actType = MethodCall;
return;
}
// try split with using CSep
SplitWithQuotesConsideration(m_cmd, CSep, params);
SetParams(params);
if (params.size() > 1) m_actType = MethodCall;
}
void FieldBaseImpl::insert_restriction(
const char * arg_method ,
EntityRank arg_entity_rank ,
const Selector & arg_selector ,
const unsigned * arg_stride,
const void* arg_init_value )
{
TraceIfWatching("stk::mesh::impl::FieldBaseImpl::insert_restriction", LOG_FIELD, m_ordinal);
FieldRestriction tmp( arg_entity_rank , arg_selector );
{
unsigned i = 0 ;
if ( m_field_rank ) {
for ( i = 0 ; i < m_field_rank ; ++i ) { tmp.stride(i) = arg_stride[i] ; }
}
else { // Scalar field is 0 == m_field_rank
i = 1 ;
tmp.stride(0) = 1 ;
}
// Remaining dimensions are 1, no change to stride
for ( ; i < MaximumFieldDimension ; ++i ) {
tmp.stride(i) = tmp.stride(i-1) ;
}
for ( i = 1 ; i < m_field_rank ; ++i ) {
const bool bad_stride = 0 == tmp.stride(i) ||
0 != tmp.stride(i) % tmp.stride(i-1);
ThrowErrorMsgIf( bad_stride,
arg_method << " FAILED for " << *this <<
" WITH BAD STRIDE!");
}
}
if (arg_init_value != NULL) {
//insert_restriction can be called multiple times for the same field, giving
//the field different lengths on different mesh-parts.
//We will only store one initial-value array, we need to store the one with
//maximum length for this field so that it can be used to initialize data
//for all field-restrictions. For the parts on which the field is shorter,
//a subset of the initial-value array will be used.
//
//We want to end up storing the longest arg_init_value array for this field.
//
//Thus, we call set_initial_value only if the current length is longer
//than what's already been stored.
//length in bytes is num-scalars X sizeof-scalar:
size_t num_scalars = 1;
//if rank > 0, then field is not a scalar field, so num-scalars is
//obtained from the stride array:
if (m_field_rank > 0) num_scalars = tmp.stride(m_field_rank-1);
size_t sizeof_scalar = m_data_traits.size_of;
size_t nbytes = sizeof_scalar * num_scalars;
size_t old_nbytes = 0;
if (get_initial_value() != NULL) {
old_nbytes = get_initial_value_num_bytes();
}
if (nbytes > old_nbytes) {
set_initial_value(arg_init_value, num_scalars, nbytes);
}
}
{
FieldRestrictionVector & srvec = selector_restrictions();
bool restriction_already_exists = false;
for(FieldRestrictionVector::const_iterator it=srvec.begin(), it_end=srvec.end();
it!=it_end; ++it) {
if (tmp == *it) {
restriction_already_exists = true;
if (tmp.not_equal_stride(*it)) {
ThrowErrorMsg("Incompatible selector field-restrictions!");
}
}
}
if ( !restriction_already_exists ) {
// New field restriction, verify we are not committed:
ThrowRequireMsg(!m_meta_data->is_commit(), "mesh MetaData has been committed.");
srvec.push_back( tmp );
}
}
}
void compute_memory_usage(const BulkData& bulk, MemoryUsage& mem_usage)
{
mem_usage.entity_rank_names = bulk.mesh_meta_data().entity_rank_names();
const FieldVector& fields = bulk.mesh_meta_data().get_fields();
mem_usage.num_fields = fields.size();
mem_usage.field_bytes = fields.size()*sizeof(FieldBase);
for(size_t i=0; i<fields.size(); ++i) {
mem_usage.field_bytes += fields[i]->name().length();
mem_usage.field_bytes += sizeof(FieldRestriction)*fields[i]->restrictions().size();
}
const PartVector& parts = bulk.mesh_meta_data().get_parts();
mem_usage.num_parts = parts.size();
mem_usage.part_bytes = parts.size()*sizeof(Part);
for(size_t i=0; i<parts.size(); ++i) {
mem_usage.part_bytes += parts[i]->name().length();
mem_usage.part_bytes += sizeof(Part*) * parts[i]->supersets().size();
mem_usage.part_bytes += sizeof(Part*) * parts[i]->subsets().size();
}
size_t total_bytes = mem_usage.field_bytes + mem_usage.part_bytes;
mem_usage.entity_counts.clear();
mem_usage.downward_relation_counts.clear();
mem_usage.upward_relation_counts.clear();
mem_usage.bucket_counts.clear();
mem_usage.bucket_bytes.clear();
Selector all = bulk.mesh_meta_data().universal_part();
count_entities(all, bulk, mem_usage.entity_counts);
size_t nranks = mem_usage.entity_counts.size();
mem_usage.downward_relation_counts.resize(nranks, 0);
mem_usage.upward_relation_counts.resize(nranks, 0);
mem_usage.bucket_counts.resize(nranks, 0);
mem_usage.bucket_bytes.resize(nranks, 0);
std::vector<Entity> entities;
for(size_t i=0; i<nranks; ++i) {
EntityRank rank_i = static_cast<EntityRank>(i);
total_bytes += mem_usage.entity_counts[rank_i]*sizeof(Entity);
get_entities(bulk, rank_i, entities);
for(size_t n=0; n<entities.size(); ++n) {
Entity entity = entities[n];
for(EntityRank r=stk::topology::NODE_RANK; r<rank_i; ++r) {
unsigned num_rels = bulk.num_connectivity(entity, r);
mem_usage.downward_relation_counts[r] += num_rels;
ThrowErrorMsg("stk::mesh::compute_memory_usage need to be largely re-written for the new Connectivity scheme but is not needed for this 4.27.7.");
}
for(EntityRank r=static_cast<EntityRank>(rank_i+1); r<nranks; ++r) {
unsigned num_rels = bulk.num_connectivity(entity, r);
mem_usage.upward_relation_counts[r] += num_rels;
ThrowErrorMsg("stk::mesh::compute_memory_usage need to be largely re-written for the new Connectivity scheme but is not needed for this 4.27.7.");
}
}
const BucketVector& buckets = bulk.buckets(rank_i);
mem_usage.bucket_counts[rank_i] = buckets.size();
for(size_t b=0; b<buckets.size(); ++b) {
Bucket& bucket = *buckets[b];
mem_usage.bucket_bytes[rank_i] += bucket.allocation_size();
total_bytes += bucket.allocation_size();
}
}
mem_usage.total_bytes = total_bytes;
}
STKUNIT_UNIT_TEST(UnitTestingOfThrowMacros, testUnit)
{
// Setting assert handler to NULL should cause exception
STKUNIT_ASSERT_THROW(stk::set_assert_handler(0), std::runtime_error);
// Check that Throw*Msg works
STKUNIT_ASSERT_THROW(force_throw_require_trigger(), std::logic_error);
STKUNIT_ASSERT_THROW(force_throw_error_trigger(), std::runtime_error);
STKUNIT_ASSERT_THROW(force_throw_invarg_trigger(), std::invalid_argument);
// Check that Throw* works
STKUNIT_ASSERT_THROW(force_throw_require_trigger(false), std::logic_error);
STKUNIT_ASSERT_THROW(force_throw_error_trigger(false), std::runtime_error);
STKUNIT_ASSERT_THROW(force_throw_invarg_trigger(false), std::invalid_argument);
// Check that macro interacts appropriately with if statements
STKUNIT_ASSERT_THROW(check_interaction_with_if(), std::logic_error);
STKUNIT_ASSERT_THROW(check_interaction_with_if(false), std::logic_error);
// Check that usage of ThrowRequireMsg/ThrowAssertMsg does not change program
// semantics. Code blocks that are not contained within braces seem to be
// the most likely to be problematic.
bool expected_execution_path = false;
if (false)
ThrowRequireMsg(false, "test");
else
expected_execution_path = true;
STKUNIT_ASSERT(expected_execution_path);
expected_execution_path = false;
if (false)
ThrowAssertMsg(false, "test");
else
expected_execution_path = true;
STKUNIT_ASSERT(expected_execution_path);
expected_execution_path = false;
if (false)
ThrowErrorMsg("test");
else
expected_execution_path = true;
STKUNIT_ASSERT(expected_execution_path);
// These next four statements are to check compilation success
if (false)
ThrowRequireMsg(false, "test");
if (false)
ThrowAssertMsg(false, "test");
if (false)
ThrowRequire(false);
if (false)
ThrowAssert(false);
// Check that do-while still works, again, we are mostly checking compilation
// success here.
do ThrowRequireMsg(true, "test");
while (false);
do ThrowAssertMsg(true, "test");
while (false);
// Check that message with put-tos compiles
int temp = 0;
ThrowRequireMsg(true, "test: " << temp << " blah");
ThrowAssertMsg(true, "test: " << temp << " blah");
// Check that assert behaves as expected (throws in debug, not in opt)
#ifdef NDEBUG
force_throw_assert();
#else
STKUNIT_ASSERT_THROW(force_throw_assert(), std::logic_error);
#endif
// Check that ThrowErrorMsg works
STKUNIT_ASSERT_THROW(test_no_expr_error(), std::runtime_error);
// Check that setting handler for asserts works.
stk::ErrorHandler orig = stk::set_assert_handler(test_assert_handler);
ThrowRequireMsg(false, "test");
STKUNIT_ASSERT(test_assert_handler_called);
stk::set_assert_handler(orig);
STKUNIT_ASSERT_THROW(force_throw_require_trigger(), std::logic_error);
// Check that setting handler for errors works.
orig = stk::set_error_handler(test_error_handler);
ThrowErrorMsgIf(true, "test");
STKUNIT_ASSERT(test_error_handler_called);
stk::set_error_handler(orig);
STKUNIT_ASSERT_THROW(force_throw_error_trigger(), std::runtime_error);
// Check that setting handler for invalid args works.
orig = stk::set_invalid_arg_handler(test_invarg_handler);
ThrowInvalidArgMsgIf(true, "test");
STKUNIT_ASSERT(test_invarg_handler_called);
stk::set_invalid_arg_handler(orig);
STKUNIT_ASSERT_THROW(force_throw_invarg_trigger(), std::invalid_argument);
}
