* tamuratak-fix_ruby_wstring:
[ruby] use %fragment to clarify the dependency of code.
[ruby] should initialize static variables inside %init{}, in which it will not be excuted concurrently by multiple threads.
[ruby] * use static variable to avoid creating stirngs every time. * fix possible overflow.
[ruby] add std::wstring tests for string including a null terminator.
[ruby] * rewrite SWIG_AsWCharPtrAndSize and SWIG_FromWCharPtrAndSize * use UTF-32LE and UTF-16LE to avoid BOM * add tests
[ruby] use WCHAR_MAX to determine the encoding of std::wstring.
[ruby] add a few tests for std::wstring
[ruby] fix support for std::wstring.
* tamuratak-fix_ruby_null_shared_ptr:
[ruby] add a test.
[ruby] use std::vector::back() method.
[ruby] enable a test for null shared_ptr in containers.
[ruby] add a test for null shared_ptr in containers.
[ruby] treat null shared_ptr in std containers properly.
Conflicts:
Examples/test-suite/ruby/Makefile.in
* tamuratak-fix_ruby_director_and_shared_ptr:
Rename shared_ptr testcase
[ruby] use boost/shared_ptr and boost_shared_ptr.i. not use auto.
[ruby] delete unnecessary changes.
[ruby] add %typemap(directorin) for shared_ptr.
[ruby] enable a test, cpp11_shared_ptr_director.
[ruby] add %typemap(directorin) and %typemap(directorout) for shared_ptr.
[ruby] add %typemap(directorout) for shared_ptr.
add a test for shared_ptr with director
Conflicts:
CHANGES.current
* tamuratak-shared_ptr_derived_2:
Correct comment about const removal for shared_ptr
Correct ordering of declarations in testcase
Ruby shared_ptr on error code improvement in traits_as::as
Add support for pointers to shared_ptr and null shared_ptr in Ruby containers
Add shared_ptr non-overloaded upcast tests
use forward declaration to treat the dependency of fragments
[ruby] must not do a null check for VALUE.
[ruby] add tests for shared_ptr of const Type.
[ruby] For swig::from, use template specialization to convert shared_ptr<const T> to shared_ptr<T>.
[ruby] edit comments [skip ci]
[ruby] move template specialization to std_shared_ptr.i.
[ruby] add tests for upcasting std::shared_ptr within std containers.
[ruby] use template specialization for swig::asptr,asval functions on std:shared_ptr.
* tamuratak-fix_typo_ruby_unordered_map:
[ruby] add a test to make sure that std::multiset is including Enumerable.
[ruyb] enable std::list test for Ruby.
[ruby] make std::list include Enumerable.
[ruby] make std::multiset and std::unordered_multiset include Enumerable. tests added.
[ruby] make std::unordered_map include Enumerable.
The vector of pointers (just fixed) were not working correctly because the
descriptors returned from swig::type_info() were sometimes returning
zero. Zero should only be used for void * as the subsequent call to
SWIG_ConvertPtr will blindly cast the pointer without checking
descriptor.
std::vector<void *> does not work and will require further changes:
specializing traits_info<void *> to return 0 and traits_asptr<void *>.
I tried this and traits_asptr<void> also needs to be added in which
seems odd and requires further investigation...
Lib/python/pystdcommon.swg:
template <> struct traits_info<void *> {
static swig_type_info *type_info() {
static swig_type_info *info = 0;
}
};
Lib/std/std_common.i:
template <>
struct traits_asptr<void *> {
static int asptr(PyObject *obj, void ***val) {
void **p;
swig_type_info *descriptor = 0;
int res = SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0);
if (SWIG_IsOK(res)) {
if (val) *val = p;
}
return res;
}
};
// this is needed, but am not sure this is expected
template <>
struct traits_asptr<void> {
static int asptr(PyObject *obj, void **val) {
void **p;
swig_type_info *descriptor = 0;
int res = SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0);
if (SWIG_IsOK(res)) {
if (val) *val = p;
}
return res;
}
};
This bug was introduced in swig-3.0.8 in #146252 adding shared_ptr
support. An ObjectPreviouslyDeleted error was incorrectly thrown
when the pointer was used as a parameter after being set to zero
via a call to 'DATA_PTR(self) = 0'.
It isn't clear to me which approach is better in this corner case,
so I've gone for backwards compatibility and restored the old behaviour.
Closes#602
Adds preprocessor checks to avoid defining functions that use long long if it isn't available
Effects the following languages: javascript, octave, perl, python, r, ruby, tcl
Hack to use the std::array support for boost::array.
Is limited as it currently exposes some 'using' bugs in SWIG.
For example, the type system fails to see that pointers to std::array
and pointers to boost::array are the same.
This approach saves having to maintain separate boost::array support.
The 'using' bug ought to be fixed, otherwise separate boost_array.i
files could be easily made from the std_array.i files.
Setting an STL container wrapper slice better matches the way Ruby
arrays work. The behaviour is now the same as Ruby arrays. The only
exception is the default value used when expanding a container
cannot be nil as this is not a valid type/value for C++ container
elements.
Access via ranges and slices now behave identically to Ruby arrays.
The fixes are mostly for out of range indices and lengths.
- Zero length slice requests return an empty container instead of nil.
- Slices which request a length greater than the size of the container
no longer chop off the last element.
- Ranges which used to return nil now return an empty array when the
the start element is a valid index.
Using negative indexes to set values works the same as Ruby arrays, eg
%template(IntVector) std::vector<int>;
iv = IntVector.new([1,2,3,4])
iv[-4] = 9 # => [1,2,3,9]
iv[-5] = 9 # => IndexError
