/*
Build a pipeline from filters specified as command-line arguments.
*/
void TranslateKernel::makeArgPipeline()
{
std::string readerType(m_readerType);
if (!readerType.empty() && !Utils::startsWith(readerType, "readers."))
readerType.insert(0, "readers.");
Stage& reader = m_manager.makeReader(m_inputFile, readerType);
Stage* stage = &reader;
// add each filter provided on the command-line,
// updating the stage pointer
for (auto const f : m_filterType)
{
std::string filter_name(f);
if (!Utils::startsWith(f, "filters."))
filter_name.insert(0, "filters.");
Stage& filter = m_manager.makeFilter(filter_name, *stage);
stage = &filter;
}
std::string writerType(m_writerType);
if (!writerType.empty() && !Utils::startsWith(writerType, "writers."))
writerType.insert(0, "writers.");
m_manager.makeWriter(m_outputFile, writerType, *stage);
}
std::pair<int, const ParameterInfoPrivate*>
ParameterInfoPrivateHoard::
find_parameter(const std::string &pname)
{
std::map<std::string, int>::const_iterator iter;
iter = m_map.find(pname);
if(iter != m_map.end())
{
const ParameterInfoPrivate *q;
q = &m_values[iter->second];
return FindParameterResult(q->m_location, q);
}
std::string filtered_name;
int array_index;
filtered_name = filter_name(pname.begin(), pname.end(), array_index);
iter = m_map.find(filtered_name);
if(iter != m_map.end())
{
const ParameterInfoPrivate *q;
q = &m_values[iter->second];
if(array_index < q->m_count)
{
return FindParameterResult(q->m_location + array_index, q);
}
}
return FindParameterResult(-1, NULL);
}
void DashcoinWallet::load_wallets()
{
ui->select_wallet->clear();
QStringList filter_name("*.bin.keys");
QDir directory_wallets(QDir::currentPath ()+"/wallets");
QStringList list_wallets = directory_wallets.entryList(filter_name);
for(int i=0;i<list_wallets.length();i++){
QString cur = list_wallets[i];
ui->select_wallet->addItem(cur.mid(0,cur.length()-9),cur);
}
}
/**
* Creates a cloud watch logs subscription filter, based on command line input
*/
int main(int argc, char** argv)
{
if (argc != 5)
{
std::cout << "Usage: " << std::endl << " put_subscription_filter "
<< "<filter_name> <filter_pattern> <log_group_name> " <<
"<lambda_function_arn>" << std::endl;
return 1;
}
Aws::SDKOptions options;
Aws::InitAPI(options);
{
Aws::String filter_name(argv[1]);
Aws::String filter_pattern(argv[2]);
Aws::String log_group(argv[3]);
Aws::String dest_arn(argv[4]);
Aws::CloudWatchLogs::CloudWatchLogsClient cwl;
Aws::CloudWatchLogs::Model::PutSubscriptionFilterRequest request;
request.SetFilterName(filter_name);
request.SetFilterPattern(filter_pattern);
request.SetLogGroupName(log_group);
request.SetDestinationArn(dest_arn);
auto outcome = cwl.PutSubscriptionFilter(request);
if (!outcome.IsSuccess())
{
std::cout << "Failed to create cloudwatch logs subscription filter "
<< filter_name << ": " << outcome.GetError().GetMessage() <<
std::endl;
}
else
{
std::cout << "Successfully created cloudwatch logs subscription " <<
"filter " << filter_name << std::endl;
}
}
Aws::ShutdownAPI(options);
return 0;
}
int TranslateKernel::execute()
{
// setting common options for each stage propagates the debug flag and
// verbosity level
Options readerOptions, filterOptions, writerOptions;
setCommonOptions(readerOptions);
setCommonOptions(filterOptions);
setCommonOptions(writerOptions);
m_manager = std::unique_ptr<PipelineManager>(new PipelineManager);
if (!m_readerType.empty())
{
m_manager->addReader(m_readerType);
}
else
{
StageFactory factory;
std::string driver = factory.inferReaderDriver(m_inputFile);
if (driver.empty())
throw app_runtime_error("Cannot determine input file type of " +
m_inputFile);
m_manager->addReader(driver);
}
if (m_manager == NULL)
throw pdal_error("Error making pipeline\n");
Stage* reader = m_manager->getStage();
if (reader == NULL)
throw pdal_error("Error getting reader\n");
readerOptions.add("filename", m_inputFile);
reader->setOptions(readerOptions);
Stage* stage = reader;
// add each filter provided on the command-line, updating the stage pointer
for (auto const f : m_filterType)
{
std::string filter_name(f);
if (!Utils::startsWith(f, "filters."))
filter_name.insert(0, "filters.");
Stage* filter = &(m_manager->addFilter(filter_name));
if (filter == NULL)
{
std::ostringstream oss;
oss << "Unable to add filter " << filter_name << ". Filter "
"is invalid or plugin could not be loaded. Check "
"'pdal --drivers'.";
throw pdal_error("Error getting filter\n");
}
filter->setOptions(filterOptions);
filter->setInput(*stage);
stage = filter;
}
if (!m_writerType.empty())
{
m_manager->addWriter(m_writerType);
}
else
{
StageFactory factory;
std::string driver = factory.inferWriterDriver(m_outputFile);
if (driver.empty())
throw app_runtime_error("Cannot determine output file type of " +
m_outputFile);
Options options = factory.inferWriterOptionsChanges(m_outputFile);
writerOptions += options;
m_manager->addWriter(driver);
}
Stage* writer = m_manager->getStage();
if (writer == NULL)
throw pdal_error("Error getting writer\n");
writerOptions.add("filename", m_outputFile);
writer->setOptions(writerOptions);
writer->setInput(*stage);
// be sure to recurse through any extra stage options provided by the user
applyExtraStageOptionsRecursive(writer);
m_manager->execute();
if (m_pipelineOutput.size() > 0)
PipelineWriter::writePipeline(m_manager->getStage(), m_pipelineOutput);
return 0;
}
/**
*
* \brief Handle the file.
*
* \param file_name is the filename which has to be checked against the find options.
* \param file_info file information of file_name which has to be checked against the find options.
* \param params is the program argument vector.
*
* \return int represents the exit status of do_file.
* \retval EXIT_SUCCESS successful exit status.
* \retval EXIT_FAILURE failing exit status.
*/
static int do_file(const char* file_name, StatType* file_info, const char* const* params)
{
int i = 1;
boolean printed_print = FALSE; /* flag for: already printed */
boolean printed_ls = FALSE; /* flag for: already printed in ls mode*/
boolean to_print_ls = FALSE; /* flag for: must be printed in ls mode*/
boolean matched = FALSE; /* flag for: line meets filter criteria */
boolean filter = FALSE; /* flag for: result of filter */
boolean filtered = FALSE; /* flag for: at least one filter has been applied */
boolean path_given = FALSE; /* flag for: first commandline parameter is a file/dir */
char test_char = '\0';
/*check if first command line parameter is an option or a file/dir*/
test_char = *params[1];
path_given = ('-' == test_char) ? FALSE : TRUE;
matched = path_given;
/* loop all command line parameters */
while (NULL != params[i])
{
/* could be later optimzed by remembering for each params[i] element, if it
* is matched for the i-th parameter, store for each filter in an bool filter_array[argc]
* if strcmp matched for the filter e.g for type cmp_filter_type[arg]
*/
/* apply filters */
if (strcmp(params[i], PARAM_STR_TYPE) == 0)
{
filter = filter_type(i, params, file_info);
matched = matched && filter;
filtered = TRUE;
++i;
continue;
}
if (strcmp(params[i], PARAM_STR_USER) == 0)
{
filter = filter_user(i, params, file_info);
matched = matched && filter;
filtered = TRUE;
++i;
continue;
}
if (strcmp(params[i], PARAM_STR_NOUSER) == 0)
{
filter = filter_nouser(file_info);
matched = matched && filter;
filtered = TRUE;
++i;
continue;
}
if (strcmp(params[i], PARAM_STR_NAME) == 0)
{
filter = filter_name(file_name, i, params);
matched = matched && filter;
filtered = TRUE;
++i;
continue;
}
if (strcmp(params[i], PARAM_STR_PATH) == 0)
{
filter = filter_path(file_name, i, params);
matched = matched && filter;
filtered = TRUE;
++i;
continue;
}
/* apply actions */
if (strcmp(params[i], PARAM_STR_LS) == 0)
{
if (filtered && matched)
{
print_detail_ls(file_name, file_info);
printed_ls = TRUE;
}
else
{
/* special case -ls defined before filter parameters */
to_print_ls = TRUE;
}
}
if (strcmp(params[i], PARAM_STR_PRINT) == 0)
{
if (filtered && matched)
{
print_detail_print(file_name);
printed_print = TRUE;
}
}
++i;
}
/* special cases */
/* no -print action or no filter parameter on command line */
if ((matched && !printed_print && !printed_ls) || (!filtered))
{
if (to_print_ls)
{
print_detail_ls(file_name, file_info);
}
else
{
print_detail_print(file_name);
}
}
return EXIT_SUCCESS;
}
void
ParameterInfoPrivateHoard::
fill_hoard(GLuint program,
GLenum count_enum, GLenum length_enum,
F fptr, G gptr)
{
GLint count, largest_length;
std::vector<char> pname;
glGetProgramiv(program, count_enum, &count);
if(count > 0)
{
m_values.resize(count);
glGetProgramiv(program, length_enum, &largest_length);
++largest_length;
pname.resize(largest_length, '\0');
for(int i = 0; i != count; ++i)
{
GLsizei name_length, psize;
GLenum ptype;
int array_index;
std::memset(&pname[0], 0, largest_length);
fptr(program, i, largest_length,
&name_length, &psize,
&ptype, &pname[0]);
m_values[i].m_type = ptype;
m_values[i].m_count = psize;
m_values[i].m_name = filter_name(pname.begin(),
pname.begin() + name_length,
array_index);
if(array_index != 0)
{
/*
crazy GL... it lists an element
from an array as a unique location,
chicken out and add it with the
array index:
*/
m_values[i].m_name = std::string(pname.begin(),
pname.begin() + name_length);
}
m_values[i].m_index = i;
m_values[i].m_location = gptr(program, &pname[0]);
}
/* sort m_values by name and then make our map
*/
std::sort(m_values.begin(), m_values.end());
for(unsigned int i = 0, endi = m_values.size(); i < endi; ++i)
{
m_map[m_values[i].m_name] = i;
}
}
}
