x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
closures.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\lambda\closures.hpp
旋转
特效
属性
历史版本
/*============================================================================= Adaptable closures Phoenix V0.9 Copyright (c) 2001-2002 Joel de Guzman Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) URL: http://spirit.sourceforge.net/ ==============================================================================*/ #ifndef PHOENIX_CLOSURES_HPP #define PHOENIX_CLOSURES_HPP /////////////////////////////////////////////////////////////////////////////// #include "boost/lambda/core.hpp" /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace lambda { /////////////////////////////////////////////////////////////////////////////// // // Adaptable closures // // The framework will not be complete without some form of closures // support. Closures encapsulate a stack frame where local // variables are created upon entering a function and destructed // upon exiting. Closures provide an environment for local // variables to reside. Closures can hold heterogeneous types. // // Phoenix closures are true hardware stack based closures. At the // very least, closures enable true reentrancy in lambda functions. // A closure provides access to a function stack frame where local // variables reside. Modeled after Pascal nested stack frames, // closures can be nested just like nested functions where code in // inner closures may access local variables from in-scope outer // closures (accessing inner scopes from outer scopes is an error // and will cause a run-time assertion failure). // // There are three (3) interacting classes: // // 1) closure: // // At the point of declaration, a closure does not yet create a // stack frame nor instantiate any variables. A closure declaration // declares the types and names[note] of the local variables. The // closure class is meant to be subclassed. It is the // responsibility of a closure subclass to supply the names for // each of the local variable in the closure. Example: // // struct my_closure : closure
{ // // member1 num; // names the 1st (int) local variable // member2 message; // names the 2nd (string) local variable // member3 real; // names the 3rd (double) local variable // }; // // my_closure clos; // // Now that we have a closure 'clos', its local variables can be // accessed lazily using the dot notation. Each qualified local // variable can be used just like any primitive actor (see // primitives.hpp). Examples: // // clos.num = 30 // clos.message = arg1 // clos.real = clos.num * 1e6 // // The examples above are lazily evaluated. As usual, these // expressions return composite actors that will be evaluated // through a second function call invocation (see operators.hpp). // Each of the members (clos.xxx) is an actor. As such, applying // the operator() will reveal its identity: // // clos.num() // will return the current value of clos.num // // *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB) // introduced and initilally implemented the closure member names // that uses the dot notation. // // 2) closure_member // // The named local variables of closure 'clos' above are actually // closure members. The closure_member class is an actor and // conforms to its conceptual interface. member1..memberN are // predefined typedefs that correspond to each of the listed types // in the closure template parameters. // // 3) closure_frame // // When a closure member is finally evaluated, it should refer to // an actual instance of the variable in the hardware stack. // Without doing so, the process is not complete and the evaluated // member will result to an assertion failure. Remember that the // closure is just a declaration. The local variables that a // closure refers to must still be instantiated. // // The closure_frame class does the actual instantiation of the // local variables and links these variables with the closure and // all its members. There can be multiple instances of // closure_frames typically situated in the stack inside a // function. Each closure_frame instance initiates a stack frame // with a new set of closure local variables. Example: // // void foo() // { // closure_frame
frame(clos); // /* do something */ // } // // where 'clos' is an instance of our closure 'my_closure' above. // Take note that the usage above precludes locally declared // classes. If my_closure is a locally declared type, we can still // use its self_type as a paramater to closure_frame: // // closure_frame
frame(clos); // // Upon instantiation, the closure_frame links the local variables // to the closure. The previous link to another closure_frame // instance created before is saved. Upon destruction, the // closure_frame unlinks itself from the closure and relinks the // preceding closure_frame prior to this instance. // // The local variables in the closure 'clos' above is default // constructed in the stack inside function 'foo'. Once 'foo' is // exited, all of these local variables are destructed. In some // cases, default construction is not desirable and we need to // initialize the local closure variables with some values. This // can be done by passing in the initializers in a compatible // tuple. A compatible tuple is one with the same number of // elements as the destination and where each element from the // destination can be constructed from each corresponding element // in the source. Example: // // tuple
init(123, "Hello", 1000); // closure_frame
frame(clos, init); // // Here now, our closure_frame's variables are initialized with // int: 123, char const*: "Hello" and int: 1000. // /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // // closure_frame class // /////////////////////////////////////////////////////////////////////////////// template
class closure_frame : public ClosureT::tuple_t { public: closure_frame(ClosureT& clos) : ClosureT::tuple_t(), save(clos.frame), frame(clos.frame) { clos.frame = this; } template
closure_frame(ClosureT& clos, TupleT const& init) : ClosureT::tuple_t(init), save(clos.frame), frame(clos.frame) { clos.frame = this; } ~closure_frame() { frame = save; } private: closure_frame(closure_frame const&); // no copy closure_frame& operator=(closure_frame const&); // no assign closure_frame* save; closure_frame*& frame; }; /////////////////////////////////////////////////////////////////////////////// // // closure_member class // /////////////////////////////////////////////////////////////////////////////// template
class closure_member { public: typedef typename ClosureT::tuple_t tuple_t; closure_member() : frame(ClosureT::closure_frame_ref()) {} template
struct sig { typedef typename detail::tuple_element_as_reference< N, typename ClosureT::tuple_t >::type type; }; template
// typename detail::tuple_element_as_reference //
::type Ret call(A&, B&, C&) const { assert(frame); return boost::tuples::get
(*frame); } private: typename ClosureT::closure_frame_t*& frame; }; /////////////////////////////////////////////////////////////////////////////// // // closure class // /////////////////////////////////////////////////////////////////////////////// template < typename T0 = null_type, typename T1 = null_type, typename T2 = null_type, typename T3 = null_type, typename T4 = null_type > class closure { public: typedef tuple
tuple_t; typedef closure
self_t; typedef closure_frame
closure_frame_t; closure() : frame(0) { closure_frame_ref(&frame); } closure_frame_t& context() { assert(frame); return frame; } closure_frame_t const& context() const { assert(frame); return frame; } typedef lambda_functor
> member1; typedef lambda_functor
> member2; typedef lambda_functor
> member3; typedef lambda_functor
> member4; typedef lambda_functor
> member5; private: closure(closure const&); // no copy closure& operator=(closure const&); // no assign template
friend struct closure_member; template
friend class closure_frame; static closure_frame_t*& closure_frame_ref(closure_frame_t** frame_ = 0) { static closure_frame_t** frame = 0; if (frame_ != 0) frame = frame_; return *frame; } closure_frame_t* frame; }; }} // namespace #endif
closures.hpp
网页地址
文件地址
上一页
4/13
下一页
下载
( 9 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.