int main(int argc, char ** argv) { try { bool document_object = false; bool show_navigation = false; const option_group general_options = { nullptr, { { 'm', "document-object", bind_value(document_object, true), i18n("Process events through a cainteoir::document object model") }, { 'n', "show-navigation", bind_value(show_navigation, true), i18n("Print the navigation structure, not document content") }, }}; const std::initializer_list<const char *> usage = { i18n("events [OPTION..] DOCUMENT"), i18n("events [OPTION..]"), }; const std::initializer_list<option_group> options = { general_options, }; if (!parse_command_line(options, usage, argc, argv)) return 0; rdf::graph metadata; const char *filename = (argc == 1) ? argv[0] : nullptr; rdf::uri subject(filename ? filename : std::string(), std::string()); auto reader = cainteoir::createDocumentReader(filename, metadata, std::string()); if (!reader) { fprintf(stderr, "unsupported document format for file \"%s\"\n", argv[0]); return 0; } if (document_object || show_navigation) { cainteoir::document doc(reader, metadata); if (show_navigation) print_navigation(metadata, doc, subject); else { auto docreader = cainteoir::createDocumentReader(doc.children()); print_events(docreader); } } else print_events(reader); } catch (std::runtime_error &e) { fprintf(stderr, "error: %s\n", e.what()); } return 0; }
bindable &bindable::bind(const std::vector<sql_value> &values, size_t start_index) { size_t index = start_index; for(auto &value : values) { bind_value(index++, value); } return *this; }
static int foreach(sqlite3_stmt* statement, const Tuple& t) { int code = tuple_printer<Tuple, N - 1>::foreach(statement, t); if (code != SQLITE_OK) { return code; } return bind_value(statement, N, std::get<N - 1>(t)); }
int main(int argc, char ** argv) { try { decltype(writeTextDocument) *writer = nullptr; const option_group general_options = { nullptr, { { 0, "text", bind_value(writer, &writeTextDocument), i18n("Output as plain text.") }, { 0, "html", bind_value(writer, &writeHtmlDocument), i18n("Output as a HTML document.") }, }}; const std::initializer_list<const char *> usage = { i18n("doc2doc [OPTION..] DOCUMENT"), i18n("doc2doc [OPTION..]"), }; if (!parse_command_line({ general_options }, usage, argc, argv)) return 0; const char *filename = (argc == 1) ? argv[0] : nullptr; if (!writer) throw std::runtime_error(i18n("unsupported format to convert to (html and text only)")); rdf::graph metadata; auto reader = cainteoir::createDocumentReader(filename, metadata, std::string()); if (!reader) { fprintf(stderr, i18n("unsupported document format for file \"%s\"\n"), filename ? filename : "<stdin>"); return EXIT_FAILURE; } writer(reader); } catch (std::runtime_error &e) { fprintf(stderr, i18n("error: %s\n"), e.what()); return EXIT_FAILURE; } return EXIT_SUCCESS; }
bind_mapping &bind_mapping::bind(const std::string &name, const sql_value &value) { if (mappings_.count(name) == 0) { throw binding_error("No parameter named '" + name + "' found"); } auto indexes = mappings_[name]; for (auto &index : indexes) { bind_value(index, value); } return *this; }
void mysql_statement::bind_value(MYSQL_BIND &bind, enum_field_types type, const object_base_ptr &value, int index) { bind_value(bind, type, value.id(), index); }
void mysql_statement::write(const char *, const object_base_ptr &x) { bind_value(host_array[host_index], MYSQL_TYPE_LONG, x.id(), host_index); ++host_index; }
void mysql_statement::write(const char *, const varchar_base &x) { bind_value(host_array[host_index], MYSQL_TYPE_VAR_STRING, x.c_str(), x.size(), host_index); ++host_index; }
void mysql_statement::write(const char *, const std::string &x) { bind_value(host_array[host_index], MYSQL_TYPE_STRING, x.data(), x.size(), host_index); ++host_index; }
void mysql_statement::write(const char *, const char *x, int s) { bind_value(host_array[host_index], MYSQL_TYPE_VAR_STRING, x, s, host_index); ++host_index; }
int main(int argc, char ** argv) { try { tts::stress_type stress = tts::stress_type::as_transcribed; phoneme_mode mode = phoneme_mode::joined; bool no_pauses = false; bool show_features = false; const char *phoneme_map = nullptr; const char *accent = nullptr; const option_group general_options = { nullptr, { { 's', "separate", bind_value(mode, phoneme_mode::separate), i18n("Display each phoneme on a new line") }, { 'f', "features", bind_value(show_features, true), i18n("Show the features along with the transcription") }, { 0, "no-pauses", bind_value(no_pauses, true), i18n("Do not process pause phonemes") }, { 'M', "phoneme-map", phoneme_map, "PHONEME_MAP", i18n("Use PHONEME_MAP to convert phonemes (e.g. accent conversion)") }, { 'a', "accent", accent, "ACCENT", i18n("Use ACCENT to convert phonemes to the specified accent") }, }}; const option_group stress_options = { i18n("Phoneme Stress Placement:"), { { 0, "syllables", bind_value(mode, phoneme_mode::syllables), i18n("Show the syllable structure") }, { 0, "vowel-stress", bind_value(stress, tts::stress_type::vowel), i18n("Place the stress on vowels (e.g. espeak, arpabet)") }, { 0, "syllable-stress", bind_value(stress, tts::stress_type::syllable), i18n("Place the stress on syllable boundaries") }, }}; const option_group marker_options = { i18n("Phoneme Markers:"), { { 0, "broad", bind_value(mode, phoneme_mode::broad_markers), i18n("Use /.../ between phonetic transcriptions") }, { 0, "narrow", bind_value(mode, phoneme_mode::narrow_markers), i18n("Use [...] between phonetic transcriptions") }, { 0, "espeak", bind_value(mode, phoneme_mode::espeak_markers), i18n("Use [[...]] between phonetic transcriptions") }, }}; const std::initializer_list<const option_group *> options = { &general_options, &stress_options, &marker_options }; const std::initializer_list<const char *> usage = { i18n("phoneme-converter [OPTION..] FROM TO TRANSCRIPTION"), i18n("phoneme-converter [OPTION..] FROM TO"), }; if (!parse_command_line(options, usage, argc, argv)) return 0; if (argc != 2 && argc != 3) { print_help(options, usage); return 0; } auto from = tts::createPhonemeReader(argv[0]); auto to = tts::createPhonemeWriter(argv[1]); auto data = argc == 3 ? cainteoir::make_file_buffer(argv[2]) : cainteoir::make_file_buffer(stdin); if (phoneme_map) from = tts::createPhonemeToPhonemeConverter(phoneme_map, from); if (accent) from = tts::createAccentConverter(accent, from); if (mode == phoneme_mode::syllables) { auto syllables = tts::create_syllable_reader(); ipa::phonemes phonemes; from->reset(data); while (read_phonemes(from, phonemes)) { tts::make_stressed(phonemes, stress); print_phonemes(phonemes, to, syllables); } } else { ipa::phonemes phonemes; from->reset(data); while (read_phonemes(from, phonemes)) { tts::make_stressed(phonemes, stress); print_phonemes(phonemes, to, mode, no_pauses, show_features); } } } catch (std::runtime_error &e) { fprintf(stderr, i18n("error: %s\n"), e.what()); return EXIT_FAILURE; } return EXIT_SUCCESS; }
void mysql_statement::write(const char *, float x) { bind_value(host_array[host_index], MYSQL_TYPE_FLOAT, x, host_index); ++host_index; }
void mysql_statement::write(const char *, bool x) { bind_value(host_array[host_index], MYSQL_TYPE_TINY, x, host_index); ++host_index; }
void mysql_statement::write(const char *, unsigned long x) { bind_value(host_array[host_index], MYSQL_TYPE_LONGLONG, x, host_index); ++host_index; }
void mysql_statement::write(const char *, unsigned short x) { bind_value(host_array[host_index], MYSQL_TYPE_SHORT, x, host_index); ++host_index; }
static int foreach(sqlite3_stmt* statement, const Tuple& t) { return bind_value(statement, 1, std::get<0>(t)); }
void mysql_statement::write(const char *, double x) { bind_value(host_array[host_index], MYSQL_TYPE_DOUBLE, x, host_index); ++host_index; }
int main(int argc, char ** argv) { setlocale(LC_MESSAGES, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); try { enum { rdf_ntriple, rdf_turtle, vorbis_comments, metadata_author, metadata_creation, metadata_description, metadata_language, metadata_modification, metadata_publication, metadata_publisher, metadata_rights, metadata_subjects, metadata_title, } output_type = rdf_ntriple; bool print_time = false; bool all_metadata = false; const option_group general_options = { nullptr, { { 't', "time", bind_value(print_time, true), i18n("Time how long it takes to extract the metadata") }, { 'a', "all", bind_value(all_metadata, true), i18n("Extract all available metadata") }, }}; const option_group format_options = { i18n("Metadata Format:"), { { 0, "ntriple", bind_value(output_type, rdf_ntriple), i18n("Output RDF N-Triple metadata statements") }, { 0, "turtle", bind_value(output_type, rdf_turtle), i18n("Output RDF Turtle metadata statements") }, { 0, "vorbis", bind_value(output_type, vorbis_comments), i18n("Output VorbisComment entries") }, }}; const option_group extract_options = { i18n("Metadata Extraction:"), { { 0, "author", bind_value(output_type, metadata_author), i18n("Output the document author") }, { 0, "creation", bind_value(output_type, metadata_creation), i18n("Output the document creation date") }, { 0, "description", bind_value(output_type, metadata_description), i18n("Output the document description") }, { 0, "language", bind_value(output_type, metadata_language), i18n("Output the document language") }, { 0, "modification", bind_value(output_type, metadata_modification), i18n("Output the document modification date") }, { 0, "publication", bind_value(output_type, metadata_publication), i18n("Output the document publication date") }, { 0, "publisher", bind_value(output_type, metadata_publisher), i18n("Output the document publisher") }, { 0, "rights", bind_value(output_type, metadata_rights), i18n("Output the document rights (e.g. copyright)") }, { 0, "subjects", bind_value(output_type, metadata_subjects), i18n("Output the document subjects") }, { 0, "title", bind_value(output_type, metadata_title), i18n("Output the document title") }, }}; const std::initializer_list<const option_group *> options = { &general_options, &format_options, &extract_options, }; const std::initializer_list<const char *> usage = { i18n("metadata [OPTION..] DOCUMENT.."), }; if (!parse_command_line(options, usage, argc, argv)) return 0; cainteoir::stopwatch timer; rdf::graph metadata; if (argc == 0) cainteoir::createDocumentReader(nullptr, metadata, std::string()); else for(int i = 0; i < argc; ++i) { auto reader = cainteoir::createDocumentReader(argv[i], metadata, std::string()); if (!reader) fprintf(stderr, i18n("unsupported document format for file \"%s\"\n"), argv[i]); if (all_metadata) while (reader->read(&metadata)) ; } if (print_time) fprintf(stderr, "Extraction Time: %G\n", timer.elapsed()); const char *filename = (argc == 1) ? argv[0] : nullptr; rdf::uri subject(filename ? filename : std::string(), std::string()); if (!metadata.empty()) switch (output_type) { case vorbis_comments: { const rdf::uri subject = rdf::uri(argv[0], std::string()); std::list<cainteoir::vorbis_comment> comments; cainteoir::add_document_metadata(comments, metadata, subject); for (auto &comment : comments) std::cout << comment.label << "=" << comment.value << std::endl; } break; case metadata_author: fprintf(stdout, "%s\n", get_author(metadata, subject).c_str()); break; case metadata_creation: fprintf(stdout, "%s\n", get_date(metadata, subject, "creation").c_str()); break; case metadata_description: fprintf(stdout, "%s\n", get_dublincore(metadata, subject, "description").c_str()); break; case metadata_language: fprintf(stdout, "%s\n", get_dublincore(metadata, subject, "language").c_str()); break; case metadata_modification: fprintf(stdout, "%s\n", get_date(metadata, subject, "modification").c_str()); break; case metadata_publication: fprintf(stdout, "%s\n", get_date(metadata, subject, "publication").c_str()); break; case metadata_publisher: fprintf(stdout, "%s\n", get_dublincore(metadata, subject, "publisher").c_str()); break; case metadata_rights: fprintf(stdout, "%s\n", get_dublincore(metadata, subject, "rights").c_str()); break; case metadata_subjects: for (auto &item : get_dublincore_items(metadata, subject, "subject")) fprintf(stdout, "%s\n", item.c_str()); break; case metadata_title: fprintf(stdout, "%s\n", get_dublincore(metadata, subject, "title").c_str()); break; default: { (*rdf::create_formatter(std::cout, output_type == rdf_ntriple ? rdf::formatter::ntriple : rdf::formatter::turtle)) << rdf::rdf << rdf::rdfa << rdf::rdfs << rdf::xsd << rdf::xml << rdf::owl << rdf::dc << rdf::dcterms << rdf::dcam << rdf::epub << rdf::epv << rdf::opf << rdf::ocf << rdf::pkg << rdf::media << rdf::onix << rdf::marc << rdf::ncx << rdf::dtb << rdf::smil << rdf::xhtml << rdf::skos << rdf::foaf << rdf::ref << rdf::tts << rdf::iana << rdf::subtag << metadata; } break; } } catch (std::runtime_error &e) { fprintf(stderr, i18n("error: %s\n"), e.what()); return EXIT_FAILURE; } return EXIT_SUCCESS; }