char* pri_print_(char* s, size_t cch, int i, size_t& cchWritten) { STLSOFT_ASSERT(NULL != s); STLSOFT_ASSERT(i >= 0); STLSOFT_ASSERT(i < 256); STLSOFT_ASSERT(cch >= 6); s[0] = '\0'; s[cch - 1] = '\0'; char* r = const_cast<char*>(stlsoft::integer_to_string(s, cch - 1, i, &cchWritten)); s[cch - 2] = '>'; ++cchWritten; *--r = '<'; ++cchWritten; return r; }
/// Tokenise the given string with the given delimiter /// /// \param str The string whose contents will be tokenised /// \param delim The delimiter to perform the tokenisation /// /// \note The tokeniser class takes a copy of \c str. It does not alter the contents of \c str string_tokeniser(string_type const& str, delimiter_type const& delim) : m_str(str) , m_delimiter(delim) { STLSOFT_MESSAGE_ASSERT("Delimiter of zero-length", 0 != comparator_type::length(m_delimiter)); STLSOFT_ASSERT(is_valid()); }
inline void call_set_null(T *&pt, void (T::*F)()) { STLSOFT_ASSERT(NULL != pt); (pt->*F)(); pt = NULL; }
inline C const* integer_to_string(C* buf, ss_size_t cchBuf, ss_uint64_t const& i, ss_size_t* pcchRes) { STLSOFT_ASSERT(NULL != pcchRes); return unsigned_integer_to_string(buf, cchBuf, i, pcchRes); }
inline bool find_next_token( C const*& p0 , C const*& p1 , C delim ) { STLSOFT_ASSERT(NULL != p0); STLSOFT_ASSERT(NULL != p1); STLSOFT_ASSERT(p0 <= p1); if('\0' == *p1) { p0 = p1; return false; } if(p0 != p1) { p0 = ++p1; } else { p0 = p1; } if(delim == *p1) { ++p0; ++p1; } else for(;; ++p1) { if('\0' == *p1) { return p0 != p1; } else if(delim == *p1) { break; } } return true; }
static string_type empty_string() { // This character array is initialised to 0, which conveniently happens to // be the empty string, by the module/application load, so it is // guaranteed to be valid, and there are no threading/race conditions static char_type s_empty[1]; STLSOFT_ASSERT(s_empty[0] == '\0'); // Paranoid check return s_empty; }
/// Writes the results, according to the given flags class_type& write(size_t numResults, ff_string_slice_t const* results, int flags) { stlsoft::auto_buffer<iovec> vectors(numResults + 2); ff_string_slice_t crlf = fastformat_getNewlineForPlatform(); #ifdef STLSOFT_CF_THROW_BAD_ALLOC if(!vectors.empty()) #endif /* STLSOFT_CF_THROW_BAD_ALLOC */ { STLSOFT_ASSERT(vectors.size() == numResults + 2); { for(size_t i = 0; i != vectors.size() - 2; ++i) { vectors[i].iov_base = const_cast<char*>(results[i].ptr); vectors[i].iov_len = results[i].len; }} if(!m_delim.empty()) { vectors[vectors.size() - 2].iov_base = const_cast<char*>(m_delim.data()); vectors[vectors.size() - 2].iov_len = m_delim.size(); } else { vectors.resize(vectors.size() - 1); } if(flags::ff_newLine & flags) { vectors[vectors.size() - 1].iov_base = const_cast<char*>(crlf.ptr); vectors[vectors.size() - 1].iov_len = crlf.len; } else { vectors.resize(vectors.size() - 1); } if(::writev(m_fh, &vectors[0], static_cast<int>(vectors.size())) < 0) { #ifdef STLSOFT_CF_EXCEPTION_SUPPORT throw platformstl::platform_exception("failed to write vector payload", errno); #endif /* STLSOFT_CF_EXCEPTION_SUPPORT */ } #if 0 if(flags::ff_flush & flags) { ::flush(m_fh); } #endif /* 0 */ } return *this; }
value_type minmax_element(P pr) const { ss_bool_t bRetrieved; value_type result; m_r.for_each_cancelable(minmax_element_2_function<value_type, P>(bRetrieved, pr, result)); STLSOFT_ASSERT(bRetrieved); return result; }
inline C const* signed_integer_to_string(C* buf, ss_size_t cchBuf, I i, ss_size_t* cchRes) { STLSOFT_ASSERT(NULL != cchRes); C const* psz = signed_integer_to_string<C, I>(buf, cchBuf, i); *cchRes = cchBuf - (psz - (buf - 1)); return psz; }
inline bool string_lookup_from_slice_( L const* input , L const** output , ss_size_t numMappings , L const* fromMappings , L const* toMappings ) { STLSOFT_ASSERT(NULL != output); STLSOFT_ASSERT(0 == numMappings || (NULL != fromMappings && NULL != toMappings)); *output = NULL; if(0 == numMappings) { return false; } if(0 == input->len) { return false; } { for(ss_size_t i = 0; i != numMappings; ++i) { L const& from = fromMappings[i]; if( input->len == from.len && 0 == ::memcmp(input->ptr, from.ptr, sizeof(C) * input->len)) { *output = toMappings + i; return true; } }} return false; }
inline /* static */ DISPID object_helper:: internal_GetIDOfName( object const& o, LPCOLESTR methodName ) /* const */ { DISPID dispids[1] = { 0 }; HRESULT hr = internal_has_member(o, methodName, &dispids[0]); if(FAILED(hr)) { if(DISP_E_UNKNOWNNAME == hr) { #if 0 stlsoft::exception_string_creator creator(256u); creator .append("Unknown name: '") .append(methodName) .append('\'') ; throw invocation_exception(creator.c_str(), hr); #else /* ? 0 */ typedef winstl::system_traits<char> traits_t; static const char msg[] = "Unknown name: '"; winstl::w2a a(methodName); stlsoft::auto_buffer<char> buff(STLSOFT_NUM_ELEMENTS(msg) + a.size() + 1); traits_t::char_copy(&buff[0], msg, STLSOFT_NUM_ELEMENTS(msg) - 1); traits_t::char_copy(&buff[0] + (STLSOFT_NUM_ELEMENTS(msg) - 1), a, a.size()); buff[(STLSOFT_NUM_ELEMENTS(msg) - 1) + a.size()] = '\''; buff[(STLSOFT_NUM_ELEMENTS(msg) - 1) + a.size() + 1] = '\0'; STLSOFT_ASSERT(1 + ::strlen(buff.data()) == buff.size()); // Guard against changing "size()" for winstl::wide2multibyte throw invocation_exception(buff.data(), hr); #endif /* 0 */ } else { throw invocation_exception("GetIDsOfNames failed", hr); } } return dispids[0]; }
static int main_(int /* argc */, char** /* argv */) { #ifdef FASTFORMAT_USE_WIDE_STRINGS #else /* ? FASTFORMAT_USE_WIDE_STRINGS */ char const* arg0 = "abcdefghi"; const char arg1[] = "jklmnopq"; std::string arg2 = "rstuvwxyz"; { char buff[30]; ff::sinks::c_string_sink sink(STLSOFT_NUM_ELEMENTS(buff), &buff[0]); ff::write(sink, arg0); STLSOFT_ASSERT(9u == sink.size()); ff::write(sink, arg1); STLSOFT_ASSERT(17u == sink.size()); ff::write(sink, arg2); STLSOFT_ASSERT(26u == sink.size()); STLSOFT_ASSERT(0 == ::strcmp("abcdefghijklmnopqrstuvwxyz", buff)); } try { char buff[20]; ff::sinks::c_string_sink sink(STLSOFT_NUM_ELEMENTS(buff), &buff[0]); ff::write(sink, arg0); STLSOFT_ASSERT(9u == sink.size()); ff::write(sink, arg1); STLSOFT_ASSERT(17u == sink.size()); ff::write(sink, arg2); // Teleport to ... STLSOFT_MESSAGE_ASSERT("should never get here", 0); } catch(std::out_of_range& /* x */) { // ... here! } #endif /* FASTFORMAT_USE_WIDE_STRINGS */ return EXIT_SUCCESS; }
inline /* static */ void object_helper:: internal_Invoke( object const& o, DISPID dispid , WORD flags , VARIANT* result ) /* const */ { STLSOFT_ASSERT(NULL != result); internal_Invoke(o, dispid, flags, NULL, 0, result); }
static int pantheios_be_WindowsSyslog_logEntry_( void* feToken , void* beToken , int severity , pan_char_t const* entry , size_t cchEntry ) { #ifdef PANTHEIOS_USE_WIDE_STRINGS stlsoft::w2m e(entry, cchEntry); STLSOFT_ASSERT(e.size() <= cchEntry); return pantheios_be_WindowsSyslog_logEntry_a_(feToken, beToken, severity, e.data(), e.size()); #else /* ? PANTHEIOS_USE_WIDE_STRINGS */ return pantheios_be_WindowsSyslog_logEntry_a_(feToken, beToken, severity, entry, cchEntry); #endif /* PANTHEIOS_USE_WIDE_STRINGS */ }
inline /* static */ void object_helper:: internal_Invoke( object const& o, DISPID dispid , WORD flags , DISPPARAMS* pDispParams , VARIANT* pVarResult , EXCEPINFO* pExcepInfo , UINT* puArgErr ) /* const */ { STLSOFT_ASSERT(NULL != puArgErr); EXCEPINFO xinfo_ = { 0, 0, NULL, NULL, NULL, 0, NULL, NULL, 0 }; ptr_type disp = get_checked_disp_(o.get()); HRESULT hr = disp->Invoke(dispid, IID_NULL, o.lcid(), flags, pDispParams, pVarResult, (NULL == pExcepInfo) ? (pExcepInfo = &xinfo_,pExcepInfo) : pExcepInfo, puArgErr); /* if(DISP_E_TYPEMISMATCH == hr) { char msg[101]; ::sprintf(*puArgErr) throw ; } else */ if(FAILED(hr)) { #ifdef __SYNSOFT_DBS_COMPILER_SUPPORTS_PRAGMA_MESSAGE # pragma message(_sscomp_fileline_message("Turn this into an automation_exception / invocation_exception, so can pass in the argErr, and excep info")) #endif /* __SYNSOFT_DBS_COMPILER_SUPPORTS_PRAGMA_MESSAGE */ // We always free the COM exception info in this scope because // we always throw a C++ exception out of it stlsoft::scoped_handle<EXCEPINFO*> scopexi(pExcepInfo, comstl::EXCEPINFO_free); throw invocation_exception(dispid, "Method/property invocation failed", hr, pExcepInfo); } }
static void test_ROLL_ON_ENTRIES() { // Create a file, with rolling quantum of unsigned flags = 0 | PANTHEIOS_BE_FILE_F_DISCARD_CACHED_CONTENTS | PANTHEIOS_BE_FILE_F_TRUNCATE | PANTHEIOS_BE_FILE_F_ROLL_ON_ENTRY_COUNT | 0; pantheios_be_file_setFilePath("rolling-log.test.remote", flags, flags, PANTHEIOS_BEID_REMOTE); const int NUM_ENTRIES = 104; { for(size_t i = 0; i < NUM_ENTRIES; ++i) { pantheios::log_NOTICE("stmt #", pantheios::integer(i)); }} pantheios_be_file_setFilePath(NULL, PANTHEIOS_BEID_REMOTE); { for(size_t i = 0; i < NUM_ENTRIES; i += ENTRY_QUANTUM) { size_t index = i / ENTRY_QUANTUM; path_t path = "rolling-log.test.remote"; path /= pantheios::integer(index).c_str(); file_lines_t remote_lines(path); size_t numRemote = remote_lines.size(); STLSOFT_ASSERT(index < (NUM_ENTRIES / ENTRY_QUANTUM) ? ENTRY_QUANTUM == numRemote : (NUM_ENTRIES % ENTRY_QUANTUM) == numRemote); fs_traits_t::delete_file(path.c_str()); fs_traits_t::get_last_error(); }} }
inline ss_size_t translate_thousands( C* dest , ss_size_t cchDest , C const* picture , C const* rawNumber , C fmtSep , C outputSep ) { typedef char_traits<C> traits_t; const ss_size_t cchRawNumber = traits_t::length(rawNumber); auto_buffer<C> res(1 + 2 * cchRawNumber); C const* pic_next; for(pic_next = picture; fmtSep == *pic_next; ++pic_next) {} STLSOFT_ASSERT('0' != *pic_next); STLSOFT_ASSERT('0' < *pic_next); C const* raw_end = rawNumber + cchRawNumber; C const* const raw_begin = rawNumber; C* res_end = &*(res.end() - 1); ss_size_t num = static_cast<ss_size_t>(*pic_next - '0'); // Derive the first ss_size_t n = num; *res_end = '\0'; for(--raw_end, --res_end; raw_end != raw_begin; --raw_end, --res_end) { *res_end = *raw_end; if( 0 != n && 0 == --n) { if('\0' == *pic_next) { } else if('0' == *pic_next) { n = num; } else { C const* pic_end_next = ++pic_next; for(; *pic_end_next == fmtSep; ++pic_end_next) {} pic_next = pic_end_next; if('\0' == *pic_next) { *--res_end = outputSep; } else if('0' == *pic_next) { n = num; } else { num = static_cast<ss_size_t>(*pic_next - '0'); n = num; } } if(0 != n) { *--res_end = outputSep; } } } *res_end = *raw_end; ss_size_t cch = static_cast<ss_size_t>(res.end() - res_end); if(NULL != dest) { if(cch > cchDest) { cch = cchDest; } traits_t::copy(dest, res_end, cch); } return cch; }
/// Indicates whether the search sequence is empty ss_bool_t empty() const { STLSOFT_ASSERT(is_valid()); return begin() == end(); }
/// Ends the iteration /// /// \return An iterator representing the end of the sequence const_iterator end() const { STLSOFT_ASSERT(is_valid()); return const_iterator(traits_type::end(m_str), traits_type::end(m_str), m_delimiter); }
void interval::construct_() { m_result.reserve(20); interval::units units = m_units; pan_sint64_t interval = m_interval; if(0 == interval) { static pan_char_t const* const s_zeroes[] = { NULL , PANTHEIOS_LITERAL_STRING("0 us") , PANTHEIOS_LITERAL_STRING("0 ms") , PANTHEIOS_LITERAL_STRING("0 s") , PANTHEIOS_LITERAL_STRING("0 mins") , PANTHEIOS_LITERAL_STRING("0 hrs") , PANTHEIOS_LITERAL_STRING("0 days") }; pan_char_t const* const ptr = s_zeroes[units]; size_t const len = pan_strlen_(ptr); m_result.assign(ptr, len); } else { pan_char_t const* u = NULL; switch(units) { case microseconds: if(0 != (interval % 1000)) { u = PANTHEIOS_LITERAL_STRING("us"); } else { interval /= 1000; case milliseconds: if(0 != (interval % 1000)) { u = PANTHEIOS_LITERAL_STRING("ms"); } else { interval /= 1000; case seconds: if(0 != (interval % 60)) { u = PANTHEIOS_LITERAL_STRING("s"); } else { interval /= 60; case minutes: if(0 != (interval % 60)) { u = (1 == interval) ? PANTHEIOS_LITERAL_STRING("min") : PANTHEIOS_LITERAL_STRING("mins"); } else { interval /= 60; case hours: if(0 != (interval % 24)) { u = (1 == interval) ? PANTHEIOS_LITERAL_STRING("hr") : PANTHEIOS_LITERAL_STRING("hrs"); } else { interval /= 24; case days: u = (1 == interval) ? PANTHEIOS_LITERAL_STRING("day") : PANTHEIOS_LITERAL_STRING("days"); } } } } break; } } STLSOFT_ASSERT(NULL != u); pan_char_t buf[21]; size_t cch; #ifdef PANTHEIOS_STLSOFT_1_12_OR_LATER pan_char_t const* const num = stlsoft::integer_to_decimal_string(buf, STLSOFT_NUM_ELEMENTS(buf), interval, &cch); #else /* ? PANTHEIOS_STLSOFT_1_12_OR_LATER */ pan_char_t const* const num = stlsoft::integer_to_string(buf, STLSOFT_NUM_ELEMENTS(buf), interval, cch); #endif /* PANTHEIOS_STLSOFT_1_12_OR_LATER */ m_result.assign(num, cch); m_result.append(1, ' '); m_result.append(u); } }
ff::properties_bundle const& getAppBundle() { STLSOFT_ASSERT(NULL != bundle); return *bundle; }
inline C const* signed_integer_to_string(C *buf, ss_size_t cchBuf, I i) { #ifndef STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT // If the compiler does not evaluate -9 % 10 to equal -9, then we need to work // with it as if an unsigned, and prepend the -ve typedef limit_traits<I> limit_traits_t; typedef sign_traits<I> sign_traits_t; typedef ss_typename_type_k sign_traits_t::signed_type signed_type_t; typedef ss_typename_type_k sign_traits_t::unsigned_type unsigned_type_t; // If this fires, something has happened to invoke this function on an // unsigned type. STLSOFT_STATIC_ASSERT((0 != is_same_type<signed_type_t, I>::value)); C const* psz; if(i == limit_traits_t::minimum()) { STLSOFT_ASSERT(i == -i); // Special case of the (signed) minimum, since the maximum -ve value // of a signed integer cannot be negated. // // We instead take the equivalent value as an unsigned integer, // convert that (as unsigned), and prepend a '-' psz = unsigned_integer_to_string(buf, cchBuf, static_cast<unsigned_type_t>(limit_traits_t::minimum())); *const_cast<C*>(--psz) = C('-'); } else { // Just using the unsigned version here for the absence of // sign. Perversely, The invoked function is still a signed // specialisation. psz = unsigned_integer_to_string(buf, cchBuf, i); if(i < 0) { *const_cast<C*>(--psz) = C('-'); } } return psz; #else /* ? STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT */ // Compiler evaluates -9 % 10 to equal -9, so use the full -ve algorithm. This // is chosen because it is more efficient on most compilers than calling the // unsigned peer and converting. #if defined(STLSOFT_COMPILER_IS_MSVC) typedef I rem_t; #else /* ? compiler */ typedef ss_sint_t rem_t; #endif /* compiler */ C *psz = buf + cchBuf - 1; // Set pointer to last character. *psz = 0; // Set the terminating null character. if(i < 0) { do { rem_t lsd = static_cast<rem_t>(i % 10); // Determine the least significant digit. i = static_cast<I>(i / 10); // Deal with next most significant. --psz; // Move back. #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS *psz = get_digit_character(static_cast<C*>(NULL))[lsd]; #else /* ? STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */ *psz = get_digit_character<C>()[lsd]; #endif /* STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */ } while(i != 0); *(--psz) = C('-'); // Prepend the minus sign. } else { do { rem_t lsd = static_cast<rem_t>(i % 10); // Determine the least significant digit. i = static_cast<I>(i / 10); // Deal with next most significant. --psz; // Move back. #ifdef STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS *psz = get_digit_character(static_cast<C*>(NULL))[lsd]; #else /* ? STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */ *psz = get_digit_character<C>()[lsd]; #endif /* STLSOFT_CF_TEMPLATE_TYPE_REQUIRED_IN_ARGS */ } while(i != 0); } STLSOFT_ASSERT(!(psz < buf)); return psz; #endif /* !STLSOFT_CF_NEGATIVE_MODULUS_POSITIVE_GIVES_NEGATIVE_RESULT */ }
static int main_(int /* argc */, char** /*argv*/) { fastformat::fmtln(std::cout, "format with two replacements; #1={0}, #2={1}", 10, 200); try { fastformat::fmtln(std::cout, "{0,", 10); } catch(fastformat::illformed_format_exception& x) { fprintf(stdout, "illformed_format_exception: %s\n", x.what()); } catch(fastformat::format_parsing_exception& x) { fprintf(stdout, "format_parsing_exception: %s\n", x.what()); } catch(fastformat::missing_argument_exception& x) { fprintf(stdout, "missing_argument_exception: %s\n", x.what()); } catch(fastformat::unreferenced_argument_exception& x) { fprintf(stdout, "unreferenced_argument_exception: %s\n", x.what()); } catch(fastformat::mismatched_replacements_exception& x) { fprintf(stdout, "mismatched_replacements_exception: %s\n", x.what()); } try { fastformat::fmtln(std::cout, "format string with no replacements", 10, 200); } catch(fastformat::fastformat_exception& x) { fprintf(stdout, "exception: %s\n", x.what()); } try { fastformat::ignore_unreferenced_arguments_scope scoper; fastformat::fmtln(std::cout, "format string with no replacements", 10, 200); } catch(fastformat::fastformat_exception& x) { fprintf(stdout, "exception: %s\n", x.what()); } try { fastformat::fmtln(std::cout, "{0,,,}{1,,,}", 10, 200); } catch(fastformat::fastformat_exception& x) { fprintf(stdout, "exception: %s\n", x.what()); } try { fastformat::ignore_missing_arguments_scope scoper; std::string str; fastformat::fmt(str, "format string with no replacements {0} {1}", 10); STLSOFT_ASSERT("format string with no replacements 10 " == str); } catch(fastformat::fastformat_exception& x) { fprintf(stdout, "exception: %s\n", x.what()); } return EXIT_SUCCESS; }
/// Returns the current key+value pair in the range const_reference current() const { STLSOFT_ASSERT(is_open()); return *m_position; }
inline void release_reference(I* pi) { STLSOFT_ASSERT(NULL != pi); pi->Release(); }
inline void add_reference(I* pi) { STLSOFT_ASSERT(NULL != pi); pi->AddRef(); }
/// Returns the number of characters in the message size_type size() const { STLSOFT_ASSERT(m_message.size() > 0); return m_message.size() - 1; }