wrapture 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67db9aad9a4383dca21f730d07b2af31642334204a66377167154a4849975005
-  data.tar.gz: de35dd304d427fe35f768567e58684a9217714ec01447c73a5961db1760b6ed1
+  metadata.gz: d8d17aaf86d72f9bb0c19ce28c34f1f869f4a1bff88e9312f712f607952f6fb8
+  data.tar.gz: cce93f31ba213f89d569470af45b35ece17976ad555946e9769e0f27dc7a7a19
 SHA512:
-  metadata.gz: 7afe9e387587d8efa3524566e9d9d4d2d9a87bc82fdcdb4995757c6d86a04eca17c452fee716c63681b84be536398beee5a4b429ec9f8fb34723e6650d72d219
-  data.tar.gz: 62d4696980ec04a870f32cdfc987340f840ba269601996b824db8f4e11f564fe5836943ee1e66cebb1c4e9776b052f7adb5b2eef0f7f92514b9622f1e900200b
+  metadata.gz: 249236b5ddda18f3e9d2c6e0254631484f93c665cb7c831df98bee58e3b39a7240eefba10b982ac48a972c9584b3a4e3fc84c338c3f1e166d8f19b905bfb8c04
+  data.tar.gz: 0ed25c495034eef0ea0cbbe3acaf88bb28b99a2a80453f9ab6fd2d9a698a4c208e01a09f6a37de144f5b05dfc3acfcadea153c441c2a62f9bd5d28e8ac38622f

data/bin/wrapture

@@ -1,12 +1,13 @@
 #!/usr/bin/env ruby
 
+# frozen_string_literal: true
+
 require 'yaml'
 require 'wrapture'
 
 spec = YAML.load_file ARGV[0]
 
-normalized_spec = Wrapture.normalize_spec spec
-
-normalized_spec['classes'].each do |class_spec|
-  Wrapture.wrap_class class_spec
+spec['classes'].each do |spec_hash|
+  class_spec = Wrapture::ClassSpec.new spec_hash
+  class_spec.generate_wrappers
 end

data/lib/wrapture.rb

@@ -1,8 +1,10 @@
-module Wrapture
+# frozen_string_literal: true
 
+##
+# Classes and functions for generating language wrappers
+module Wrapture
+  require 'wrapture/constant_spec'
   require 'wrapture/class_spec'
-  require 'wrapture/wrapper'
-  require 'wrapture/validator'
+  require 'wrapture/function_spec'
   require 'wrapture/version'
-
 end

data/lib/wrapture/class_spec.rb

@@ -1,60 +1,70 @@
+# frozen_string_literal: true
+
+require 'wrapture/constant_spec'
+require 'wrapture/function_spec'
+
 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
+
     def initialize(spec)
       @spec = ClassSpec.normalize_spec_hash(spec)
+
+      @functions = []
+      @spec['functions'].each do |function_spec|
+        @functions << FunctionSpec.new(function_spec, self)
+      end
+
+      @constants = []
+      @spec['constants'].each do |constant_spec|
+        @constants << ConstantSpec.new(constant_spec)
+      end
     end
 
     def generate_wrappers
-      generate_declaration_file
-      generate_definition_file
+      files = []
+      files << generate_declaration_file
+      files << generate_definition_file
     end
 
-    def self.normalize_spec_hash(spec)
-      normalized_spec = spec.dup
-
-      if normalized_spec['constructors'].nil?
-        normalized_spec['constructors'] = []
+    def resolve_param(param)
+      case param
+      when 'equivalent-struct'
+        equivalent_struct
+      when 'equivalent-struct-pointer'
+        equivalent_struct_pointer
+      else
+        param
       end
+    end
 
-      if normalized_spec['equivalent-struct']['members'].nil?
-        normalized_spec['equivalent-struct']['members'] = []
-      end
+    def function_call(spec)
+      resolved_params = []
 
-      if normalized_spec['functions'].nil?
-        normalized_spec['functions'] = []
-      else
-        normalized_spec['functions'].each do |function_spec|
-          if function_spec['params'].nil?
-            function_spec['params'] = []
-          end
-
-          if function_spec['wrapped-function']['params'].nil?
-            function_spec['wrapped-function']['params'] = []
-          end
-
-          if function_spec['return'].nil?
-            function_spec['return'] = {}
-            function_spec['return']['type'] = 'void'
-          end
-
-          if function_spec['return']['includes'].nil?
-            function_spec['return']['includes'] = []
-          end
-        end
+      spec['params'].each do |param|
+        resolved_params << resolve_param(param['name'])
       end
 
-      if normalized_spec['constants'].nil?
-        normalized_spec['constants'] = []
+      "#{spec['name']}( #{resolved_params.join ', '} )"
+    end
 
-      else
-        normalized_spec['constants'].each do |constant_spec|
-          if constant_spec['includes'].nil?
-            constant_spec['includes'] = []
-          end
-        end
-      end
+    def self.normalize_spec_hash(spec)
+      normalized_spec = spec.dup
+      normalized_spec.default = []
 
-      return normalized_spec
+      normalized_spec['equivalent-struct']['members'] ||= []
+      normalized_spec['equivalent-struct']['includes'] ||= []
+
+      normalized_spec
     end
 
     private
@@ -64,12 +74,28 @@ module Wrapture
     end
 
     def declaration_includes
-      includes = []
+      includes = @spec['equivalent-struct']['includes'].dup
 
-      includes.concat @spec['equivalent-struct']['includes']
+      @functions.each do |func|
+        includes.concat func.declaration_includes
+      end
 
-      @spec['functions'].each do |function_spec|
-        includes.concat function_spec['return']['includes']
+      @constants.each do |const|
+        includes.concat const.declaration_includes
+      end
+
+      includes.uniq
+    end
+
+    def definition_includes
+      includes = ["#{@spec['name']}.hpp"]
+
+      @functions.each do |func|
+        includes.concat func.definition_includes
+      end
+
+      @constants.each do |const|
+        includes.concat const.definition_includes
       end
 
       includes.uniq
@@ -77,12 +103,20 @@ module Wrapture
 
     def pointer_wrapper?
       @spec['constructors'].each do |constructor_spec|
-        if constructor_spec['wrapped-function']['return']['type'] == 'equivalent-struct-pointer'
-          return true
-        end
+        return_type = constructor_spec['wrapped-function']['return']['type']
+
+        return true if return_type == 'equivalent-struct-pointer'
       end
 
-      return false
+      false
+    end
+
+    def equivalent_member(member)
+      if pointer_wrapper?
+        "this->equivalent->#{member}"
+      else
+        "this->equivalent.#{member}"
+      end
     end
 
     def equivalent_name
@@ -93,36 +127,212 @@ module Wrapture
       end
     end
 
+    def equivalent_struct
+      if pointer_wrapper?
+        '*(this->equivalent)'
+      else
+        'this->equivalent'
+      end
+    end
+
+    def equivalent_struct_pointer
+      if pointer_wrapper?
+        'this->equivalent'
+      else
+        '&this->equivalent'
+      end
+    end
+
+    def wrapped_constructor_signature(index)
+      function_spec = @spec['constructors'][index]['wrapped-function']
+
+      "#{@spec['name']}( #{FunctionSpec.param_list function_spec} )"
+    end
+
+    def destructor_signature
+      "~#{@spec['name']}( void )"
+    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 '}'
+    end
+
+    def member_constructor_signature
+      params = []
+
+      @spec['equivalent-struct']['members'].each do |member|
+        params << ClassSpec.typed_variable(member['type'], member['name'])
+      end
+
+      "#{@spec['name']}( #{params.join ', '} )"
+    end
+
+    def struct_constructor_signature
+      struct_name = @spec['equivalent-struct']['name']
+      "#{@spec['name']}( struct #{struct_name} equivalent )"
+    end
+
+    def pointer_constructor_signature
+      struct_name = @spec['equivalent-struct']['name']
+      "#{@spec['name']}( struct #{struct_name} *equivalent )"
+    end
+
     def generate_declaration_file
-      file = File.open("#{@spec['name']}.hpp", 'w')
+      filename = "#{@spec['name']}.hpp"
 
-      file.puts "#ifndef #{header_guard}"
-      file.puts "#define #{header_guard}"
+      File.open(filename, 'w') do |file|
+        declaration_contents do |line|
+          file.puts line
+        end
+      end
 
-      file.puts unless declaration_includes.empty?
+      filename
+    end
+
+    def declaration_contents
+      yield "#ifndef #{header_guard}"
+      yield "#define #{header_guard}"
+
+      yield unless declaration_includes.empty?
       declaration_includes.each do |include_file|
-        file.puts "#include <#{include_file}"
+        yield "#include <#{include_file}>"
       end
 
-      file.puts "namespace #{@spec['namespace']} {"
-      file.puts "  class #{@spec['name']} {"
-      file.puts '  public:'
+      yield
+      yield "namespace #{@spec['namespace']} {"
+      yield
+      yield "  class #{@spec['name']} {"
+      yield '  public:'
 
-      file.puts unless @spec['constants'].empty?
-      @spec['constants'].each do |constant_spec|
-        file.puts "    static const #{constant_spec['type']} #{constant_spec['name']}"
+      yield unless @constants.empty?
+      @constants.each do |const|
+        yield "  #{const.declaration};"
+      end
+
+      yield
+      struct_name = @spec['equivalent-struct']['name']
+      yield "    struct #{struct_name} #{equivalent_name};"
+      yield
+
+      unless @spec['equivalent-struct']['members'].empty?
+        yield "    #{member_constructor_signature};"
       end
 
-      file.puts
-      file.puts "    struct #{@spec['equivalent-struct']['name']} #{equivalent_name}"
+      unless pointer_wrapper?
+        yield "    #{struct_constructor_signature};"
+        yield "    #{pointer_constructor_signature};"
+      end
 
-      file.puts '  };' # end of class
-      file.puts '}' # end of namespace
+      @spec['constructors'].each_index do |constructor|
+        yield "    #{wrapped_constructor_signature constructor};"
+      end
 
-      file.close
+      yield "    #{destructor_signature};" if @spec.key? 'destructor'
+
+      @functions.each do |func|
+        yield "    #{func.declaration};"
+      end
+
+      yield '  };' # end of class
+      yield
+      yield '}' # end of namespace
+      yield
+      yield '#endif' # end of header guard
     end
 
     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
+
+    def definition_contents
+      definition_includes.each do |include_file|
+        yield "#include <#{include_file}>"
+      end
+
+      yield
+      yield "namespace #{@spec['namespace']} {"
+
+      yield unless @constants.empty?
+      @constants.each do |const|
+        yield "  #{const.definition @spec['name']};"
+      end
+
+      unless @spec['equivalent-struct']['members'].empty?
+        yield
+        yield "  #{@spec['name']}::#{member_constructor_signature} {"
+
+        @spec['equivalent-struct']['members'].each do |member|
+          member_decl = equivalent_member member['name']
+          yield "    #{member_decl} = #{member['name']};"
+        end
+
+        yield '  }'
+      end
+
+      unless pointer_wrapper?
+        yield
+        yield "  #{@spec['name']}::#{struct_constructor_signature} {"
+
+        @spec['equivalent-struct']['members'].each do |member|
+          member_decl = equivalent_member member['name']
+          yield "    #{member_decl} = equivalent.#{member['name']};"
+        end
+
+        yield '  }'
+
+        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']};"
+        end
+
+        yield '  }'
+      end
+
+      @spec['constructors'].each_index do |constructor|
+        yield
+        wrapped_constructor_definition(constructor) do |line|
+          yield "  #{line}"
+        end
+      end
+
+      if @spec.key? 'destructor'
+        yield
+        yield "  #{@spec['name']}::#{destructor_signature} {"
+        func_spec = @spec['destructor']['wrapped-function']
+        yield "    #{function_call func_spec};"
+        yield '  }'
+      end
+
+      @functions.each do |func|
+        yield
+
+        func.definition(@spec['name']) do |def_line|
+          yield "  #{def_line}"
+        end
+      end
+
+      yield
+      yield '}' # end of namespace
     end
   end
 end

data/lib/wrapture/constant_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Wrapture
+  ##
+  # A description of a constant.
+  class ConstantSpec
+    def self.normalize_spec_hash(spec)
+      normalized_spec = spec.dup
+
+      normalized_spec['includes'] ||= []
+      normalized_spec['includes'].uniq!
+
+      normalized_spec
+    end
+
+    def initialize(spec)
+      @spec = ConstantSpec.normalize_spec_hash spec
+    end
+
+    def declaration_includes
+      @spec['includes'].dup
+    end
+
+    def definition_includes
+      @spec['includes'].dup
+    end
+
+    def declaration
+      "static const #{ClassSpec.typed_variable(@spec['type'], @spec['name'])}"
+    end
+
+    def definition(class_name)
+      expanded_name = "#{class_name}::#{@spec['name']}"
+      "const #{@spec['type']} #{expanded_name} = #{@spec['value']}"
+    end
+  end
+end

data/lib/wrapture/function_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Wrapture
+  ##
+  # A description of a function to be generated, including details about the
+  # underlying implementation.
+  class FunctionSpec
+    def self.normalize_spec_hash(spec)
+      normalized_spec = spec.dup
+
+      normalized_spec['params'] ||= []
+      normalized_spec['wrapped-function']['params'] ||= []
+      normalized_spec['wrapped-function']['includes'] ||= []
+
+      if normalized_spec['return'].nil?
+        normalized_spec['return'] = {}
+        normalized_spec['return']['type'] = 'void'
+      end
+
+      normalized_spec['return']['includes'] ||= []
+
+      normalized_spec
+    end
+
+    def self.param_list(spec)
+      return 'void' if spec['params'].empty?
+
+      params = []
+
+      spec['params'].each do |param|
+        params << ClassSpec.typed_variable(param['type'], param['name'])
+      end
+
+      params.join ', '
+    end
+
+    def initialize(spec, owner)
+      @owner = owner
+      @spec = FunctionSpec.normalize_spec_hash(spec)
+    end
+
+    def declaration_includes
+      @spec['return']['includes'].dup
+    end
+
+    def definition_includes
+      includes = @spec['return']['includes'].dup
+      includes.concat @spec['wrapped-function']['includes']
+
+      includes.uniq
+    end
+
+    def signature
+      "#{@spec['name']}( #{FunctionSpec.param_list @spec} )"
+    end
+
+    def declaration
+      modifier_prefix = @spec['static'] ? 'static ' : ''
+      "#{modifier_prefix}#{@spec['return']['type']} #{signature}"
+    end
+
+    def definition(class_name)
+      return_type = @spec['return']['type']
+      yield "#{return_type} #{class_name}::#{signature} {"
+
+      wrapped_call = String.new
+      wrapped_call << "return #{return_type} ( " unless return_type == 'void'
+      wrapped_call << @owner.function_call(@spec['wrapped-function'])
+      wrapped_call << ' )' unless return_type == 'void'
+      yield "  #{wrapped_call};"
+      yield '}'
+    end
+  end
+end

data/lib/wrapture/version.rb

@@ -1,5 +1,5 @@
-module Wrapture
-
-  VERSION = '0.1.0'
+# frozen_string_literal: true
 
+module Wrapture
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wrapture
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Joel Anderson
@@ -9,7 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2019-04-01 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.4
 description: Wraps C code in C++.
 email: joelanderson333@gmail.com
 executables:
@@ -20,13 +34,16 @@ files:
 - bin/wrapture
 - lib/wrapture.rb
 - lib/wrapture/class_spec.rb
-- lib/wrapture/validator.rb
+- lib/wrapture/constant_spec.rb
+- lib/wrapture/function_spec.rb
 - lib/wrapture/version.rb
-- lib/wrapture/wrapper.rb
 homepage: http://rubygems.org/gems/wrapture
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/goatshriek/wrapture/issues
+  changelog_uri: https://github.com/goatshriek/wrapture/blob/master/ChangeLog.md
+  source_code_uri: https://github.com/goatshriek/wrapture/
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -35,7 +52,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/wrapture/validator.rb

@@ -1,16 +0,0 @@
-module Wrapture
-
-  def self.normalize_spec(spec)
-
-    normalized_spec = Hash.new
-    normalized_spec['classes'] = Array.new
-
-    spec['classes'].each do |class_spec|
-      normalized_spec['classes'] << ClassSpec.normalize_spec_hash(class_spec)
-    end
-
-    return normalized_spec
-
-  end
-
-end

data/lib/wrapture/wrapper.rb

@@ -1,266 +0,0 @@
-module Wrapture
-
-  def self.wrap_class( class_spec )
-
-    spec = ClassSpec.new class_spec
-    spec.generate_wrappers
-
-    class_name = class_spec['name']
-    struct_name = class_spec['equivalent-struct']['name']
-
-    # generating constructor signatures
-    constructor_signatures = Array.new
-    equivalent_name = 'equivalent'
-    equivalent_struct = 'this->equivalent'
-    equivalent_struct_pointer = '&this->equivalent'
-    member_operator = '.'
-
-    class_spec['constructors'].each do |constructor_spec|
-      if constructor_spec['wrapped-function']['return']['type'] == 'equivalent-struct-pointer'
-        equivalent_name = '*equivalent'
-        equivalent_struct = '*(this->equivalent)'
-        equivalent_struct_pointer = 'this->equivalent'
-        member_operator = '->'
-      end
-
-      params = Array.new
-      constructor_spec['wrapped-function']['params'].each do |param|
-        params << "#{param['type']} #{param['name']}"
-      end
-
-      constructor_signatures << "#{class_name}( #{params.join ', '} )"
-    end
-
-    members = Array.new
-    class_spec['equivalent-struct']['members'].each do |member|
-      members << "#{member['type']} #{member['name']}"
-    end
-
-    member_constructor_signature = "#{class_name}( #{members.join ', '} )"
-    struct_constructor_signature = "#{class_name}( struct #{struct_name} equivalent )"
-    pointer_constructor_signature = "#{class_name}( const struct #{struct_name} *equivalent )"
-
-    # get the list of includes for declarations
-    declaration_includes = class_spec['equivalent-struct']['includes'].dup
-    class_spec['functions'].each do |function_spec|
-      declaration_includes.concat function_spec['return']['includes']
-    end
-    declaration_includes.uniq!
-
-    # generate the header file
-    File.open("#{class_name}.hpp", 'w') do |file|
-      # header guard
-      file.puts "#ifndef __#{class_name.upcase}_HPP"
-      file.puts "#define __#{class_name.upcase}_HPP"
-
-      file.puts
-
-      declaration_includes.each do |include_file|
-        file.puts "#include <#{include_file}>"
-      end
-
-      file.puts unless declaration_includes.empty?
-
-      file.puts "namespace #{class_spec['namespace']} {"
-      file.puts "  class #{class_name} {"
-      file.puts '  public:'
-
-      class_spec['constants'].each do |constant_spec|
-        file.puts "    static const #{constant_spec['type']} #{constant_spec['name']};"
-      end
-      file.puts unless class_spec['constants'].empty?
-
-      file.puts "    struct #{struct_name} #{equivalent_name};"
-      file.puts
-
-      constructor_signatures.each do |signature|
-        file.puts "    #{signature};"
-      end
-
-      unless members.empty?
-        file.puts "    #{member_constructor_signature};"
-      end
-
-      file.puts "    #{struct_constructor_signature};"
-      file.puts "    #{pointer_constructor_signature};"
-
-      class_spec['equivalent-struct']['members'].each do |member|
-        file.puts "    #{member['type']} Get#{member['name'].capitalize}( void ) const;"
-        file.puts "    void Set#{member['name'].capitalize}( #{member['type']} #{member['name']} );"
-      end
-
-      class_spec['functions'].each do |function_spec|
-        static_modifier = if function_spec['static'] then 'static ' else '' end
-        file.write "    #{static_modifier}#{function_spec['return']['type']} #{function_spec['name']}( "
-
-        wrapped_params = Array.new
-        function_spec['params'].each do |param|
-          wrapped_params << "#{param['type']} #{param['name']}"
-        end
-        file.write(wrapped_params.join ', ')
-
-        file.puts ' );'
-      end
-
-      # destructor
-      unless class_spec['destructor'].nil?
-        file.puts "    ~#{class_name}( void );"
-      end
-
-      file.puts '  };' # end of class
-      file.puts '}' # end of namespace
-      file.puts '#endif' # end of header guard
-    end
-
-    # get the complete list of includes for definitions
-    definition_includes = Array.new
-    definition_includes << "#{class_name}.hpp"
-    class_spec['functions'].each do |function_spec|
-      definition_includes.concat function_spec['return']['includes']
-      definition_includes.concat function_spec['wrapped-function']['includes']
-    end
-
-    class_spec['constants'].each do |constant_spec|
-      definition_includes.concat constant_spec['includes']
-    end
-    definition_includes.uniq!
-
-    # generate the definition file
-    File.open("#{class_name}.cpp", 'w') do |file|
-      definition_includes.each do |include_file|
-        file.puts "#include <#{include_file}>"
-      end
-
-      file.puts
-      file.puts "namespace #{class_spec['namespace']} {"
-
-      # constants
-      class_spec['constants'].each do |constant_spec|
-        file.puts
-        file.puts "  const #{constant_spec['type']} #{class_name}::#{constant_spec['name']} = #{constant_spec['value']};"
-      end
-
-      # constructors
-      class_spec['constructors'].each_index do |i|
-        wrapped_function = class_spec['constructors'][i]['wrapped-function']
-        function_params = Array.new
-        wrapped_function['params'].each do |param|
-          function_params << param['name']
-        end
-
-        file.puts
-        file.puts "  #{class_name}::#{constructor_signatures[i]} {"
-        file.write('    ')
-        case wrapped_function['return']['type']
-        when 'equivalent-struct'
-          file.write(equivalent_struct)
-        when 'equivalent-struct-pointer'
-          file.write(equivalent_struct_pointer)
-        end
-        file.puts " = #{wrapped_function['name']}( #{function_params.join ', '} );"
-        file.puts '  }'
-      end
-
-      unless members.empty?
-        file.puts
-        file.puts "  #{class_name}::#{member_constructor_signature} {"
-        class_spec['equivalent-struct']['members'].each do |member|
-          file.puts "    this->equivalent#{member_operator}#{member['name']} = #{member['name']};"
-        end
-        file.puts '  }' # end of the member constructor
-      end
-
-      file.puts
-      file.puts "  #{class_name}::#{struct_constructor_signature} {"
-      class_spec['equivalent-struct']['members'].each do |member|
-        file.puts "    this->equivalent#{member_operator}#{member['name']} = equivalent.#{member['name']};"
-      end
-      file.puts '  }' # end of struct conversion
-
-      file.puts
-      file.puts "  #{class_name}::#{pointer_constructor_signature} {"
-      class_spec['equivalent-struct']['members'].each do |member|
-        file.puts "    this->equivalent#{member_operator}#{member['name']} = equivalent->#{member['name']};"
-      end
-      file.puts '  }' # end of pointer conversion
-
-      class_spec['equivalent-struct']['members'].each do |member|
-        file.puts # line to separate from previous functions
-        file.puts "  #{member['type']} #{class_name}::Get#{member['name'].capitalize}( void ) const {"
-        file.puts "    return this->equivalent#{member_operator}#{member['name']};"
-        file.puts '  }'
-        file.puts
-        file.puts "  void #{class_name}::Set#{member['name'].capitalize}( #{member['type']} #{member['name']} ) {"
-        file.puts "    this->equivalent#{member_operator}#{member['name']} = #{member['name']};"
-        file.puts '  }'
-      end
-
-      class_spec['functions'].each do |function_spec|
-        file.puts
-        file.write "  #{function_spec['return']['type']} #{class_name}::#{function_spec['name']}( "
-
-        wrapped_params = Array.new
-        function_spec['params'].each do |param|
-          wrapped_params << "#{param['type']} #{param['name']}"
-        end
-        file.write(wrapped_params.join ', ')
-
-        file.puts ' ) {'
-
-        # the function body
-        if function_spec['return']['type'] == 'void'
-          file.write "    #{function_spec['wrapped-function']['name']}( "
-        else
-          file.write "    return #{function_spec['return']['type']}( #{function_spec['wrapped-function']['name']}( "
-        end
-
-        # building the parameters
-        wrapped_params = Array.new
-        function_spec['wrapped-function']['params'].each do |param|
-          case param['name']
-          when 'equivalent-struct'
-            wrapped_params << equivalent_struct
-          when 'equivalent-struct-pointer'
-            wrapped_params << equivalent_struct_pointer
-          else
-            wrapped_params << param['name']
-          end
-        end
-        file.write(wrapped_params.join ', ')
-
-        if function_spec['return']['type'] == 'void'
-          file.puts ' );'
-        else
-          file.puts ' ) );'
-        end
-        file.puts '  }'
-      end
-
-      # destructor
-      unless class_spec['destructor'].nil?
-        file.puts
-        file.puts "  #{class_name}::~#{class_name}( void ) {"
-        file.write("    #{class_spec['destructor']['wrapped-function']['name']}( ")
-        wrapped_params = Array.new
-        class_spec['destructor']['wrapped-function']['params'].each do |param|
-          case param['name']
-          when 'equivalent-struct'
-            wrapped_params << equivalent_struct
-          when 'equivalent-struct-pointer'
-            wrapped_params << equivalent_struct_pointer
-          else
-            wrapped_params << param['name']
-          end
-        end
-        file.write(wrapped_params.join ', ')
-        file.puts ' );'
-        file.puts '  }'
-      end
-
-      file.puts # line after last function
-      file.puts '}' # end of namespace
-    end
-
-  end
-
-end