summaryrefslogtreecommitdiff
path: root/src/conversion.rs
AgeCommit message (Collapse)Author
2022-12-22Add `Function::wrap`/`Function::wrap_mut`/`Function::wrap_async` to wrap ↵Alex Orlenko
functions into a type that implements `IntoLua` trait. This is useful to avoid calling `lua.create_function*` every time when `Function` handle is needed.
2022-12-20Remove FromLua impl for UserData+CloneAlex Orlenko
2022-12-19Rename ToLua/ToLuaMulti -> IntoLua/IntoLuaMultiAlex Orlenko
2022-12-19Add "unstable" feature flag.Alex Orlenko
Hide owned types under the new feature flag. Drop OwnedString/OwnedThread types (unlikely they are useful).
2022-12-18Initial implementation of owned Lua typesAlex Orlenko
2022-05-30Update integer/number coercion logicAlex Orlenko
2022-05-29More inline attributesAlex Orlenko
2022-03-22Add Luau vector datatype supportAlex Orlenko
2021-11-25More performance optimizationsAlex Orlenko
2021-11-04Refactor a bit conversion int->numberAlex Orlenko
2021-11-04Replace macro-based implementation `ToLua` for arrays to const genericsAlex Orlenko
2021-10-04Add serializing i128/u128 types.Alex Orlenko
Fixes #81.
2021-09-28Add inline attributes to few hot funcsAlex Orlenko
2021-06-25Fix converting Lua sequence table to HashSet/BTreeSetAlex Orlenko
2021-05-04Fix clippy warningsAlex Orlenko
2021-05-03Implement ToLua/FromLua for Box<str> and Box<[T]>Alex Orlenko
2021-02-26Add ToLua implementation for Cow<str> and Cow<CStr>Alex Orlenko
2021-01-20Fix numeric types conversion for 32bit lua. Fix #27Alex Orlenko
2020-09-27impl `ToLua` and `FromLua` for `HashSet` and `BTreeSet`Kai Schmidt
2020-05-15Remove redundant lifetimesAlex Orlenko
2020-05-15Add clippy check and fix clippy warningsAlex Orlenko
2020-05-11Scope support (including async)Alex Orlenko
2020-05-11Hide Lua "Send" capability under the optional "send" feature flagAlex Orlenko
2020-05-11Add Send capability to LuaAlex Orlenko
2020-04-29Add ToLua implementation for slices and arraysAlex Orlenko
2020-04-17v0.3.0-alpha.1 with async supportAlex Orlenko
Squashed commit of the async branch.
2019-09-29Backport changes from rlua 0.16 (master branch)Alex Orlenko
2018-09-26Improve the situation with numerical conversionkyren
This is a somewhat involved change with two breaking API changes: 1) Lua::coerce_xxx methods now return Option (this is easier and faster than dealing with Result) 2) rlua numeric conversions now allow more loss of precision conversions (e.g. 1.5f32 to 1i32) The logic for the first breaking change is that mostly the coerce methods are probably used internally, and they make sense as low-level fallible casts and are now used as such, and there's no reason to confuse things with a Result with a large error type and force the user to match on the error which will hopefully only be FromLuaConversionError anyway. The logic for the second change is that it matches the behavior of num_traits::cast, and is more consistent in that *some* loss of precision conversions were previously allowed (e.g. f64 to f32). The problem is that now, Lua::coerce_integer and Lua::unpack::<i64> have different behavior when given, for example, the number 1.5. I still think this is the best option, though, because the Lua::coerce_xxx methods represent how Lua works internally and the standard C API cast functions that Lua provides, and the ToLua / FromLua code represents the most common form of fallible Rust numeric conversion. I could revert this change and turn `Lua::eval::<i64>("1.5", None)` back into an error, but it seems inconsistent to allow f64 -> f32 loss of precision but not f64 -> i64 loss of precision.
2018-09-24Return rlua::Error on out of range numeric conversions using num_traits::castkyren
2018-09-04Initial design for non-'static scoped userdatakyren
Uses the same UserData trait, and should at least in theory support everything that 'static UserData does, except that any functions added that rely on AnyUserData are pretty much useless. Probably pretty slow and I'm not sure how to make it dramatically faster, which is a shame because generally when you need non'-static userdata you might be creating it kind of a lot (if it was long-lived, it would probably be 'static). Haven't added tests yet, will do that next.
2018-08-05format with up-to-date rustfmtkyren
2018-03-19Clean up some lifetime specificationkyren
2018-03-11A lot of performance changes.kyren
Okay, so this is kind of a mega-commit of a lot of performance related changes to rlua, some of which are pretty complicated. There are some small improvements here and there, but most of the benefits of this change are from a few big changes. The simplest big change is that there is now `protect_lua` as well as `protect_lua_call`, which allows skipping a lightuserdata parameter and some stack manipulation in some cases. Second simplest is the change to use Vec instead of VecDeque for MultiValue, and to have MultiValue be used as a sort of "backwards-only" Vec so that ToLuaMulti / FromLuaMulti still work correctly. The most complex change, though, is a change to the way LuaRef works, so that LuaRef can optionally point into the Lua stack instead of only registry values. At state creation a set number of stack slots is reserved for the first N LuaRef types (currently 16), and space for these are also allocated separately allocated at callback time. There is a huge breaking change here, which is that now any LuaRef types MUST only be used with the Lua on which they were created, and CANNOT be used with any other Lua callback instance. This mostly will affect people using LuaRef types from inside a scope callback, but hopefully in those cases `Function::bind` will be a suitable replacement. On the plus side, the rules for LuaRef types are easier to state now. There is probably more easy-ish perf on the table here, but here's the preliminary results, based on my very limited benchmarks: create table time: [314.13 ns 315.71 ns 317.44 ns] change: [-36.154% -35.670% -35.205%] (p = 0.00 < 0.05) create array 10 time: [2.9731 us 2.9816 us 2.9901 us] change: [-16.996% -16.600% -16.196%] (p = 0.00 < 0.05) Performance has improved. create string table 10 time: [5.6904 us 5.7164 us 5.7411 us] change: [-53.536% -53.309% -53.079%] (p = 0.00 < 0.05) Performance has improved. call add function 3 10 time: [5.1134 us 5.1222 us 5.1320 us] change: [-4.1095% -3.6910% -3.1781%] (p = 0.00 < 0.05) Performance has improved. call callback add 2 10 time: [5.4408 us 5.4480 us 5.4560 us] change: [-6.4203% -5.7780% -5.0013%] (p = 0.00 < 0.05) Performance has improved. call callback append 10 time: [9.8243 us 9.8410 us 9.8586 us] change: [-26.937% -26.702% -26.469%] (p = 0.00 < 0.05) Performance has improved. create registry 10 time: [3.7005 us 3.7089 us 3.7174 us] change: [-8.4965% -8.1042% -7.6926%] (p = 0.00 < 0.05) Performance has improved. I think that a lot of these benchmarks are too "easy", and most API usage is going to be more like the 'create string table 10' benchmark, where there are a lot of handles and tables and strings, so I think that 25%-50% improvement is a good guess for most use cases.
2018-03-08Simplify stack_guard / stack_err_guardkyren
The expected change is always zero, because stack_guard / stack_err_guard are always used at `rlua` entry / exit points.
2018-02-06Lots of changes, not sure if actually safe yet.kyren
* Make Lua Send * Add Send bounds to (nearly) all instances where userdata and functions are passed to Lua * Add a "scope" method which takes a callback that accepts a `Scope`, and give `Scope` the ability to create functions and userdata that are !Send, *and also functions that are not even 'static!*.
2018-01-26ACTUALLY expose `RegistryKey` APIkyren
Also fixes a safety issue with RegistryKey, where you could use RegistryKeys with mismatching Lua instances.
2017-12-04more reorganization in an attempt to shrink the size of lua.rskyren
2017-12-04Move function and thread into their own modules, auto-formattingkyren
2017-12-03I believe this is all the external API changes necessary for 'm' safetykyren
2017-10-24Fix some clippy lints, possible edge case API incompatibility around HashMapkyren
2017-10-23auto-formattingkyren
2017-09-30more reorganization, move simple type defines to types.rs modulekyren
2017-09-30crudely move LightUserData/UserData/AnyUserData to their own modulekyren
2017-09-15Move string and table wrappers into own filesJonas Schievink
2017-08-02Remove expected field from FromLuaConversionErrorJonas Schievink
2017-08-01Enhance error messagesJonas Schievink
2017-07-29Relax requirements for UserData to impl FromLuaJonas Schievink
This was only allowed for `UserData` implementors that are also `Copy`. This relaxes the requirement to be `Clone` instead. While `Copy` makes sense to prevent allocations and other potentially costly operations, other `FromLua` impls already do pretty expensive stuff, so this seems worth it.
2017-07-24Do several more Lua prefix renames, add prelude modulekyren
Rename the following: LuaNil => Nil LuaExternalError => ExternalError LuaExternalResult => ExternalResult LuaCallback => Callback (internal only) Use qualified re-exports at the top of the module. Add a new public 'prelude' module which re-exports everything with a non-conflicting name (Adds back the Lua prefix), and is meant to be imported unqualified.
2017-07-23Rename `LuaString` to `String`Jonas Schievink
This required a lot of little adjustments where we used std's `String` before. In downstream code, this shouldn't be necessary, as you can just do `use rlua::String as LuaString` to disambiguate.
2017-07-23Remove the `Lua*` prefix from most typesJonas Schievink
cc #15 Doesn't touch `LuaString` mainly because that's a *lot* of renaming work and the code looks weird. Also I want feedback before I proceed.