autoc 1.4 → 2.0.0

data/lib/autoc/vector.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+
+require 'autoc/ranges'
+require 'autoc/sequential'
+require 'autoc/association'
+
+
+module AutoC
+
+
+  using STD::Coercions
+
+
+  class Vector < Association
+
+    include STD
+
+    include Sequential
+
+    def _range_class = Range
+
+    def range = @range ||= _range_class.new(self, visibility: visibility, parallel: @parallel)
+
+    def initialize(type, element, parallel: nil, **kws)
+      super(type, element, :size_t, **kws)
+      dependencies << STRING_H
+      @parallel = parallel
+    end
+
+    def render_interface(stream)
+      if public?
+        stream << %{
+          /**
+            #{defgroup}
+
+            @brief Resizable vector of elements of type #{element}
+
+            #{type} is a container that encapsulates dynamic size array of values of type #{element}.
+
+            It is a contiguous direct access collection where elements can be directly referenced by an integer index belonging to the [0, @ref #{size}) range.
+
+            For iteration over the vector elements refer to @ref #{range}.
+
+            @see C++ [std::vector<T>](https://en.cppreference.com/w/cpp/container/vector)
+
+            @since 2.0
+          */
+        }
+        stream << %{
+          /**
+            #{ingroup}
+
+            @brief Opaque structure holding state of the vector
+
+            @since 2.0
+          */
+        }
+      else
+        stream << PRIVATE
+      end
+      stream << %{
+        typedef struct {
+          #{element.lvalue} elements; /**< @private */
+          size_t size; /**< @private */
+        } #{signature};
+      }
+
+    end
+
+    def render_implementation(stream)
+      if element.orderable?
+        stream << %{
+          static int
+          #ifdef __POCC__
+            __cdecl
+          #endif
+          #{ascend}(const void* left, const void* right) {
+            return #{element.compare.("(*(#{element.lvalue})left)", "(*(#{element.lvalue})right)")};
+          }
+          static int
+          #ifdef __POCC__
+            __cdecl
+          #endif
+          #{descend}(const void* left, const void* right) {
+            return -#{ascend}(left, right);
+          }
+          #{sort.prototype} {
+            qsort(#{storage(:target)}, #{size.('*target')}, sizeof(#{element}), direction > 0 ? #{ascend} : #{descend});
+          }
+        }
+      end
+      super
+    end
+
+    def storage(target) = "#{target}->elements" # Return C pointer to contiguous storage
+
+    def type_tag = "#{signature}<#{element}>"
+
+  private
+
+    def configure
+      super
+      method(:void, :_allocate, { target: lvalue, size: :size_t.const_rvalue }, visibility: :internal).configure do
+        code %{
+          if((target->size = size) > 0) {
+            #{storage(:target)} = #{memory.allocate(element, size)}; assert(#{storage(:target)});
+          } else {
+            #{storage(:target)} = NULL;
+          }
+        }
+      end
+      method(:void, :create_size, { target: lvalue, size: :size_t.const_rvalue }, instance: :custom_create, constraint:-> { custom_constructible? && element.default_constructible? }).configure do
+        code %{
+          size_t index;
+          assert(target);
+          #{_allocate.(target, size)};
+          for(index = 0; index < size; ++index) {
+            #{element.default_create.("#{storage(:target)}[index]")};
+          }
+        }
+        header %{
+          @brief Create a new vector of specified size
+
+          @param[out] target vector to be initialized
+          @param[in] size size of new vector
+
+          Each new vector's element is initialized with the respective default constructor.
+
+          This function requires the element type to be *default constructible* (i.e. to have a well-defined parameterless constructor).
+
+          @note Previous contents of `*target` is overwritten.
+
+          @since 2.0
+        }
+      end
+      method(:void, :create_set, { target: lvalue, size: :size_t.const_rvalue, initializer: element.const_rvalue }, constraint:-> { element.copyable? }).configure do
+        code %{
+          size_t index;
+          assert(target);
+          #{_allocate.(target, size)};
+          for(index = 0; index < size; ++index) {
+            #{element.copy.("#{storage(:target)}[index]", initializer)};
+          }
+        }
+        header %{
+          @brief Create and initialize a new vector of specified size
+
+          @param[out] target vector to be initialized
+          @param[in] size size of new vector
+          @param[in] initializer value to initialize the vector with
+
+          Each new vector's element is set to a *copy* of the specified value.
+
+          This function requires the element type to be *copyable* (i.e. to have a well-defined copy operation).
+
+          @note Previous contents of `*target` is overwritten.
+
+          @since 2.0
+        }
+      end
+      destroy_elements = "for(index = common_size; index < old_size; ++index) {#{element.destroy.('old_elements[index]')};}" if element.destructible?
+      method(:void, :resize, { target: lvalue, new_size: :size_t.const_rvalue }, constraint:-> { element.default_constructible? }).configure do
+        code %{
+          size_t old_size;
+          assert(target);
+          if((old_size = #{size.(target)}) != new_size) {
+            size_t common_size, index;
+            #{element.lvalue} new_elements;
+            #{element.lvalue} old_elements;
+            old_elements = #{storage(:target)};
+            #{_allocate.(target, new_size)};
+            new_elements = #{storage(:target)};
+            common_size = old_size < new_size ? old_size : new_size; /* min(old_size, new_size) */
+            if(common_size > 0) {
+              memcpy(new_elements, old_elements, common_size*sizeof(#{element}));
+            }
+            for(index = common_size; index < new_size; ++index) {
+              #{element.default_create.('new_elements[index]')};
+            }
+            #{destroy_elements}
+            #{memory.free(:old_elements)};
+          }
+        }
+        header %{
+          @brief Resize vector
+
+          @param[out] target vector to be resized
+          @param[in] new_size new size of new vector
+
+          This function sets new size for existing vector, expanding or shrinking it - whatever is applicable.
+
+          When expanding, new elements are default initialized.
+          When shrinking, excessive elements are destroyed with the respective destructor.
+
+          @since 2.0
+        }
+      end
+      default_create.configure do
+        inline_code %{
+          assert(target);
+          #{storage(:target)} = NULL;
+          target->size = 0;
+        }
+      end
+      destroy_elements = "for(index = 0; index < #{size}(target); ++index) {#{element.destroy.("#{storage(:target)}[index]")};}" if element.destructible?
+      destroy.configure do
+        code %{
+          #{'size_t index;' if element.destructible?}
+          assert(target);
+          #{destroy_elements}
+          #{memory.free(storage(:target))};
+        }
+      end
+      copy.configure do
+        code %{
+          size_t index, size;
+          assert(target);
+          assert(source);
+          size = #{size.(source)};
+          #{_allocate.(target, :size)};
+          for(index = 0; index < size; ++index) {
+            #{element.copy.("#{storage(:target)}[index]", "#{storage(:source)}[index]")};
+          }
+        }
+      end
+      size.configure do
+        inline_code %{
+          assert(target);
+          return target->size;
+        }
+      end
+      check.configure do
+        dependencies << size
+        inline_code %{
+          assert(target);
+          return index < #{size.(target)};
+        }
+      end
+      empty.configure do
+        dependencies << size
+        inline_code %{
+          assert(target);
+          return !#{size.(target)};
+        }
+      end
+      view.configure do
+        dependencies << check
+        inline_code %{
+          assert(target);
+          assert(#{check.(target, index)});
+          return &#{storage(:target)}[index];
+        }
+      end
+      set.configure do
+        dependencies << check << view
+        inline_code %{
+          #{element.lvalue} e;
+          assert(target);
+          assert(#{check.(target, index)});
+          e = (#{element.lvalue})#{view.(target, index)};
+          #{element.destroy.('*e') if element.destructible?};
+          #{element.copy.('*e', value)};
+        }
+      end
+      method(:void, :sort, { target: rvalue, direction: :int.const_rvalue }, constraint:-> { orderable? }, abstract: true).configure do
+        header %{
+          @brief Sort vector's values
+
+          @param[in] target vector to sort
+          @param[in] direction sorting direction
+
+          This function performs in-place sorting of the contained elements.
+          If `direction` is greater than zero, the elements are placed in ascending (lowest to highset) order,
+          otherwise the elements are placed in descending (highest to lowest) order.
+
+          The sorting process does not reallocate memory nor does it call elements' copy constructors.
+
+          @since 2.0
+        }
+      end
+    end
+
+  end # Vector
+
+
+  Vector::Range = ContiguousRange # Range
+
+
+end

data/lib/autoc.rb

@@ -1,39 +1,8 @@
-=begin rdoc
+# frozen_string_literal: true
 
-*AutoC* is a host of Ruby modules related to automatic C source code generation.
 
-. {AutoC::Code} generic C multi-source module generator.
-. {AutoC::Collection} strongly-typed data structure generators similar
-to the C++ STL container classes.
-. {AutoC::String} wrapper around the standard C string with string building capability.
-
-== Versioning scheme
-
-AutoC adheres to simple major.minor versioning scheme.
-
-Change in major number states incompatible changes in the code
-while change in minor number states (rather) small incremental changes that
-should not normally break things.
-
-That said, release 1.0 is the _first_ release of version 1 which is considered beta, not stable.
-_Note that it is not necessary stable or feature complete._
-Releases 1.1+ will present incremental improvements, bugfixes, documentation updates etc. to version 1.
-Should the major incompatible changes be made, the new release 2.0 will be introduced and so forth.
-
-=end
 module AutoC
-  VERSION = "1.4"
-end # AutoC
-
 
-require "autoc/code"
-require "autoc/type"
-require "autoc/string"
-require "autoc/collection"
-require "autoc/collection/list"
-require "autoc/collection/queue"
-require "autoc/collection/vector"
-require "autoc/collection/hash_set"
-require "autoc/collection/hash_map"
-require "autoc/collection/tree_set"
-require "autoc/collection/tree_map"
+  VERSION = '2.0.0'
+  
+end

metadata

@@ -1,101 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: autoc
 version: !ruby/object:Gem::Version
-  version: '1.4'
+  version: 2.0.0
 platform: ruby
 authors:
 - Oleg A. Khlybov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2023-03-14 00:00:00.000000000 Z
 dependencies: []
 description: |2
-      AutoC is a collection of Ruby modules related to automatic C source code generation:
-      1) Multi-file C module generator.
-      2) Generators for strongly-typed generic collections (Vector, List, Set etc.).
+      The package contains a functionality related to the C source code generation,
+      including generation of the strongly-typed data structures (vectors, lists, maps etc.)
+      in a manner provided by the C++'s STL library.
 email: fougas@mail.ru
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- CHANGES.md
 files:
-- ".yardopts"
-- CHANGES
-- README
-- doc/AutoC.html
-- doc/AutoC/Code.html
-- doc/AutoC/Collection.html
-- doc/AutoC/HashMap.html
-- doc/AutoC/HashSet.html
-- doc/AutoC/Iterators.html
-- doc/AutoC/Iterators/Bidirectional.html
-- doc/AutoC/Iterators/Unidirectional.html
-- doc/AutoC/List.html
-- doc/AutoC/Maps.html
-- doc/AutoC/Module.html
-- doc/AutoC/Module/File.html
-- doc/AutoC/Module/Header.html
-- doc/AutoC/Module/Source.html
-- doc/AutoC/Priority.html
-- doc/AutoC/Queue.html
-- doc/AutoC/Reference.html
-- doc/AutoC/Sets.html
-- doc/AutoC/String.html
-- doc/AutoC/TreeMap.html
-- doc/AutoC/TreeSet.html
-- doc/AutoC/Type.html
-- doc/AutoC/UserDefinedType.html
-- doc/AutoC/Vector.html
-- doc/_index.html
-- doc/class_list.html
-- doc/css/common.css
-- doc/css/full_list.css
-- doc/css/style.css
-- doc/file.CHANGES.html
-- doc/file.README.html
-- doc/file_list.html
-- doc/frames.html
-- doc/index.html
-- doc/js/app.js
-- doc/js/full_list.js
-- doc/js/jquery.js
-- doc/method_list.html
-- doc/top-level-namespace.html
+- CHANGES.md
+- README.md
+- cmake/AutoC.cmake
 - lib/autoc.rb
-- lib/autoc/code.rb
+- lib/autoc/allocators.rb
+- lib/autoc/association.rb
+- lib/autoc/box.rb
+- lib/autoc/cmake.rb
 - lib/autoc/collection.rb
-- lib/autoc/collection/hash_map.rb
-- lib/autoc/collection/hash_set.rb
-- lib/autoc/collection/iterator.rb
-- lib/autoc/collection/list.rb
-- lib/autoc/collection/map.rb
-- lib/autoc/collection/queue.rb
-- lib/autoc/collection/set.rb
-- lib/autoc/collection/tree_map.rb
-- lib/autoc/collection/tree_set.rb
-- lib/autoc/collection/vector.rb
-- lib/autoc/string.rb
+- lib/autoc/composite.rb
+- lib/autoc/cstring.rb
+- lib/autoc/function.rb
+- lib/autoc/hash_map.rb
+- lib/autoc/hash_set.rb
+- lib/autoc/hashers.rb
+- lib/autoc/list.rb
+- lib/autoc/module.rb
+- lib/autoc/openmp.rb
+- lib/autoc/primitive.rb
+- lib/autoc/ranges.rb
+- lib/autoc/record.rb
+- lib/autoc/scaffold.rb
+- lib/autoc/scaffold/docs.rb
+- lib/autoc/scaffold/generic_value.rb
+- lib/autoc/scaffold/project.rb
+- lib/autoc/scaffold/test_cstring.rb
+- lib/autoc/scaffold/test_cstring_hash_set.rb
+- lib/autoc/scaffold/test_int_box.rb
+- lib/autoc/scaffold/test_int_hash_set.rb
+- lib/autoc/scaffold/test_int_list.rb
+- lib/autoc/scaffold/test_int_vector.rb
+- lib/autoc/scaffold/test_v2v_hash_map.rb
+- lib/autoc/scaffold/test_value_hash_set.rb
+- lib/autoc/scaffold/test_value_vector.rb
+- lib/autoc/scaffold/tests.rb
+- lib/autoc/sequential.rb
+- lib/autoc/set.rb
+- lib/autoc/std.rb
 - lib/autoc/type.rb
-- test/test.rb
-- test/test_auto.c
-- test/test_auto.h
-- test/test_char_string.rb
-- test/test_int_list.rb
-- test/test_int_tree_set.rb
-- test/test_int_vector.rb
-- test/test_value_hash_map.rb
-- test/test_value_hash_set.rb
-- test/test_value_list.rb
-- test/test_value_queue.rb
-- test/test_value_tree_map.rb
-- test/test_value_tree_set.rb
-- test/test_value_vector.rb
-- test/value.rb
-homepage: http://autoc.sourceforge.net/
+- lib/autoc/vector.rb
+homepage: https://github.com/okhlybov/autoc
 licenses:
-- BSD-3-Clause
-metadata: {}
-post_install_message: 
+- BSD-2-Clause
+metadata:
+  source_code_uri: https://github.com/okhlybov/autoc
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -103,16 +74,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.8'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.4.6
+signing_key:
 specification_version: 4
-summary: A host of Ruby modules related to automatic C source code generation
+summary: C source code generation package
 test_files: []

data/.yardopts

@@ -1,4 +0,0 @@
---markup asciidoc
---no-private
--
-CHANGES

data/CHANGES

@@ -1,23 +0,0 @@
-== 1.4
-
-Introduced AutoC::TreeSet and AutoC::TreeMap binary tree based containers.
-
-== 1.3
-
-Introduced AutoC::String string type.
-
-== 1.2
-
-Introduced counted reference type AutoC::Reference.
-
-Introduced type capabilities/restrictions and optional operations for collections.
-
-Made AutoC::Vector#sort() an optional operation.
-
-== 1.1
-
-Fixed online documentation generation issues.
-
-== 1.0
-
-Initial release of version 1.

data/README

@@ -1,28 +0,0 @@
-== AutoC - a collection of Ruby modules related to automatic C source code generation.
-
-AutoC is a free software distributed under the terms of modified BSD license.
-
-Project home page is http://autoc.sourceforge.net/
-
-AutoC is available via the RubyGems infrastructure; the easiest way to obtain it is:
-----
-> gem install autoc
-----
-
-Offline user documentation in HTML form is in doc/ directory.
-
-For more information refer to {::AutoC}.
-
-Ad-hoc test build instructions:
-----
-> cd test
-> ruby -I. -I../lib test.rb
-> cc test_auto.c
-> ./a.out
-----
-
-For (in)complete list of changes refer to {file:CHANGES}.
-
-That's all for now, folks! Stay tuned.
-
-Oleg A. Khlybov <fougas@mail.ru>