Exemple #1
0
    def maybe_create_dqti(self, type_mgr, cpp_type_expr):
        undq_cpp_type_expr, dq = cpp_type_expr.get_undq()
        if dq.is_direct:
            spec = self.cpp_global_expr_to_spec.get(undq_cpp_type_expr)
            if spec:
                kl_global_name = spec.kl_global_name
                cpp_global_expr = spec.cpp_global_expr
                existing_kl_global_name = spec.existing_kl_global_name
                existing_kl_ext_name = spec.existing_kl_ext_name
                namespace = spec.namespace

                type_info_cache_key = kl_global_name
                type_info = self.type_info_cache.get(type_info_cache_key)
                if not type_info:
                    type_info = MirrorTypeInfo(
                        self.jinjenv, kl_global_name, cpp_global_expr,
                        existing_kl_global_name, existing_kl_ext_name,
                        Record(
                            namespace,
                            include_empty_ctor=False,
                            include_copy_ctor=False,
                            include_simple_ass_op=False,
                            include_getters_setters=False,
                            include_dtor=False,
                        ))
                    self.type_info_cache.setdefault(type_info_cache_key,
                                                    type_info)
                    self.ext.add_decl(MirrorBuiltinDecl(self.ext, type_info))

                return DirQualTypeInfo(dq, type_info)
Exemple #2
0
 def maybe_create_dqti(self, type_mgr, cpp_type_expr):
     undq_cpp_type_expr, dq = cpp_type_expr.get_undq()
     if dq.is_direct:
         kl_type_name = undq_cpp_type_expr.get_kl_desc()
         record = Record(
             self.ext.root_namespace,
             child_namespace_component=undq_cpp_type_expr.components[0],
             child_namespace_kl_name=kl_type_name,
         )
         type_mgr.named_selectors['owned'].register(
             kl_type_name=kl_type_name,
             kl_type_name_for_derivatives=kl_type_name,
             cpp_type_expr=undq_cpp_type_expr,
             extends=None,
             record=record,
         )
         return True  # restart
Exemple #3
0
    def maybe_create_dqti(self, type_mgr, cpp_type_expr):
        undq_cpp_type_expr, dq = cpp_type_expr.get_undq()
        if dq.is_direct \
          and isinstance(undq_cpp_type_expr, Named) \
          and len(undq_cpp_type_expr.components) == 2 \
          and undq_cpp_type_expr.components[0] == Simple("std") \
          and isinstance(undq_cpp_type_expr.components[1], Template) \
          and undq_cpp_type_expr.components[1].name == "vector" \
          and len(undq_cpp_type_expr.components[1].params) == 1:
            element_type_info = type_mgr.get_dqti(
                undq_cpp_type_expr.components[1].params[0]).type_info
            element_cpp_type_name = element_type_info.lib.name.compound
            element_kl_type_name = element_type_info.kl.name.compound
            element_type_info_for_derivatives = element_type_info.for_derivatives(
            )
            element_cpp_type_name_for_derivatives = element_type_info_for_derivatives.lib.name.compound
            element_kl_type_name_for_derivatives = element_type_info_for_derivatives.kl.name.compound
            kl_type_name = element_kl_type_name + '_StdVector'
            record = Record(
                self.ext.root_namespace,
                child_namespace_component=undq_cpp_type_expr.components[0],
                child_namespace_kl_name=kl_type_name,
            )
            record.add_ctor([])
            record.add_ctor(['size_t'])
            record.add_ctor([
                element_cpp_type_name + ' const *',
                element_cpp_type_name + ' const *'
            ])
            record.add_const_method('size', 'size_t')
            record.add_mutable_method('reserve', None, ['size_t'])
            record.add_mutable_method('push_back', None,
                                      [element_cpp_type_name])
            record.add_get_ind_op(element_cpp_type_name + ' const &')
            record.add_set_ind_op(element_cpp_type_name + ' const &')
            record.add_mutable_method('pop_back')
            record.add_kl(
                """
{{type_name}}({{element_type_name}} array<>) {
  this = {{type_name}}(
    {{element_type_name_for_derivatives}}_CxxConstPtr(array, 0),
    {{element_type_name_for_derivatives}}_CxxConstPtr(array, array.size())
    );
}

{{type_name}} Make_{{type_name}}({{element_type_name}} array<>) {
  return {{type_name}}(array);
}

inline {{element_type_name}}[] Make_{{element_type_name}}_VariableArray({{type_name}} vec) {
  UInt32 size = UInt32(vec.size());
  {{element_type_name}} result[];
  result.reserve(size);
  for (Index i = 0; i < size; ++i)  {
    {{element_type_name_for_derivatives}}_CxxConstRef ptr = vec.cxxGetAtIndex(i);
    result.push(ptr.cxxGet());
  }
  return result;
}

{{type_name}}.appendDesc(io String string) {
  string += "{{type_name}}:[";
  UInt64 count = this.size();
  for (UInt64 index = 0; index < count; ++index) {
    if (index > 0 )
      string += ",";
    if (index == 32) {
      string += "...";
      break;
    }
    string += this.cxxGetAtIndex(index);
  }
  string += "]";
}
""",
                element_type_name=element_kl_type_name,
                element_type_name_for_derivatives=
                element_kl_type_name_for_derivatives,
            )
            type_mgr.named_selectors['owned'].register(
                kl_type_name=kl_type_name,
                kl_type_name_for_derivatives=kl_type_name,
                cpp_type_expr=undq_cpp_type_expr,
                extends=None,
                record=record,
            )
            return True  # restart
Exemple #4
0
 def maybe_create_dqti(self, type_mgr, cpp_type_expr):
     undq_cpp_type_expr, dq = cpp_type_expr.get_undq()
     if dq.is_direct \
       and isinstance(undq_cpp_type_expr, Named) \
       and len(undq_cpp_type_expr.components) == 2 \
       and undq_cpp_type_expr.components[0] == Simple("std") \
       and isinstance(undq_cpp_type_expr.components[1], Template) \
       and undq_cpp_type_expr.components[1].name == "set" \
       and len(undq_cpp_type_expr.components[1].params) == 1:
         element_type_info = type_mgr.get_dqti(
             undq_cpp_type_expr.components[1].params[0]).type_info
         element_cpp_type_name = element_type_info.lib.name.compound
         element_kl_type_name = element_type_info.kl.name.compound
         kl_type_name = element_kl_type_name + '_StdSet'
         record = Record(
             self.ext.root_namespace,
             child_namespace_component=undq_cpp_type_expr.components[0],
             child_namespace_kl_name=kl_type_name,
         )
         record.add_ctor([])
         record.add_const_method('count', 'size_t',
                                 [element_cpp_type_name + ' const &'])
         record.add_mutable_method('clear')
         record.add_mutable_method('insert', None,
                                   [element_cpp_type_name + ' const &'])
         record.add_mutable_method('erase', None,
                                   [element_cpp_type_name + ' const &'])
         type_mgr.named_selectors['owned'].register(
             kl_type_name=kl_type_name,
             kl_type_name_for_derivatives=kl_type_name,
             cpp_type_expr=undq_cpp_type_expr,
             extends=None,
             record=record,
         )
         return True  # restart
Exemple #5
0
    def maybe_create_dqti(self, type_mgr, cpp_type_expr):
        undq_cpp_type_expr, dq = cpp_type_expr.get_undq()
        if dq.is_direct and undq_cpp_type_expr == self.cpp_type_expr:
            kl_type_name = 'CxxStdString'
            record = Record(
                self.ext.root_namespace,
                child_namespace_component=undq_cpp_type_expr.components[0],
                child_namespace_kl_name=kl_type_name,
                is_kludge_ext=True,
            )
            record.add_ctor([])
            record.add_ctor(['char const *'], dont_promote=True)
            record.add_ctor(['char const *', 'size_t'])
            record.add_ctor(['char const *', 'char const *'])
            record.add_const_method('c_str', 'char const *')
            record.add_const_method('data', 'char const *', kl_name='cxxData')
            record.add_const_method('size', 'size_t')
            record.add_mutable_method('clear')
            record.add_mutable_method('append', None,
                                      ['char const *', 'char const *'])
            record.add_get_ind_op('char')
            record.add_set_ind_op('char')
            record.add_mutable_method('push_back', None, ['char'])
            record.add_kl("""
/// \dfgPresetOmit
/// \internal
inline {{type_name}}(String string) {
  CxxChar array<>(string.data(), string.length());
  this = {{type_name}}(CxxCharConstPtr(array, 0), CxxCharConstPtr(array, string.length()));
}

/// \dfgPresetOmit
/// \internal
inline {{type_name}} Make_{{type_name}}(String string) {
  return {{type_name}}(string);
}

/// Convert to a string
/// \dfgPresetOmit
/// \internal
{{type_name}}.appendDesc(io String string) {
  CxxCharConstPtr ptr = this.cxx_c_str();
  string += String(ptr);
}
""")
            type_mgr.named_selectors['owned'].register(
                kl_type_name=kl_type_name,
                kl_type_name_for_derivatives=kl_type_name,
                cpp_type_expr=undq_cpp_type_expr,
                extends=None,
                record=record,
                simplifier=StdStringTypeSimplifier(),
                is_kludge_ext=True,
            )
            return True  # restart