def make_object_class_inline(self, is_connection, class_name=""): member = "" method_name = self.name if not is_connection: member = "resource(),\n" method_name = replace_class(method_name, class_name) if self.is_void: return _inline_void_class(self.request_name, method_name, member, get_namespace(self.namespace)) else: return _inline_reply_class(self.request_name, method_name, member, get_namespace(self.namespace))
def __init__(self, request, name, is_void, namespace, reply): self.request = request self.name = name self.request_name = _ext(_n_item(self.request.name[-1])) self.is_void = is_void self.namespace = namespace self.reply = reply self.c_namespace = \ "" if namespace.header.lower() == "xproto" \ else get_namespace(namespace) self.accessors = [] self.parameter_list = ParameterList() self.c_name = "xcb" \ + (("_" + get_namespace(namespace)) if namespace.is_ext else "") \ + "_" + self.request_name
def make_class(self): # if not self.namespace.is_ext: # return "" # else: ns = get_namespace(self.namespace) if self.namespace.is_ext: base = "\n : public xpp::generic::extension<extension, &xcb_%s_id>\n" % ns ctor = " using base = xpp::generic::extension<extension, &xcb_%s_id>;\n" % ns + \ " using base::base;\n" else: base = " " ctor = "" return \ '''\ template<typename Derived, typename Connection> class interface; namespace event { template<typename Connection> class dispatcher; }; namespace error { class dispatcher; }; class extension%s{ public: %s\ template<typename Derived, typename Connection> using interface = xpp::%s::interface<Derived, Connection>; template<typename Connection> using event_dispatcher = xpp::%s::event::dispatcher<Connection>; using error_dispatcher = xpp::%s::error::dispatcher; };\ ''' % (base, ctor, ns, # typedef xpp::interface::%s interface; ns, # typedef xpp::event::dispatcher::%s dispatcher; ns) # typedef xpp::error::dispatcher::%s dispatcher;
def get_abstract_enum(node, tu, scf_path): enum_constant_nodes = matchers.get_children(node, lambda n: n.kind == CursorKind.ENUM_CONSTANT_DECL) full_namespace = utils.get_namespace(node) constants = [generic.EnumConstant(cons.spelling, cons.enum_value) for cons in enum_constant_nodes] return generic.DefinedEnum(name=node.spelling, namespace=full_namespace, constants=constants, \ defined_in_header=utils.get_header(node, tu, scf_path), \ location=_convert_location(node.location))
def get_abstract_entity(node, tu, scf_path, prev): ns = utils.get_namespace(node) full_name = ns + '::' + node.spelling if ns else node.spelling if any(full_name == p for p in prev): return generic.RecursiveType(node.spelling, ns) if node.kind == CursorKind.ENUM_DECL: return get_abstract_enum(node, tu, scf_path) else: return get_abstract_class(node, tu, scf_path, prev)
def __init__(self, namespace, is_void, name, reply, parameter_list): self.namespace = namespace self.is_void = is_void self.name = name self.reply = reply self.parameter_list = parameter_list self.request_name = _ext(_n_item(self.name[-1])) self.c_name = "xcb" \ + (("_" + get_namespace(namespace)) if namespace.is_ext else "") \ + "_" + self.request_name
def get_abstract_class(node, tu, scf_path, prev): ns = utils.get_namespace(node) full_name = ns + '::' + node.spelling if ns else node.spelling base_nodes = matchers.get_children(node, matchers.is_base_class()) base_type_infos = [utils.get_type_info(base_node.type, tu, scf_path) for base_node in base_nodes] base_classes = [_create_entity_info(base_type.name, base_node.type.spelling, \ def_node, template_class, tu, scf_path, prev + [full_name]) \ for (base_node, (base_type, def_node, template_class)) in zip(base_nodes, base_type_infos)] field_nodes = matchers.get_children(node, matchers.is_field()) fields = [_get_field_info(field_node, tu, scf_path, prev + [full_name]) for field_node in field_nodes] api_nodes = matchers.get_children(node, matchers.is_method()) apis = [_get_api(api_node, tu, scf_path, prev + [full_name]) for api_node in api_nodes] annotation = _get_annotation(node) template_args = [node.type.get_template_argument_type(i) for i in range(node.type.get_num_template_arguments())] if template_args: template_args_entities = [ generic.PrimitiveType( utils.get_primitive_type(templ_arg)) if utils.is_primitive(templ_arg) else get_abstract_entity(templ_arg.get_declaration(), tu, scf_path, prev + [full_name]) for templ_arg in template_args] header = utils.get_header(node, tu, scf_path) if header or not scf_path: return generic.DefinedClass(name=node.spelling, namespace=utils.get_namespace(node), template_args=template_args_entities, members=fields, methods=apis, bases=base_classes, defined_in_header=header, location=_convert_location(node.location), annotation=annotation) else: return generic.DeclaredClass(node.spelling, utils.get_namespace(node), template_args_entities, None) else: type_info, _, _ = utils.get_type_info(node.type, tu, scf_path) if type_info.header_with_def or not scf_path: return generic.DefinedClass(name=type_info.name, namespace=type_info.namespace, template_args=[], members=fields, methods=apis, bases=base_classes, defined_in_header=type_info.header_with_def, location=_convert_location(node.location), annotation=annotation) else: return generic.DeclaredClass(type_info.name, type_info.namespace, [], None)
def __init__(self, namespace, name, cookie, reply, accessors, parameter_list): self.namespace = namespace self.name = name self.reply = reply self.cookie = cookie self.accessors = accessors self.parameter_list = parameter_list self.request_name = _ext(_n_item(self.name[-1])) self.c_name = "xcb" \ + (("_" + get_namespace(namespace)) if namespace.is_ext else "") \ + "_" + self.request_name
def error_dispatcher_class(namespace, cpperrors): ns = get_namespace(namespace) ctor_name = "dispatcher" typedef = [] ctors = [] members = [] opcode_switch = "error->error_code" typedef = [ "typedef xpp::%s::extension extension;\n" % ns ] # >>> if begin <<< if namespace.is_ext: opcode_switch = "error->error_code - m_first_error" members += \ [ "protected:" , " uint8_t m_first_error;" ] ctors = \ [ "%s(uint8_t first_error)" % (ctor_name) , " : m_first_error(first_error)" , "{}" , "" , "%s(const xpp::%s::extension & extension)" % (ctor_name, ns) , " : %s(extension->first_error)" % ctor_name , "{}" ] # >>> if end <<< if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n" else: typedef = "" if len(ctors) > 0: ctors = "\n".join(map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n" else: ctors = "" if len(members) > 0: members = "\n".join(map(lambda s: " " + s, members)) + "\n" else: members = "" switch = error_switch_cases(cpperrors, opcode_switch, "error") return _error_dispatcher_class(typedef, ctors, switch, members, len(cpperrors) > 0)
def make_class(self): cppcookie = CppCookie(self.namespace, self.is_void, self.request.name, self.reply, self.parameter_list) if self.is_void: void_functions = cppcookie.make_void_functions() if len(void_functions) > 0: return void_functions else: return _void_request_function(get_namespace(self.namespace), self.request_name, self.c_name) else: cppreply = CppReply(self.namespace, self.request.name, cppcookie, self.reply, self.accessors, self.parameter_list) return cppreply.make() + "\n\n" + _reply_request_function(self.request_name)
def void_functions(self, protos, calls, template="", initializer=[]): inits = "" if len(initializer) > 0 else "\n" for i in initializer: inits += "\n" for line in i.split('\n'): inits += " " + line + "\n" return_value = "xcb_void_cookie_t" return _void_cookie_function(get_namespace(self.namespace), self.request_name, self.c_name, template, return_value, self.comma() + protos, self.comma() + calls, inits)
def make_class(self): cppcookie = CppCookie(self.namespace, self.is_void, self.request.name, self.reply, self.parameter_list) if self.is_void: void_functions = cppcookie.make_void_functions() if len(void_functions) > 0: return void_functions else: return _void_request_function(get_namespace(self.namespace), self.request_name, self.c_name) else: cppreply = CppReply(self.namespace, self.request.name, cppcookie, self.reply, self.accessors, self.parameter_list) return cppreply.make() + "\n\n" + _reply_request_function( self.request_name)
def make_proto(self): ns = get_namespace(self.namespace) methods = "" for request in self.requests: methods += request.make_object_class_inline(True) + "\n\n" typedef = [] if self.namespace.is_ext: typedef = ["typedef xpp::%s::extension extension;" % ns] if len(typedef) > 0: typedef = "".join([" " + s for s in typedef]) + "\n\n" else: typedef = "" return (_templates['interface_class'] \ % (typedef, ns, methods)) + \ '\n' + event_dispatcher_class(self.namespace, self.events) + \ '\n' + error_dispatcher_class(self.namespace, self.errors)
def make_proto(self): ns = get_namespace(self.namespace) methods = "" for request in self.requests: methods += request.make_object_class_inline(True) + "\n\n" typedef = [] if self.namespace.is_ext: typedef = [ "typedef xpp::%s::extension extension;" % ns ] if len(typedef) > 0: typedef = "".join(map(lambda s: " " + s, typedef)) + "\n\n" else: typedef = "" return (_templates['interface_class'] \ % (typedef, ns, methods)) + \ '\n' + event_dispatcher_class(self.namespace, self.events) + \ '\n' + error_dispatcher_class(self.namespace, self.errors)
def make_inline(self): ns = get_namespace(self.namespace) name = self.name.lower() c_name = self.c_name methods = "" for request in self.requests: methods += request.make_object_class_inline(False, self.name.lower()) + "\n\n" if methods == "": return "" else: return \ """\ template<typename Derived, typename Connection> class %s { protected: Connection connection(void) const { return static_cast<const Derived *>(this)->connection(); } const %s & resource(void) const { return static_cast<const Derived *>(this)->resource(); } public: virtual ~%s(void) {} %s }; // class %s """ % (name, # class %s c_name, # %s resource(void) { ... } name, # virtual ~%s(void) methods, name) # }; // class %s
def make(self): accessors = [self.make_accessors()] naccessors = len(self.accessors) for field in self.reply.fields: if (field.field_type[-1] in _resource_classes and not field.type.is_list and not field.type.is_container): naccessors = naccessors + 1 name = field.field_name.lower() c_type = field.c_field_type template_type = field.field_name.capitalize() accessors.append(_reply_member_accessor(self.request_name, name, c_type, template_type)) result = "" result += _reply_class( self.request_name, self.c_name, get_namespace(self.namespace), self.cookie, "\n".join(accessors)) return result
def ns_attributes(self): prefix_omit = set() ns_omit = list(self.ns_omit) root = self.element.getroottree().getroot() if root is None or utils.get_namespace(root) == config.META_NS: ns_omit.append("http://www.w3.org/1999/xhtml") prefix_omit = set() namespaces = self.element.nsmap.values() parent = self.element.getparent() while parent is not None: for prefix, ns in parent.nsmap.items(): if ns in namespaces: prefix_omit.add(prefix) parent = parent.getparent() attrs = dict(((prefix and "xmlns:%s" % prefix or "xmlns", ns) for (prefix, ns) in self.element.nsmap.items() if ns not in ns_omit and prefix not in prefix_omit)) return attrs
def ns_attributes(self): prefix_omit = set() ns_omit = list(self.ns_omit) root = self.element.getroottree().getroot() if root is None or utils.get_namespace(root) == config.META_NS: ns_omit.append("http://www.w3.org/1999/xhtml") prefix_omit = set() namespaces = self.element.nsmap.values() parent = self.element.getparent() while parent is not None: for prefix, ns in parent.nsmap.items(): if ns in namespaces: prefix_omit.add(prefix) parent = parent.getparent() attrs = dict( ((prefix and "xmlns:%s" % prefix or "xmlns", ns) for (prefix, ns) in self.element.nsmap.items() if ns not in ns_omit and prefix not in prefix_omit)) return attrs
def make_class(self): ns = get_namespace(self.namespace) typedef = [] members = [] opcode_accessor = \ [ "static uint8_t opcode(void)" , "{" , " return %s;" % self.opcode_name , "}" ] if self.namespace.is_ext: opcode_accessor += \ [ "" , "static uint8_t opcode(uint8_t first_error)" , "{" , " return first_error + opcode();" , "}" , "" , "static uint8_t opcode(const xpp::%s::extension & extension)" % ns , "{" , " return opcode(extension->first_error);" , "}" ] members = \ [ "protected:" , " uint8_t m_first_error;" ] if len(opcode_accessor) > 0: opcode_accessor = "\n".join(map(lambda s: " " + s, opcode_accessor)) + "\n" else: opcode_accessor = "" if len(members) > 0: members = "\n" + "\n".join(map(lambda s: " " + s, members)) + "\n" else: members = "" if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n" else: typedef = "" name = self.name if self.name in _reserved_keywords: name = self.name + "_" return \ ''' namespace error { class %s : public xpp::generic::error<%s, %s> { public: %s\ using xpp::generic::error<%s, %s>::error; virtual ~%s(void) {} %s static std::string description(void) { return std::string("%s"); } %s\ }; // class %s }; // namespace error ''' % (self.get_name(), # class %s self.get_name(), # : public xpp::generic::error<%s, self.c_name, # %s> typedef, self.get_name(), self.c_name, # using xpp::generic::error<%s, %s>::error; self.get_name(), # virtual ~%s(void) {} opcode_accessor, self.opcode_name, # static constexpr const char * opcode_literal members, self.get_name()) # // class %s
def set_namespace(self, namespace): self.namespace = namespace name = (get_namespace(namespace) + "_") if namespace.is_ext else "" self.c_name = "xcb_%s_t" % (name + self.name.lower())
def event_dispatcher_class(namespace, cppevents): ns = get_namespace(namespace) ctor_name = "dispatcher" typedef = [] ctors = [] members = [] opcode_switch = "event->response_type & ~0x80" typedef = [ "typedef xpp::%s::extension extension;\n" % ns ] members = \ [ "protected:" , " Connection m_c;" ] ctors = \ [ "template<typename C>" , "%s(C && c)" % ctor_name , " : m_c(std::forward<C>(c))" , "{}" ] # >>> if begin <<< if namespace.is_ext: opcode_switch = "(event->response_type & ~0x80) - m_first_event" members += [ " uint8_t m_first_event;" ] ctors = \ [ "template<typename C>" , "%s(C && c, uint8_t first_event)" % (ctor_name) , " : m_c(std::forward<C>(c))" , " , m_first_event(first_event)" , "{}" , "" , "template<typename C>" , "%s(C && c, const xpp::%s::extension & extension)" % (ctor_name, ns) , " : %s(std::forward<C>(c), extension->first_event)" % ctor_name , "{}" ] # >>> if end <<< if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n" else: typedef = "" if len(ctors) > 0: ctors = "\n".join(map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n" else: ctors = "" if len(members) > 0: members = "\n".join(map(lambda s: " " + s, members)) + "\n" else: members = "" switch = event_switch_cases(cppevents, opcode_switch, "handler", "event", namespace) return _event_dispatcher_class(typedef, ctors, switch, members, len(cppevents) > 0)
def make_class(self): member_accessors = [] member_accessors_special = [] for field in self.fields: if field.field_type[-1] in _resource_classes: template_name = field.field_name.capitalize() c_type = field.c_field_type method_name = field.field_name.lower() if (method_name == self.get_name() or method_name in _reserved_keywords): method_name += "_" member = field.c_field_name member_accessors.append(_field_accessor_template(c_type, method_name, member)) ns = get_namespace(self.namespace) extension = "xpp::%s::extension" % ns ctor = \ [ "template<typename C>" , "%s(C && c," % self.get_name() , (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)" , " : base(event)" , " , m_c(std::forward<C>(c))" , "{}" ] m_first_event = "" typedef = [ "typedef xpp::%s::extension extension;" % ns ] description = \ [ "static std::string description(void)" , "{" , " return std::string(\"%s\");" % self.opcode_name , "}" ] opcode_accessor = \ [ "static uint8_t opcode(void)" , "{" , " return %s;" % self.opcode_name , "}" ] first_event = [] if self.namespace.is_ext: opcode_accessor += \ [ "" , "static uint8_t opcode(uint8_t first_event)" , "{" , " return first_event + opcode();" , "}" , "" , "static uint8_t opcode(const xpp::%s::extension & extension)" % ns , "{" , " return opcode(extension->first_event);" , "}" ] first_event = \ [ "uint8_t first_event(void)" , "{" , " return m_first_event;" , "}" ] ctor = \ [ "template<typename C>" , "%s(C && c," % self.get_name() , (" " * len(self.get_name())) + " uint8_t first_event," , (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)" , " : base(event)" , " , m_c(std::forward<C>(c))" , " , m_first_event(first_event)" , "{}" ] m_first_event = " const uint8_t m_first_event;\n" if len(opcode_accessor) > 0: opcode_accessor = "\n".join(map(lambda s: " " + s, opcode_accessor)) + "\n" else: opcode_accessor = "" if len(ctor) > 0: ctor = "\n".join(map(lambda s: " " + s, ctor)) + "\n" else: ctor = "" if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n" else: typedef = "" if len(member_accessors) > 0: member_accessors = "\n" + "\n\n".join(member_accessors) + "\n\n" member_accessors_special = "\n" + "\n\n".join(member_accessors_special) + "\n\n" else: member_accessors = "" member_accessors_special = "" if len(description) > 0: description = "\n" + "\n".join(map(lambda s: " " + s, description)) + "\n" else: description = "" if len(first_event) > 0: first_event = "\n" + "\n".join(map(lambda s: " " + s, first_event)) + "\n" else: first_event = "" return \ ''' namespace event { template<typename Connection> class %s : public xpp::generic::event<%s> { public: %s\ typedef xpp::generic::event<%s> base; %s\ virtual ~%s(void) {} %s\ %s\ %s\ %s\ protected: Connection m_c; %s\ }; // class %s %s\ }; // namespace event ''' % (self.get_name(), # class %s self.c_name, # %s> typedef, self.c_name, # typedef xpp::generic::event<%s>::base; ctor, self.get_name(), # virtual ~%s(void) {} opcode_accessor, description, first_event, member_accessors, m_first_event, self.get_name(), # // class %s member_accessors_special)
def scoped_name(self): ns = get_namespace(self.namespace) return "xpp::" + ns + "::error::" + self.get_name()
def make_class(self): ns = get_namespace(self.namespace) typedef = [] members = [] opcode_accessor = \ [ "static uint8_t opcode(void)" , "{" , " return %s;" % self.opcode_name , "}" ] if self.namespace.is_ext: opcode_accessor += \ [ "" , "static uint8_t opcode(uint8_t first_error)" , "{" , " return first_error + opcode();" , "}" , "" , "static uint8_t opcode(const xpp::%s::extension & extension)" % ns , "{" , " return opcode(extension->first_error);" , "}" ] members = \ [ "protected:" , " uint8_t m_first_error;" ] if len(opcode_accessor) > 0: opcode_accessor = "\n".join(map(lambda s: " " + s, opcode_accessor)) + "\n" else: opcode_accessor = "" if len(members) > 0: members = "\n" + "\n".join(map(lambda s: " " + s, members)) + "\n" else: members = "" if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n" else: typedef = "" name = self.name if self.name in _reserved_keywords: name = self.name + "_" return \ ''' namespace error { class %s : public xpp::generic::error<%s, %s> { public: %s\ using xpp::generic::error<%s, %s>::error; virtual ~%s(void) {} %s static std::string description(void) { return std::string("%s"); } %s\ }; // class %s } // namespace error ''' % (self.get_name(), # class %s self.get_name(), # : public xpp::generic::error<%s, self.c_name, # %s> typedef, self.get_name(), self.c_name, # using xpp::generic::error<%s, %s>::error; self.get_name(), # virtual ~%s(void) {} opcode_accessor, self.opcode_name, # static constexpr const char * opcode_literal members, self.get_name()) # // class %s
def event_dispatcher_class(namespace, cppevents): ns = get_namespace(namespace) ctor_name = "dispatcher" typedef = [] ctors = [] members = [] opcode_switch = "event->response_type & ~0x80" typedef = ["typedef xpp::%s::extension extension;\n" % ns] members = \ [ "protected:" , " Connection m_c;" ] ctors = \ [ "template<typename C>" , "%s(C && c)" % ctor_name , " : m_c(std::forward<C>(c))" , "{}" ] # >>> if begin <<< if namespace.is_ext: opcode_switch = "(event->response_type & ~0x80) - m_first_event" members += [" uint8_t m_first_event;"] ctors = \ [ "template<typename C>" , "%s(C && c, uint8_t first_event)" % (ctor_name) , " : m_c(std::forward<C>(c))" , " , m_first_event(first_event)" , "{}" , "" , "template<typename C>" , "%s(C && c, const xpp::%s::extension & extension)" % (ctor_name, ns) , " : %s(std::forward<C>(c), extension->first_event)" % ctor_name , "{}" ] # >>> if end <<< if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n" else: typedef = "" if len(ctors) > 0: ctors = "\n".join( map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n" else: ctors = "" if len(members) > 0: members = "\n".join(map(lambda s: " " + s, members)) + "\n" else: members = "" switch = event_switch_cases(cppevents, opcode_switch, "handler", "event", namespace) return _event_dispatcher_class(typedef, ctors, switch, members, len(cppevents) > 0)
def make_class(self): member_accessors = [] member_accessors_special = [] for field in self.fields: if field.field_type[-1] in _resource_classes: template_name = field.field_name.capitalize() c_type = field.c_field_type method_name = field.field_name.lower() if (method_name == self.get_name() or method_name in _reserved_keywords): method_name += "_" member = field.c_field_name member_accessors.append( _field_accessor_template(c_type, method_name, member)) ns = get_namespace(self.namespace) extension = "xpp::%s::extension" % ns ctor = \ [ "template<typename C>" , "%s(C && c," % self.get_name() , (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)" , " : base(event)" , " , m_c(std::forward<C>(c))" , "{}" ] m_first_event = "" typedef = ["typedef xpp::%s::extension extension;" % ns] description = \ [ "static std::string description(void)" , "{" , " return std::string(\"%s\");" % self.opcode_name , "}" ] opcode_accessor = \ [ "static uint8_t opcode(void)" , "{" , " return %s;" % self.opcode_name , "}" ] first_event = [] if self.namespace.is_ext: opcode_accessor += \ [ "" , "static uint8_t opcode(uint8_t first_event)" , "{" , " return first_event + opcode();" , "}" , "" , "static uint8_t opcode(const xpp::%s::extension & extension)" % ns , "{" , " return opcode(extension->first_event);" , "}" ] first_event = \ [ "uint8_t first_event(void)" , "{" , " return m_first_event;" , "}" ] ctor = \ [ "template<typename C>" , "%s(C && c," % self.get_name() , (" " * len(self.get_name())) + " uint8_t first_event," , (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)" , " : base(event)" , " , m_c(std::forward<C>(c))" , " , m_first_event(first_event)" , "{}" ] m_first_event = " const uint8_t m_first_event;\n" if len(opcode_accessor) > 0: opcode_accessor = "\n".join( map(lambda s: " " + s, opcode_accessor)) + "\n" else: opcode_accessor = "" if len(ctor) > 0: ctor = "\n".join(map(lambda s: " " + s, ctor)) + "\n" else: ctor = "" if len(typedef) > 0: typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n" else: typedef = "" if len(member_accessors) > 0: member_accessors = "\n" + "\n\n".join(member_accessors) + "\n\n" member_accessors_special = "\n" + "\n\n".join( member_accessors_special) + "\n\n" else: member_accessors = "" member_accessors_special = "" if len(description) > 0: description = "\n" + "\n".join( map(lambda s: " " + s, description)) + "\n" else: description = "" if len(first_event) > 0: first_event = "\n" + "\n".join( map(lambda s: " " + s, first_event)) + "\n" else: first_event = "" return \ ''' namespace event { template<typename Connection> class %s : public xpp::generic::event<%s> { public: %s\ typedef xpp::generic::event<%s> base; %s\ virtual ~%s(void) {} %s\ %s\ %s\ %s\ protected: Connection m_c; %s\ }; // class %s %s\ }; // namespace event ''' % (self.get_name(), # class %s self.c_name, # %s> typedef, self.c_name, # typedef xpp::generic::event<%s>::base; ctor, self.get_name(), # virtual ~%s(void) {} opcode_accessor, description, first_event, member_accessors, m_first_event, self.get_name(), # // class %s member_accessors_special)
def scoped_name(self): ns = get_namespace(self.namespace) return "xpp::" + ns + "::event::" + self.get_name()