• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

Slice到C++映射

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

按:本文是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


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
c#各类型数据库连接字符串格式发布时间:2022-07-13
下一篇:
Objective-C如何自己实现一个基于数组下标的属性访问模式发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap