wrapture 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a6c087443d51b13a641bf0810c398c073415422de2a3a5cc715bc75ab265230
-  data.tar.gz: a2d2175fe6d0ffbdc5e1a878fda7c9ed3db8dd8d0ae8d2c88b143167bf76b0a8
+  metadata.gz: fb5e341af7e97543a1ee20d0a4d962f461372c5ef948de704c1508e346ca71c7
+  data.tar.gz: af4cf7f89111e459a866107ebc46823b81d6a4de0bbdd944a3b5294dc0ad9220
 SHA512:
-  metadata.gz: e722abc8af3af03e5e98189c034a3d60df5f1814776d127cee8be5bebdc9d87a1226f4b305e1b083da38c03a9ad239e98e1572b75f1b5bb9dd4d5bc5e93a95ea
-  data.tar.gz: e26c2a12e04af2b22172de83b31246846f6a73780a46987604748da9232b9191f5204c94ead1b3016db55b8c6b29e2d1e193629abfee0a1a18bd63d592e97f9f
+  metadata.gz: 9a3e8e31db51f492ab179bc047de225cd7db2ceb7156c1734ce45929cbce325f38abd40d54637c87839d0b0cc2bbf41ec8cf491d128e0a61a01aaafa724c6ef3
+  data.tar.gz: eb13f2975a79f0caf669b3a72408e9af1c61155598ce516c43d406e2b95f3016550724e2efe35766da6ebec0695d8052c2fa9b2149cedad87d0c89eab7672e44

data/bin/wrapture

@@ -5,9 +5,14 @@
 require 'yaml'
 require 'wrapture'
 
-spec = YAML.load_file ARGV[0]
+scope = Wrapture::Scope.new
 
-spec['classes'].each do |spec_hash|
-  class_spec = Wrapture::ClassSpec.new spec_hash
-  class_spec.generate_wrappers
+ARGV.each do |spec_file|
+  spec = YAML.load_file(spec_file)
+
+  spec['classes'].each do |class_spec|
+    Wrapture::ClassSpec.new(class_spec, scope: scope)
+  end
 end
+
+scope.generate_wrappers

data/lib/wrapture.rb

@@ -1,10 +1,33 @@
+# SPDX-License-Identifier: Apache-2.0
+
 # frozen_string_literal: true
 
-##
+# Copyright 2019 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 # Classes and functions for generating language wrappers
 module Wrapture
+  require 'wrapture/action_spec'
   require 'wrapture/constant_spec'
+  require 'wrapture/constants'
   require 'wrapture/class_spec'
+  require 'wrapture/errors'
   require 'wrapture/function_spec'
+  require 'wrapture/normalize'
+  require 'wrapture/rule_spec'
+  require 'wrapture/scope'
+  require 'wrapture/struct_spec'
   require 'wrapture/version'
+  require 'wrapture/wrapped_function_spec'
 end

data/lib/wrapture/action_spec.rb

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+# Copyright 2020 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'wrapture/constants'
+require 'wrapture/errors'
+
+module Wrapture
+  # An action to take within a generated program.
+  class ActionSpec
+    # Normalizes a hash specification of a rule. Normalization checks for
+    # invalid keys and unrecognized conditions.
+    def self.normalize_spec_hash(spec)
+      normalized = spec.dup
+
+      required_keys = %w[name constructor]
+
+      missing_keys = required_keys - spec.keys
+      unless missing_keys.empty?
+        missing_msg = "required keys are missing: #{missing_keys.join(', ')}"
+        raise(MissingSpecKey, missing_msg)
+      end
+
+      extra_keys = spec.keys - required_keys
+      unless extra_keys.empty?
+        extra_msg = "these keys are unrecognized: #{extra_keys.join(', ')}"
+        raise(InvalidSpecKey, extra_msg)
+      end
+
+      includes = Wrapture.normalize_includes(spec['constructor']['includes'])
+      normalized['constructor']['includes'] = includes
+
+      normalized
+    end
+
+    # Creates an action spec based on the provided spec hash.
+    #
+    # The hash must have the following keys:
+    # name:: the type of action to take (currently only throw-exception is
+    # supported)
+    # constructor:: the function to use to create the exception, described as a
+    # wrapped function call
+    def initialize(spec)
+      @spec = ActionSpec.normalize_spec_hash(spec)
+    end
+
+    # A list of includes needed for the action.
+    def includes
+      @spec['constructor']['includes'].dup
+    end
+
+    # A string containing the invocation of this action.
+    def take
+      call_spec = @spec['constructor']
+
+      params = call_spec['params'].map do |param_spec|
+        if param_spec['value'] == RETURN_VALUE_KEYWORD
+          'return_val'
+        else
+          param_spec['value']
+        end
+      end
+
+      "throw #{call_spec['name']}( #{params.join(', ')} )"
+    end
+  end
+end

data/lib/wrapture/class_spec.rb

@@ -1,203 +1,214 @@
+# SPDX-License-Identifier: Apache-2.0
+
 # frozen_string_literal: true
 
+# Copyright 2019-2020 Joel E. Anderson
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 require 'wrapture/constant_spec'
+require 'wrapture/constants'
 require 'wrapture/function_spec'
+require 'wrapture/normalize'
 
 module Wrapture
-  ##
   # A description of a class, including its constants, functions, and other
   # details.
   class ClassSpec
-    def self.typed_variable(type, name)
-      if type.end_with? '*'
-        "#{type}#{name}"
-      else
-        "#{type} #{name}"
-      end
-    end
+    # Normalizes a hash specification of a class. Normalization will check for
+    # things like invalid keys, duplicate entries in include lists, and will set
+    # missing keys to their default values (for example, an empty list if no
+    # includes are given).
+    #
+    # If this spec cannot be normalized, for example because it is invalid or
+    # it uses an unsupported version type, then an exception is raised.
+    def self.normalize_spec_hash(spec)
+      raise NoNamespace unless spec.key?('namespace')
 
-    def initialize(spec)
-      @spec = ClassSpec.normalize_spec_hash(spec)
+      normalized = spec.dup
+      normalized.default = []
 
-      @functions = []
-      @spec['functions'].each do |function_spec|
-        @functions << FunctionSpec.new(function_spec, self)
-      end
+      normalized['version'] = Wrapture.spec_version(spec)
+      normalized['includes'] = Wrapture.normalize_includes(spec['includes'])
+      normalized['type'] = ClassSpec.effective_type(normalized)
 
-      @constants = []
-      @spec['constants'].each do |constant_spec|
-        @constants << ConstantSpec.new(constant_spec)
+      if spec.key?('parent')
+        includes = Wrapture.normalize_includes(spec['parent']['includes'])
+        normalized['parent']['includes'] = includes
       end
-    end
 
-    def generate_wrappers
-      files = []
-      files << generate_declaration_file
-      files << generate_definition_file
+      normalized
     end
 
-    def resolve_param(param)
-      case param
-      when 'equivalent-struct'
-        equivalent_struct
-      when 'equivalent-struct-pointer'
-        equivalent_struct_pointer
-      else
-        param
+    # Gives the effective type of the given class spec hash.
+    def self.effective_type(spec)
+      inferred_pointer_wrapper = spec['constructors'].any? do |func|
+        func['wrapped-function']['return']['type'] == EQUIVALENT_POINTER_KEYWORD
       end
-    end
 
-    def function_call(spec)
-      resolved_params = []
+      if spec.key?('type')
+        valid_types = %w[pointer struct]
+        unless valid_types.include?(spec['type'])
+          type_message = "#{spec['type']} is not a valid class type"
+          raise InvalidSpecKey.new(type_message, valid_keys: valid_types)
+        end
 
-      spec['params'].each do |param|
-        resolved_params << resolve_param(param['name'])
+        spec['type']
+      elsif inferred_pointer_wrapper
+        'pointer'
+      else
+        'struct'
       end
-
-      "#{spec['name']}( #{resolved_params.join ', '} )"
     end
 
-    def self.normalize_spec_hash(spec)
-      normalized_spec = spec.dup
-      normalized_spec.default = []
-
-      normalized_spec['equivalent-struct']['members'] ||= []
-      normalized_spec['equivalent-struct']['includes'] ||= []
-
-      normalized_spec
+    # Returns a string of the variable with it's type, properly formatted.
+    def self.typed_variable(type, name)
+      "#{type}#{' ' unless type.end_with?('*')}#{name}"
     end
 
-    private
-
-    def header_guard
-      "__#{@spec['name'].upcase}_HPP"
-    end
+    # The underlying struct of this class.
+    attr_reader :struct
+
+    # Creates a class spec based on the provided hash spec.
+    #
+    # The scope can be provided if available.
+    #
+    # The hash must have the following keys:
+    # name:: the name of the class
+    # namespace:: the namespace to put the class into
+    # equivalent-struct:: a hash describing the struct this class wraps
+    #
+    # The following keys are optional:
+    # constructors:: a list of function specs that can create this class
+    # destructor:: a function spec for the destructor of the class
+    # functions:: a list of function specs
+    # constants:: a list of constant specs
+    def initialize(spec, scope: Scope.new)
+      @spec = ClassSpec.normalize_spec_hash(spec)
 
-    def declaration_includes
-      includes = @spec['equivalent-struct']['includes'].dup
+      @struct = StructSpec.new @spec[EQUIVALENT_STRUCT_KEYWORD]
 
-      @functions.each do |func|
-        includes.concat func.declaration_includes
-      end
+      @functions = @spec['constructors'].map do |constructor_spec|
+        full_spec = constructor_spec.dup
+        full_spec['name'] = @spec['name']
+        full_spec['params'] = constructor_spec['wrapped-function']['params']
 
-      @constants.each do |const|
-        includes.concat const.declaration_includes
+        FunctionSpec.new(full_spec, self, constructor: true)
       end
 
-      includes.uniq
-    end
+      if @spec.key?('destructor')
+        destructor_spec = @spec['destructor'].dup
+        destructor_spec['name'] = "~#{@spec['name']}"
 
-    def definition_includes
-      includes = ["#{@spec['name']}.hpp"]
+        @functions << FunctionSpec.new(destructor_spec, self, destructor: true)
+      end
 
-      @functions.each do |func|
-        includes.concat func.definition_includes
+      @spec['functions'].each do |function_spec|
+        @functions << FunctionSpec.new(function_spec, self)
       end
 
-      @constants.each do |const|
-        includes.concat const.definition_includes
+      @constants = @spec['constants'].map do |constant_spec|
+        ConstantSpec.new(constant_spec)
       end
 
-      includes.uniq
+      scope << self
+      @scope = scope
     end
 
-    def pointer_wrapper?
-      @spec['constructors'].each do |constructor_spec|
-        return_type = constructor_spec['wrapped-function']['return']['type']
+    # Returns a cast of an instance of this class to the provided type, if
+    # possible.
+    def cast_to(name, type)
+      struct = "struct #{@struct.name}"
 
-        return true if return_type == 'equivalent-struct-pointer'
+      if [EQUIVALENT_STRUCT_KEYWORD, struct].include?(type)
+        equivalent_struct(name)
+      elsif [EQUIVALENT_POINTER_KEYWORD, "#{struct} *"].include?(type)
+        equivalent_struct_pointer(name)
       end
-
-      false
     end
 
-    def equivalent_member(member)
-      if pointer_wrapper?
-        "this->equivalent->#{member}"
-      else
-        "this->equivalent.#{member}"
-      end
+    # The equivalent struct of this class from an instance of it.
+    def equivalent_struct(instance_name)
+      "#{'*' if pointer_wrapper?}#{instance_name}.equivalent"
     end
 
-    def equivalent_name
-      if pointer_wrapper?
-        '*equivalent'
-      else
-        'equivalent'
-      end
+    # A pointer to the equivalent struct of this class from an instance of it.
+    def equivalent_struct_pointer(instance_name)
+      "#{'&' unless pointer_wrapper?}#{instance_name}.equivalent"
     end
 
-    def equivalent_struct
-      if pointer_wrapper?
-        '*(this->equivalent)'
-      else
-        'this->equivalent'
-      end
+    # Generates the wrapper class declaration and definition files.
+    def generate_wrappers
+      [generate_declaration_file, generate_definition_file]
     end
 
-    def equivalent_struct_pointer
-      if pointer_wrapper?
-        'this->equivalent'
-      else
-        '&this->equivalent'
-      end
+    # The name of the class
+    def name
+      @spec['name']
     end
 
-    def wrapped_constructor_signature(index)
-      function_spec = @spec['constructors'][index]['wrapped-function']
-
-      "#{@spec['name']}( #{FunctionSpec.param_list function_spec} )"
+    # True if this class overloads the given one. A class is considered an
+    # overload if its parent is the given class, it has the same equivalent
+    # struct name, and the equivalent struct has a set of rules. The overloaded
+    # class cannot have any rules in its equivalent struct, or it will not be
+    # overloaded.
+    def overloads?(parent_spec)
+      return false unless parent_spec.struct.rules.empty?
+
+      parent_spec.struct.name == struct_name &&
+        parent_spec.name == parent_name &&
+        !@struct.rules.empty?
     end
 
-    def destructor_signature
-      "~#{@spec['name']}( void )"
+    # The name of the parent of this class, or nil if there is no parent.
+    def parent_name
+      @spec['parent']['name'] if @spec.key?('parent')
     end
 
-    def wrapped_constructor_definition(index)
-      constructor_spec = @spec['constructors'][index]
-      wrapped_function = constructor_spec['wrapped-function']
-
-      yield "#{@spec['name']}::#{wrapped_constructor_signature(index)}{"
-
-      result = resolve_param wrapped_function['return']['type']
-
-      yield "  #{result} = #{function_call wrapped_function};"
-
-      yield '}'
+    # The name of the equivalent struct of this class.
+    def struct_name
+      @struct.name
     end
 
-    def member_constructor_signature
-      params = []
-
-      @spec['equivalent-struct']['members'].each do |member|
-        params << ClassSpec.typed_variable(member['type'], member['name'])
+    # Gives a code snippet that accesses the equivalent struct from within the
+    # class using the 'this' keyword.
+    def this_struct
+      if pointer_wrapper?
+        '*(this->equivalent)'
+      else
+        'this->equivalent'
       end
-
-      "#{@spec['name']}( #{params.join ', '} )"
     end
 
-    def struct_constructor_signature
-      struct_name = @spec['equivalent-struct']['name']
-      "#{@spec['name']}( struct #{struct_name} equivalent )"
+    # Gives a code snippet that accesses the equivalent struct pointer from
+    # within the class using the 'this' keyword.
+    def this_struct_pointer
+      "#{'&' unless pointer_wrapper?}this->equivalent"
     end
 
-    def pointer_constructor_signature
-      struct_name = @spec['equivalent-struct']['name']
-      "#{@spec['name']}( struct #{struct_name} *equivalent )"
+    # Returns the ClassSpec for the given type in this class's scope.
+    def type(type)
+      @scope.type(type)
     end
 
-    def generate_declaration_file
-      filename = "#{@spec['name']}.hpp"
-
-      File.open(filename, 'w') do |file|
-        declaration_contents do |line|
-          file.puts line
-        end
-      end
-
-      filename
+    # Returns true if the given type exists in this class's scope.
+    def type?(type)
+      @scope.type?(type)
     end
 
+    private
+
+    # Gives the content of the class declaration to a block, line by line.
     def declaration_contents
       yield "#ifndef #{header_guard}"
       yield "#define #{header_guard}"
@@ -210,33 +221,32 @@ module Wrapture
       yield
       yield "namespace #{@spec['namespace']} {"
       yield
-      yield "  class #{@spec['name']} {"
+
+      parent = if @spec.key?('parent')
+                 ": public #{parent_name} "
+               else
+                 ''
+               end
+      yield "  class #{@spec['name']} #{parent}{"
+
       yield '  public:'
 
       yield unless @constants.empty?
       @constants.each do |const|
-        yield "  #{const.declaration};"
+        yield "    #{const.declaration};"
       end
 
       yield
-      struct_name = @spec['equivalent-struct']['name']
-      yield "    struct #{struct_name} #{equivalent_name};"
+      yield "    #{@struct.declaration equivalent_name};"
       yield
 
-      unless @spec['equivalent-struct']['members'].empty?
-        yield "    #{member_constructor_signature};"
-      end
+      member_constructor_declaration { |line| yield "    #{line}" }
 
-      unless pointer_wrapper?
-        yield "    #{struct_constructor_signature};"
-        yield "    #{pointer_constructor_signature};"
-      end
+      pointer_constructor_declaration { |line| yield "    #{line}" }
 
-      @spec['constructors'].each_index do |constructor|
-        yield "    #{wrapped_constructor_signature constructor};"
-      end
+      yield "    #{struct_constructor_signature};" unless pointer_wrapper?
 
-      yield "    #{destructor_signature};" if @spec.key? 'destructor'
+      overload_declaration { |line| yield "    #{line}" }
 
       @functions.each do |func|
         yield "    #{func.declaration};"
@@ -249,18 +259,26 @@ module Wrapture
       yield '#endif' # end of header guard
     end
 
-    def generate_definition_file
-      filename = "#{@spec['name']}.cpp"
+    # A list of includes needed for the declaration of the class.
+    def declaration_includes
+      includes = @spec['includes'].dup
 
-      File.open(filename, 'w') do |file|
-        definition_contents do |line|
-          file.puts line
-        end
+      includes.concat(@struct.includes)
+
+      @functions.each do |func|
+        includes.concat(func.declaration_includes)
       end
 
-      filename
+      @constants.each do |const|
+        includes.concat(const.declaration_includes)
+      end
+
+      includes.concat(@spec['parent']['includes']) if @spec.key?('parent')
+
+      includes.uniq
     end
 
+    # Gives the content of the class definition to a block, line by line.
     def definition_contents
       definition_includes.each do |include_file|
         yield "#include <#{include_file}>"
@@ -271,68 +289,217 @@ module Wrapture
 
       yield unless @constants.empty?
       @constants.each do |const|
-        yield "  #{const.definition @spec['name']};"
+        yield "  #{const.definition(@spec['name'])};"
       end
 
-      unless @spec['equivalent-struct']['members'].empty?
-        yield
-        yield "  #{@spec['name']}::#{member_constructor_signature} {"
+      member_constructor_definition { |line| yield "  #{line}" }
 
-        @spec['equivalent-struct']['members'].each do |member|
-          member_decl = equivalent_member member['name']
-          yield "    #{member_decl} = #{member['name']};"
-        end
-
-        yield '  }'
-      end
+      pointer_constructor_definition { |line| yield "  #{line}" }
 
       unless pointer_wrapper?
         yield
         yield "  #{@spec['name']}::#{struct_constructor_signature} {"
 
-        @spec['equivalent-struct']['members'].each do |member|
-          member_decl = equivalent_member member['name']
+        @struct.members.each do |member|
+          member_decl = this_member(member['name'])
           yield "    #{member_decl} = equivalent.#{member['name']};"
         end
 
         yield '  }'
+      end
+
+      overload_definition { |line| yield "  #{line}" }
 
+      @functions.each do |func|
         yield
-        yield "  #{@spec['name']}::#{pointer_constructor_signature} {"
 
-        @spec['equivalent-struct']['members'].each do |member|
-          member_decl = equivalent_member member['name']
-          yield "    #{member_decl} = equivalent->#{member['name']};"
+        func.definition(@spec['name']) do |def_line|
+          yield "  #{def_line}"
         end
+      end
 
-        yield '  }'
+      yield
+      yield '}' # end of namespace
+    end
+
+    # A list of includes needed for the definition of the class.
+    def definition_includes
+      includes = ["#{@spec['name']}.hpp"]
+
+      includes.concat(@spec['includes'])
+
+      @functions.each do |func|
+        includes.concat(func.definition_includes)
       end
 
-      @spec['constructors'].each_index do |constructor|
-        yield
-        wrapped_constructor_definition(constructor) do |line|
-          yield "  #{line}"
-        end
+      @constants.each do |const|
+        includes.concat(const.definition_includes)
       end
 
-      if @spec.key? 'destructor'
-        yield
-        yield "  #{@spec['name']}::#{destructor_signature} {"
-        func_spec = @spec['destructor']['wrapped-function']
-        yield "    #{function_call func_spec};"
-        yield '  }'
+      includes.concat(overload_definition_includes)
+
+      includes.uniq
+    end
+
+    # Gives the name of the equivalent struct.
+    def equivalent_name
+      "#{'*' if pointer_wrapper?}equivalent"
+    end
+
+    # Generates the declaration of the class.
+    def generate_declaration_file
+      filename = "#{@spec['name']}.hpp"
+
+      File.open(filename, 'w') do |file|
+        declaration_contents do |line|
+          file.puts(line)
+        end
       end
 
-      @functions.each do |func|
-        yield
+      filename
+    end
 
-        func.definition(@spec['name']) do |def_line|
-          yield "  #{def_line}"
+    # Generates the definition of the class.
+    def generate_definition_file
+      filename = "#{@spec['name']}.cpp"
+
+      File.open(filename, 'w') do |file|
+        definition_contents do |line|
+          file.puts(line)
         end
       end
 
+      filename
+    end
+
+    # The header guard for the class.
+    def header_guard
+      "__#{@spec['name'].upcase}_HPP"
+    end
+
+    # Yields the declaration of the member constructor for a class. This will be
+    # empty if the wrapped struct is a pointer wrapper.
+    def member_constructor_declaration
+      return unless @struct.members?
+
+      yield "#{@spec['name']}( #{@struct.member_list_with_defaults} );"
+    end
+
+    # Yields the definition of the member constructor for a class. This will be
+    # empty if the wrapped struct is a pointer wrapper.
+    def member_constructor_definition
+      return unless @struct.members?
+
+      yield "#{@spec['name']}::#{@spec['name']}( #{@struct.member_list} ) {"
+
+      @struct.members.each do |member|
+        member_decl = this_member(member['name'])
+        yield "  #{member_decl} = #{member['name']};"
+      end
+
+      yield '}'
+    end
+
+    # Yields the declaration of the overload function for this class. If there
+    # is no overload function for this class, then nothing is yielded.
+    def overload_declaration
+      return unless @scope.overloads?(self)
+
+      yield "static #{name} *new#{name}( struct #{@struct.name} *equivalent );"
+    end
+
+    # Yields each line of the definition of the overload function, with a
+    # leading empty yield. If there is no overload function for this class,
+    # then nothing is yielded.
+    def overload_definition
+      return unless @scope.overloads?(self)
+
       yield
-      yield '}' # end of namespace
+
+      parameter = "struct #{@struct.name} *equivalent"
+      yield "#{name} *#{name}::new#{name}( #{parameter} ) {"
+
+      line_prefix = '  '
+      @scope.overloads(self).each do |overload|
+        check = overload.struct.rules_check('equivalent')
+        yield "#{line_prefix}if( #{check} ) {"
+        yield "    return new #{overload.name}( equivalent );"
+        line_prefix = '  } else '
+      end
+
+      yield "#{line_prefix}{"
+      yield "    return new #{name}( equivalent );"
+      yield '  }'
+      yield '}'
+    end
+
+    # A list of the includes needed for the overload definitions.
+    def overload_definition_includes
+      @scope.overloads(self).map { |overload| "#{overload.name}.hpp" }
+    end
+
+    # Yields the declaration of the pointer constructor for a class.
+    #
+    # If there is already a constructor provided with this signature, then this
+    # function will return with no output.
+    def pointer_constructor_declaration
+      signature_prefix = "#{@spec['name']}( #{@struct.pointer_declaration('')}"
+      return if @functions.any? do |func|
+        func.constructor? && func.signature.start_with?(signature_prefix)
+      end
+
+      yield "#{pointer_constructor_signature};"
+    end
+
+    # Yields the definition of the pointer constructor for a class.
+    #
+    # If there is already a constructor provided with this signature, then this
+    # function will return with no output.
+    #
+    # If this is a pointer wrapper class, then the constructor will simply set
+    # the underlying pointer to the provied one, and return the new object.
+    #
+    # If this is a struct wrapper class, then a constructor will be created that
+    # sets each member of the wrapped struct to the provided value.
+    def pointer_constructor_definition
+      signature_prefix = "#{@spec['name']}( #{@struct.pointer_declaration('')}"
+      return if @functions.any? do |func|
+        func.constructor? && func.signature.start_with?(signature_prefix)
+      end
+
+      yield "#{@spec['name']}::#{pointer_constructor_signature} {"
+
+      if pointer_wrapper?
+        yield '  this->equivalent = equivalent;'
+      else
+        @struct.members.each do |member|
+          member_decl = this_member(member['name'])
+          yield "  #{member_decl} = equivalent->#{member['name']};"
+        end
+      end
+
+      yield '}'
+    end
+
+    # The signature of the constructor given an equivalent strucct pointer.
+    def pointer_constructor_signature
+      "#{@spec['name']}( #{@struct.pointer_declaration 'equivalent'} )"
+    end
+
+    # Determines if this class is a wrapper for a struct pointer or not.
+    def pointer_wrapper?
+      @spec['type'] == 'pointer'
+    end
+
+    # The signature of the constructor given an equivalent struct type.
+    def struct_constructor_signature
+      "#{@spec['name']}( #{@struct.declaration 'equivalent'} )"
+    end
+
+    # Gives a code snippet that accesses a member of the equivalent struct for
+    # this class within the class using the 'this' keyword.
+    def this_member(member)
+      "this->equivalent#{pointer_wrapper? ? '->' : '.'}#{member}"
     end
   end
 end