Changeset 1976

Show
Ignore:
Timestamp:
02/06/11 12:11:34 (2 years ago)
Author:
ahu
Message:

big batch of 'using namespace std;' removal

Location:
trunk/pdns
Files:
106 modified

Legend:

Unmodified
Added
Removed

  • trunk/pdns/modules/db2backend/DB2Backend.cc

    r1471 r1976  
    66#include <sstream> 
    77 
    8 using namespace std; 
     8#include "namespaces.hh" 
    99 
    1010#include <dns.hh> 

  • trunk/pdns/modules/db2backend/DB2Backend.hh

    r477 r1976  
    77#include <map> 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111#include <sqlcli1.h> 

  • trunk/pdns/modules/db2backend/DB2Exception.hh

    r477 r1976  
    66#include <string> 
    77 
    8 using namespace std; 
     8#include "namespaces.hh" 
    99 
    1010#include <sqlcli1.h> 

  • trunk/pdns/modules/geobackend/geobackend.hh

    r1471 r1976  
    1616#include "ippreftree.hh" 
    1717 
    18 using namespace std; 
     18#include "namespaces.hh" 
    1919 
    2020class GeoRecord { 

  • trunk/pdns/modules/geobackend/ippreftree.hh

    r1471 r1976  
    1111#include <stdint.h> 
    1212 
    13 using namespace std; 
     13#include "namespaces.hh" 
    1414 
    1515// Use old style C structs for efficiency 

  • trunk/pdns/modules/gmysqlbackend/gmysqlbackend.cc

    r1804 r1976  
    33#include <map> 
    44 
    5 using namespace std; 
     5#include "pdns/namespaces.hh" 
    66 
    77#include "pdns/dns.hh" 

  • trunk/pdns/modules/gmysqlbackend/gmysqlbackend.hh

    r1896 r1976  
    44#include "pdns/backends/gsql/gsqlbackend.hh" 
    55 
    6 using namespace std; 
     6#include "pdns/namespaces.hh" 
    77 
    88/** The gMySQLBackend is a DNSBackend that can answer DNS related questions. It looks up data 

  • trunk/pdns/modules/gmysqlbackend/smysql.cc

    r1471 r1976  
    88#include "pdns/logger.hh" 
    99#include "pdns/dns.hh" 
    10 using namespace std; 
     10#include "pdns/namespaces.hh" 
    1111 
    1212bool SMySQL::s_dolog; 

  • trunk/pdns/modules/goraclebackend/goraclebackend.cc

    r1471 r1976  
    33#include <map> 
    44 
    5 using namespace std; 
     5#include "namespaces.hh" 
    66 
    77#include "pdns/dns.hh" 

  • trunk/pdns/modules/goraclebackend/goraclebackend.hh

    r337 r1976  
    44#include "pdns/backends/gsql/gsqlbackend.hh" 
    55 
    6 using namespace std; 
     6#include "namespaces.hh" 
    77 
    88/** The gOracleBackend is a DNSBackend that can answer DNS related questions. It looks up data 

  • trunk/pdns/modules/goraclebackend/soracle.cc

    r1471 r1976  
    99#include "pdns/dns.hh" 
    1010#include <regex.h> 
    11 using namespace std; 
     11#include "namespaces.hh" 
    1212 
    1313bool SOracle::s_dolog; 

  • trunk/pdns/modules/gpgsqlbackend/gpgsqlbackend.cc

    r1807 r1976  
    22#include <map> 
    33 
    4 using namespace std; 
     4#include "pdns/namespaces.hh" 
    55 
    66#include "pdns/dns.hh" 

  • trunk/pdns/modules/gpgsqlbackend/gpgsqlbackend.hh

    r78 r1976  
    33#include "pdns/backends/gsql/gsqlbackend.hh" 
    44 
    5 using namespace std; 
     5#include "pdns/namespaces.hh" 
    66 
    77/** The gPgSQLBackend is a DNSBackend that can answer DNS related questions. It looks up data 

  • trunk/pdns/modules/gpgsqlbackend/spgsql.cc

    r1471 r1976  
    88#include "pdns/dns.hh" 
    99 
    10 using namespace std; 
     10#include "pdns/namespaces.hh" 
    1111 
    1212bool SPgSQL::s_dolog; 

  • trunk/pdns/modules/gpgsqlbackend/spgsql.hh

    r1471 r1976  
    33#ifndef SPGSQL_HH 
    44#define SPGSQL_HH 
    5 using namespace std; 
     5#include "pdns/namespaces.hh" 
    66#include "pdns/backends/gsql/ssql.hh" 
    77 

  • trunk/pdns/modules/mydnsbackend/mydnsbackend.cc

    r1471 r1976  
    2525#include <sstream> 
    2626 
    27 using namespace std; 
     27#include "namespaces.hh" 
    2828 
    2929#include <pdns/dns.hh> 

  • trunk/pdns/modules/mydnsbackend/mydnsbackend.hh

    r1471 r1976  
    55#include <map> 
    66 
    7 using namespace std; 
     7#include "namespaces.hh" 
    88 
    99#include <modules/gmysqlbackend/smysql.hh> 

  • trunk/pdns/modules/mysqlbackend/mysqlcbackend.cc

    r1471 r1976  
    66#include <sstream> 
    77 
    8 using namespace std; 
     8#include "namespaces.hh" 
    99 
    1010#include <pdns/dns.hh> 

  • trunk/pdns/modules/mysqlbackend/mysqlcbackend.hh

    r180 r1976  
    55#include <map> 
    66 
    7 using namespace std; 
     7#include "namespaces.hh" 
    88 
    99#include <mysql.h> 

  • trunk/pdns/modules/oraclebackend/oraclebackend.cc

    r1922 r1976  
    1212#include <string> 
    1313 
    14 using namespace std; 
     14#include "namespaces.hh" 
    1515 
    1616#include "pdns/dns.hh" 

  • trunk/pdns/modules/oraclebackend/oraclebackend.hh

    r1922 r1976  
    77#include <oci.h> 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111class OracleException : public DBException 

  • trunk/pdns/modules/pdnsbackend/pdnsbackend.cc

    r1906 r1976  
    77#include <sstream> 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111#include <pdns/dns.hh> 

  • trunk/pdns/modules/pdnsbackend/pdnsbackend.hh

    r1317 r1976  
    77#include <map> 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111#include <mysql.h> 

  • trunk/pdns/modules/pipebackend/coprocess.hh

    r569 r1976  
    66#include <string> 
    77 
    8 using namespace std;  
     8#include "pdns/namespaces.hh"  
    99 
    1010class CoProcess 

  • trunk/pdns/modules/pipebackend/pipebackend.cc

    r1833 r1976  
    1111#include "coprocess.hh" 
    1212 
    13 using namespace std; 
     13#include "pdns/namespaces.hh" 
    1414 
    1515#include <pdns/dns.hh> 

  • trunk/pdns/modules/pipebackend/pipebackend.hh

    r525 r1976  
    1212#include <regex.h> 
    1313#include <boost/shared_ptr.hpp> 
    14 using namespace boost; 
    1514 
    16 using namespace std; 
     15#include "pdns/namespaces.hh" 
    1716 
    1817/** very small regex wrapper */ 

  • trunk/pdns/modules/xdbbackend/xgdbm.cc

    r1471 r1976  
    77#include <iostream> 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111GDBM_FILE XGDBMWrapper::s_db; 

  • trunk/pdns/modules/xdbbackend/xtdb.cc

    r1471 r1976  
    1010 
    1111 
    12 using namespace std; 
     12#include "namespaces.hh" 
    1313 
    1414TDB_CONTEXT *XTDBWrapper::s_db; 

  • trunk/pdns/pdns/ahuexception.hh

    r681 r1976  
    2323#include<string> 
    2424 
    25 using namespace std; 
     25#include "namespaces.hh" 
    2626 
    2727//! Generic Exception thrown  

  • trunk/pdns/pdns/anadns.hh

    r1427 r1976  
    99 
    1010#include "namespaces.hh" 
    11 using namespace std; 
     11#include "namespaces.hh" 
    1212 
    1313struct QuestionIdentifier 

  • trunk/pdns/pdns/argtng.hh

    r1472 r1976  
    77#include <boost/shared_ptr.hpp> 
    88#include <boost/regex.hpp> 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010#include "namespaces.hh" 
    1111 

  • trunk/pdns/pdns/arguments.hh

    r1348 r1976  
    3333#endif 
    3434 
    35 using namespace std; 
     35#include "namespaces.hh" 
    3636 
    3737typedef AhuException ArgException; 

  • trunk/pdns/pdns/backends/bind/bindbackend2.hh

    r1957 r1976  
    3535#include "misc.hh" 
    3636 
    37 using namespace std; 
     37#include "namespaces.hh" 
    3838using namespace boost; 
    3939using namespace ::boost::multi_index; 

  • trunk/pdns/pdns/backends/bind/bindparser.hh

    r1400 r1976  
    2424#include <set> 
    2525 
    26 using namespace std; 
     26#include "namespaces.hh" 
    2727 
    2828class BindDomainInfo  

  • trunk/pdns/pdns/backends/bind/huffman.hh

    r681 r1976  
    2626#include "../../ahuexception.hh" 
    2727 
    28 using namespace std; 
     28#include "namespaces.hh" 
    2929 
    3030class HuffmanCodec 

  • trunk/pdns/pdns/backends/bind/zone2ldap.cc

    r1472 r1976  
    155155        { 
    156156#if __GNUC__ >= 3 
    157                 ios_base::sync_with_stdio( false ); 
     157                std::ios_base::sync_with_stdio( false ); 
    158158#endif 
    159159                reportAllTypes(); 

  • trunk/pdns/pdns/backends/bind/zone2sql.cc

    r1925 r1976  
    3131#include <stdio.h> 
    3232 
    33 using namespace std; 
     33#include "namespaces.hh" 
    3434 
    3535#include "dns.hh" 
    … …  
    199199    reportFancyTypes(); 
    200200#if __GNUC__ >= 3 
    201     ios_base::sync_with_stdio(false); 
     201    std::ios_base::sync_with_stdio(false); 
    202202#endif 
    203203    lastsoa_qname=" "; 

  • trunk/pdns/pdns/backends/gsql/gsqlbackend.cc

    r1931 r1976  
    77#include <map> 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111#include "pdns/dns.hh" 

  • trunk/pdns/pdns/backends/gsql/gsqlbackend.hh

    r1791 r1976  
    33#include "ssql.hh" 
    44 
    5 using namespace std; 
     5#include "../../namespaces.hh" 
    66 
    77/** The GSQLBackend is a DNSBackend that can answer DNS related questions. It looks up data 

  • trunk/pdns/pdns/backends/gsql/ssql.hh

    r477 r1976  
    1111#include <string> 
    1212#include <vector> 
    13 using namespace std; 
     13#include "../../namespaces.hh" 
    1414 
    1515 

  • trunk/pdns/pdns/base32.cc

    r1827 r1976  
    66#include <iostream> 
    77#include "base32.hh" 
    8 using namespace std; 
     8#include "namespaces.hh" 
    99 
    1010/* based on freebsd:src/contrib/opie/libopie/btoe.c extract: get bit ranges from a char* */ 

  • trunk/pdns/pdns/binpatch.cc

    r681 r1976  
    3333 
    3434 
    35 using namespace std; 
     35#include "namespaces.hh" 
    3636 
    3737static void imbue(char *pname, const char *search, const string &replace); 

  • trunk/pdns/pdns/communicator.hh

    r1859 r1976  
    4040#include "packethandler.hh" 
    4141 
    42 using namespace std; 
     42#include "namespaces.hh" 
    4343 
    4444struct SuckRequest 
    … …  
    114114  time_t earliest() 
    115115  { 
    116     time_t early=numeric_limits<time_t>::max() - 1;  
     116    time_t early=std::numeric_limits<time_t>::max() - 1;  
    117117    for(d_nqueue_t::const_iterator i=d_nqueue.begin();i!=d_nqueue.end();++i)  
    118118      early=min(early,i->next); 
    … …  
    130130  }; 
    131131 
    132   typedef list<NotificationRequest>d_nqueue_t; 
     132  typedef std::list<NotificationRequest>d_nqueue_t; 
    133133  d_nqueue_t d_nqueue; 
    134134 

  • trunk/pdns/pdns/devpollmplexer.cc

    r1432 r1976  
    99 
    1010#include "namespaces.hh" 
    11 using namespace std; 
     11#include "namespaces.hh" 
    1212 
    1313class DevPollFDMultiplexer : public FDMultiplexer 

  • trunk/pdns/pdns/dnsbackend.hh

    r1796 r1976  
    3939#include "dns.hh" 
    4040#include <vector> 
    41 using namespace std; 
     41#include "namespaces.hh" 
    4242   
    4343class DNSBackend;   

  • trunk/pdns/pdns/dnsdemog.cc

    r1472 r1976  
    1212 
    1313#include "namespaces.hh" 
    14 using namespace std; 
     14#include "namespaces.hh" 
    1515 
    1616StatBag S; 

  • trunk/pdns/pdns/dnsgram.cc

    r1609 r1976  
    1313 
    1414#include "namespaces.hh" 
    15 using namespace std; 
     15#include "namespaces.hh" 
    1616 
    1717StatBag S; 

  • trunk/pdns/pdns/dnspacket.cc

    r1958 r1976  
    399399 
    400400  if(getEDNSOpts(mdp, &edo)) { 
    401     d_maxreplylen=min(edo.d_packetsize, (uint16_t)1680); 
     401    d_maxreplylen=std::min(edo.d_packetsize, (uint16_t)1680); 
    402402//    cerr<<edo.d_Z<<endl; 
    403403    if(edo.d_Z & EDNSOpts::DNSSECOK) 

  • trunk/pdns/pdns/dnsparser.cc

    r1900 r1976  
    265265#endif  
    266266  } 
    267   catch(out_of_range &re) { 
     267  catch(std::out_of_range &re) { 
    268268    if(validPacket && d_header.tc) { // don't sweat it over truncated packets, but do adjust an, ns and arcount 
    269269      if(n < d_header.ancount) { 
    … …  
    318318{ 
    319319  if(d_pos + len > d_content.size()) 
    320     throw out_of_range("Attempt to copy outside of packet"); 
     320    throw std::out_of_range("Attempt to copy outside of packet"); 
    321321 
    322322  memcpy(dest, &d_content.at(d_pos), len); 
    … …  
    575575    d_notyouroffset += by; 
    576576    if(d_notyouroffset > d_packet.length()) 
    577       throw out_of_range("dns packet out of range: "+lexical_cast<string>(d_notyouroffset) +" > "  
     577      throw std::out_of_range("dns packet out of range: "+lexical_cast<string>(d_notyouroffset) +" > "  
    578578      + lexical_cast<string>(d_packet.length()) ); 
    579579  } 

  • trunk/pdns/pdns/dnsparser.hh

    r1900 r1976  
    4848*/ 
    4949     
    50 using namespace std; 
     50#include "namespaces.hh" 
    5151#include "namespaces.hh" 
    5252 

  • trunk/pdns/pdns/dnspcap.hh

    r1175 r1976  
    1414#include <vector> 
    1515#include <boost/format.hpp> 
    16 using namespace std; 
     16#include "namespaces.hh" 
    1717 
    1818struct pdns_pcap_file_header { 

  • trunk/pdns/pdns/dnsproxy.hh

    r1549 r1976  
    3232#include "iputils.hh" 
    3333 
    34 using namespace std; 
     34#include "namespaces.hh" 
    3535 
    3636/** 

  • trunk/pdns/pdns/dnsrecords.hh

    r1936 r1976  
    2727#include <bitset> 
    2828 
    29 using namespace std; 
     29#include "namespaces.hh" 
    3030#include "namespaces.hh" 
    3131 

  • trunk/pdns/pdns/dnsreplay.cc

    r1472 r1976  
    6262#include "namespaces.hh" 
    6363using namespace ::boost::multi_index; 
    64 using namespace std; 
     64#include "namespaces.hh" 
    6565 
    6666StatBag S; 
    … …  
    370370      s_wednserrors++; 
    371371    } 
    372     catch(out_of_range &e) 
     372    catch(std::out_of_range &e) 
    373373    { 
    374374      s_wednserrors++; 
    … …  
    552552    s_origdnserrors++; 
    553553  } 
    554   catch(out_of_range &e) 
     554  catch(std::out_of_range &e) 
    555555  { 
    556556    s_origdnserrors++; 

  • trunk/pdns/pdns/dnsscan.cc

    r1472 r1976  
    2020#include "namespaces.hh" 
    2121using namespace ::boost::multi_index; 
    22 using namespace std; 
     22#include "namespaces.hh" 
    2323StatBag S; 
    2424 

  • trunk/pdns/pdns/dnsscope.cc

    r1544 r1976  
    1212 
    1313#include "namespaces.hh" 
    14 using namespace std; 
     14#include "namespaces.hh" 
    1515 
    1616StatBag S; 

  • trunk/pdns/pdns/dnssecinfra.hh

    r1967 r1976  
    8888 
    8989 
    90 struct CanonicalCompare: public binary_function<string, string, bool>   
     90struct CanonicalCompare: public std::binary_function<string, string, bool>   
    9191{ 
    9292  bool operator()(const std::string& a, const std::string& b) { 

  • trunk/pdns/pdns/dnswasher.cc

    r1472 r1976  
    1717 
    1818#include "namespaces.hh" 
    19 using namespace std; 
     19#include "namespaces.hh" 
    2020 
    2121StatBag S; 

  • trunk/pdns/pdns/dnswriter.cc

    r1900 r1976  
    155155      else  
    156156        for (unsigned int i = 0; i < beg->length(); i += 0xff){ 
    157           d_record.push_back(min((string::size_type)0xffU, beg->length()-i)); 
     157          d_record.push_back(std::min((string::size_type)0xffU, beg->length()-i)); 
    158158          const uint8_t* ptr=(uint8_t*)(beg->c_str()) + i; 
    159           d_record.insert(d_record.end(), ptr, ptr+min((string::size_type)0xffU, beg->length()-i)); 
     159          d_record.insert(d_record.end(), ptr, ptr+ std::min((string::size_type)0xffU, beg->length()-i)); 
    160160        } 
    161161    } 

  • trunk/pdns/pdns/dnswriter.hh

    r1900 r1976  
    1111#endif 
    1212#include "dns.hh" 
    13 using namespace std; 
     13#include "namespaces.hh" 
    1414 
    1515/** this class can be used to write DNS packets. It knows about DNS in the sense that it makes  

  • trunk/pdns/pdns/dynhandler.hh

    r681 r1976  
    3232#endif // WIN32 
    3333 
    34 using namespace std; 
     34#include "namespaces.hh" 
    3535 
    3636 

  • trunk/pdns/pdns/dynlistener.hh

    r1246 r1976  
    3838#endif // WIN32 
    3939 
    40 using namespace std; 
     40#include "namespaces.hh" 
    4141 
    4242class DynListener : public boost::noncopyable 

  • trunk/pdns/pdns/dynloader.cc

    r1472 r1976  
    3838#include "statbag.hh" 
    3939#include "misc.hh" 
    40 using namespace std; 
     40#include "namespaces.hh" 
    4141#include "namespaces.hh" 
    4242 

  • trunk/pdns/pdns/dynmessenger.hh

    r1246 r1976  
    3939#include "ahuexception.hh" 
    4040 
    41 using namespace std; 
     41#include "namespaces.hh" 
    4242 
    4343//! The DynMessenger can send messages to UNIX domain sockets and TCP sockets 

  • trunk/pdns/pdns/epollmplexer.cc

    r1432 r1976  
    1111 
    1212#include "namespaces.hh" 
    13 using namespace std; 
     13#include "namespaces.hh" 
    1414 
    1515class EpollFDMultiplexer : public FDMultiplexer 

  • trunk/pdns/pdns/htimer.cc

    r1893 r1976  
    55HTimer::timers_t HTimer::s_timers; 
    66 
    7 using namespace std; 
     7#include "namespaces.hh" 
    88#include "namespaces.hh" 
    99 

  • trunk/pdns/pdns/inflighter.cc

    r1717 r1976  
    1111#include <sys/socket.h> 
    1212 
    13 using namespace std; 
     13#include "namespaces.hh" 
    1414using namespace boost::multi_index; 
    1515 

  • trunk/pdns/pdns/iputils.hh

    r1638 r1976  
    3737#include <boost/lexical_cast.hpp> 
    3838 
    39 using namespace std; 
     39#include "namespaces.hh" 
    4040 
    4141union ComboAddress { 
    … …  
    7979  } 
    8080 
    81   struct addressOnlyLessThan: public binary_function<string, string, bool> 
     81  struct addressOnlyLessThan: public std::binary_function<string, string, bool> 
    8282  { 
    8383    bool operator()(const ComboAddress& a, const ComboAddress& b) const 

  • trunk/pdns/pdns/kqueuemplexer.cc

    r1432 r1976  
    1313 
    1414#include "namespaces.hh" 
    15 using namespace std; 
     15#include "namespaces.hh" 
    1616 
    1717class KqueueFDMultiplexer : public FDMultiplexer 

  • trunk/pdns/pdns/logger.cc

    r680 r1976  
    2424#endif 
    2525 
    26 using namespace std; 
     26#include "namespaces.hh" 
    2727 
    2828Logger &theL(const string &pname) 

  • trunk/pdns/pdns/logger.hh

    r1472 r1976  
    3737#endif // WIN32 
    3838 
    39 using namespace std; 
     39#include "namespaces.hh" 
    4040 
    4141//! The Logger class can be used to log messages in various ways. 
    … …  
    118118 
    119119#ifndef WIN32 
    120   Logger& operator<<(ostream & (&)(ostream &)); //!< this is to recognise the endl, and to commit the log 
     120  Logger& operator<<(std::ostream & (&)(std::ostream &)); //!< this is to recognise the endl, and to commit the log 
    121121#else 
    122122  // This is a hack to keep MSVC from generating a internal compiler error. 

  • trunk/pdns/pdns/lua-pdns-recursor.cc

    r1636 r1976  
    4141#include <stdexcept> 
    4242#include "logger.hh" 
    43 using namespace std; 
     43#include "namespaces.hh" 
    4444 
    4545bool netmaskMatchTable(lua_State* lua, const std::string& ip) 

  • trunk/pdns/pdns/lwres.hh

    r1472 r1976  
    3939#include "ahuexception.hh" 
    4040#include "dns.hh" 
    41 using namespace std; 
     41#include "namespaces.hh" 
    4242 
    4343int asendto(const char *data, int len, int flags, const ComboAddress& ip, uint16_t id,  

  • trunk/pdns/pdns/md5.cc

    r1427 r1976  
    99#include "md5.hh" 
    1010 
    11 using namespace std; 
     11#include "namespaces.hh" 
    1212 
    1313namespace { 

  • trunk/pdns/pdns/misc.hh

    r1968 r1976  
    6969#include <boost/optional.hpp> 
    7070 
    71 using namespace std; 
     71#include "namespaces.hh" 
    7272bool chopOff(string &domain); 
    7373bool chopOffDotted(string &domain); 
    … …  
    415415 
    416416 
    417 struct CIStringCompare: public binary_function<string, string, bool>   
     417struct CIStringCompare: public std::binary_function<string, string, bool>   
    418418{ 
    419419  bool operator()(const string& a, const string& b) const 

  • trunk/pdns/pdns/nameserver.hh

    r1472 r1976  
    11/* 
    22    PowerDNS Versatile Database Driven Nameserver 
    3     Copyright (C) 2005 PowerDNS.COM BV 
     3    Copyright (C) 2005 - 2011 PowerDNS.COM BV 
    44 
    55    This program is free software; you can redistribute it and/or modify it 
    … …  
    3333#include <vector> 
    3434#include "statbag.hh" 
    35 using namespace std; 
     35#include "namespaces.hh" 
    3636 
    3737/** This is the main class. It opens a socket on udp port 53 and waits for packets. Those packets can  

  • trunk/pdns/pdns/notify.cc

    r1608 r1976  
    1616#include "namespaces.hh" 
    1717using namespace ::boost::multi_index; 
    18 using namespace std; 
     18#include "namespaces.hh" 
    1919 
    2020namespace po = boost::program_options; 

  • trunk/pdns/pdns/nproxy.cc

    r1730 r1976  
    1919#include "namespaces.hh" 
    2020using namespace ::boost::multi_index; 
    21 using namespace std; 
     21#include "namespaces.hh" 
    2222 
    2323namespace po = boost::program_options; 

  • trunk/pdns/pdns/packetcache.hh

    r1869 r1976  
    2626#include "dns.hh" 
    2727#include <boost/version.hpp> 
    28 using namespace std; 
     28#include "namespaces.hh" 
    2929using namespace ::boost::multi_index; 
    3030 
    … …  
    4545*/ 
    4646 
    47 struct CIBackwardsStringCompare: public binary_function<string, string, bool>   
     47struct CIBackwardsStringCompare: public std::binary_function<string, string, bool>   
    4848{ 
    4949  bool operator()(const string& str_a, const string& str_b) const 

  • trunk/pdns/pdns/packethandler.hh

    r1930 r1976  
    3131#include "dnsseckeeper.hh" 
    3232 
    33 using namespace std; 
     33#include "namespaces.hh" 
    3434 
    3535// silly Solaris people define PC 

  • trunk/pdns/pdns/pdns_hw.cc

    r1711 r1976  
    1212#include <sstream> 
    1313 
    14 using namespace std; 
     14#include "namespaces.hh" 
    1515int main() 
    1616{ 

  • trunk/pdns/pdns/polarrsakeyinfra.cc

    r1966 r1976  
    325325{ 
    326326  string keystring; 
    327   char tmp[max(mpi_size(&d_context.E), mpi_size(&d_context.N))]; 
     327  char tmp[std::max(mpi_size(&d_context.E), mpi_size(&d_context.N))]; 
    328328 
    329329  mpi_write_binary(&d_context.E, (unsigned char*)tmp, mpi_size(&d_context.E) ); 

  • trunk/pdns/pdns/pollmplexer.cc

    r1911 r1976  
    88#include "utility.hh"  
    99#include "namespaces.hh" 
    10 using namespace std; 
     10#include "namespaces.hh" 
    1111 
    1212 

  • trunk/pdns/pdns/portsmplexer.cc

    r1622 r1976  
    1313 
    1414#include "namespaces.hh" 
    15 using namespace std; 
     15#include "namespaces.hh" 
    1616 
    1717class PortsFDMultiplexer : public FDMultiplexer 

  • trunk/pdns/pdns/qtype.hh

    r1944 r1976  
    2525#include <utility> 
    2626 
    27 using namespace std; 
     27#include "namespaces.hh" 
    2828 
    2929/** The QType class is meant to deal easily with the different kind of resource types, like 'A', 'NS', 

  • trunk/pdns/pdns/rcpgenerator.hh

    r1900 r1976  
    2929#endif 
    3030 
    31 using namespace std; 
     31#include "namespaces.hh" 
    3232 
    3333class RecordTextException : public runtime_error 

  • trunk/pdns/pdns/rec_channel.cc

    r1675 r1976  
    1212#include "ahuexception.hh" 
    1313 
    14 using namespace std; 
     14#include "namespaces.hh" 
    1515 
    1616RecursorControlChannel::RecursorControlChannel() 

  • trunk/pdns/pdns/rec_channel_rec.cc

    r1750 r1976  
    2424#endif 
    2525 
    26 using namespace std; 
     26#include "namespaces.hh" 
    2727#include "namespaces.hh" 
    2828map<string, const uint32_t*> d_get32bitpointers; 

  • trunk/pdns/pdns/rec_control.cc

    r1943 r1976  
    2222#include "config.h" 
    2323 
    24 using namespace std; 
     24#include "namespaces.hh" 
    2525 
    2626#ifndef RECURSOR 

  • trunk/pdns/pdns/recursor_cache.cc

    r1748 r1976  
    99#include "cachecleaner.hh" 
    1010 
    11 using namespace std; 
     11#include "namespaces.hh" 
    1212#include "namespaces.hh" 
    1313 

  • trunk/pdns/pdns/recursor_memcached.cc

    r1362 r1976  
    55#include <boost/lexical_cast.hpp> 
    66 
    7 using namespace std; 
     7#include "namespaces.hh" 
    88using boost::lexical_cast; 
    99 

  • trunk/pdns/pdns/resolver.hh

    r1859 r1976  
    3636#include "ahuexception.hh" 
    3737#include "dns.hh" 
    38 using namespace std; 
     38#include "namespaces.hh" 
    3939 
    4040class ResolverException : public AhuException 

  • trunk/pdns/pdns/selectmplexer.cc

    r1432 r1976  
    99 
    1010#include "namespaces.hh" 
    11 using namespace std; 
     11#include "namespaces.hh" 
    1212 
    1313static FDMultiplexer* make() 

  • trunk/pdns/pdns/sstuff.hh

    r1472 r1976  
    2020#include <boost/utility.hpp> 
    2121#include <csignal> 
    22 using namespace std; 
     22#include "namespaces.hh" 
    2323#include "namespaces.hh" 
    2424 

  • trunk/pdns/pdns/statbag.cc

    r1284 r1976  
    2727#include "lock.hh" 
    2828 
    29 using namespace std; 
     29#include "namespaces.hh" 
    3030 
    3131StatBag::StatBag() 

  • trunk/pdns/pdns/statbag.hh

    r1284 r1976  
    2424#include <vector> 
    2525#include "lock.hh" 
    26 using namespace std; 
     26#include "namespaces.hh" 
    2727 
    2828class StatRing 

  • trunk/pdns/pdns/tcpreceiver.hh

    r1443 r1976  
    4040#endif // WIN32 
    4141 
    42 using namespace std; 
     42#include "namespaces.hh" 
    4343 
    4444class TCPNameserver 

  • trunk/pdns/pdns/ueberbackend.hh

    r1932 r1976  
    4141#include "dnsbackend.hh" 
    4242 
    43 using namespace std; 
     43#include "namespaces.hh" 
    4444 
    4545class BackendReporter; 

  • trunk/pdns/pdns/unix_utility.cc

    r1681 r1976  
    3636 
    3737 
    38 using namespace std; 
     38#include "namespaces.hh" 
    3939 
    4040// Closes a socket. 

  • trunk/pdns/pdns/utility.hh

    r1681 r1976  
    7272#include <string> 
    7373 
    74 using namespace std; 
     74#include "namespaces.hh" 
    7575 
    7676//! A semaphore class. 

  • trunk/pdns/pdns/webserver.hh

    r1629 r1976  
    2323 
    2424 
    25 using namespace std; 
     25#include "namespaces.hh" 
    2626class Server; 
    2727 

  • trunk/pdns/pdns/win32_dynloader.cc

    r1472 r1976  
    3737#include "statbag.hh" 
    3838#include "misc.hh" 
    39 using namespace std; 
     39#include "namespaces.hh" 
    4040 
    4141ArgvMap &arg() 

  • trunk/pdns/pdns/win32_logger.cc

    r1472 r1976  
    2222#include "ntservice.hh"  
    2323#include "pdnsmsg.hh" 
    24 using namespace std; 
     24#include "namespaces.hh" 
    2525 
    2626Logger &theL(const string &pname) 

  • trunk/pdns/pdns/win32_rec_channel.cc

    r802 r1976  
    77#include "ahuexception.hh" 
    88 
    9 using namespace std; 
     9#include "namespaces.hh" 
    1010 
    1111RecursorControlChannel::RecursorControlChannel() 

  • trunk/pdns/pdns/ws.hh

    r1629 r1976  
    3535 
    3636#include "misc.hh" 
    37 using namespace std; 
     37#include "namespaces.hh" 
    3838 
    3939class Ewma 

  • trunk/pdns/pdns/zoneparser-tng.hh

    r1240 r1976  
    2424#include <stack> 
    2525 
    26 using namespace std; 
     26#include "namespaces.hh" 
    2727 
    2828class ZoneParserTNG 
    … …  
    5858    int d_lineno; 
    5959  }; 
    60   stack<filestate> d_filestates; 
     60  std::stack<filestate> d_filestates; 
    6161}; 
    6262