C++博客-qiezi的学习园地-随笔分类-自家破烂http://www.cppblog.com/cpunion/category/48.htmlAS/C/C++/D/Java/JS/Python/Rubyzh-cnMon, 26 May 2008 15:24:30 GMTMon, 26 May 2008 15:24:30 GMT60搬家http://www.cppblog.com/cpunion/archive/2006/10/09/13499.htmlqieziqieziMon, 09 Oct 2006 14:33:00 GMThttp://www.cppblog.com/cpunion/archive/2006/10/09/13499.htmlhttp://www.cppblog.com/cpunion/comments/13499.htmlhttp://www.cppblog.com/cpunion/archive/2006/10/09/13499.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/13499.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/13499.html

qiezi 2006-10-09 22:33 发表评论
]]>段落文本渲染引擎http://www.cppblog.com/cpunion/archive/2006/10/09/13484.htmlqieziqieziMon, 09 Oct 2006 03:44:00 GMThttp://www.cppblog.com/cpunion/archive/2006/10/09/13484.htmlhttp://www.cppblog.com/cpunion/comments/13484.htmlhttp://www.cppblog.com/cpunion/archive/2006/10/09/13484.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/13484.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/13484.html
有了freetype实现底层字体渲染，我只需要处理一些布局方法即可，其中要实现的有以下几点：

1、英、中字体
很多中文字体中的英文字体都比较难看，所以在X的字体配置中设置了一个字体顺序。我也可以学学，传递一个字体列表，拿到一个字符时，按顺序从字体列表中查询，查询不到时就查下一个字体，这样就可以实现英、中使用不同字体了。

2、分行
段落分行要考虑到中、英文不同的分割方式，还有标点符号，某引起标点符号不能在行尾（比如“<等），某些标点不能在行首（比如”>），某些标点不能分割（比如破折号），所以实际上要有一个分割算法，把段落分成一个个的标记，汉字直接分割，英文按空格分割，不能在行首的标点就分到前面单词里，不能在行尾的就分在后面的单词里。

3、对齐
对齐方式有左、中、右、两端(Full Justification)这几种方式，目前大部分开源渲染库都不支持两端对齐，这也是我要自己实现的主要原因。左、中、右只要计算出一行的所有字符宽度，再计算出左边距即可。两端对齐则需要计算每个单词的间距。

4、段首缩进
原来设想在分段后直接加上全角空格，不想这个空格在转成UNICODE编码时，它的编码是\u0000，不能获取到全角空格的宽度。于是把它设成字体高度，看了一下效果还好。


qiezi 2006-10-09 11:44 发表评论
]]>[private] 文字绘图库资料收集http://www.cppblog.com/cpunion/archive/2006/09/28/13124.htmlqieziqieziThu, 28 Sep 2006 12:03:00 GMThttp://www.cppblog.com/cpunion/archive/2006/09/28/13124.htmlhttp://www.cppblog.com/cpunion/comments/13124.htmlhttp://www.cppblog.com/cpunion/archive/2006/09/28/13124.html#Feedback3http://www.cppblog.com/cpunion/comments/commentRss/13124.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/13124.html
一、imagemagick:
http://www.cit.gu.edu.au/~anthony/graphics/imagick6/
可以绘制文字，不过中文好像不能自动断行。

二、vips
http://vips.sourceforge.net
使用pango绘制文字，中文可以断行，缺少2端对齐功能。自己修改代码增加了调整行距功能，做成ruby扩展库，amd64上使用失败，原因待查。

三、freetype
http://vips.sourceforge.net
不依赖其它图形/窗口库，其它不熟悉，待查。

四、Graphite
跨平台的字体渲染库。待查。


搜寻已有数月，目前看到的几个库都不太理想，mac osx上可能比较专业，不过集成较困难。

苹果网站上的比较完整的字体绘制和布局方面的资料：
http://developer.apple.com/documentation/Carbon/Conceptual/ATSUI_Concepts/index.html
其中布局方面的专业知识：
http://developer.apple.com/documentation/Carbon/Conceptual/ATSUI_Concepts/atsui_chap3/chapter_3_section_3.html#//apple_ref/doc/uid/TP30000029-TPXREF157


其它资料：



qiezi 2006-09-28 20:03 发表评论
]]>[RoR] 实现一个auto_redirect_tohttp://www.cppblog.com/cpunion/archive/2006/05/20/7434.htmlqieziqieziFri, 19 May 2006 18:33:00 GMThttp://www.cppblog.com/cpunion/archive/2006/05/20/7434.htmlhttp://www.cppblog.com/cpunion/comments/7434.htmlhttp://www.cppblog.com/cpunion/archive/2006/05/20/7434.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/7434.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/7434.html
我遇到的一个问题是，当使用Ajax更新页面局部内容时，session内容已经过期，这时需要整个页面跳转到登录页面。

直接调用redirect_to会使局部内容显示成登录页面，它是在HTTP头里写入重定向参数来实现的。在我这里的特殊情况下，正确的做法是让它执行一个包含在<script>标记中的脚本，在脚本中更改窗口location值来跳转。

不过RoR中使用Ajax时，会根据:update参数来决定是使用Updater还是Request。如果使用Updater方式，则应返回一段纯脚本；如果是Request方式，应返回一段包括在<script>标记中的脚本；如果是普通方式，就应该使用原有的redirect_to函数了。因为服务端无法区分使用的是哪种方式来请求，所以简单的做法是每个请求都附加一个参数用来区分，不加参数则是普通请求方式。

为了达到这个目的，我修改了prototype_helper中的remote_function函数。这个函数根据传递进来的参数来决定使用Request或是Updater，我就在这里下手：

      def remote_function(options)
        javascript_options = options_for_ajax(options)

        update = ''
        if options[:update] and options[:update].is_a?Hash
          update  = []
          update << "success:'#{options[:update][:success]}'" if options[:update][:success]
          update << "failure:'#{options[:update][:failure]}'" if options[:update][:failure]
          update  = '{' + update.join(',') + '}'
        elsif options[:update]
          update << "'#{options[:update]}'"
        end

        function = update.empty? ? 
          "new Ajax.Request(" :
          "new Ajax.Updater(#{update}, "
    
        url_options = options[:url]
        ajax_options = options[:update] ? {:ajax => 'update'} : {:ajax => 'request'}
        url_options = url_options.merge(ajax_options)
        url_options = url_options.merge(:escape => false) if url_options.is_a? Hash
        function << "'#{url_for(url_options)}'"
        function << ", #{javascript_options})"

        function = "#{options[:before]}; #{function}" if options[:before]
        function = "#{function}; #{options[:after]}"  if options[:after]
        function = "if (#{options[:condition]}) { #{function}; }" if options[:condition]
        function = "if (confirm('#{escape_javascript(options[:confirm])}')) { #{function}; }" if options[:confirm]

        return function
      end

有红色的2行是我添加的，由于这个编辑器的原因，没有显示成整行红色。这2行的作用是判断是否有:update参数，用它来决定是添加ajax=update还是ajax=request。

现在可以实现一个简单的auto_redirect_to了：

  def auto_redirect_to(method, url)
    case method
    when 'request'
      request_redirect_to(url)
    when 'update'
      update_redirect_to(url)
    else
      redirect_to(url)
    end
  end
  
  def request_redirect_to(url)
    render :update do |page|
      page.redirect_to(url)
    end
  end
  
  def update_redirect_to(url)
    render :inline => <<-EOS
      <script language="javascript">
      <%=
        render :update do |page|
          page.redirect_to("#{url_for(url)}")
        end
      %>
      </script>
    EOS
  end

使用helper方式使它能够被include到ApplicationController中就行了。

为了不和参数绑得太死，这里把method作为参数由调用者传入。

使用方法，以Login Engine为例，它在access_denied中处理跳转。在ApplicationController中重写这个函数：

    def access_denied
      auto_redirect_to(params[:ajax], :controller => "/user", :action => "login")
      false
    end  

现在可以测试了。请求可以是普通的（超链接），Updater方式（请求到一个DIV里），Request方式，现在都能够跳转到正确页面。

ajax参数通过hack库代码来实现，对于使用者来说基本上是透明的。


qiezi 2006-05-20 02:33 发表评论
]]>[RoR] 在RoR中调用.Net webservicehttp://www.cppblog.com/cpunion/archive/2006/05/14/7138.htmlqieziqieziSun, 14 May 2006 12:08:00 GMThttp://www.cppblog.com/cpunion/archive/2006/05/14/7138.htmlhttp://www.cppblog.com/cpunion/comments/7138.htmlhttp://www.cppblog.com/cpunion/archive/2006/05/14/7138.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/7138.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/7138.html
using System;
using System.Web;
using System.Web.Services;
using System.Web.Services.Protocols;

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
    [WebMethod]
    public string HelloWorld(string name) {
        return "Hello, " + name;
    }
    
}

在RoR项目里，添加app/apis/test_api.rb：

class TestApi < ActionWebService::API::Base
  api_method :HelloWorld, :expects => [{:name => :string}], :returns => [:string]
end

这是RoR里面通用的webservice元信息描述。

添加app/controllers/test_controller.rb:

class TestController < ApplicationController
  web_client_api :test, :soap, "http://localhost/test/Service.asmx", 
                 :namespace => "http://tempuri.org/",
                 :soap_action_base => "http://tempuri.org",
                 :driver_options=>{:default_encodingstyle => SOAP::EncodingStyle::ASPDotNetHandler::Namespace }

  def hello
    render_text test.HelloWorld("Li Jie")
  end
end

:soap_action_base选项是一个修补，不加这个选项会产生SOAPAction头错误。

运行服务器，在浏览器中访问/test/hello，发现名字为空。经过长时间调试，发现.Net在解析SOAP消息体时，不能处理这种命名空间：

    <n1:HelloWorld xmlns:n1="http://tempuri.org/"
        soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
      <name xsi:type="xsd:string">Li Jie</name>
    </n1:HelloWorld>

把n1去掉就行了。不过这部分实现在rubylib/soap/rpc/proxy.rb里面，实在不方便修改。为了让这个测试通过，暂时做了点小修改：

  def route(req_header, req_body, reqopt, resopt)
    req_env = ::SOAP::SOAPEnvelope.new(req_header, req_body)
    unless reqopt[:envelopenamespace].nil?
      set_envelopenamespace(req_env, reqopt[:envelopenamespace])
    end
    reqopt[:external_content] = nil
    conn_data = marshal(req_env, reqopt)
    if ext = reqopt[:external_content]
      mime = MIMEMessage.new
      ext.each do |k, v|
          mime.add_attachment(v.data)
      end
      mime.add_part(conn_data.send_string + "\r\n")
      mime.close
      conn_data.send_string = mime.content_str
      conn_data.send_contenttype = mime.headers['content-type'].str
    end

    conn_data.send_string.gsub!(/:n1/, '')
    conn_data.send_string.gsub!(/n1:/, '')

    conn_data = @streamhandler.send(@endpoint_url, conn_data,
      reqopt[:soapaction])
    if conn_data.receive_string.empty?
      return nil
    end
    unmarshal(conn_data, resopt)
  end

加粗的2行是我添加的代码，勉强可以让它工作，不过显然不是正确的方法。

不知道是不是.Net库里面的BUG。

qiezi 2006-05-14 20:08 发表评论
]]>[RoR] 脚本模拟RJS刷新页面http://www.cppblog.com/cpunion/archive/2006/05/13/7087.htmlqieziqieziSat, 13 May 2006 15:49:00 GMThttp://www.cppblog.com/cpunion/archive/2006/05/13/7087.htmlhttp://www.cppblog.com/cpunion/comments/7087.htmlhttp://www.cppblog.com/cpunion/archive/2006/05/13/7087.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/7087.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/7087.html
演示页面直接在浏览器中观看。

演示下载

qiezi 2006-05-13 23:49 发表评论
]]>[RoR] 用javascript脚本模拟一个actionhttp://www.cppblog.com/cpunion/archive/2006/05/12/7046.htmlqieziqieziFri, 12 May 2006 15:41:00 GMThttp://www.cppblog.com/cpunion/archive/2006/05/12/7046.htmlhttp://www.cppblog.com/cpunion/comments/7046.htmlhttp://www.cppblog.com/cpunion/archive/2006/05/12/7046.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/7046.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/7046.html
有些时候我们并不需要请求服务器，只想在浏览器上执行某些脚本更新，但又想使用RJS。所以为RoR增加了这项功能。

使用方法：

<script language="javascript">
<%= 
render :update do |page|
  page.define_action 'test_action' do
    page.call_script <<-EOS
      alert(params.comment.title);
      alert(params.comment.body);
    EOS
    page.replace_html 'errors', 'ERROR'
  end

  page.define_action 'link_action' do
    page.replace_html 'errors', 'ERROR'
  end
end
%>
</script>

<div id="errors"></div>

<%= form_local_tag :html => {:action => 'test_action'} %>
  <input name="comment[title]" /><br />
  <input name="comment[body]" /><br />
  <%= submit_tag 'Create' %>
<%= end_form_tag %>

<%= link_to_local 'Test', :action => 'link_action()' %>

上面演示了form_local_tag和link_to_local的使用，打开这个页面以后，可以关掉服务器测试，会发现它不请求服务器也能执行相应脚本。

define_action定义一个脚本函数，call_script用来实现javascript和RJS代码的混合。当使用form_local_tag时，action方法的参数已经被处理过，所以可以直接在action中使用params.comment.title。

当然现在还不完善，比如还只能使用转换完的页面模板，一些动态页面将看不出效果。要做到这点，需要用javascript实现一整套的ActionView辅助方法。

下面提供一个针对rails 1.1.2的一个补丁文件：

补丁文件下载

qiezi 2006-05-12 23:41 发表评论
]]>[RoR] 简单的角色权限检查插件http://www.cppblog.com/cpunion/archive/2006/05/08/6790.htmlqieziqieziMon, 08 May 2006 13:30:00 GMThttp://www.cppblog.com/cpunion/archive/2006/05/08/6790.htmlhttp://www.cppblog.com/cpunion/comments/6790.htmlhttp://www.cppblog.com/cpunion/archive/2006/05/08/6790.html#Feedback0http://www.cppblog.com/cpunion/comments/commentRss/6790.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/6790.html
module ActionController #:nodoc:

  class CheckGroupError < ActionControllerError #:nodoc:
    attr_reader :group_name
    def initialize(group_name)
      @group_name = group_name
    end
  end
  
  class CheckRoleError < ActionControllerError #:nodoc:
    attr_reader :role_name
    def initialize(role_name)
      @role_name = role_name
    end
  end
  
  class Base #:nodoc:
    def roles
      []
    end
    
    def groups
      []
    end
    
    def check_roles(*role_args)
      role_args.each do |role|
        check_role(role)
      end
    end
    
    def check_groups(*group_args)
      group_args.each do |group|
        check_group(group)
      end
    end
    
    def check_group(group)
      raise CheckGroupError.new(group.to_s) unless groups().include?(group.to_s)
    end
    
    def check_role(role)
      raise CheckRoleError.new(role.to_s)   unless roles().include?(role.to_s)      
    end
  end
  
end

只需要在ApplicationController中实现roles和groups这2个方法，对数据库模式没有任何限制，只要能保证这2个方法能够得到当前用户的角色和组即可。

有4个check方法可用，可任意使用一个或多个。

简单模拟测试一下：

class ApplicationController < ActionController::Base
  def roles
    %w(add show)
  end

  def groups
    %w(users)
  end
end

class TestController < ApplicationController
  def test1
    check_role :add
    render_text "OK"
  end

  def test2
    check_role :add
    check_group :users
    render_text "OK"
  end

  def test3
    check_groups :admin, :users
    render_text "OK"
  end

  def test4
    check_roles :add, :remove
    render_text "OK"
  end
end

其中，test1、test2都会成功，而test3和test4则会失败显示异常，只需要处理rescue_action把它修改为自己的显示页面即可。

qiezi 2006-05-08 21:30 发表评论
]]>C＋＋实现简单的类型库http://www.cppblog.com/cpunion/archive/2005/09/26/435.htmlqieziqieziMon, 26 Sep 2005 09:31:00 GMThttp://www.cppblog.com/cpunion/archive/2005/09/26/435.htmlhttp://www.cppblog.com/cpunion/comments/435.htmlhttp://www.cppblog.com/cpunion/archive/2005/09/26/435.html#Feedback9http://www.cppblog.com/cpunion/comments/commentRss/435.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/435.html
不过当时没有去考虑动态加载DLL的情况。

今天在cpp@codingnow.com中也有人问到这个问题，就把它给做完了。

当然只是简单地做到了“从全局类型库中，根据类名创建实例，支持动态DLL加载”，说得更明白点：

在应用程序App1中，向全局类型库中注册一个类型"Test"，在另一个隐式链接的DLL中（即App1一启动就加载的DLL），向全局类型库中注册另外几个类型。这时可以在App1中通过类型的名字生成实例。

在另一个显式加载的DLL中（即调用LoadLibrary加载），向全局类型库中注册其它几个类型。这时通过LoadLibrary加载这个DLL，就可以生成这几个类型的实例了。

这地方不能上传文件，就把代码贴一点吧：

typelib.h文件：

#ifndef __TYPE_LIB_H__
#define __TYPE_LIB_H__

typedef void*(*CREATE_FUNC)();
typedef void(*RELEASE_FUNC)(void*);

void regtype (const char* name, CREATE_FUNC cfunc, RELEASE_FUNC rfunc);

void* createObject (const char* name);

void releaseObject (const char* name, void* p);

struct ITestInterface
{
    virtual ~ITestInterface () {}
    virtual void print () const = 0;
};

template <class T>
void* create ()
{
    return new T;
}

template <class T>
void release (void* p)
{
    delete (T*)p;
}

#endif // __TYPE_LIB_H__

typelib.cpp文件：

#include "typelib.h"

#include <string>
#include <map>
using namespace std;

namespace TypeRegistry
{
    static map < string, pair<CREATE_FUNC, RELEASE_FUNC> >  types_info;

    template <class T>
    void regType (const string& name)
    {
        types_info.insert (make_pair(name, make_pair(create<T>, release<T>)));
    }
}

void regtype (const char* name, CREATE_FUNC cfunc, RELEASE_FUNC rfunc)
{
    TypeRegistry::types_info.insert (make_pair(name, make_pair(cfunc, rfunc)));
}

void* createObject (const char* name)
{
    map < string, pair<CREATE_FUNC, RELEASE_FUNC> >::const_iterator iter;
    iter = TypeRegistry::types_info.find (name);
    if (iter != TypeRegistry::types_info.end ())
        return (*iter->second.first)();
    return NULL;
}

void releaseObject (const char* name, void* p)
{
    map < string, pair<CREATE_FUNC, RELEASE_FUNC> >::const_iterator iter;
    iter = TypeRegistry::types_info.find (name);
    if (iter != TypeRegistry::types_info.end ())
        (*iter->second.second)(p);
}

把它编译成静态lib或DLL，就可以使用了。

在那2个为我们提供类型的DLL中，DllMain函数中加入下面的代码：

// FirstTest和SecondTest是2个类名
regtype("FirstTest", create<FirstTest>, release<FirstTest>);
regtype("FirstTest", create<SecondTest>, release<SecondTest>);

就可以向全局类型库中注册类型。注意在类型库中是没有保存类信息的，所以最好是使用单根类库来做。

下面是一点测试代码：

int main()
{
       // 程序启动时注册类型。
       // 实际上启动时就加载了另一个动态链接库，那里面有3个类型，所以现在有4个类型
       regtype ("MyTest", create<MyTest>, release<MyTest>);
       while (1)
       {
               string class_name;
               cin >> class_name;
               if (class_name == "q")
                       break;
               // 当输入load时，把另一个动态链接库加载进来，那个链接库中有2个类型，现在共有6个类型可用。
               if (class_name == "load")
               {
                       LoadLibrary("typelibdll_test.dll");
                       continue;
               }
               ITestInterface* test = (ITestInterface*)createObject (class_name.c_str());
               if (!test)
               {
                       cout << "This type not found" << endl;
                       continue;
               }
               test->print ();
               releaseObject (class_name.c_str(), test);
       }
       return 0;
}

还有一个没考虑的地方，就是没有给它加锁，因为有可能在一个线程中加载一个DLL。

不过我还有些怀疑这东西是否真的有用？

qiezi 2005-09-26 17:31 发表评论
]]>为C＋＋实现一个IDL　（二）http://www.cppblog.com/cpunion/archive/2005/09/20/349.htmlqieziqieziTue, 20 Sep 2005 14:34:00 GMThttp://www.cppblog.com/cpunion/archive/2005/09/20/349.htmlhttp://www.cppblog.com/cpunion/comments/349.htmlhttp://www.cppblog.com/cpunion/archive/2005/09/20/349.html#Feedback6http://www.cppblog.com/cpunion/comments/commentRss/349.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/349.html说明：
要看懂后面那部分代码，即使用Typelist的部分，最好预先看过《C＋＋设计新思维》，英文版名为《Modern C++ Design》。
If模板类在写完后想起来好像在哪见过，早晨去公司查阅了一下，在《产生式编程——方法、工具与应用》一书中有讲，英文名为《Generative Programming -- Methods, Tools, and Applications》基本和本篇中一个样。


前2篇乱七八糟地讲了一些，有一个遗留问题，函数原型的推导。

简要描述如下：

Method < void(in<int>, in<char>, inout<string>, out<short>) > method;

// 同步调用
string str = "hello";
short value = 2;
method (3, 'a', str, value);

// 异步调用1
method.async_call (3, 'a', "hello");

// 异步调用2
void test_func (int, char, string, short);
method.async_call (3, 'a', "hello", test_func);


要产生这3种函数形式。参数类型如何转换，是以后的话题，本篇主要解决异步调用的函数原形推导问题。本篇也不讨论Method的模板参数（即那个函数类型）返回类型不为void的情况。

第一种形式，同步调用，比较好处理，参数个数和模板参数的数量相同。

后2种形式，如何让编译器根据in/out来推导出函数原型？

我们需要编译器做这样的处理，async_call的参数类型中，in类型的参数将保留，out类型的参数不需要，inout类型也需要保留。

要用到的Loki头文件：

#include <static_check.h>
#include <Typelist.h>

using namespace Loki;
using namespace Loki::TL;


首先看看in/inout/out的声明。为了简化，这里去掉了跟类型推导无关的部分。

class NullType
{
    NullType ();
};

template <class T>
struct in
{
    typedef T OriginalType;
};

template <class T>
struct out
{
    typedef T OriginalType;
};

template <class T>
struct inout
{
    typedef T OriginalType;
};

下面Method模板类的声明，使用偏特化来产生代码。为了简化，我只取函数参数个数为4个参数的版本，比照着上面的代码来解释，只解释method.async_call (3, 'a', "hello", test_func);这个版本，因为另一个比它简单。

template <class T>
struct Method
{
};

template <class Ret, class A, class B, class C, class D>
struct Method <Ret(A,B,C,D)> 
{
};


根据上面Method的定义，Method < void(in, in, inout, out) > ，async_call函数的类型将是：

typedef void (*FUNC_TYPE)(int, char, string, short);
void async_call (int, char, string, FUNC_TYPE func);

实际上FUNC_TYPE应该能够接受更广泛的类型，比如void(int, char, char*, short)，这可以在内部做一些转换，不过本篇的重点不在这里，所以只讲上面的那种形式。

直接在Method类中实现有些麻烦，所以我把这个函数放在一个基类中实现，只要编译器能帮我们推导出下面这种形式就行了：

template <class Ret, class A, class B, class C, class D>
struct Method <Ret(A,B,C,D)> : public Base < A, B, C >
{
};


注意，这里是以Method < void(in, in, inout, out) >这种形式来讲的，才会有上面那种继承关系。而实际上，由于in/out在参数中的位置、数量都是未知的，要到定义时才能确定，所以使用模板来推导。（入正题了）

也就是说，只要我们能使用静态推导方式，获得A,B,C,D这四个参数中所有的in类型，把它交给Base作为模板参数就成了。

这里需要一个辅助的模板类，用来在编译时帮助推导：

template <class T>
class InOutTypeTraits
{
    Loki::CompileTimeError <false> Not_Supported_Type;
};

template <class T>
struct InOutTypeTraits < in<T> >
{
    enum {isin=1, isout=0};
};

template <class T>
struct InOutTypeTraits < out<T> >
{
    enum {isin=0, isout=1};
};

template <class T>
struct InOutTypeTraits < inout<T> >
{
    enum {isin=1, isout=1};
};

template <>
struct InOutTypeTraits < NullType >
{
    enum {isin=0, isout=0};
};

通过另一个模板类InList来帮我们产生所有的in类型，它的结果是一个Typelist。为了方便以后使用，我把out类型产生器也做了一个OutList。

template <int CONDITION, class _IF, class _ELSE>
struct If
{
    typedef _IF Result;
};

template <class _IF, class _ELSE>
struct If <0, _IF, _ELSE>
{
    typedef _ELSE Result;
};

template <class A = NullType, class B = NullType, class C = NullType, class D = NullType, 
    class E = NullType, class F = NullType, class G = NullType, class H = NullType
>
struct InList
{
    typedef typename If < 
        InOutTypeTraits <A>::isin,
        typename Typelist < A, typename InList<B,C,D,E,F,G>::Result >, 
        typename InList<B,C,D,E,F,G,H>::Result 
    >::Result Result;
};

template <class A>
struct InList <A, NullType, NullType, NullType, NullType, NullType, NullType, NullType>
{
    typedef typename If <
        InOutTypeTraits <A>::isin,
        typename MakeTypelist <A>::Result,
        typename MakeTypelist <>::Result
    >::Result Result;
};

template <class A = NullType, class B = NullType, class C = NullType, class D = NullType, 
    class E = NullType, class F = NullType, class G = NullType, class H = NullType
>
struct OutList
{
    typedef typename If < 
        InOutTypeTraits<A>::isout,
        typename Typelist < A, typename OutList<B,C,D,E,F,G>::Result >, 
        typename OutList<B,C,D,E,F,G,H>::Result 
    >::Result Result;
};

template <class A>
struct OutList <A, NullType, NullType, NullType, NullType, NullType, NullType, NullType>
{
    typedef typename MakeTypelist <A>::Result Result;
};

它的原理是，根据If模板类来判断一个类型是不是in类型，是的话就把它加入到Typelist中，不是就排除它。

InList , in, inout, out::Result是一个Typelist , Typelist, Typelist, NullType> > >类型，说简单点，它和MakeTypelist < in, in, inout >::Result是等价的。

现在Base模板类将接受一个模板参数，它是一个Typelist类型，这个不详细讲了，把它的定义写出来：

template <class T, int T_COUNT = Length <IN_TYPE>::value >
struct Base
{
    Loki::CompileTimeError <false> Only_Use_Partial_Specialisation_Version;
};

template <class T>
struct Base <T, 0>
{
    typedef void(*FUNC_TYPE)();

    template <class FUNC_TYPE>
    void async_call (FUNC_TYPE func)
    {
    }
    void async_call ()
    {
    }
};

template <class T>
struct Base <T, 1>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        FUNC_TYPE func)
    {
    }
    void async_call (typename TypeAt <T, 0>::Result::OriginalType v0)
    {
    }
};

template <class T>
struct Base <T, 2>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType,
        typename TypeAt <T, 1>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0, 
        typename TypeAt <T, 1>::Result::OriginalType v1, 
        FUNC_TYPE func)
    {
    }
    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0, 
        typename TypeAt <T, 1>::Result::OriginalType v1)
    {
    }
};

template <class T>
struct Base <T, 3>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType, 
        typename TypeAt <T, 1>::Result::OriginalType,
        typename TypeAt <T, 2>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0, 
        typename TypeAt <T, 1>::Result::OriginalType v1, 
        typename TypeAt <T, 2>::Result::OriginalType v2, 
        FUNC_TYPE func)
    {
    }
    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        typename TypeAt <T, 1>::Result::OriginalType v1,
        typename TypeAt <T, 2>::Result::OriginalType v2)
    {
    }
};

template <class T>
struct Base <T, 4>
{
    typedef void(*FUNC_TYPE)(
        typename TypeAt <T, 0>::Result::OriginalType, 
        typename TypeAt <T, 1>::Result::OriginalType,
        typename TypeAt <T, 2>::Result::OriginalType,
        typename TypeAt <T, 3>::Result::OriginalType);

    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0, 
        typename TypeAt <T, 1>::Result::OriginalType v1, 
        typename TypeAt <T, 2>::Result::OriginalType v2, 
        typename TypeAt <T, 3>::Result::OriginalType v3,
        FUNC_TYPE func)
    {
    }
    void async_call (
        typename TypeAt <T, 0>::Result::OriginalType v0,
        typename TypeAt <T, 1>::Result::OriginalType v1,
        typename TypeAt <T, 2>::Result::OriginalType v2,
        typename TypeAt <T, 3>::Result::OriginalType v3)
    {
    }
};

这部分有点多，其实还是比较清晰的。注意这个Base的版本已经不是上面所讲的那个了。

函数原形推导问题就讲完了。上面的代码不一定还能编译，昨天是能编译的，被我修改了一些，为了解释，又改成昨天那样子。

qiezi 2005-09-20 22:34 发表评论
]]>正式建立asgard项目 (因ancients已经被人使用了）http://www.cppblog.com/cpunion/archive/2005/09/20/327.htmlqieziqieziTue, 20 Sep 2005 02:30:00 GMThttp://www.cppblog.com/cpunion/archive/2005/09/20/327.htmlhttp://www.cppblog.com/cpunion/comments/327.htmlhttp://www.cppblog.com/cpunion/archive/2005/09/20/327.html#Feedback16http://www.cppblog.com/cpunion/comments/commentRss/327.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/327.html
项目命名为ancients，字面意思是“远古的，旧的”，实际上这个主题也算是旧的了。原本打算命名为C++ Remoting，不过想了一下，还是换个名字，免得让人一看就想拿去跟java, c#的remoting比较。

取这个名字主要是因为喜欢看《星际之门》剧集，里面最喜欢的一个种族就是ancients。

asgard是另一个种族，在ancients这个名字被人占用了的情况下，只好选它了。它的字面意思是“仙宫”，也是不错的名字，呵呵。asgard这个种族的科技非常发达，有先进的亚空间旅行技术，先进的光传送技术，身体也比较符合一些报道中外星人的样子。

暂时还没找到合适的空间来放这个项目，就以压缩包的形式在这个blog上做吧。

打算先实现动态部分，我给它命名为reflection，模仿java的，当然也不会做它那么完整。这部分必须先做，这样方便用来测试静态结构。

然后是静态结构部分，前面已经写了2篇乱七八糟的描述，剩余问题（函数原形推导问题）基本已经解决了。

整个框架在Service以下都是环境无关的，这里的环境指的是协议、通讯等环境。也就是说，定义一个Service，并不在一开始就指定它所使用的通讯协议。定义完成以后，把它指定给一个协议，就可以实现协议绑定，甚至在运行时刻动态切换到另一个协议。当然这可能是不合理的，不过我认为如果支持这种做法，本身就是灵活性的一种体现。



前面还有些地方，和实际情况有些差别的，需要补充完善。简要描述如下：

使用宏来定义Service，前面只定义了方法的原型、名称、服务端绑定的函数，其实还差一个重要的东西，就是参数的名字。
如果使用自己的协议，或者是顺序存储的协议，比如BENCODE，来作为远程调用协议，那么参数的名字是不重要的，只要按顺序把参数序列化、反序列化就可以了。
但在使用SOAP作为远程调用协议时，就得考虑为参数加上名字了，SOAP是从XML元素中，按参数名称来提取参数值的，虽然我们可以为参数生成一个名字，但这个名字不能描述参数所表达的意思。
所以需要考虑为参数取上名字。

暂时就补充这一点，其它方面有等进一步研究。

qiezi 2005-09-20 10:30 发表评论
]]>为C＋＋实现一个IDL　（一）http://www.cppblog.com/cpunion/archive/2005/09/17/284.htmlqieziqieziSat, 17 Sep 2005 11:40:00 GMThttp://www.cppblog.com/cpunion/archive/2005/09/17/284.htmlhttp://www.cppblog.com/cpunion/comments/284.htmlhttp://www.cppblog.com/cpunion/archive/2005/09/17/284.html#Feedback4http://www.cppblog.com/cpunion/comments/commentRss/284.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/284.html前面简单写了点静态结构，这一次将主要关注动态模型以及调用方式。

这个系列的名字叫“为C++实现一个IDL”，实际上应该叫“为C++实现一个Remoting”可能更好一些，说是IDL，主要是想通过宏，使用简单的类型定义达到自动生成调用代码的目的。

一、首先来看看调用习惯。

从调用习惯入手，主要是因为看到目前有很多库/工具包在调用上都有很多不便之处。假如能在一开始就从这点出发，就能把调用接口设计得更好一些。

先来看看服务端如何开放一个服务。

int main ()
{
    // 发布为SOAP服务，先生成一个服务容器。
    // 服务将发布在localhost的7911上，localhost用来绑定loopback网卡。
    SOAPProxy soap_service (7911, “localhost”);

    TestService test_service; 
    soap_service.addService  (“test_service”, &test_service);

    TestService service1;
    soap_service.addService (“HelloService”, &service1);

    try{
        soap_service.run ();
    } catch (SocketException& e)
    {
    } catch (SignalException& e)
    {
    }

    return 0;
}


我希望就是这么简单，客户端调用有多种方式：
1、 使用服务的IDL定义，直接调用：

int main ()
{
    SOAPProxy soap_service (7911, “localhost”);

    try{
        TestService test_service (“test_service”, &soap_service);
        test_service.method1 (/**/);
    } catch (SocketException& e)
    {
    }
    return 0;
}


这种方式比较简单，调用时会检查是否已经连接，然后发送调用请求，并处理调用结果。

2、 服务验证方式：

int main ()
{
    SOAPProxy soap_service (7911, “localhost”);
    TestService test_service;
    soap_service.getService (“test_service”, &test_service);

    if (test_service)
    {
        try{
            test_service.method1 (/**/);
        } catch (SocketException& e)
        {
        }
    }
    return 0;
}


3、 服务发现方式：

int main ()
{
    SOAPProxy soap_service (7911, “localhost”);
    vector <string> services_name = soap_service.getServiceNames ();
    // 
    IService* test_service = soap_service.getService (“test_service”);
    if (test_service)
    {
        vector <string> methods = test_service->getMethodNames ();
        IMethod* method = test_service->getMethod (“method1”);
        vector <Type*> types = method->getParameterType s()
        method->addArg (3);
        method->addArg (4);
        // 
        method->invoke ();
        // 
    }
    return 0;
}


二、基本需求。

简单分析一下，上面一共涉及了哪些类型？
IProxy:
这是所有Proxy类的基类(和接口)，它可以容纳多个服务对象，提供服务绑定、服务查询、服务发现、服务验证。
IService:
所有Service类的基类，可以容纳多个方法(Method)，提供方法查询、服务验证。
IMethod:
所有Method模板类的基类，容纳多个参数，包括返回值，可通过查询参数类型获得方法的类型定义。
IParameter:
所有参数的基类，包含一个参数类型描述和一个参数值。
IType:
所有类型的基类，预定义了一些基本类型，可自定义类型。

看起来挺多的，其实很难接触到这些，只需要使用宏来定义一个服务，就可以通过模板的类型推导，自动生成这些复杂的定义。

三、调用过程。

以下只简单分析一下同步调用，异步调用将是以后的扩充话题。
根据第二节的3种不同调用过程，简要描述如下：
  1. 直接调用。

    • 生成SOAPProxy，让它连接到远程主机。
    • 生成一个TestService对象，设置远程主机上的服务名称，并指定使用SOAPProxy，也即使用SOAP协议。
    • 调用TestService::method1方法。根据method1的定义，把服务名称、方法名称、各个in参数等打包成一个“集合”，交给SOAPProxy处理。
    • SOAPProxy把这个“集合”转换成SOAP消息，发送到远程主机，阻塞线程。
    • 远程主机上的SOAPProxy对象收到数据，进行解析。当解析出一个服务调用时，把它交给TestService服务处理。
    • TestService解析出一个方法调用，把它交给Method处理。
    • Method解析出各个参数，验证参数类型、完整性等，并执行调用或返回错误。
    • Method调用的返回信息(包括调用结果、返回值、out参数等)被打包成一个“集合”，交给TestService处理。
    • TestService处理后，交给SOAPProxy。
    • SOAPProxy把结果打包成SOAP消息，发回调用端。
    • 调用端解析SOAP消息，把OUT参数值赋给调用者提供的对象，调用完成。

     

  2. 服务验证方式。
    • 生成SOAPProxy，让它连接到远程主机。
    • 生成TestService对象，调用SOAPProxy的getService验证版本。
    • SOAPProxy把TestService对象的信息(名称、成员及基类型等)发送到远程主机，阻塞。
    • 远程主机解析收到的信息，查找服务名，并比较查找到的服务类型与解析得到的类型。
    • 比较结果发回给调用端。
    • 调用端接着采用直接调用的方式，调用远程服务。

    这种方式看起来多了一些操作，不过验证的好处是能够减少调用时的异常。

  3. 服务发现方式。
    • 生成SOAPProxy，让它连接到远程主机。
    • 查询远程开放的服务名称。(可省略)
    • 查找特定服务，得到服务描述信息。
    • 查找服务中的方法，得到方法描述信息。
    • 压入各个参数，并执行调用。
    • 调用前先判断参数是否与描述一致，然后调用SOAPProxy生成SOAP消息，发送到远程主机，阻塞。
    • 远程主机解析出调用。。。后面过程与第1种方式相同，远程主机并不知道客户端使用的是哪种方式来调用。远程主机处理结束，将返回SOAP消息给调用端。
    • 调用端解析出调用结果，并把各个OUT参数的值赋给method对象。

    使用这种方式，调用端不需要服务的类型定义。

四、异步调用/异步分派(AMI/AMD)。

同步调用时，调用端线程需要等待调用结果，服务端线程也要等待调用结束返回，才处理下一个调用。
为了在服务调用期间让线程能做更多的事：
调用端把调用交给线程池完成，并在调用完成后采用某种机制通知线程处理结果，或者直接由线程池中的调用线程调用结果处理函数。这种方式称为AMI(异步方法调用)。
服务端主线程则把接收到的消息解析后，放入处理队列，由线程池去处理调用过程。当调用完成后，结果放入结果队列，由主线程处理成消息，发送回调用端。这种方式称为AMD(异步方法分派)。
调用端和服务端依旧是使用通讯协议来沟通，双方都不知道对方是否采用了异步方式。

AMI和AMD对于静态定义的服务是有影响的，比如下面一个服务：

struct TestService
{
    Method <void(in<int>, out<int>)> method1;
}


在同步调用时，它的调用方式：

TestService test_service;
int a;
service.method1 (3, a); // 或者 service.method1 (3, &a)，打算兼容这2种方式。


异步调用时，调用方式：

void method1_result (int, int);
TestService test_service;
test_service.method1.async_call(3, method1_result); // 调用完成后，让调用线程去调用method1_result通知调用结果。
// 或者像下面
IMethod* result = test_service.method1.async_call (3);
while (!result->done())  // 还有很多好办法，这里只是为了简单。
{
    sleep (1);
}
cout << result->getArg(1)->toInt(); 


正如上面演示的一样，异步调用的结果有2种方式去处理。
一是由线程池调用完以后，接着调用一个函数以通知结果。它不需要轮询，不过涉及到了线程问题，增加了一些复杂性。
另一种方式调用结束后，原调用线程在某个适当的“时机”去查询调用结果。这个时机可以是定时查询，也可以是被线程消息通知而去处理。

五、其它。

这一篇加上前一篇，应该是提到了全部的要点。
目前剩下的唯一一个难点，可能是在处理异步调用时，Method的定义。
正如上面演示的，一个方法在同步调用和异步调用时，就有3种调用方式：

service.method1 (3, a);
test_service.method1.async_call(3, method1_result);
IMethod* result = test_service.method1.async_call (3);


特别地，它如何根据in和个数和out的个数，产生那2个参数个数匹配的异步调用函数？
再来回顾一下method1的定义：

Method <void(in<int>, out<int>)> method1;


显然有一定的复杂性，不过我认为还是可以处理掉的。拿3个参数的偏特化版本来说明：

template <class Ret, class A, class B, class C>
class Method <Out<Ret>(A,B,C)> : public MethodBase <Out<Ret>,A,B,C>
{
};

template <class Ret=NullType, class A=NullType, class B=NullType, class C=NullType, class D=NullType, IN_COUNT=InCount< A,B,C,D>::value >
class MethodBase
{
};


通过对MethodBase类的IN＿COUNT参数定义偏特化，即可定义出这些不同的版本。

当然仅仅是知道了IN参数的个数，还没有提取出IN参数的类型，所以还不能生成函数的原型，或许需要把typelist加进来了（loki中的那个）。



这是后面要考虑的内容，今天先想到这。



qiezi 2005-09-17 19:40 发表评论
]]>为C＋＋实现一个IDL　（零）http://www.cppblog.com/cpunion/archive/2005/09/15/272.htmlqieziqieziWed, 14 Sep 2005 17:27:00 GMThttp://www.cppblog.com/cpunion/archive/2005/09/15/272.htmlhttp://www.cppblog.com/cpunion/comments/272.htmlhttp://www.cppblog.com/cpunion/archive/2005/09/15/272.html#Feedback4http://www.cppblog.com/cpunion/comments/commentRss/272.htmlhttp://www.cppblog.com/cpunion/services/trackbacks/272.html一、问题。

这段时间考虑实现一个纯C＋＋的分布式服务包装库，简要描述如下：

有如下类和函数：

struct Test
{
    void test1 (/*in*/ int v1, /*in*/ int* v2);
    int test2 (/*in*/ int& v1, /*out*/ int* v2);
};

int test_func (/*in*/ int* v1, /*inout*/ string* v2);


想把它们作为服务发布出去，以SOAP或其它方式。发布为一个TestService，并让它携带多一些信息:

struct TestService
{
    void test1 (in<int> v1, in<int> v2);
    int test2 (in<int> v1, out<int> v2);
    int test_func (in<int> v1, inout<string> v2);
};


C＋＋有许多工具、库来做到这点，但是，都需要生成一堆代码，很是不爽。

其它语言，比如python, java, c#等，都可以通过自省机制，抛开IDL在语言内实现。

C＋＋并非不能做这个，它只是缺少足够的类型信息。比如上面的例子，如果要发布为服务，那么至少应该把它的参数、返回值搞得明确些，否则要么会造成不必要的参数传递，要么会产生错误（把OUT参数取值可不是安全的）。

比如上面出现的int, int&, int*，在作为in参数时，我们是想传递它的值，类型为int。而int*和string*作为out参数时，我们想让它传递指针或引用，当调用返回时，我们给它赋值。

C＋＋语言的类型极为丰富，却没有描述一个参数到底是in还是out。java也没有，但它可以正常序列化一个null值，在C＋＋中，这可能存在一些麻烦。

再考虑一下char*类型，假如它是in参数，那么它是要传递一个字符还是一个字符串？C＋＋语言没有对它进行描述。

所以要实现一个分布式服务包装（或代理）库，必须让发布者提供这些信息。

我们知道，要查询一个远程服务，必须查询相应主机端口，获取服务信息。最简单的服务信息包括：服务列表，每个服务中的方法列表，方法的类型（包括参数和返回值类型，in/out信息等）。

实际上，我们是要为C＋＋增加一些简单的自省能力。上面那个服务发布接口，实际上离这个要求还有很远，再来看一下：

struct TestService
{
    void test1 (in<int> v1, in<int> v2);
    int test2 (in<int> v1, out<int> v2);
    int test_func (in<int> v1, inout<string> v2);
};


可以想见，它是没有一点自省能力的，我们如何向它查询，它的名字？它的方法列表？方法的类型？它如何与Test类的成员函数以及test_func函数关联？

二、方向。

要让上面那个服务具有自省能力，要做的扩充其实并不多。考虑下面的代码：

struct TestService : public Service
{
    TestService ();
    Method <void(in<int>, in<int>)> test1;
    Method <int(in<int>, out<int>)> test2;
    Method <int(in<int>, inout<string>) test_func;
};


这几个Method可以用自己写的委托类来做。

1、假如我们在TestService的构造函数里给它分配一个“TestService”名字，并且Service类实现了查询名字的接口，那么它就知道它自己的名字了。

2、假如在TestService的构造函数里为各个Method分配名字，并且注册到TestService，那么它就能够查询方法列表。

3、方法的类型？通过模板方式，把各个参数类型收集起来，给个字符串名称就可以了。

使用宏来实现，大概可以写成这样：

BEGIN_SERVICE (TestService)
    METHOD (void(in<int>, in<int>), test1, &Test::test1)
    METHOD (int(in<int>, out<int>), test2, &Test::test2)
    METHOD (int<in<int>, inout<string>), test_func, test_func)
END_SERVICE ()


通过上面这几个宏，我们能够生成TestService声明。

不过，有几个问题，罗列如下，并一一解决它：

1、如何把函数指针传给它？如何把方法名称传给它？
这个只是C＋＋语言为我们增加了一些麻烦，我们无法在定义成员的地方调用它的构造函数，不过这并不会造成多大障碍。
上面的METHOD宏如果只是生成类的声明，那么函数指针可以省略。我把它加上的原因是，它可以被我用Ctrl+C, Ctrl+V这种世界上最先进的技术原样拷贝下来，并且通过简单修改的方法实现这种世界上最先进的重用。

上面的代码经过修改，结果就成这样：

BEGIN_SERVICE (TestService)
    METHOD (void(in<int>, in<int>), test1, &Test::test1)
    METHOD (int(in<int>, out<int>), test2, &Test::test2)
    METHOD (int<in<int>, inout<string>), test_func, test_func)

    BEGIN_DEFINE (TestService)
        METHOD_DEFINE (void(in<int>, in<int>), test1, &Test::test1)
        METHOD_DEFINE(int(in<int>, out<int>), test2, &Test::test2)
        METHOD_DEFINE(int(in<int>, inout<string>), test_func, test_func)
    END_DEFINE ()

END_SERVICE ()


看上去对应得非常整齐，修改起来也比较简单。上面那部分被扩充为如下代码：

struct TestService : public Service
{
    Method <void(in<int>, in<int>)> test1;
    Method <int(in<int>, out<int>)> test2;
    Method <int(in<int>, inout<string>) test_func;
    TestService ()
    : Service ("TestService")
    {
        test1.setName ("test1");
        test1.setMethod (&Test::test1);
        this->registerMethod (&test1);
        test2.setName ("test2");
        test2.setMethod (&Test::test2);
        this->registerMethod (&test2);
        test_func.setName ("test_func");
        test_func.setMethod (test_func);
        this->registerMethod (&test3);
    }
};


基本上需要的东西都在这里了。

2、客户端的问题。

上面这种映射，直接拿到客户端会有问题，Test类和test_func函数我们并不打算交给客户端，所以使用函数指针会出现链接错误。

实际上客户端不需要这个，我们想办法把它拿掉就行了。客户端实际需要生成的代码如下：

struct TestService : public Service
{
    Method <void(in<int>, in<int>)> test1;
    Method <int(in<int>, out<int>)> test2;
    Method <int(in<int>, inout<string>) test_func;
    TestService ()
    : Service ("TestService")
    {
        test1.setName ("test1");
        this->registerMethod (&test1);
        test2.setName ("test2");
        this->registerMethod (&test2);
        test_func.setName ("test_func");
        this->registerMethod (&test3);
    }
};


还是上面提到的，C++给我们带来的麻烦。这次需要另一组宏来完成它：

BEGIN_SERVICE_D (TestService)
    METHOD_D (void(in<int>, in<int>), test1)
    METHOD_D (int(in<int>, out<int>), test2)
    METHOD_D (int(in<int>, inout<string>), test_func)

    BEGIN_DEFINE_D (TestService)
        METHOD_DEFINE_D (void(in<int>, in<int>), test1)
        METHOD_DEFINE_D(int(in<int>, out<int>), test2)
        METHOD_DEFINE_D(int(in<int>, inout<string>), test_func)
    END_DEFINE_D ()

END_SERVICE_D ()


METHOD*和METHOD_DEFINE*宏的参数都有一些多余的信息，没有去掉是因为放在一起容易看到写错的地方。（这个技巧来源于前几天看的一篇BLOG，很报歉没有记下地址）

3、使用的问题。

如何才能比较方便地使用？我考虑了下面这种方式：

template <class T>
struct IProxy;

template <class T>
struct SOAPProxy;

SOAPProxy <TestService> service;
service.connect (5000, "localhost");
int a=0;
int *n = &a;
service.test1 (3, n);
service.test1 (3, *n);
service.test2 (3, n);
service.test2 (3, *n);
service.test2 (3, NONE);
//


Method::operator ()的各个参数都将可以接受相容的类型，像上面一样，因为在TestService中我们已经定义了它要传输的值的类型。

a.NONE是什么？其实是为异步调用考虑的。假如指定某个OUT参数为NONE，则这个参数的值并不真正的OUT，而是保存在Method中。实际上Method中保存每个参数的值。

b.Method与Service如何发生关系？
从TestService的定义中我们知道，Method向Service注册自己以实现自省，但它同时也会保存Service的指向。
我们的Proxy实际上是一个继承模板，上面并没有把它指出来。它的定义是：

template <class T>
class XProxy : public T
{
    //
};


所以我们的TestService其实也是模板类，它将使用XProxy中定义的序列化类。XProxy将实现Service基类中序列化虚函数以及调用虚函数。

当一个Method调用时，它会调用Service的序列化，由于被重写了，所以调用的是XProxy中的序列化方法。这个方法会把这个Method的各in/inout参数序列化，然后执行远程调用，再把调用结果反序列化给inout/out参数。

4、其它想法。

在考虑上面的定义方式时，我也考虑了其它方式，主要是返回值处理的方法，简述如下。

前面我们假设了一段将被开放为远程服务的代码：

struct Test
{
    void test1 (/*in*/ int v1, /*in*/ int* v2);
    int test2 (/*in*/ int& v1, /*out*/ int* v2);
};

int test_func (/*in*/ int* v1, /*inout*/ string* v2);


在前面的做法中，我们的服务描述是放在那一组宏里面，好处是不用改这段代码，坏处就是代码定义的地方和描述不在一起，协调可能会有一些不便。

我也考虑了另一种做法：

struct Test
{
    idl <void(in<int>, in<int>)> test1 (int v1, int* v2);
    idl <int(in<int>, out<int>)> test2 (int& v1, int* v2);
};

idl <int(in<int>, inout<string>) test_func int* v1, string* v2);


对于实现代码，只需要修改返回值为void的函数，把return;修改为return VOID;，并且为没有写此语句的分支加上此句。

VOID是一个特殊类型的静态变量，专为void返回值的函数设定。

这种做法修改了原有的代码，不过在定义服务时可以节省一些工作：

BEGIN_SERVICE (TestService)
    METHOD (test1, &Test::test1)
    METHOD (test2, &Test::test2)
    METHOD (test_func, test_func)

    BEGIN_DEFINE (TestService)
        METHOD_DEFINE (test1, &Test::test1)
        METHOD_DEFINE (test2, &Test::test2)
        METHOD_DEFINE (test_func, test_func)
    END_DEFINE ()

END_SERVICE ()


它所需要的函数类型，将由函数指针推导。

在G＋＋编译器下，可以使用typeof来获得函数指针的类型而不需要真得获得函数指针值，不过目前仅仅在G＋＋下可用。（顺便说一下，typeof已经列入c++0x）

最终我放弃了这个想法，毕竟它要修改现有的代码，某些情况下这是不可能的，而且typeof目前也不能跨编译器。

三、实现。

老实说我现在还没有一份完整的或半完整的实现，大部分想法还在头脑中，测试代码倒是写了不少，主要是用来测试上述想法能否实现，我想大部分情况都已经测试了，只需要有时间来把它实现出来。

这是我近期要做的事之一，争取月内把它做完罢。



qiezi 2005-09-15 01:27 发表评论
]]>