/* 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; } } }