cleanup, lots of it

47 files changed, 359 insertions, 361 deletions

diff --git a/cpp/include/Ice/Acceptor.h b/cpp/include/Ice/Acceptor.h
index fb188e3b070..e729a209045 100644
--- a/cpp/include/Ice/Acceptor.h
+++ b/cpp/include/Ice/Acceptor.h
@@ -18,7 +18,7 @@
 namespace __Ice
 {
 
-class AcceptorI : public Shared
+class Acceptor : public Shared
 {
 public:
 
@@ -26,13 +26,13 @@ public:
     virtual void close() = 0;
     virtual void shutdown() = 0;
     virtual void listen() = 0;
-    virtual Transceiver accept(int) = 0;
+    virtual Transceiver_ptr accept(int) = 0;
     virtual std::string toString() const = 0;
 
 protected:
 
-    AcceptorI() { }
-    virtual ~AcceptorI() { }
+    Acceptor() { }
+    virtual ~Acceptor() { }
 };
 
 }
diff --git a/cpp/include/Ice/AcceptorF.h b/cpp/include/Ice/AcceptorF.h
index c2ddd8fcbd6..675681cbad7 100644
--- a/cpp/include/Ice/AcceptorF.h
+++ b/cpp/include/Ice/AcceptorF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class AcceptorI;
-void incRef(AcceptorI*);
-void decRef(AcceptorI*);
-typedef __Ice::Handle<AcceptorI> Acceptor;
+class Acceptor;
+void incRef(Acceptor*);
+void decRef(Acceptor*);
+typedef __Ice::Handle<Acceptor> Acceptor_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Buffer.h b/cpp/include/Ice/Buffer.h
index 2b6ea465c16..469a6771f57 100644
--- a/cpp/include/Ice/Buffer.h
+++ b/cpp/include/Ice/Buffer.h
@@ -22,9 +22,9 @@ public:
 
     Buffer() : i(b.begin()) { }
 
-    typedef std::vector<Ice::Byte> Container;
-    Container b;
-    Container::iterator i;
+    typedef std::vector<Ice::Byte> Container_ptr;
+    Container_ptr b;
+    Container_ptr::iterator i;
 };
 
 }
diff --git a/cpp/include/Ice/Collector.h b/cpp/include/Ice/Collector.h
index c6d09644b62..9a2e2a0e786 100644
--- a/cpp/include/Ice/Collector.h
+++ b/cpp/include/Ice/Collector.h
@@ -35,7 +35,7 @@ namespace __Ice
 
 class Incoming;
 
-class CollectorI : public EventHandlerI, public JTCRecursiveMutex
+class Collector : public EventHandler, public JTCRecursiveMutex
 {
 public:
 
@@ -47,7 +47,7 @@ public:
     void sendReply(Incoming*);
 
     //
-    // Operations from EventHandlerI
+    // Operations from EventHandler
     //
     virtual bool server() const;
     virtual bool readable() const;
@@ -58,13 +58,13 @@ public:
 
 private:
 
-    CollectorI(const CollectorI&);
-    void operator=(const CollectorI&);
+    Collector(const Collector&);
+    void operator=(const Collector&);
 
-    CollectorI(const ::Ice::ObjectAdapter&, const Transceiver&,
-	       const Endpoint&);
-    virtual ~CollectorI();
-    friend class CollectorFactoryI;
+    Collector(const ::Ice::ObjectAdapter_ptr&, const Transceiver_ptr&,
+	       const Endpoint_ptr&);
+    virtual ~Collector();
+    friend class CollectorFactory;
 
     enum State
     {
@@ -78,19 +78,19 @@ private:
     void closeConnection();
     void warning(const ::Ice::LocalException&) const;
 
-    ::Ice::ObjectAdapter adapter_;
-    Transceiver transceiver_;
-    Endpoint endpoint_;
-    ThreadPool threadPool_;
+    ::Ice::ObjectAdapter_ptr adapter_;
+    Transceiver_ptr transceiver_;
+    Endpoint_ptr endpoint_;
+    ThreadPool_ptr threadPool_;
     int responseCount_;
     State state_;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
-class CollectorFactoryI : public EventHandlerI, public JTCMutex
+class CollectorFactory : public EventHandler, public JTCMutex
 {
 public:
 
@@ -98,10 +98,10 @@ public:
     void hold();
     void activate();
 
-    Endpoint endpoint() const;
+    Endpoint_ptr endpoint() const;
 
     //
-    // Operations from EventHandlerI
+    // Operations from EventHandler
     //
     virtual bool server() const;
     virtual bool readable() const;
@@ -112,12 +112,12 @@ public:
     
 private:
 
-    CollectorFactoryI(const CollectorFactoryI&);
-    void operator=(const CollectorFactoryI&);
+    CollectorFactory(const CollectorFactory&);
+    void operator=(const CollectorFactory&);
 
-    CollectorFactoryI(const ::Ice::ObjectAdapter&, const Endpoint&);
-    virtual ~CollectorFactoryI();
-    friend class ::Ice::ObjectAdapterI;
+    CollectorFactory(const ::Ice::ObjectAdapter_ptr&, const Endpoint_ptr&);
+    virtual ~CollectorFactory();
+    friend class ::Ice::ObjectAdapter;
 
     enum State
     {
@@ -131,15 +131,15 @@ private:
     void clearBacklog();
     void warning(const ::Ice::LocalException&) const;
 
-    ::Ice::ObjectAdapter adapter_;
-    Acceptor acceptor_;
-    Endpoint endpoint_;
-    ThreadPool threadPool_;
-    std::list<Collector> collectors_;
+    ::Ice::ObjectAdapter_ptr adapter_;
+    Acceptor_ptr acceptor_;
+    Endpoint_ptr endpoint_;
+    ThreadPool_ptr threadPool_;
+    std::list<Collector_ptr> collectors_;
     State state_;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
diff --git a/cpp/include/Ice/CollectorF.h b/cpp/include/Ice/CollectorF.h
index 231d92836b2..a04c4749073 100644
--- a/cpp/include/Ice/CollectorF.h
+++ b/cpp/include/Ice/CollectorF.h
@@ -16,15 +16,15 @@
 namespace __Ice
 {
 
-class CollectorI;
-void incRef(CollectorI*);
-void decRef(CollectorI*);
-typedef __Ice::Handle<CollectorI> Collector;
+class Collector;
+void incRef(Collector*);
+void decRef(Collector*);
+typedef __Ice::Handle<Collector> Collector_ptr;
 
-class CollectorFactoryI;
-void incRef(CollectorFactoryI*);
-void decRef(CollectorFactoryI*);
-typedef __Ice::Handle<CollectorFactoryI> CollectorFactory;
+class CollectorFactory;
+void incRef(CollectorFactory*);
+void decRef(CollectorFactory*);
+typedef __Ice::Handle<CollectorFactory> CollectorFactory_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Communicator.h b/cpp/include/Ice/Communicator.h
index 050d209ca13..f9372f4a26c 100644
--- a/cpp/include/Ice/Communicator.h
+++ b/cpp/include/Ice/Communicator.h
@@ -24,7 +24,7 @@
 namespace Ice
 {
 
-class ICE_API CommunicatorI : public ::__Ice::Shared, public JTCRecursiveMutex
+class ICE_API Communicator : public ::__Ice::Shared, public JTCRecursiveMutex
 {
 public:
     
@@ -34,35 +34,35 @@ public:
 
     Object_pptr stringToProxy(const std::string&);
 
-    ObjectAdapter createObjectAdapter(const std::string&);
-    ObjectAdapter createObjectAdapter(const std::string&, const std::string&);
+    ObjectAdapter_ptr createObjectAdapter(const std::string&);
+    ObjectAdapter_ptr createObjectAdapter(const std::string&, const std::string&);
 
-    void installValueFactory(const ValueFactory&);
+    void installValueFactory(const ValueFactory_ptr&);
 
-    Properties properties();
+    Properties_ptr properties();
 
-    Logger logger();
-    void logger(const Logger&);
+    Logger_ptr logger();
+    void logger(const Logger_ptr&);
 
 private:
 
-    CommunicatorI(const Properties&);
-    virtual ~CommunicatorI();
+    Communicator(const Properties_ptr&);
+    virtual ~Communicator();
 
     // The following operations may create CommunicatorIs
-    friend ICE_API Communicator initialize(int&, char*[]);
-    friend ICE_API Communicator initialize(int&, char*[], const Properties&);
+    friend ICE_API Communicator_ptr initialize(int&, char*[]);
+    friend ICE_API Communicator_ptr initialize(int&, char*[], const Properties_ptr&);
 
-    ::__Ice::Instance instance_;
-    std::map<std::string, ObjectAdapter> adapters_;
+    ::__Ice::Instance_ptr instance_;
+    std::map<std::string, ObjectAdapter_ptr> adapters_;
 };
 
-ICE_API Communicator initialize(int&, char*[]);
-ICE_API Communicator initialize(int&, char*[], const Properties&);
+ICE_API Communicator_ptr initialize(int&, char*[]);
+ICE_API Communicator_ptr initialize(int&, char*[], const Properties_ptr&);
 
-ICE_API Properties createProperties();
-ICE_API Properties createProperties(const Properties&);
-ICE_API Properties createProperties(const std::string&);
+ICE_API Properties_ptr createProperties();
+ICE_API Properties_ptr createProperties(const Properties_ptr&);
+ICE_API Properties_ptr createProperties(const std::string&);
 
 }
 
diff --git a/cpp/include/Ice/CommunicatorF.h b/cpp/include/Ice/CommunicatorF.h
index 68b263f51ee..c6a0c107452 100644
--- a/cpp/include/Ice/CommunicatorF.h
+++ b/cpp/include/Ice/CommunicatorF.h
@@ -13,20 +13,20 @@
 
 #include <Ice/Handle.h>
 
-namespace Ice { class CommunicatorI; }
+namespace Ice { class Communicator; }
 
 namespace __Ice
 {
 
-void ICE_API incRef(::Ice::CommunicatorI*);
-void ICE_API decRef(::Ice::CommunicatorI*);
+void ICE_API incRef(::Ice::Communicator*);
+void ICE_API decRef(::Ice::Communicator*);
 
 }
 
 namespace Ice
 {
 
-typedef __Ice::Handle<CommunicatorI> Communicator;
+typedef __Ice::Handle<Communicator> Communicator_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Connector.h b/cpp/include/Ice/Connector.h
index 6f0157af9af..ba2b5ffe159 100644
--- a/cpp/include/Ice/Connector.h
+++ b/cpp/include/Ice/Connector.h
@@ -18,17 +18,17 @@
 namespace __Ice
 {
 
-class ConnectorI : public Shared
+class Connector : public Shared
 {
 public:
     
-    virtual Transceiver connect(int) = 0;
+    virtual Transceiver_ptr connect(int) = 0;
     virtual std::string toString() const = 0;
     
 protected:
 
-    ConnectorI() { }
-    virtual ~ConnectorI() { }
+    Connector() { }
+    virtual ~Connector() { }
 };
 
 }
diff --git a/cpp/include/Ice/ConnectorF.h b/cpp/include/Ice/ConnectorF.h
index e9e6087183f..a2f097be132 100644
--- a/cpp/include/Ice/ConnectorF.h
+++ b/cpp/include/Ice/ConnectorF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class ConnectorI;
-void incRef(ConnectorI*);
-void decRef(ConnectorI*);
-typedef __Ice::Handle<ConnectorI> Connector;
+class Connector;
+void incRef(Connector*);
+void decRef(Connector*);
+typedef __Ice::Handle<Connector> Connector_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Emitter.h b/cpp/include/Ice/Emitter.h
index 5ce97a7c5f3..69b763b9f49 100644
--- a/cpp/include/Ice/Emitter.h
+++ b/cpp/include/Ice/Emitter.h
@@ -34,7 +34,7 @@ namespace __Ice
 
 class Outgoing;
 
-class EmitterI : public EventHandlerI, public JTCMutex
+class Emitter : public EventHandler, public JTCMutex
 {
 public:
 
@@ -44,7 +44,7 @@ public:
     int timeout() const;
 
     //
-    // Operations from EventHandlerI
+    // Operations from EventHandler
     //
     virtual bool server() const;
     virtual bool readable() const;
@@ -55,12 +55,12 @@ public:
 
 private:
 
-    EmitterI(const EmitterI&);
-    void operator=(const EmitterI&);
+    Emitter(const Emitter&);
+    void operator=(const Emitter&);
 
-    EmitterI(const Instance&, const Transceiver&, const Endpoint&);
-    virtual ~EmitterI();
-    friend class EmitterFactoryI;
+    Emitter(const Instance_ptr&, const Transceiver_ptr&, const Endpoint_ptr&);
+    virtual ~Emitter();
+    friend class EmitterFactory;
 
     enum State
     {
@@ -72,37 +72,37 @@ private:
 
     void setState(State, const ::Ice::LocalException&);
 
-    Transceiver transceiver_;
-    Endpoint endpoint_;
-    ThreadPool threadPool_;
+    Transceiver_ptr transceiver_;
+    Endpoint_ptr endpoint_;
+    ThreadPool_ptr threadPool_;
     ::Ice::Int nextRequestId_;
     std::map< ::Ice::Int, Outgoing*> requests_;
     std::auto_ptr< ::Ice::LocalException> exception_;
     State state_;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
-class EmitterFactoryI : public Shared, public JTCMutex
+class EmitterFactory : public Shared, public JTCMutex
 {
 public:
 
-    Emitter create(const Endpoint&);
+    Emitter_ptr create(const Endpoint_ptr&);
 
 private:
 
-    EmitterFactoryI(const EmitterFactoryI&);
-    void operator=(const EmitterFactoryI&);
+    EmitterFactory(const EmitterFactory&);
+    void operator=(const EmitterFactory&);
 
-    EmitterFactoryI(const Instance&);
-    virtual ~EmitterFactoryI();
+    EmitterFactory(const Instance_ptr&);
+    virtual ~EmitterFactory();
     void destroy();
-    friend class InstanceI;
+    friend class Instance;
 
-    Instance instance_;
-    std::map<Endpoint, Emitter> emitters_;
+    Instance_ptr instance_;
+    std::map<Endpoint_ptr, Emitter_ptr> emitters_;
 };
 
 }
diff --git a/cpp/include/Ice/EmitterF.h b/cpp/include/Ice/EmitterF.h
index 6d4f998cb29..07103017e0d 100644
--- a/cpp/include/Ice/EmitterF.h
+++ b/cpp/include/Ice/EmitterF.h
@@ -16,15 +16,15 @@
 namespace __Ice
 {
 
-class EmitterI;
-void incRef(EmitterI*);
-void decRef(EmitterI*);
-typedef __Ice::Handle<EmitterI> Emitter;
+class Emitter;
+void incRef(Emitter*);
+void decRef(Emitter*);
+typedef __Ice::Handle<Emitter> Emitter_ptr;
 
-class EmitterFactoryI;
-void incRef(EmitterFactoryI*);
-void decRef(EmitterFactoryI*);
-typedef __Ice::Handle<EmitterFactoryI> EmitterFactory;
+class EmitterFactory;
+void incRef(EmitterFactory*);
+void decRef(EmitterFactory*);
+typedef __Ice::Handle<EmitterFactory> EmitterFactory_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Endpoint.h b/cpp/include/Ice/Endpoint.h
index 1adfcf5314c..9d59eccd75a 100644
--- a/cpp/include/Ice/Endpoint.h
+++ b/cpp/include/Ice/Endpoint.h
@@ -27,21 +27,21 @@ const ::Ice::Short UnknownEndpointType = 0;
 const ::Ice::Short TcpEndpointType = 1;
 const ::Ice::Short UdpEndpointType = 2;
 
-class EndpointI : public Shared
+class Endpoint : public Shared
 {
 public:
 
-    EndpointI() { }
+    Endpoint() { }
 
     //
     // Create an endpoint from a string
     //
-    static Endpoint endpointFromString(const std::string&);
+    static Endpoint_ptr endpointFromString(const std::string&);
     
     //
     // Unmarshal an endpoint
     //
-    static void streamRead(Stream*, Endpoint&);
+    static void streamRead(Stream*, Endpoint_ptr&);
     
     //
     // Marshal the endpoint
@@ -69,7 +69,7 @@ public:
     // that timeouts are supported by the endpoint. Otherwise the same
     // endpoint is returned.
     //
-    virtual Endpoint timeout(::Ice::Int) const = 0;
+    virtual Endpoint_ptr timeout(::Ice::Int) const = 0;
 
     //
     // Return true if the endpoint is datagram-based.
@@ -83,48 +83,48 @@ public:
 
     //
     // Return client- and server-side Transceivers for the endpoint,
-    // or null if a Transceiver can only be created by Acceptors or
+    // or null if a Transceiver_ptr can only be created by Acceptors or
     // Connectors.
     //
-    virtual Transceiver clientTransceiver(const Instance&) const = 0;
-    virtual Transceiver serverTransceiver(const Instance&) const = 0;
+    virtual Transceiver_ptr clientTransceiver(const Instance_ptr&) const = 0;
+    virtual Transceiver_ptr serverTransceiver(const Instance_ptr&) const = 0;
 
     //
     // Return Acceptors and Connectors for the endpoint, or null if no
     // Acceptors and Connectors are available.
     //
-    virtual Connector connector(const Instance&) const = 0;
-    virtual Acceptor acceptor(const Instance&) const = 0;
+    virtual Connector_ptr connector(const Instance_ptr&) const = 0;
+    virtual Acceptor_ptr acceptor(const Instance_ptr&) const = 0;
 
     //
     // Compare endpoints for sorting purposes
     //
-    virtual bool operator==(const EndpointI&) const = 0;
-    virtual bool operator!=(const EndpointI&) const = 0;
-    virtual bool operator<(const EndpointI&) const = 0;
+    virtual bool operator==(const Endpoint&) const = 0;
+    virtual bool operator!=(const Endpoint&) const = 0;
+    virtual bool operator<(const Endpoint&) const = 0;
 };
 
-class UnknownEndpointI : public EndpointI
+class UnknownEndpoint : public Endpoint
 {
 public:
 
-    UnknownEndpointI(Stream*);
+    UnknownEndpoint(Stream*);
 
     virtual void streamWrite(Stream*) const;
     virtual ::Ice::Short type() const;
     virtual bool oneway() const;
     virtual ::Ice::Int timeout() const;
-    virtual Endpoint timeout(::Ice::Int) const;
+    virtual Endpoint_ptr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual Transceiver clientTransceiver(const Instance&) const;
-    virtual Transceiver serverTransceiver(const Instance&) const;
-    virtual Connector connector(const Instance&) const;
-    virtual Acceptor acceptor(const Instance&) const;
+    virtual Transceiver_ptr clientTransceiver(const Instance_ptr&) const;
+    virtual Transceiver_ptr serverTransceiver(const Instance_ptr&) const;
+    virtual Connector_ptr connector(const Instance_ptr&) const;
+    virtual Acceptor_ptr acceptor(const Instance_ptr&) const;
 
-    virtual bool operator==(const EndpointI&) const;
-    virtual bool operator!=(const EndpointI&) const;
-    virtual bool operator<(const EndpointI&) const;
+    virtual bool operator==(const Endpoint&) const;
+    virtual bool operator!=(const Endpoint&) const;
+    virtual bool operator<(const Endpoint&) const;
 
 private:
 
@@ -134,29 +134,29 @@ private:
     const std::vector< ::Ice::Byte> rawBytes_;
 };
 
-class TcpEndpointI : public EndpointI
+class TcpEndpoint : public Endpoint
 {
 public:
 
-    TcpEndpointI(const std::string&, ::Ice::Int, ::Ice::Int);
-    TcpEndpointI(const std::string&);
-    TcpEndpointI(Stream*);
+    TcpEndpoint(const std::string&, ::Ice::Int, ::Ice::Int);
+    TcpEndpoint(const std::string&);
+    TcpEndpoint(Stream*);
 
     virtual void streamWrite(Stream*) const;
     virtual ::Ice::Short type() const;
     virtual bool oneway() const;
     virtual ::Ice::Int timeout() const;
-    virtual Endpoint timeout(::Ice::Int) const;
+    virtual Endpoint_ptr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual Transceiver clientTransceiver(const Instance&) const;
-    virtual Transceiver serverTransceiver(const Instance&) const;
-    virtual Connector connector(const Instance&) const;
-    virtual Acceptor acceptor(const Instance&) const;
+    virtual Transceiver_ptr clientTransceiver(const Instance_ptr&) const;
+    virtual Transceiver_ptr serverTransceiver(const Instance_ptr&) const;
+    virtual Connector_ptr connector(const Instance_ptr&) const;
+    virtual Acceptor_ptr acceptor(const Instance_ptr&) const;
 
-    virtual bool operator==(const EndpointI&) const;
-    virtual bool operator!=(const EndpointI&) const;
-    virtual bool operator<(const EndpointI&) const;
+    virtual bool operator==(const Endpoint&) const;
+    virtual bool operator!=(const Endpoint&) const;
+    virtual bool operator<(const Endpoint&) const;
 
 private:
 
@@ -168,29 +168,29 @@ private:
     const ::Ice::Int timeout_;
 };
 
-class UdpEndpointI : public EndpointI
+class UdpEndpoint : public Endpoint
 {
 public:
 
-    UdpEndpointI(const std::string&, ::Ice::Int);
-    UdpEndpointI(const std::string&);
-    UdpEndpointI(Stream*);
+    UdpEndpoint(const std::string&, ::Ice::Int);
+    UdpEndpoint(const std::string&);
+    UdpEndpoint(Stream*);
 
     virtual void streamWrite(Stream*) const;
     virtual ::Ice::Short type() const;
     virtual bool oneway() const;
     virtual ::Ice::Int timeout() const;
-    virtual Endpoint timeout(::Ice::Int) const;
+    virtual Endpoint_ptr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual Transceiver clientTransceiver(const Instance&) const;
-    virtual Transceiver serverTransceiver(const Instance&) const;
-    virtual Connector connector(const Instance&) const;
-    virtual Acceptor acceptor(const Instance&) const;
-
-    virtual bool operator==(const EndpointI&) const;
-    virtual bool operator!=(const EndpointI&) const;
-    virtual bool operator<(const EndpointI&) const;
+    virtual Transceiver_ptr clientTransceiver(const Instance_ptr&) const;
+    virtual Transceiver_ptr serverTransceiver(const Instance_ptr&) const;
+    virtual Connector_ptr connector(const Instance_ptr&) const;
+    virtual Acceptor_ptr acceptor(const Instance_ptr&) const;
+
+    virtual bool operator==(const Endpoint&) const;
+    virtual bool operator!=(const Endpoint&) const;
+    virtual bool operator<(const Endpoint&) const;
 
 private:
 
diff --git a/cpp/include/Ice/EndpointF.h b/cpp/include/Ice/EndpointF.h
index 86a45c292d1..7a502f289df 100644
--- a/cpp/include/Ice/EndpointF.h
+++ b/cpp/include/Ice/EndpointF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class EndpointI;
-void incRef(EndpointI*);
-void decRef(EndpointI*);
-typedef __Ice::Handle<EndpointI> Endpoint;
+class Endpoint;
+void incRef(Endpoint*);
+void decRef(Endpoint*);
+typedef __Ice::Handle<Endpoint> Endpoint_ptr;
 
 }
 
diff --git a/cpp/include/Ice/EventHandler.h b/cpp/include/Ice/EventHandler.h
index c090b76fece..c90b58eabd7 100644
--- a/cpp/include/Ice/EventHandler.h
+++ b/cpp/include/Ice/EventHandler.h
@@ -27,7 +27,7 @@ class LocalException;
 namespace __Ice
 {
 
-class EventHandlerI : public Shared
+class EventHandler : public Shared
 {
 public:
     
@@ -67,16 +67,16 @@ public:
 
 protected:
     
-    EventHandlerI(const Instance& instance)
+    EventHandler(const Instance_ptr& instance)
 	: instance_(instance), stream_(instance) { }
-    virtual ~EventHandlerI() { }
+    virtual ~EventHandler() { }
 
-    Instance instance_;
+    Instance_ptr instance_;
 
 private:
 
-    // ThreadPoolI may use the following private data member
-    friend ThreadPoolI;
+    // ThreadPool may use the following private data member
+    friend ThreadPool;
     Stream stream_;
 };
 
diff --git a/cpp/include/Ice/EventHandlerF.h b/cpp/include/Ice/EventHandlerF.h
index ff45c2af5a6..fc19b06ebe2 100644
--- a/cpp/include/Ice/EventHandlerF.h
+++ b/cpp/include/Ice/EventHandlerF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class EventHandlerI;
-void incRef(EventHandlerI*);
-void decRef(EventHandlerI*);
-typedef __Ice::Handle<EventHandlerI> EventHandler;
+class EventHandler;
+void incRef(EventHandler*);
+void decRef(EventHandler*);
+typedef __Ice::Handle<EventHandler> EventHandler_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Handle.h b/cpp/include/Ice/Handle.h
index a7f0115f8ae..461dc304eb2 100644
--- a/cpp/include/Ice/Handle.h
+++ b/cpp/include/Ice/Handle.h
@@ -31,8 +31,6 @@ class Handle
 public:
     
     typedef T element_type;
-    typedef T I;
-    typedef T S;
     
     Handle(T* p = 0)
 	: ptr_(p)
diff --git a/cpp/include/Ice/Incoming.h b/cpp/include/Ice/Incoming.h
index 6257a2e694c..141163bb298 100644
--- a/cpp/include/Ice/Incoming.h
+++ b/cpp/include/Ice/Incoming.h
@@ -21,7 +21,7 @@ class ICE_API Incoming : noncopyable
 {
 public:
 
-    Incoming(const ::Ice::ObjectAdapter&);
+    Incoming(const ::Ice::ObjectAdapter_ptr&);
     ~Incoming();
 
     void invoke(Stream&);
@@ -31,7 +31,7 @@ public:
 
 private:
 
-    ::Ice::ObjectAdapter adapter_;
+    ::Ice::ObjectAdapter_ptr adapter_;
 
     Stream is_;
     Stream os_;
diff --git a/cpp/include/Ice/Instance.h b/cpp/include/Ice/Instance.h
index 3a53eeb3c8e..2dcc8fb4fb1 100644
--- a/cpp/include/Ice/Instance.h
+++ b/cpp/include/Ice/Instance.h
@@ -25,35 +25,35 @@
 namespace __Ice
 {
 
-class InstanceI : public Shared, public JTCMutex
+class Instance : public Shared, public JTCMutex
 {
 public:
 
-    ::Ice::Communicator communicator();
-    ::Ice::Properties properties();
-    ::Ice::Logger logger();
-    void logger(const ::Ice::Logger&);
-    TraceLevels traceLevels();
-    ProxyFactory proxyFactory();
-    ThreadPool threadPool();
-    EmitterFactory emitterFactory();
-    ValueFactoryManager valueFactoryManager();
+    ::Ice::Communicator_ptr communicator();
+    ::Ice::Properties_ptr properties();
+    ::Ice::Logger_ptr logger();
+    void logger(const ::Ice::Logger_ptr&);
+    TraceLevels_ptr traceLevels();
+    ProxyFactory_ptr proxyFactory();
+    ThreadPool_ptr threadPool();
+    EmitterFactory_ptr emitterFactory();
+    ValueFactoryManager_ptr valueFactoryManager();
     
 private:
 
-    InstanceI(const ::Ice::Communicator&, const ::Ice::Properties&);
-    virtual ~InstanceI();
+    Instance(const ::Ice::Communicator_ptr&, const ::Ice::Properties_ptr&);
+    virtual ~Instance();
     void destroy();
-    friend class ::Ice::CommunicatorI;
+    friend class ::Ice::Communicator;
 
-    ::Ice::Communicator communicator_;
-    ::Ice::Properties properties_;
-    ::Ice::Logger logger_;
-    TraceLevels traceLevels_;
-    ProxyFactory proxyFactory_;
-    ThreadPool threadPool_;
-    EmitterFactory emitterFactory_;
-    ValueFactoryManager valueFactoryManager_;
+    ::Ice::Communicator_ptr communicator_;
+    ::Ice::Properties_ptr properties_;
+    ::Ice::Logger_ptr logger_;
+    TraceLevels_ptr traceLevels_;
+    ProxyFactory_ptr proxyFactory_;
+    ThreadPool_ptr threadPool_;
+    EmitterFactory_ptr emitterFactory_;
+    ValueFactoryManager_ptr valueFactoryManager_;
 
     //
     // Global state management
diff --git a/cpp/include/Ice/InstanceF.h b/cpp/include/Ice/InstanceF.h
index 4a2fa0744c6..cdced7489a2 100644
--- a/cpp/include/Ice/InstanceF.h
+++ b/cpp/include/Ice/InstanceF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class InstanceI;
-void incRef(InstanceI*);
-void decRef(InstanceI*);
-typedef __Ice::Handle<InstanceI> Instance;
+class Instance;
+void incRef(Instance*);
+void decRef(Instance*);
+typedef __Ice::Handle<Instance> Instance_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Logger.h b/cpp/include/Ice/Logger.h
index da2774227a2..057e30c5811 100644
--- a/cpp/include/Ice/Logger.h
+++ b/cpp/include/Ice/Logger.h
@@ -18,21 +18,21 @@
 namespace Ice
 {
 
-class ICE_API LoggerI : public ::__Ice::Shared
+class ICE_API Logger : public ::__Ice::Shared
 {
 public:
     
-    LoggerI() { }
+    Logger() { }
     virtual void trace(const std::string&, const std::string&) = 0;
     virtual void warning(const std::string&) = 0;
     virtual void error(const std::string&) = 0;
 };
 
-class ICE_API StderrLoggerI : public LoggerI, public JTCMutex
+class ICE_API StderrLogger : public Logger, public JTCMutex
 {
 public:
 
-    StderrLoggerI();
+    StderrLogger();
     virtual void trace(const std::string&, const std::string&);
     virtual void warning(const std::string&);
     virtual void error(const std::string&);
diff --git a/cpp/include/Ice/LoggerF.h b/cpp/include/Ice/LoggerF.h
index c018a232750..345eb6a56c3 100644
--- a/cpp/include/Ice/LoggerF.h
+++ b/cpp/include/Ice/LoggerF.h
@@ -15,26 +15,26 @@
 
 namespace Ice
 {
-    class LoggerI;
-    class StderrLoggerI;
+    class Logger;
+    class StderrLogger;
 }
 
 namespace __Ice
 {
 
-void ICE_API incRef(::Ice::LoggerI*);
-void ICE_API decRef(::Ice::LoggerI*);
+void ICE_API incRef(::Ice::Logger*);
+void ICE_API decRef(::Ice::Logger*);
 
-void ICE_API incRef(::Ice::StderrLoggerI*);
-void ICE_API decRef(::Ice::StderrLoggerI*);
+void ICE_API incRef(::Ice::StderrLogger*);
+void ICE_API decRef(::Ice::StderrLogger*);
 
 }
 
 namespace Ice
 {
 
-typedef __Ice::Handle<LoggerI> Logger;
-typedef __Ice::Handle<StderrLoggerI> StderrLogger;
+typedef __Ice::Handle<Logger> Logger_ptr;
+typedef __Ice::Handle<StderrLogger> StderrLogger_ptr;
 
 }
 
diff --git a/cpp/include/Ice/ObjectAdapter.h b/cpp/include/Ice/ObjectAdapter.h
index 5bbcda404d3..fc02c4e53a7 100644
--- a/cpp/include/Ice/ObjectAdapter.h
+++ b/cpp/include/Ice/ObjectAdapter.h
@@ -24,12 +24,12 @@
 namespace Ice
 {
 
-class ICE_API ObjectAdapterI : public ::__Ice::Shared, public JTCMutex
+class ICE_API ObjectAdapter : public ::__Ice::Shared, public JTCMutex
 {
 public:
 
     std::string name() const;
-    Communicator communicator() const;
+    Communicator_ptr communicator() const;
 
     void activate();
     void hold();
@@ -42,19 +42,19 @@ public:
 
     Object_pptr proxy(const std::string&);
 
-    ::__Ice::Instance __instance() const;
+    ::__Ice::Instance_ptr __instance() const;
     Object_iptr __findServant(const std::string&) const;
 
 private:
 
-    ObjectAdapterI(const ::__Ice::Instance&, const std::string&,
+    ObjectAdapter(const ::__Ice::Instance_ptr&, const std::string&,
 		   const std::string&);
-    virtual ~ObjectAdapterI();
-    friend CommunicatorI;
+    virtual ~ObjectAdapter();
+    friend Communicator;
 
-    ::__Ice::Instance instance_;
+    ::__Ice::Instance_ptr instance_;
     std::string name_;
-    std::vector< __Ice::CollectorFactory> collectorFactories_;
+    std::vector< __Ice::CollectorFactory_ptr> collectorFactories_;
     std::map<std::string, Object_iptr> objects_;
 };
 
diff --git a/cpp/include/Ice/ObjectAdapterF.h b/cpp/include/Ice/ObjectAdapterF.h
index 2a4a3d26aae..1a14ea55eda 100644
--- a/cpp/include/Ice/ObjectAdapterF.h
+++ b/cpp/include/Ice/ObjectAdapterF.h
@@ -13,20 +13,20 @@
 
 #include <Ice/Handle.h>
 
-namespace Ice { class ObjectAdapterI; }
+namespace Ice { class ObjectAdapter; }
 
 namespace __Ice
 {
 
-void ICE_API incRef(::Ice::ObjectAdapterI*);
-void ICE_API decRef(::Ice::ObjectAdapterI*);
+void ICE_API incRef(::Ice::ObjectAdapter*);
+void ICE_API decRef(::Ice::ObjectAdapter*);
 
 }
 
 namespace Ice
 {
 
-typedef __Ice::Handle<ObjectAdapterI> ObjectAdapter;
+typedef __Ice::Handle<ObjectAdapter> ObjectAdapter_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Outgoing.h b/cpp/include/Ice/Outgoing.h
index 2775a55d0c5..9f7b1769d2a 100644
--- a/cpp/include/Ice/Outgoing.h
+++ b/cpp/include/Ice/Outgoing.h
@@ -29,7 +29,7 @@ class ICE_API Outgoing : noncopyable, public JTCMonitorT< JTCMutex >
 {
 public:
 
-    Outgoing(const Emitter&, const Reference&);
+    Outgoing(const Emitter_ptr&, const Reference_ptr&);
     ~Outgoing();
 
     void invoke();
@@ -41,8 +41,8 @@ public:
 
 private:
 
-    Emitter emitter_;
-    Reference reference_;
+    Emitter_ptr emitter_;
+    Reference_ptr reference_;
     std::auto_ptr< ::Ice::LocalException> exception_;
 
     enum
diff --git a/cpp/include/Ice/Properties.h b/cpp/include/Ice/Properties.h
index d9921ce8c47..61bb022abe1 100644
--- a/cpp/include/Ice/Properties.h
+++ b/cpp/include/Ice/Properties.h
@@ -19,7 +19,7 @@
 namespace Ice
 {
 
-class ICE_API PropertiesI : public ::__Ice::Shared
+class ICE_API Properties : public ::__Ice::Shared
 {
 public:
     
@@ -28,15 +28,15 @@ public:
 
 private:
 
-    PropertiesI();
-    PropertiesI(const std::string&);
-    PropertiesI(const Properties&);
+    Properties();
+    Properties(const std::string&);
+    Properties(const Properties_ptr&);
 
     // The following operations may create PropertiesIs
-    friend ICE_API Communicator initialize(int&, char*[]);
-    friend ICE_API Properties createProperties();
-    friend ICE_API Properties createProperties(const Properties&);
-    friend ICE_API Properties createProperties(const std::string&);
+    friend ICE_API Communicator_ptr initialize(int&, char*[]);
+    friend ICE_API Properties_ptr createProperties();
+    friend ICE_API Properties_ptr createProperties(const Properties_ptr&);
+    friend ICE_API Properties_ptr createProperties(const std::string&);
 
     void load(const std::string&);
     void parse(std::istream&);
diff --git a/cpp/include/Ice/PropertiesF.h b/cpp/include/Ice/PropertiesF.h
index 59217a5407e..d799348f810 100644
--- a/cpp/include/Ice/PropertiesF.h
+++ b/cpp/include/Ice/PropertiesF.h
@@ -13,20 +13,20 @@
 
 #include <Ice/Handle.h>
 
-namespace Ice { class PropertiesI; }
+namespace Ice { class Properties; }
 
 namespace __Ice
 {
 
-void ICE_API incRef(::Ice::PropertiesI*);
-void ICE_API decRef(::Ice::PropertiesI*);
+void ICE_API incRef(::Ice::Properties*);
+void ICE_API decRef(::Ice::Properties*);
 
 }
 
 namespace Ice
 {
 
-typedef __Ice::Handle<PropertiesI> Properties;
+typedef __Ice::Handle<Properties> Properties_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index 682f939c3d7..f1340efbaa3 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -44,7 +44,7 @@ public:
     ::Ice::Object_pptr _datagram() const;
     ::Ice::Object_pptr _timeout(int) const;
 
-    ::__Ice::Reference __reference() const;
+    ::__Ice::Reference_ptr __reference() const;
     void __copyTo(Object*) const;
 
 protected:
@@ -57,12 +57,12 @@ protected:
 
 private:
 
-    void setup(const ::__Ice::Reference&);
+    void setup(const ::__Ice::Reference_ptr&);
 
-    ::__Ice::Reference reference_;
+    ::__Ice::Reference_ptr reference_;
     ::__Ice::Handle< ::__IceDelegate::Ice::Object> delegate_;
 
-    friend class ::__Ice::ProxyFactoryI;
+    friend class ::__Ice::ProxyFactory;
 };
 
 } }
@@ -83,7 +83,7 @@ protected:
 
 private:
 
-    virtual void setup(const ::__Ice::Reference&) = 0;
+    virtual void setup(const ::__Ice::Reference_ptr&) = 0;
     friend class ::__IceProxy::Ice::Object;
 };
 
@@ -103,15 +103,15 @@ protected:
     Object();
     virtual ~Object();
 
-    const ::__Ice::Emitter& __emitter(); // const...& for performance
-    const ::__Ice::Reference& __reference(); // const...& for performance
+    const ::__Ice::Emitter_ptr& __emitter(); // const...& for performance
+    const ::__Ice::Reference_ptr& __reference(); // const...& for performance
 
 private:
 
-    ::__Ice::Emitter emitter_;
-    ::__Ice::Reference reference_;
+    ::__Ice::Emitter_ptr emitter_;
+    ::__Ice::Reference_ptr reference_;
 
-    virtual void setup(const ::__Ice::Reference&);
+    virtual void setup(const ::__Ice::Reference_ptr&);
     friend class ::__IceProxy::Ice::Object;
 };
 
diff --git a/cpp/include/Ice/ProxyFactory.h b/cpp/include/Ice/ProxyFactory.h
index 9a3204c0e10..9b03b477365 100644
--- a/cpp/include/Ice/ProxyFactory.h
+++ b/cpp/include/Ice/ProxyFactory.h
@@ -22,22 +22,22 @@ namespace __Ice
 
 class Stream;
 
-class ProxyFactoryI : public Shared
+class ProxyFactory : public Shared
 {
 public:
     
     ::Ice::Object_pptr stringToProxy(const std::string&);
     ::Ice::Object_pptr streamToProxy(Stream*);
-    ::Ice::Object_pptr referenceToProxy(const Reference&);
+    ::Ice::Object_pptr referenceToProxy(const Reference_ptr&);
     void proxyToStream(const ::Ice::Object_pptr&, Stream*);
 
 private:
 
-    ProxyFactoryI(const Instance&);
-    virtual ~ProxyFactoryI();
-    friend class InstanceI;
+    ProxyFactory(const Instance_ptr&);
+    virtual ~ProxyFactory();
+    friend class Instance;
 
-    Instance instance_;
+    Instance_ptr instance_;
 };
 
 }
diff --git a/cpp/include/Ice/ProxyFactoryF.h b/cpp/include/Ice/ProxyFactoryF.h
index 6d674ad6f14..9678ecfab24 100644
--- a/cpp/include/Ice/ProxyFactoryF.h
+++ b/cpp/include/Ice/ProxyFactoryF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class ProxyFactoryI;
-void incRef(ProxyFactoryI*);
-void decRef(ProxyFactoryI*);
-typedef __Ice::Handle<ProxyFactoryI> ProxyFactory;
+class ProxyFactory;
+void incRef(ProxyFactory*);
+void decRef(ProxyFactory*);
+typedef __Ice::Handle<ProxyFactory> ProxyFactory_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Reference.h b/cpp/include/Ice/Reference.h
index e629c48dce9..41c0d905475 100644
--- a/cpp/include/Ice/Reference.h
+++ b/cpp/include/Ice/Reference.h
@@ -21,21 +21,21 @@ namespace __Ice
 
 class Stream;
 
-class ReferenceI : public Shared
+class Reference : public Shared
 {
 public:
 
-    ReferenceI(const Instance&, const std::string&,
-	       const std::vector<Endpoint>&);
-    ReferenceI(const Instance&, const std::string&);
-    ReferenceI(Stream*);
+    Reference(const Instance_ptr&, const std::string&,
+	       const std::vector<Endpoint_ptr>&);
+    Reference(const Instance_ptr&, const std::string&);
+    Reference(Stream*);
 
     void streamWrite(Stream*) const;
 
     //
     // All  members are const, because References are immutable.
     //
-    const Instance instance;
+    const Instance_ptr instance;
     const std::string identity;
 
     enum Mode
@@ -46,18 +46,18 @@ public:
     };
     const Mode mode;
 
-    const std::vector<Endpoint> endpoints;
+    const std::vector<Endpoint_ptr> endpoints;
 
     //
     // Get a new reference, based on the existing one, overwriting
     // certain values.
     //
-    Reference changeTimeout(int) const;
-    Reference changeMode(Mode) const;
+    Reference_ptr changeTimeout(int) const;
+    Reference_ptr changeMode(Mode) const;
  
-    bool operator==(const ReferenceI&) const;
-    bool operator!=(const ReferenceI&) const;
-    bool operator<(const ReferenceI&) const;
+    bool operator==(const Reference&) const;
+    bool operator!=(const Reference&) const;
+    bool operator<(const Reference&) const;
 };
 
 }
diff --git a/cpp/include/Ice/ReferenceF.h b/cpp/include/Ice/ReferenceF.h
index 9271a4259dd..0e903762322 100644
--- a/cpp/include/Ice/ReferenceF.h
+++ b/cpp/include/Ice/ReferenceF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class ReferenceI;
-void incRef(ReferenceI*);
-void decRef(ReferenceI*);
-typedef __Ice::Handle<ReferenceI> Reference;
+class Reference;
+void incRef(Reference*);
+void decRef(Reference*);
+typedef __Ice::Handle<Reference> Reference_ptr;
 
 }
 
diff --git a/cpp/include/Ice/Stream.h b/cpp/include/Ice/Stream.h
index 0cb870375c5..ffe7eeb5719 100644
--- a/cpp/include/Ice/Stream.h
+++ b/cpp/include/Ice/Stream.h
@@ -23,9 +23,9 @@ class ICE_API Stream : public Buffer
 {
 public:
 
-    Stream(const Instance&);
+    Stream(const Instance_ptr&);
 
-    Instance instance() const;
+    Instance_ptr instance() const;
 
     void swap(Stream&);
 
@@ -93,7 +93,7 @@ public:
 
 private:
 
-    Instance instance_;
+    Instance_ptr instance_;
     bool bigendian_;
     std::stack<bool> bigendianStack_;
     std::stack<int> encapsStartStack_;
diff --git a/cpp/include/Ice/TcpAcceptor.h b/cpp/include/Ice/TcpAcceptor.h
index 7bf203d2747..ba3a8226b77 100644
--- a/cpp/include/Ice/TcpAcceptor.h
+++ b/cpp/include/Ice/TcpAcceptor.h
@@ -24,9 +24,9 @@
 namespace __Ice
 {
 
-class TcpEndpointI;
+class TcpEndpoint;
 
-class TcpAcceptorI : public AcceptorI
+class TcpAcceptor : public Acceptor
 {
 public:
 
@@ -34,22 +34,22 @@ public:
     virtual void close();
     virtual void shutdown();
     virtual void listen();
-    virtual Transceiver accept(int);
+    virtual Transceiver_ptr accept(int);
     virtual std::string toString() const;
 
 private:
 
-    TcpAcceptorI(Instance, int);
-    virtual ~TcpAcceptorI();
-    friend class TcpEndpointI;
+    TcpAcceptor(Instance_ptr, int);
+    virtual ~TcpAcceptor();
+    friend class TcpEndpoint;
 
-    Instance instance_;
+    Instance_ptr instance_;
     int fd_;
     int backlog_;
     struct sockaddr_in addr_;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
diff --git a/cpp/include/Ice/TcpConnector.h b/cpp/include/Ice/TcpConnector.h
index c833dc86eab..09282cce7fe 100644
--- a/cpp/include/Ice/TcpConnector.h
+++ b/cpp/include/Ice/TcpConnector.h
@@ -24,26 +24,26 @@
 namespace __Ice
 {
 
-class TcpEndpointI;
+class TcpEndpoint;
 
-class TcpConnectorI : public ConnectorI
+class TcpConnector : public Connector
 {
 public:
     
-    virtual Transceiver connect(int);
+    virtual Transceiver_ptr connect(int);
     virtual std::string toString() const;
     
 private:
     
-    TcpConnectorI(Instance, const std::string&, int);
-    virtual ~TcpConnectorI();
-    friend class TcpEndpointI;
+    TcpConnector(Instance_ptr, const std::string&, int);
+    virtual ~TcpConnector();
+    friend class TcpEndpoint;
 
-    Instance instance_;
+    Instance_ptr instance_;
     struct sockaddr_in addr_;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
diff --git a/cpp/include/Ice/TcpTransceiver.h b/cpp/include/Ice/TcpTransceiver.h
index cec63bd5de7..326bbda39d6 100644
--- a/cpp/include/Ice/TcpTransceiver.h
+++ b/cpp/include/Ice/TcpTransceiver.h
@@ -19,10 +19,10 @@
 namespace __Ice
 {
 
-class TcpConnectorI;
-class TcpAcceptorI;
+class TcpConnector;
+class TcpAcceptor;
 
-class TcpTransceiverI : public TransceiverI
+class TcpTransceiver : public Transceiver
 {
 public:
 
@@ -35,18 +35,18 @@ public:
     
 private:
 
-    TcpTransceiverI(Instance, int);
-    virtual ~TcpTransceiverI();
-    friend class TcpConnectorI;
-    friend class TcpAcceptorI;
+    TcpTransceiver(Instance_ptr, int);
+    virtual ~TcpTransceiver();
+    friend class TcpConnector;
+    friend class TcpAcceptor;
 
-    Instance instance_;
+    Instance_ptr instance_;
     int fd_;
     fd_set rFdSet;
     fd_set wFdSet;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
diff --git a/cpp/include/Ice/ThreadPool.h b/cpp/include/Ice/ThreadPool.h
index 79783a962f6..f0382d8f6a7 100644
--- a/cpp/include/Ice/ThreadPool.h
+++ b/cpp/include/Ice/ThreadPool.h
@@ -22,11 +22,11 @@ namespace __Ice
 
 class Stream;
 
-class ThreadPoolI : public Shared, public JTCMonitorT<JTCMutex>
+class ThreadPool : public Shared, public JTCMonitorT<JTCMutex>
 {
 public:
 
-    void _register(int, const EventHandler&);
+    void _register(int, const EventHandler_ptr&);
     void unregister(int);
     void promoteFollower();
     void waitUntilServerFinished();
@@ -35,26 +35,26 @@ public:
     
 private:
 
-    ThreadPoolI(const Instance&);
-    virtual ~ThreadPoolI();
+    ThreadPool(const Instance_ptr&);
+    virtual ~ThreadPool();
     void destroy();
-    friend class InstanceI;
+    friend class Instance;
 
     void clearInterrupt();
     void setInterrupt();
 
     void run();
-    void read(const EventHandler&);
+    void read(const EventHandler_ptr&);
 
-    Instance instance_;
+    Instance_ptr instance_;
     int lastFd_;
     int maxFd_;
     int fdIntrRead_;
     int fdIntrWrite_;
     fd_set fdSet_;
-    std::vector<std::pair<int, EventHandler> > adds_;
+    std::vector<std::pair<int, EventHandler_ptr> > adds_;
     std::vector<int> removes_;
-    std::map<int, EventHandler> handlers_;
+    std::map<int, EventHandler_ptr> handlers_;
     int servers_;
     JTCMutex threadMutex_;
 
@@ -62,12 +62,12 @@ private:
     {
     public:
 	
-	EventHandlerThread(ThreadPool pool) : pool_(pool) { }
+	EventHandlerThread(ThreadPool_ptr pool) : pool_(pool) { }
 	virtual void run();
 
     private:
 
-	ThreadPool pool_;
+	ThreadPool_ptr pool_;
     };
     friend class EventHandlerThread;
     std::vector<JTCThreadHandle> threads_;
diff --git a/cpp/include/Ice/ThreadPoolF.h b/cpp/include/Ice/ThreadPoolF.h
index bb7dbdbcc05..677854f8ace 100644
--- a/cpp/include/Ice/ThreadPoolF.h
+++ b/cpp/include/Ice/ThreadPoolF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class ThreadPoolI;
-void incRef(ThreadPoolI*);
-void decRef(ThreadPoolI*);
-typedef __Ice::Handle<ThreadPoolI> ThreadPool;
+class ThreadPool;
+void incRef(ThreadPool*);
+void decRef(ThreadPool*);
+typedef __Ice::Handle<ThreadPool> ThreadPool_ptr;
 
 }
 
diff --git a/cpp/include/Ice/TraceLevels.h b/cpp/include/Ice/TraceLevels.h
index 41ed0054fe8..117e1fd0bc6 100644
--- a/cpp/include/Ice/TraceLevels.h
+++ b/cpp/include/Ice/TraceLevels.h
@@ -18,12 +18,12 @@
 namespace __Ice
 {
 
-class TraceLevelsI : public Shared
+class TraceLevels : public Shared
 {
 public:
 
-    TraceLevelsI(const ::Ice::Properties&);
-    virtual ~TraceLevelsI();
+    TraceLevels(const ::Ice::Properties_ptr&);
+    virtual ~TraceLevels();
 
     const int network;
     const char* networkCat;
diff --git a/cpp/include/Ice/TraceLevelsF.h b/cpp/include/Ice/TraceLevelsF.h
index d89d7bb72bd..825737db656 100644
--- a/cpp/include/Ice/TraceLevelsF.h
+++ b/cpp/include/Ice/TraceLevelsF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class TraceLevelsI;
-void incRef(TraceLevelsI*);
-void decRef(TraceLevelsI*);
-typedef __Ice::Handle<TraceLevelsI> TraceLevels;
+class TraceLevels;
+void incRef(TraceLevels*);
+void decRef(TraceLevels*);
+typedef __Ice::Handle<TraceLevels> TraceLevels_ptr;
 
 }
 
diff --git a/cpp/include/Ice/TraceUtil.h b/cpp/include/Ice/TraceUtil.h
index 6f78f6665a3..b88d0aedc91 100644
--- a/cpp/include/Ice/TraceUtil.h
+++ b/cpp/include/Ice/TraceUtil.h
@@ -21,11 +21,11 @@ namespace __Ice
 class Stream;
 
 void traceHeader(const char*, const Stream&,
-		 const ::Ice::Logger&, const TraceLevels&);
+		 const ::Ice::Logger_ptr&, const TraceLevels_ptr&);
 void traceRequest(const char*, const Stream&,
-		  const ::Ice::Logger&, const TraceLevels&);
+		  const ::Ice::Logger_ptr&, const TraceLevels_ptr&);
 void traceReply(const char*, const Stream&,
-		const ::Ice::Logger&, const TraceLevels&);
+		const ::Ice::Logger_ptr&, const TraceLevels_ptr&);
 
 }
 
diff --git a/cpp/include/Ice/Transceiver.h b/cpp/include/Ice/Transceiver.h
index c91a81369d2..b1abb4bf585 100644
--- a/cpp/include/Ice/Transceiver.h
+++ b/cpp/include/Ice/Transceiver.h
@@ -19,7 +19,7 @@ namespace __Ice
 
 class Buffer;
 
-class TransceiverI : public Shared
+class Transceiver : public Shared
 {
 public:
 
@@ -32,8 +32,8 @@ public:
     
 protected:
 
-    TransceiverI() { }
-    virtual ~TransceiverI() { }
+    Transceiver() { }
+    virtual ~Transceiver() { }
 };
 
 }
diff --git a/cpp/include/Ice/TransceiverF.h b/cpp/include/Ice/TransceiverF.h
index 021b4a2b135..d239f79bb3a 100644
--- a/cpp/include/Ice/TransceiverF.h
+++ b/cpp/include/Ice/TransceiverF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class TransceiverI;
-void incRef(TransceiverI*);
-void decRef(TransceiverI*);
-typedef __Ice::Handle<TransceiverI> Transceiver;
+class Transceiver;
+void incRef(Transceiver*);
+void decRef(Transceiver*);
+typedef __Ice::Handle<Transceiver> Transceiver_ptr;
 
 }
 
diff --git a/cpp/include/Ice/UdpTransceiver.h b/cpp/include/Ice/UdpTransceiver.h
index d134f5963a5..83b9d15cf40 100644
--- a/cpp/include/Ice/UdpTransceiver.h
+++ b/cpp/include/Ice/UdpTransceiver.h
@@ -23,9 +23,9 @@
 namespace __Ice
 {
 
-class UdpEndpointI;
+class UdpEndpoint;
 
-class UdpTransceiverI : public TransceiverI
+class UdpTransceiver : public Transceiver
 {
 public:
 
@@ -38,18 +38,18 @@ public:
     
 private:
 
-    UdpTransceiverI(Instance, const std::string&, int);
-    UdpTransceiverI(Instance, int);
-    virtual ~UdpTransceiverI();
-    friend class UdpEndpointI;
+    UdpTransceiver(Instance_ptr, const std::string&, int);
+    UdpTransceiver(Instance_ptr, int);
+    virtual ~UdpTransceiver();
+    friend class UdpEndpoint;
 
-    Instance instance_;
+    Instance_ptr instance_;
     bool sender_;
     int fd_;
     struct sockaddr_in addr_;
 #ifndef ICE_NO_TRACE
-    TraceLevels traceLevels_;
-    ::Ice::Logger logger_;
+    TraceLevels_ptr traceLevels_;
+    ::Ice::Logger_ptr logger_;
 #endif
 };
 
diff --git a/cpp/include/Ice/ValueFactory.h b/cpp/include/Ice/ValueFactory.h
index 0239e6cbdc0..e645f34c80b 100644
--- a/cpp/include/Ice/ValueFactory.h
+++ b/cpp/include/Ice/ValueFactory.h
@@ -18,11 +18,11 @@
 namespace Ice
 {
 
-class ICE_API ValueFactoryI : public ::__Ice::Shared
+class ICE_API ValueFactory : public ::__Ice::Shared
 {
 public:
 
-    ValueFactoryI() { }
+    ValueFactory() { }
     virtual std::vector<std::string> ids() = 0;
     virtual Ice::Object_iptr create(const std::string&) = 0;
 };
diff --git a/cpp/include/Ice/ValueFactoryF.h b/cpp/include/Ice/ValueFactoryF.h
index 051384b1dd8..65a8da7fd6e 100644
--- a/cpp/include/Ice/ValueFactoryF.h
+++ b/cpp/include/Ice/ValueFactoryF.h
@@ -13,20 +13,20 @@
 
 #include <Ice/Handle.h>
 
-namespace Ice { class ValueFactoryI; }
+namespace Ice { class ValueFactory; }
 
 namespace __Ice
 {
 
-void ICE_API incRef(::Ice::ValueFactoryI*);
-void ICE_API decRef(::Ice::ValueFactoryI*);
+void ICE_API incRef(::Ice::ValueFactory*);
+void ICE_API decRef(::Ice::ValueFactory*);
 
 }
 
 namespace Ice
 {
 
-typedef __Ice::Handle<ValueFactoryI> ValueFactory;
+typedef __Ice::Handle<ValueFactory> ValueFactory_ptr;
 
 }
 
diff --git a/cpp/include/Ice/ValueFactoryManager.h b/cpp/include/Ice/ValueFactoryManager.h
index b71f26a44cb..692a6955b1e 100644
--- a/cpp/include/Ice/ValueFactoryManager.h
+++ b/cpp/include/Ice/ValueFactoryManager.h
@@ -19,20 +19,20 @@
 namespace __Ice
 {
 
-class ValueFactoryManagerI : public Shared, public JTCMutex
+class ValueFactoryManager : public Shared, public JTCMutex
 {
 public:
 
-    void install(const ::Ice::ValueFactory&);
-    ::Ice::ValueFactory lookup(const std::string&);
+    void install(const ::Ice::ValueFactory_ptr&);
+    ::Ice::ValueFactory_ptr lookup(const std::string&);
 
 private:
 
-    ValueFactoryManagerI();
+    ValueFactoryManager();
     void destroy();
-    friend class InstanceI;
+    friend class Instance;
 
-    std::map<std::string, ::Ice::ValueFactory> factories_;
+    std::map<std::string, ::Ice::ValueFactory_ptr> factories_;
 };
 
 }
diff --git a/cpp/include/Ice/ValueFactoryManagerF.h b/cpp/include/Ice/ValueFactoryManagerF.h
index 466c9b4b5f8..c4d0f5d5244 100644
--- a/cpp/include/Ice/ValueFactoryManagerF.h
+++ b/cpp/include/Ice/ValueFactoryManagerF.h
@@ -16,10 +16,10 @@
 namespace __Ice
 {
 
-class ValueFactoryManagerI;
-void incRef(ValueFactoryManagerI*);
-void decRef(ValueFactoryManagerI*);
-typedef __Ice::Handle<ValueFactoryManagerI> ValueFactoryManager;
+class ValueFactoryManager;
+void incRef(ValueFactoryManager*);
+void decRef(ValueFactoryManager*);
+typedef __Ice::Handle<ValueFactoryManager> ValueFactoryManager_ptr;
 
 }