Add support for fixed sized buffers #105

Activity

1. vitaut commented on Feb 9, 2015

   

   vitaut

   on Feb 9, 2015

   Contributor

   More actions

   Thank you for the suggestion. The library already doesn't do dynamic memory allocations if the result of formatting is less than fmt::internal::INLINE_BUFFER_SIZE (which you can configure to better suit your application):

   fmt::MemoryWriter w;
   w.write("{}/{}", dir, filename); // no dynamic memory allocation for small output
   w.c_str(); // returns a pointer to the internal buffer

   The advantage of this method is that it works with large output by using dynamic memory allocation (only) if necessary.

   Also you can define your own function (or a writer class) that prints directly to a fixed buffer:

   #include "format.h"
   
   class FixedBuffer : public fmt::internal::Buffer<char> {
    public:
     FixedBuffer(char *array, std::size_t size)
       : fmt::internal::Buffer<char>(array, size) {}
   
    protected:
     void grow(std::size_t size) {
       throw std::runtime_error("buffer overflow");
     }
   };
   
   class FixedWriter : public fmt::Writer {
    private:
     FixedBuffer buffer_;
    public:
     FixedWriter(char *array, std::size_t size)
       : fmt::Writer(buffer_), buffer_(array, size) {}
   };
   
   int main() {
     char buffer[100];
     FixedWriter w(buffer, sizeof(buffer));
     w.write("Hello, {}!", "world");
   }
2. vitaut commented on Feb 10, 2015

   

   vitaut

   on Feb 10, 2015

   Contributor

   More actions

   Closing for now, but feel free to reopen if the alternatives I described don't fit your use cases.
3. vitaut

   closed this as completedon Feb 10, 2015
4. patlecat commented on Feb 17, 2015

   

   patlecat

   on Feb 17, 2015

   More actions

   @vitaut So fmt::internal::INLINE_BUFFER_SIZE should and can only be configured by deriving my own class like in your example above? Otherwise how is it defined?
5. vitaut commented on Feb 17, 2015

   

   vitaut

   on Feb 17, 2015

   Contributor

   More actions

   @patlecat No, you can change the value of fmt::internal::INLINE_BUFFER_SIZE constant if you embed C++ Format in your application (although in most cases the default should be fine). Deriving your own class is only necessary if you want to support a custom buffer, e.g. fixed-sized as in the above example.
6. vitaut commented on Mar 2, 2015

   

   vitaut

   on Mar 2, 2015

   Contributor

   More actions

   C++ Format now supports formatting to fixed-size arrays: http://cppformat.readthedocs.org/en/latest/reference.html#fmt::BasicArrayWriter.

   Example:

   char buffer[100];
   fmt::ArrayWriter w(buffer);
   w.write("The answer is {}", 42);
   

   👍React with 👍1Reacted by Dan Ibanez
7. patlecat commented on Mar 2, 2015

   

   patlecat

   on Mar 2, 2015

   More actions

   Does this represent any performance gain in any way or is it just a convenience for C code?
8. vitaut commented on Mar 2, 2015

   

   vitaut

   on Mar 2, 2015

   Contributor

   More actions

   There is no performance gain. It's mostly for the case where you can't replace the destination array with MemoryWriter.