User Manual
Contents
Due to a popular demand here is a short user manual on how to use "dbj defval" Option 2.2 and Option 3.
First please recall the top of this article. We are using GDI+ to add some dose of reality to these usage examples.
1 2 3 4 5 | #include <windows.h> #include <objidl.h> #include <gdiplus.h> using namespace Gdiplus; #pragma comment(lib, "Gdiplus.lib") |
How to use Option 2.2
Declared as a “stunt” but of course, perfectly usable.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | // assume it is in the // dbj::v_two namespace using dbj::v_two::holder_maker; // here we are inside some (named) namespace // create processw wide default values holders // creation happens on first call // GDI+ default smoothness inline auto default_smoot = dbj::v_two::holder_maker( SmoothingMode::SmoothingModeAntiAlias ); // GDI+ default linecap's inline auto default_lncap = dbj::v_two::holder_maker( LineCap::LineCapRound ); // just a default with inline auto default_width = dbj::v_two::holder_maker(10); inline void test_dbj_defval_option_two() { // just get the dflt width auto dw0 = default_width(); auto dw1 = default_width(); // somewhere and sometimes latter someone // might change the default value // here is how auto dw2 = default_width(42); } |
You declare and define inside some namespace the global instances; after which callers from possible separate threads can use. Or change.
How to use Option 3
note: c++ anonymous name spaces make variables inside them to have internal linkage. To make sure things are not multiplied and instances are unique I very rarely use them. Please do use named name space’s around these examples.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | // we assume: using namespace Gdiplus; // struct S final { mutable dbj::holder<REAL> width{ 0 }; S(REAL def_width) : width(def_width) {} }; // to test the const behaviour inline const S konst_{1024}; // initialized to 1024 // default process wide // smoothness using GDI+ enum's inline dbj::holder<SmoothingMode> smoothnes { SmoothingMode::SmoothingModeAntiAlias }; // default process wide // GDI+ line cap's inline dbj::holder<LineCap> linecap { LineCap::LineCapRound }; inline void test_dbj_defval_option_three() { // set the width to 512 for all the callers auto width_ = konst_.width(512); const auto w1_ = konst_.width(); // 512 auto w2_ = konst_.width(); // 512 _ASSERTE(width_ == 512); _ASSERTE(w2_ == w1_ && w2_ == width_ && w1_ == width_); //use the previosuly declared // and instantiated def val holders auto lc_ = linecap(); auto sness = smoothnes(); } |
You declare and define dbj::holder<> instances as (c++17) inline globals. Then every caller from some thread uses them. Please keep in mind calls above could be scattered across few threads, but that would make code longer and will obfuscate the usage pattern.
