Slice到C++映射

按：本文是DPWI第6章的笔记。

客户端Slice到C++映射定义的是：怎样把Slice数据类型翻译成C++类型，客户怎样调用操作、传递参数、处理错误。C++映射线程安全，不存在内存管理问题。不建议查看slice2cpp生成的C++映射文件，但建议掌握C++映射规则。



1、模块映射 

module M{...}

映射为

namespace M{...}



2、类型映射 

⑴基本类型

Slice     C++ 

bool   → bool

byte   → Ice::Byte

short  → Ice::Short

int    → Ice::Int

long   → Ice::Long

float  → Ice::Float

double → Ice::Double

string → std::string 



⑵复杂类型 

Slice     C++ 

枚举 →   枚举

结构 →   结构，支持比较符，可用于Slice词典键类型，支持深度复制、赋值。

序列 →   std::vector，可以映射为list,dequeue，数组，范围。

词典 →   std::map。 



3、异常映射 

异常可映射为同名C++类，支持如下操作：

• ice_name　 异常的名字。

• ice_clone　多态克隆异常，在不知道异常类型情况下复制异常。

• ice_throw　在不知道某个异常的确切运行时类型的情况下抛出它。

• ice_print  打印异常的名字，或直接使用重载的<<操作符： 



try {

    // ...

} catch (const Ice::Exception & e) {

    cerr << e << endl;

}

出于效率上的考虑，总是通过const引用捕捉异常。这样，编译器就能够生成不调用异常复制构造器的代码（当然，同时也防止异常被切成基类型）。调用操作抛出异常时，该操作的out参数是否赋值无法确定，但是操作的返回值肯定没有返回。



一条异常路径：

• Ice::ConnectTimeoutException

• Ice::TimeoutException

• Ice::LocalException

• Ice::UserException

• Ice::Exception

很少需要以最深派生类型捕获运行时异常，而是以LocalException捕获它们；对细粒度异常处理感兴趣的，主要是Ice运行时实现。



4、接口映射 

module M {

    interface Simple {

        void op();

    };

};

客户端，接口映射到类：

          ↓

namespace IceProxy {

    namespace M {

        class Simple;

    }

}

namespace M{

    class Simple; — 代理类

    typedef IceInternal::ProxyHandle< ::IceProxy::M::Simple> SimplePrx; — 代理句柄

    typedef IceInternal::Handle< ::M::Simple> SimplePtr;

}

namespace IceProxy {

    namespace M {

        class Simple : public virtual IceProxy::Ice::Object {

        public:

            typedef ::M::SimplePrx ProxyType;

            typedef ::M::SimplePtr PointerType;

            void op();

            void op(const Ice::Context&);

            //....

        };

    };

}

IceProxy::M::Simple是服务器Simple接口的客户端代理类，它继承自IceProxy::Ice::Object。接口中的每个操作，代理类都有两个重载的、同名的成员函数。其中一个函数的最后一个参数的类型是Ice::Context——Ice上下文，dictionary<string, string>结构，客户端向服务器发送请求时，将该结构一起发送。



客户端不能直接实例化代理类：

IceProxy::M::Simple s;  ← 错误

客户端只能使用代理句柄SimplePrx访问代理类Simple。代理句柄能够自动管理内存，支持赋值和比较操作符：

SimplePrx prx1 = ...;

SimplePrx prx2(prx1);

prx1=prx2;

assert(prx1==prx2);

cout << prx1 << ';' << prx2 << endl; ← 等效方法 prx->ice_toString()

类似方法：communicator->proxyToString(prx);



BasePrx base = ...; 

DerivedPrx derived = DerivedPrx::checkedCast(base); ← 检查转换：远程访问,失败时返回null。

derived = DerivedPrx::uncheckedCast(base); ← 不检查的转换：不进行远程访问,失败时行为不确定。



代理方法：

Ice::ObjectPrx base = communicator->stringToProxy(...);

HelloPrx hello = HelloPrx::checkedCast(base);

hello = hello->ice_timeout(10000); 

hello->sayHello();



代理比较：

代理同一性比较：==,!=,<,<=,>,>=比较，布尔比较；

代理的对象同一性比较：

bool proxyIdentityLess(p1,p2);

bool proxyIdentityEqual(p1,p2);

bool proxyIdentityAndFacetLess(p1,p2);

bool proxyIdentityAndFacetEqual(p1,p2);



5、操作映射 

对于所有被映射的Slice 类型而言都一样：你可以安全地忽略操作的返回值，不管它的类型是什么——返回值总是通过传值返回。如果你忽略返回值，不会发生内存泄漏，因为返回值的析构器会按照需要释放内存。



in 参数，使用传值或const引用传递；

out参数，使用引用传递。



支持链式调用：

p2->setName(p1->getName()); ← p1,p2为代理



6、异常处理 

SimplePrx p = ...; 

try {

    p->op();

} catch (const SimpleError & t) {

    cout << "Simple Error: " << t.reason << endl;

}

应该总是使用const引用捕捉异常。这样，编译器就能生成不调用异常复制构造器的代码，同时防止异常切成基类型。操作抛出异常后，操作的参数是否已改变不能确定；但是接收操作返回值的变量没有被改写。



7、类映射： 

Slice类映射到同名C++类。

• 每个成员映射为C++类public成员；

• 每个操作映射为虚成员函数；

• 类继承自Ice::Object(代理类继承自Ice::ObjectPrx)；

• 两个构造器，一个缺省，一个带有所有成员参数；

• 生成<class-name>Ptr智能指针(<class-name>Prx是代理句柄)。



类继承自Ice::Object基类的成员函数：

• ice_isA：是否支持指定类型ID

• ice_ping：类可达测试

• ice_ids：对象支持的类序列，从根类到最深派生类

• ice_id：类的实际ID

• ice_staticId：类的静态类型ID

• ice_hash：类的哈希值

• ice_clone：多态浅复制

• ice_preMarshal：整编本类前调用

• ice_postUnmarshal：解编本类后调用

• ice_dispatch：请求分派给服务者

• 比较操作符：== != < <= > >=



类成员可见性：

修改类成员的可见性，使用元数据指令：["protected"]



类的构造函数：

类的缺省构造函数，构造每个数据成员，简单内置类型不初始化，复杂类型使用该类型自己的缺省构造初始化。

类的非缺省构造函数，每个数据成员一个参数，可以用一条语句构造和初始化。所有参数按照基类到派生类的顺序，加入参数序列。



类的操作：

类的操作被映射为纯虚成员函数，必须创建派生类，实现这些操作，才能使用类。



类工厂：

有操作的类必须提供类工厂，无操作的类不必提供类工厂。

⑴实现类工厂

class SimpleFactory : public Ice::ObjectFactory {

public:

    virtual Ice::ObjectPtr create(const std::string &) {

        assert(type == M::Simple::ice_staticId());

        return new SimpleI;

    }

    virtual void destroy() {}

};

⑵注册类工厂：

Ice::CommunicatorPtr ic = ...;

ic->addObjectFactory(new SimpleFactory, M::Simple::ice_staticId());

⑶使用类工厂：

现在，每当Ice实例化M::Simple类时，就会自动调用SimpleFactory的create方法，创建SimpleI类，客户端可以使用该类的op方法。



类的智能指针：

Slice 编译器会为每种类类型生成智能指针。对于Slice类<class-name>，编译器会生成叫作<class-name>Ptr 的C++ 智能指针：

    TimeOfDayPtr tod = new TimeOfDayI;

不能在栈上分配类实例，也不能用静态变量定义类实例。类必须由new分配。



智能指针是异常安全的，当抛出异常时，智能指针能够安全地析构。但要注意：在构造器中抛出异常，可能使得智能指针不安全；循环引用的情况下，智能指针也会不安全，这种情况下，可以使用Ice::collectGarbage();  收集因循环引用没有释放的对象。当然只有在循环引用的情况下，垃圾收集器才有用。在没有循环引用的情况下，使用垃圾收集器没有意义。把Ice.GC.Interval 设成5，收集器线程就会每5秒运行一次垃圾收集器。



智能指针的比较只会比较内存地址，即比较两个指针是否指向同一物理类实例。

转自：http://blog.csdn.net/colorado