title: shielding #include within namespace { } block?
body: <p>Edit: I know that method 1 is essentially invalid and will probably use method 2, but I'm looking for the best hack or a better solution to mitigate rampant, mutable namespace proliferation.</p>
  
  <p>I have multiple class or method definitions in one namespace that have different dependencies, and would like to use the fewest namespace blocks or explicit scopings possible but while grouping #include directives with the definitions that require them as best as possible.  I've never seen any indication that any preprocessor could be told to exclude namespace {} scoping from #include contents, but I'm here to ask if something similar to this is possible: (see bottom for explanation of why I want something dead simple)</p>
  
  <pre><code>// NOTE: apple.h, etc., contents are *NOT* intended to be in namespace Foo!
  
  // would prefer something most this:
  #pragma magic_namespace_backout(1) // FIXME: use actually existing directive
  namespace Foo {
  
  #include "apple.h"
  B *A::blah(B const *x) { /* ... */ }
  
  #include "banana.h"
  int B::whatever(C const &amp;var) { /* ... */ }
  
  #include "blueberry.h"
  void B::something() { /* ... */ }
  
  } // namespace Foo
  </code></pre>
  
  <p>...</p>
  
  <pre><code>// over this:
  #include "apple.h"
  #include "banana.h"
  #include "blueberry.h"
  
  namespace Foo {
  B *A::blah(B const *x) { /* ... */ }
  int B::whatever(C const &amp;var) { /* ... */ }
  void B::something() { /* ... */ }
  } // namespace Foo
  </code></pre>
  
  <p>...</p>
  
  <pre><code>// or over this:
  #include "apple.h"
  namespace Foo {
  B *A::blah(B const *x) { /* ... */ }
  } // namespace Foo
  
  #include "banana.h"
  namespace Foo {
  int B::whatever(C const &amp;var) { /* ... */ }
  } // namespace Foo
  
  #include "blueberry.h"
  namespace Foo {
  void B::something() { /* ... */ }
  } // namespace Foo
  </code></pre>
  
  <p>My real problem is that I have projects where a module may need to be branched but have coexisting components from the branches in the same program.  I have classes like FooA, etc., that I've called Foo::A in the hopes being able to branch less painfully as Foo::v1_2::A, where some program may need both a Foo::A and a Foo::v1_2::A.  I'd like "Foo" or "Foo::v1_2" to show up only really once per file, as a single namespace block, if possible.  Moreover, I tend to prefer to locate blocks of #include directives immediately above the first definition in the file that requires them.  What's my best choice, or alternatively, what should I be doing instead of hijacking the namespaces?</p>