I should have simply been more faithful to this answer. A working implementation is: namespace has_insertion_operator_impl { typedef char no; typedef char yes[2]; struct any_t { template<typename T> any_t( T const& ); }; no operator<<( std::ostream const&, any_t const& ); yes& test( std::ostream& ); no test( no ); template<typename T> struct has_insertion_operator { static std::ostream … Read more
Core Working Group defect report 993 was created to address this issue: 993. Freedom to perform instantiation at the end of the translation unit Section: 14.6.4.1 [temp.point] Status: C++11 Submitter: John Spicer Date: 6 March, 2009[Voted into the WP at the March, 2011 meeting.] The intent is that it is a permissible implementation technique to … Read more
A trait you want might look like this: template <typename B, typename D> struct is_base_of // check if B is a base of D { typedef char yes[1]; typedef char no[2]; static yes& test(B*); static no& test(…); static D* get(void); static const bool value = sizeof(test(get()) == sizeof(yes); }; Then you just need a static … Read more
You can give an explicit template argument: bar<int(int)>(3, foo); or cast the ambiguous function name to a type from which the template argument can be deduced: bar(3, static_cast<int(*)(int)>(foo)); or wrap it in another function (or function object) to remove the ambiguity bar(3, [](int x){return foo(x);});
A name in C++ can pertain to three different tiers of entities: Types, values, and templates. struct Foo { typedef int A; // type static double B; // value template <typename T> struct C; // template }; The three names Foo::A, Foo::B and Foo::C are examples of all three different tiers. In the above example, … Read more
The unspecialized function templates are also called the underlying base templates. Base templates can be specialized. The overloading rules to see which ones get called in different situations, are pretty simple, at least at a high level: Nontemplate functions are first-class citizens. A plain old nontemplate function that matches the parameter types as well as … Read more
I use a singleton with a member for registration, basically: template< typename KeyType, typename ProductCreatorType > class Factory { typedef boost::unordered_map< KeyType, ProductCreatorType > CreatorMap; … }; Using Loki I then have something along these lines: typedef Loki::SingletonHolder< Factory< StringHash, boost::function< boost::shared_ptr< SomeBase >( const SomeSource& ) > >, Loki::CreateStatic > SomeFactory; Registration is usually … Read more
You can of course move your js logic into a .js file. But if you want it inline with your StringTemplate views, you can escape it using the \$ construct. In addition, you can simply use the jQuery(“selector”), instead of $(“selector”) construct if you want to avoid the escaping syntax. Here’s a good article on … Read more
There is a better way in C++0x for this class X: public Super { using Super::Super; }; If you declare a perfect-forwarding template, your type will behave badly in overload resolution. Imagine your base class is convertible from int and there exist two functions to print out classes class Base { public: Base(int n); }; … Read more
Actually, it depends. Django’s templating engine does escaping automatically, so you don’t really need to escape. If you add template filter “safe” like {{c.title|safe}} then you do need to worry about things like html injection, because “safe” marks the string as such and it means that it won’t be escaped. There is also an {% … Read more