STLSoft 1.9.93: STLSOFT_CF_NAMESPACE_SUPPORT now only in C++ compilation units

As of version 1.9.93, the symbol STLSOFT_CF_NAMESPACE_SUPPORT is now defined only in C++ compilation units. Its (former) definition in C compilation units was meaningless, and put client code to more work, discrimination for STLSOFT_CF_NAMESPACE_SUPPORT and for __cplusplus. Now the former encapsulates both.

STLSoft 1.9.92: inetstl::filesystem_traits::is_path_name_separator() added

As of version 1.9.92, inetstl::filesystem_traits now has an is_path_name_separator(), to ensure correct handle of paths that contain network ('/') and local ('\\') path name separators.

STLSoft 1.9.91: platformstl::remove_directory_recurse()

As of version 1.9.91, the UNIXSTL/WinSTL directory function remove_directory_recurse() is introduced into the platformstl namespace.

STLSoft 1.9.90: unixstl::filesystem_traits::get_full_path_name() defect fixed

Prior to version 1.9.90, unixstl::filesystem_traits::get_full_path_name() contained a defect, causing it to fault if passed "." - indicating the local directory - and instead contain spurious information. This is now fixed.

STLSoft 1.9.88: fixed conversion between const_reverse_iterator and reverse_iterator

For a long while, I've been aware of the limitations of the reverse iterator abstraction components in the STLSoft libraries - specifically  and  - which prevent assigning an instance of a collection's reverse_iterator to an instance of its const_reverse_iterator. This has caused trouble for me on occasion, and also for some users.

As of version 1.9.88 this has been addressed, via addition of conversion constructor template and operator != templates.

STLSoft 1.9.88: throwOnAccessFailure search flag for winstl::basic_findfile_sequence

As anticipated, winstl::basic_findfile_sequence, which is described in detail in Extended STL, volume 1, now defines, and responds to, the member constant throwOnAccessFailure. In the case of an access failure an instance of winstl::access_exception is thrown.

This allows for better response in cases where access may be denied.

STLSoft 1.9.88: max_size() for file_path_buffer and path

As of version 1.9.88, winstl::basic_file_path_buffer now has a (static) max_size() method, and winstl::basic_path::max_size() is changed to be static.

STLSoft 1.9.88: all-integer handling for comstl::variant

The latest release (1.9.88) of STLSoft contains an updated comstl::variant class. The previous version had three constructors for integer types: short, int and long. The new version has six constructors for integer types: sint8_t, uint8_t, sint16_t, uint16_t, sint32_t, uint32_t. (It also has short, int and long constructors for those compilers that have distinct types against the 8/16/32-fixed integer types; see chapter 29 of Imperfect C++)

STLSoft 1.9.88 released

STLSoft 1.9.88 is released today.

This version will be required for forthcoming releases, including:

• STLSoft (1.10)
• FastFormat
• Pantheios
• recls
• VOLE
  

STLSoft 1.9.88 imminent

I'm just preparing a new release of recls, and in the process have needed to enhance winstl::basic_findfile_sequence, adding a new throwOnAccessFailure flag, which (as should be obvious from the name), causes an exception to be thrown in the event of access failure. This will allow consistent behaviour between recls (C/C++) and the new recls 100% .NET library.

frequency_map: new merge() method

The stlsoft::frequency_map container class template now includes a merge() method, which allows the contents from two frequency map instances to be merged into one, as in:


  typedef std::string string_t;
  typedef stlsoft::frequency_map<string_t> fmap_t;

  fmap_t map1;
  fmap_t map2;

  map1.push("key-11");
  map1.push("key-22");

  XTESTS_TEST_BOOLEAN_FALSE(map1.empty());
  XTESTS_TEST_INTEGER_EQUAL(2u, map1.size());
  XTESTS_TEST_INTEGER_EQUAL(1u, map1["key-11"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map1["key-22"]);

  map2.push("key-11");
  map2.push("key-21");

  XTESTS_TEST_BOOLEAN_FALSE(map2.empty());
  XTESTS_TEST_INTEGER_EQUAL(2u, map2.size());
  XTESTS_TEST_INTEGER_EQUAL(1u, map2["key-11"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map2["key-21"]);

  map1.merge(map2);

  XTESTS_TEST_BOOLEAN_FALSE(map1.empty());
  XTESTS_TEST_INTEGER_EQUAL(3u, map1.size());
  XTESTS_TEST_INTEGER_EQUAL(2u, map1["key-11"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map1["key-21"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map1["key-22"]);

  XTESTS_TEST_BOOLEAN_FALSE(map2.empty());
  XTESTS_TEST_INTEGER_EQUAL(2u, map2.size());
  XTESTS_TEST_INTEGER_EQUAL(1u, map2["key-11"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map2["key-21"]);

  map2.clear();

  XTESTS_TEST_BOOLEAN_FALSE(map1.empty());
  XTESTS_TEST_INTEGER_EQUAL(3u, map1.size());
  XTESTS_TEST_INTEGER_EQUAL(2u, map1["key-11"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map1["key-21"]);
  XTESTS_TEST_INTEGER_EQUAL(1u, map1["key-22"]);

  XTESTS_TEST_INTEGER_EQUAL(0u, map2.size());
  XTESTS_TEST_BOOLEAN_TRUE(map2.empty());

STLSoft 1.10 new additions: integer_to_array()

A new component with STLSoft 1.10 (alpha 11 onwards) is the stlsoft::integer_to_array() function template. It is used to turn a single integer value into an array of bit-chunk values.

For example, given the integer i with value 0x01020304, we can split this into the 8 nibbles as follows:

stlsoft::integer_array r = stlsoft::integer_to_array(i, 4);

r[0] will be 4, r[1] will be 0, r[2] will be 3, r[3] will be 0, r[4] will be 2, r[5] will be 0, r[6] will be 1, and r[7] will be 0.

The split can be on any value between 0 and the bitsize of the input parameter (which can be any of the integral types); so you can split on 3 bits, 1 bit, 17 bits, whatever.

I've done extensive automated tests, and they all pass (natch), but I'm still a little dubious about the component, so I'm definitely interested in feedback.

In case you're wondering, the original rationale for this was a simple way to go from the s_addr member of struct in_addr, which is held in network byte order but is otherwise "opaque".

LP64 and -Wshorten-64-to-32

Along with new Mac OS-X 64-bit makefiles for FastFormat and Pantheios, I'm also playing around with the -Wshorten-64-to-32 warning flag.

In compiling FF with this I encountered a lot of similars, amounting to the following:

enum { x = sizeof(Y) };

Obviously an enum, being int in size, is too small to hold size_t (the result of sizeof operator). The ugly but effective solution to this is:

enum { x = int(sizeof(Y)) };

which you'll now see more of in the STLSoft libs.