void createTable(ostream& out, HumdrumFile& infile) {
out << "<table " << C0C0 << ">\n";
int i;
for (i=0; i<infile.getNumLines(); i++) {
if (infile[i].isGlobalComment()) {
printGlobalComment(out, infile, i);
continue;
}
if (infile[i].isBibliographic()) {
printReferenceRecord(out, infile, i);
continue;
}
if (infile[i].isData()) {
printFields(out, infile, i);
}
if (infile[i].isMeasure()) {
printFields(out, infile, i);
}
if (infile[i].isInterpretation()) {
printFields(out, infile, i);
}
}
out << "</table>\n";
if (textareaQ) {
out << "<textarea wrap=off rows=10 cols=70>";
out << infile;
out << "</textarea>\n";
}
}
static void handleFile(FILE *f,char *delim,int first,int last) {
char line[MAX_LINE_LEN];
while(fgetl(line,sizeof(line),f)) {
printFields(line,delim,first,last);
if(ferror(stdout)) {
printe("Write failed");
break;
}
}
}
int cfrf_parse_fields(cfrt_classfile *c, cfrt_file *f) {
u2 fields_count;
cfrt_field_info *fields;
u2 i;
int result;
if (c == NULL) {
return CFREADER_ERR_NULL_PTR;
}
result = cfrf_read_u2(&fields_count, f);
if (result != CFREADER_OK) {
return result;
}
if (fields_count > 0) {
fields = CFRM_NEW_ARRAY(cfrt_field_info, fields_count);
if (fields == NULL) {
return CFREADER_ERR_MALLOC;
}
for (i = 0; i < fields_count; i++) {
result = cfrf_parse_field_info(fields + i, c->constant_pool, f);
if (result != CFREADER_OK) {
free(fields);
return result;
}
}
} else {
fields = NULL;
}
c->fields_count = fields_count;
c->fields = fields;
#ifdef CFREADER_DEBUG_MODE
printFields(c);
#endif
return CFREADER_OK;
}
int main(int argc, char** argv)
{
try
{
TCLAP::CmdLine cmd("Query tool", ' ');
TCLAP::SwitchArg showArg("", "show", "Show fields and exit", false);
TCLAP::ValueArg<std::string> selectArg("s", "select", "Comma separated list of field names to select, if omitted, all fields are selected", false, "", "Field selection");
TCLAP::ValueArg<std::string> filterArg("f", "filter", "Filter expression in the form FIELDNAME=\"value\", filters selction", false, "", "Filter expression");
TCLAP::ValueArg<std::string> orderArg("o", "order", "Comma separated list of field names with which to order a selection", false, "", "Order by");
TCLAP::ValueArg<std::string> datastoreFileArg("d", "db", "JSON database file name to load or create", false, "db.json", "Database file");
cmd.add(showArg);
cmd.add(selectArg);
cmd.add(filterArg);
cmd.add(orderArg);
cmd.add(datastoreFileArg);
cmd.parse(argc, argv);
DataStore::DatabasePtrH database =
DataStore::DataStorageJson::Load(datastoreFileArg.getValue().c_str());
DataStore::IFieldDescriptorConstListConstPtrH allFields =
database->getScheme()->getFieldDescriptors();
//
// Show fields and exit?
//
if (showArg.isSet())
{
printFields(*(allFields.get()));
return 0;
}
//
// Parse selection (-s) into a list of field descriptors
//
DataStore::IFieldDescriptorConstListPtrH selectedFields;
if (selectArg.isSet())
{
selectedFields = parseFieldNameList(selectArg.getValue(),
*(allFields.get()));
}
//
// Parse filter (-f) expression into a logical expression AST
//
DataStore::Predicate filter = DataStore::Predicate::AlwaysTrue();
if (filterArg.isSet())
{
DataStore::IQualifierPtrH filterAst =
parseFilterExpression(filterArg.getValue(), *(allFields.get()));
filter = DataStore::Predicate(filterAst);
}
//
// Parse order (-o) in to list of field descriptors, order is
// always ascending.
//
DataStore::IFieldDescriptorConstListPtrH orderByFields;
if (orderArg.isSet())
{
orderByFields = parseFieldNameList(orderArg.getValue(),
*(allFields.get()));
}
//
// Perform query, and print result
//
DataStore::IQueryResultConstPtrH result =
database->query(selectedFields, &filter, orderByFields);
printResult(*(result.get()));
}
catch (TCLAP::ArgException &e)
{
std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
return 1;
}
catch (std::exception& ex)
{
std::cerr << "error: " << ex.what() << std::endl;
return 1;
}
return 0;
}
void ToolsSplashParallel::convertToText()
{
if (m_options.data.size() == 0)
throw std::runtime_error("No datasets requested");
ColTypeInt ctInt;
ColTypeDouble ctDouble;
// read data
//
std::vector<ExDataContainer> file_data;
// identify reference data class (poly, grid), reference domain size and number of elements
//
DomainCollector::DomDataClass ref_data_class = DomainCollector::UndefinedType;
try
{
dc.readAttribute(m_options.step, m_options.data[0].c_str(), DOMCOL_ATTR_CLASS,
&ref_data_class, NULL);
} catch (const DCException&)
{
errorStream << "Error: No domain information for dataset '" << m_options.data[0] << "' available." << std::endl;
errorStream << "This might not be a valid libSplash domain." << std::endl;
return;
}
switch (ref_data_class)
{
case DomainCollector::GridType:
if (m_options.verbose)
errorStream << "Converting GRID data" << std::endl;
break;
case DomainCollector::PolyType:
if (m_options.verbose)
errorStream << "Converting POLY data" << std::endl;
break;
default:
throw std::runtime_error("Could not identify data class for requested dataset");
}
Domain ref_total_domain;
ref_total_domain = dc.getGlobalDomain(m_options.step, m_options.data[0].c_str());
for (std::vector<std::string>::const_iterator iter = m_options.data.begin();
iter != m_options.data.end(); ++iter)
{
// check that all datasets match to each other
//
DomainCollector::DomDataClass data_class = DomainCollector::UndefinedType;
dc.readAttribute(m_options.step, iter->c_str(), DOMCOL_ATTR_CLASS,
&data_class, NULL);
if (data_class != ref_data_class)
throw std::runtime_error("All requested datasets must be of the same data class");
Domain total_domain = dc.getGlobalDomain(m_options.step, iter->c_str());
if (total_domain != ref_total_domain)
throw std::runtime_error("All requested datasets must map to the same domain");
// create an extended container for each dataset
ExDataContainer excontainer;
if (ref_data_class == DomainCollector::PolyType)
{
// poly type
excontainer.container = dc.readDomain(m_options.step, iter->c_str(),
Domain(total_domain.getOffset(), total_domain.getSize()), NULL, true);
} else
{
// grid type
Dimensions offset(total_domain.getOffset());
Dimensions domain_size(total_domain.getSize());
for (int i = 0; i < 3; ++i)
if (m_options.fieldDims[i] == 0)
{
offset[i] = m_options.sliceOffset;
if (offset[i] > total_domain.getBack()[i])
throw DCException("Requested offset outside of domain");
domain_size[i] = 1;
break;
}
excontainer.container = dc.readDomain(m_options.step, iter->c_str(),
Domain(offset, domain_size), NULL);
}
// read unit
//
if (m_options.applyUnits)
{
try
{
dc.readAttribute(m_options.step, iter->c_str(), "unitSI",
&(excontainer.unit), NULL);
} catch (const DCException&)
{
if (m_options.verbose)
errorStream << "no unit for '" << iter->c_str() << "', defaulting to 1.0" << std::endl;
excontainer.unit = 1.0;
}
if (m_options.verbose)
errorStream << "Loaded dataset '" << iter->c_str() << "' with unit '" <<
excontainer.unit << "'" << std::endl;
} else
{
excontainer.unit = 1.0;
if (m_options.verbose)
errorStream << "Loaded dataset '" << iter->c_str() << "'" << std::endl;
}
file_data.push_back(excontainer);
}
assert(file_data[0].container->get(0)->getData() != NULL);
// write to file
//
if (ref_data_class == DomainCollector::PolyType)
printParticles(file_data);
else
printFields(file_data);
for (std::vector<ExDataContainer>::iterator iter = file_data.begin();
iter != file_data.end(); ++iter)
{
delete iter->container;
}
}
void Programmer::printProgrammer(){
printEmployee();
printFields();
}
