static ParserRecord createSimpleParserRecord() {
ParserItem itemInt1("ITEM1", SINGLE, 0 );
ParserItem itemInt2("ITEM2", SINGLE, 0 );
ParserRecord record;
record.addItem(itemInt1);
record.addItem(itemInt2);
return record;
}
void ParserKeyword::initData(const Json::JsonObject& jsonConfig) {
this->m_fixedSize = 1U;
this->m_keywordSizeType = FIXED;
const Json::JsonObject dataConfig = jsonConfig.get_item("data");
if (!dataConfig.has_item("value_type") )
throw std::invalid_argument("The 'value_type' JSON item of keyword "+getName()+" is missing");
ParserValueTypeEnum valueType = ParserValueTypeEnumFromString(dataConfig.get_string("value_type"));
const std::string itemName("data");
bool hasDefault = dataConfig.has_item("default");
ParserRecord record;
ParserItem item( itemName, ParserItem::item_size::ALL );
switch (valueType) {
case INT:
{
item.setType( int() );
if(hasDefault) {
int defaultValue = dataConfig.get_int("default");
item.setDefault(defaultValue);
}
record.addDataItem( item );
}
break;
case STRING:
{
item.setType( std::string() );
if (hasDefault) {
std::string defaultValue = dataConfig.get_string("default");
item.setDefault(defaultValue);
}
record.addItem( item );
}
break;
case DOUBLE:
{
item.setType( double() );
if (hasDefault) {
double defaultValue = dataConfig.get_double("default");
item.setDefault(defaultValue);
}
set_dimensions( item, dataConfig, this->getName() );
record.addDataItem( item );
}
break;
default:
throw std::invalid_argument("While initializing keyword "+getName()+": Values of type "+dataConfig.get_string("value_type")+" are not implemented.");
}
this->addDataRecord( record );
}
void ParserKeyword::addItems(const Json::JsonObject& itemsConfig) {
if( !itemsConfig.is_array() )
throw std::invalid_argument("The 'items' JSON item missing must be an array in keyword "+getName()+".");
size_t num_items = itemsConfig.size();
ParserRecord record;
for (size_t i = 0; i < num_items; i++) {
const Json::JsonObject& itemConfig = itemsConfig.get_array_item(i);
record.addItem( ParserItem( itemConfig ) );
}
this->addRecord( record );
}
static ParserRecord createMixedParserRecord() {
auto sizeType = SINGLE;
ParserItem itemInt1( "INTITEM1", sizeType, 0 );
ParserItem itemInt2( "INTITEM2", sizeType, 0 );
ParserItem itemInt3( "INTITEM3", sizeType, 0 );
ParserItem itemDouble1( "DOUBLEITEM1", sizeType, 0.0 );
ParserItem itemDouble2( "DOUBLEITEM2", sizeType, 0.0 );
ParserItem itemDouble3( "DOUBLEITEM3", sizeType, 0.0 );
ParserRecord record;
record.addItem(itemInt1);
record.addItem(itemInt2);
record.addItem(itemDouble1);
record.addItem(itemDouble2);
record.addItem(itemInt3);
record.addItem(itemDouble3);
return record;
}
bool ParserRecord::equal(const ParserRecord& other) const {
bool equal_ = true;
if (size() == other.size()) {
size_t itemIndex = 0;
while (true) {
if (itemIndex == size())
break;
{
ParserItemConstPtr item = get(itemIndex);
ParserItemConstPtr otherItem = other.get(itemIndex);
if (!item->equal(*otherItem)) {
equal_ = false;
break;
}
}
itemIndex++;
}
} else
equal_ = false;
return equal_;
}
bool ParserRecord::equal(const ParserRecord& other) const {
bool equal_ = true;
if (size() == other.size()) {
size_t itemIndex = 0;
while (true) {
if (itemIndex == size())
break;
{
const auto& item = get(itemIndex);
const auto& otherItem = other.get(itemIndex);
if (item != otherItem ) {
equal_ = false;
break;
}
}
itemIndex++;
}
} else
equal_ = false;
return equal_;
}
