qualifiers

I have a Qualifier where I read from public class TestController{ @Autowired @Qualifier("jdbc") private JdbcTemplate jtm; //..... } The qualifier "jdbc" is the bean defined as @Bean(name = "jdbc") @Autowired public JdbcTemplate masterJdbcTemplate(@Qualifier("prod") DataSource prod) { return new JdbcTemplate(prod); } This is the which returns the datasource for that qualifier and works fine. Now I want to make the Qualifier name to be read from the application.properties. So I changed my code to public class TestController{ @Autowired @Qualifier("${database.connector.name}") private

Is it valid to use drawable-swdp- like drawable-sw720dp-xhdpi? Below is my scenario: My Acer iconia tab A501 (10") has a resolution of 1280x800 and density mdpi(160dp). It is expected to take the resource from drawable-sw720dp-mdpi. But the resource is being taken from drawable-sw720dp-xhdpi. I have following folders: drawable-sw720dp drawable-sw720dp-mdpi drawable-sw720dp-hdpi drawable-sw720dp-xhdpi is this the way this qualifier is to be used? or Is the density already considered while calculating the smallest width.So should i be having only one folder of the format: drawable-sw720dp I had

In this example, does correctness require global_value to be declared volatile ? int global_value = 0; void foo () { ++ global_value; } void bar () { some_function (++global_value); foo (); some_function (++global_value); } My understanding is that volatile is "intended" for pointers to mapped memory and variables which can be modified by signals (and emphatically not for thread-safety) but it's easy to imagine that bar might compile to something like this: push EAX mov EAX, global_value inc EAX push EAX call some_function call foo inc EAX push EAX call some_function mov global_value, EAX pop

Possible Duplicate: Does the evil cast get trumped by the evil compiler? Hello, If I can modify a constant through a pointer, then what is the purpose of it? Below is code: #include <stdio.h> #include <stdlib.h> int main() { const int a = 10; int *p = (int *)&a; printf("Before: %d \n", a); *p = 2; /*a = 2; gives error*/ printf("After: %d \n", *p); return 0; } OUTPUT: Before: 10 After: 2 Press any key to continue . . . Using Visual Studio 2008. The reason you could modify the value is because you did a pointer typecast that stripped off the const ness: int *p = (int *)&a; This typecasts a const

Is there any practical difference between the following prototypes? void f(const int *p); void f(const int *restrict p); void f(const int *volatile p); The section C11 6.7.6.3/15 (final sentence) says that top-level qualifiers are not considered for the purposes of determining type compatibility, i.e. it is permitted for the function definition to have different top-level qualifiers on its parameters than the prototype declaration had. However (unlike C++) it does not say that they are ignored completely. In the case of const this is clearly moot; however in the case of volatile and restrict

C++11 makes it possible to overload member functions based on reference qualifiers: class Foo { public: void f() &; // for when *this is an lvalue void f() &&; // for when *this is an rvalue }; Foo obj; obj.f(); // calls lvalue overload std::move(obj).f(); // calls rvalue overload I understand how this works, but what is a use case for it? I see that N2819 proposed limiting most assignment operators in the standard library to lvalue targets (i.e., adding " & " reference qualifiers to assignment operators), but this was rejected . So that was a potential use case where the committee decided not