mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-06-15 22:57:12 +02:00
Preliminary Poco::Data bindings.
This commit is contained in:
Sandu Liviu Catalin
77
module/Library/Utils/Vector.cpp
Normal file
77
module/Library/Utils/Vector.cpp
Normal file
@ -0,0 +1,77 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Library/Utils/Vector.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQMOD_DECL_TYPENAME(SqVectorInteger, _SC("SqVectorInteger"))
|
||||
SQMOD_DECL_TYPENAME(SqVectorString, _SC("SqVectorString"))
|
||||
SQMOD_DECL_TYPENAME(SqVectorFloat, _SC("SqVectorFloat"))
|
||||
SQMOD_DECL_TYPENAME(SqVectorByte, _SC("SqVectorByte"))
|
||||
SQMOD_DECL_TYPENAME(SqVectorBool, _SC("SqVectorBool"))
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
template < class T, class U >
|
||||
static void Register_Vector(HSQUIRRELVM vm, Table & ns, const SQChar * name)
|
||||
{
|
||||
using Vector = SqVector< T >;
|
||||
// --------------------------------------------------------------------------------------------
|
||||
Class< Vector, NoCopy< Vector > > cls(vm, U::Str);
|
||||
// Constructors
|
||||
cls.Ctor()
|
||||
.template Ctor< SQInteger >()
|
||||
.template Ctor< SQInteger, typename Vector::OptimalArg >()
|
||||
// Meta-methods
|
||||
.SquirrelFunc(_SC("_typename"), &U::Fn)
|
||||
// Properties
|
||||
.Prop(_SC("Null"), &Vector::IsNull)
|
||||
.Prop(_SC("Front"), &Vector::Front)
|
||||
.Prop(_SC("Back"), &Vector::Back)
|
||||
.Prop(_SC("Empty"), &Vector::Empty)
|
||||
.Prop(_SC("Size"), &Vector::Size, &Vector::Resize)
|
||||
.Prop(_SC("Capacity"), &Vector::Capacity, &Vector::Reserve)
|
||||
// Member Methods
|
||||
.Func(_SC("Get"), &Vector::Get)
|
||||
.Func(_SC("Set"), &Vector::Set)
|
||||
.Func(_SC("Resize"), &Vector::ResizeEx)
|
||||
.Func(_SC("Reserve"), &Vector::Reserve)
|
||||
.Func(_SC("Compact"), &Vector::Compact)
|
||||
.Func(_SC("Clear"), &Vector::Clear)
|
||||
.Func(_SC("Push"), &Vector::Push)
|
||||
.Func(_SC("Pop"), &Vector::Pop)
|
||||
.Func(_SC("EraseAt"), &Vector::EraseAt)
|
||||
.Func(_SC("EraseFrom"), &Vector::EraseFrom)
|
||||
.Func(_SC("EraseValue"), &Vector::EraseValue)
|
||||
.Func(_SC("InsertAt"), &Vector::InsertAt)
|
||||
.Func(_SC("Insert"), &Vector::Insert)
|
||||
.Func(_SC("Locate"), &Vector::Locate)
|
||||
.Func(_SC("LocateFrom"), &Vector::LocateFrom)
|
||||
.Func(_SC("Count"), &Vector::Count)
|
||||
.Func(_SC("Equal"), &Vector::Equal)
|
||||
.Func(_SC("Each"), &Vector::Each)
|
||||
.Func(_SC("EachRange"), &Vector::EachRange)
|
||||
.Func(_SC("While"), &Vector::While)
|
||||
.Func(_SC("WhileRange"), &Vector::WhileRange)
|
||||
.Func(_SC("AsArray"), &Vector::AsArray)
|
||||
.Func(_SC("Reverse"), &Vector::Reverse)
|
||||
.Func(_SC("Generate"), &Vector::Generate)
|
||||
.Func(_SC("GenerateSome"), &Vector::GenerateSome)
|
||||
.Func(_SC("GenerateFrom"), &Vector::GenerateFrom);
|
||||
// --------------------------------------------------------------------------------------------
|
||||
ns.Bind(name, cls);
|
||||
// Bind it to the root table with a `Sq` prefix
|
||||
RootTable(vm).Bind(fmt::format("Sq{}", name).c_str(), cls);
|
||||
}
|
||||
|
||||
// ================================================================================================
|
||||
void Register_Vector(HSQUIRRELVM vm, Table & ns)
|
||||
{
|
||||
Register_Vector< SQInteger, SqVectorInteger >(vm, ns, _SC("IntVec"));
|
||||
Register_Vector< String, SqVectorString >(vm, ns, _SC("StrVec"));
|
||||
Register_Vector< SQFloat, SqVectorFloat >(vm, ns, _SC("FloatVec"));
|
||||
Register_Vector< uint8_t, SqVectorByte >(vm, ns, _SC("ByteVec"));
|
||||
Register_Vector< bool, SqVectorBool >(vm, ns, _SC("BoolVec"));
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
496
module/Library/Utils/Vector.hpp
Normal file
496
module/Library/Utils/Vector.hpp
Normal file
@ -0,0 +1,496 @@
|
||||
#pragma once
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Core/Utility.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Utility used to transform optimal argument type to stored type.
|
||||
*/
|
||||
template < class T > struct SqVectorOpt
|
||||
{
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Optimal argument type.
|
||||
*/
|
||||
using Type = T;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Convert the optimal type to the stored type. Does nothing special in this case.
|
||||
*/
|
||||
inline static Type & Get(Type & v) { return v; }
|
||||
inline static const Type & Get(const Type & v) { return v; }
|
||||
// --------------------------------------------------------------------------------------------
|
||||
inline static void Put(std::vector< T > & c, SQInteger i, Type & v)
|
||||
{ c[ConvTo< size_t >::From(i)] = v; }
|
||||
inline static void Put(std::vector< T > & c, SQInteger i, const Type & v)
|
||||
{ c[ConvTo< size_t >::From(i)] = v; }
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Specialization of SqVectorOpt for String type.
|
||||
*/
|
||||
template < > struct SqVectorOpt< String >
|
||||
{
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Optimal argument type.
|
||||
*/
|
||||
using Type = StackStrF;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Convert the optimal type to the stored type.
|
||||
*/
|
||||
inline static String Get(Type & v) { return v.ToStr(); }
|
||||
inline static String Get(const Type & v) { return v.ToStr(); }
|
||||
// --------------------------------------------------------------------------------------------
|
||||
inline static void Put(std::vector< String > & c, SQInteger i, Type & v)
|
||||
{ c[ConvTo< size_t >::From(i)].assign(v.mPtr, v.GetSize()); }
|
||||
inline static void Put(std::vector< String > & c, SQInteger i, const Type & v)
|
||||
{ c[ConvTo< size_t >::From(i)].assign(v.mPtr, v.GetSize()); }
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Wrapper around a vector of values. Space efficient array.
|
||||
*/
|
||||
template < class T > struct SqVector
|
||||
{
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Type given via the template parameter.
|
||||
*/
|
||||
using Type = T;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* The typeof vector that will be used.
|
||||
*/
|
||||
using Vector = std::vector< T >;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Reference to the vector.
|
||||
*/
|
||||
using Reference = std::shared_ptr< Vector >;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Optimal type to receive a value of this type as function argument. Mainly for strings.
|
||||
*/
|
||||
using OptimalType = typename SqVectorOpt< T >::Type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Same as OptimalType but preferably with a reference qualifier to avoid copies.
|
||||
*/
|
||||
using OptimalArg = typename std::conditional< std::is_same< T, OptimalType >::value, T, OptimalType & >::type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* A vector of bool needs special treatment from the other types.
|
||||
*/
|
||||
using ReturnType = typename std::conditional< std::is_same< T, bool >::value, T, T & >::type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Reference to the container instance.
|
||||
*/
|
||||
Reference mC;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor.
|
||||
*/
|
||||
SqVector()
|
||||
: mC(std::make_shared< Vector >())
|
||||
{
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Construct with initial capacity. No element is created.
|
||||
*/
|
||||
explicit SqVector(SQInteger n)
|
||||
: SqVector()
|
||||
{
|
||||
mC->reserve(static_cast< size_t >(n));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Construct with initial size. Filled with copies of specified element.
|
||||
*/
|
||||
SqVector(SQInteger n, OptimalArg v)
|
||||
: SqVector()
|
||||
{
|
||||
ResizeEx(n, v);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Move constructor.
|
||||
*/
|
||||
SqVector(SqVector &&) noexcept = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destroys the Statement.
|
||||
*/
|
||||
~SqVector() = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Assignment operator.
|
||||
*/
|
||||
SqVector & operator = (const SqVector &) = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Move assignment.
|
||||
*/
|
||||
SqVector & operator = (SqVector &&) noexcept = default;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Make sure a container instance is referenced.
|
||||
*/
|
||||
void Validate() const
|
||||
{
|
||||
if (!mC)
|
||||
{
|
||||
STHROWF("Invalid container instance");
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Make sure a container instance is referenced and return it.
|
||||
*/
|
||||
Vector & Valid() const { Validate(); return *mC; }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Make sure an index is within rance and return the container it. Container must exist.
|
||||
*/
|
||||
Vector & ValidIdx(SQInteger i) const
|
||||
{
|
||||
if (static_cast< size_t >(i) >= mC->size())
|
||||
{
|
||||
STHROWF("Invalid container index");
|
||||
}
|
||||
return *mC;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Make sure a container instance is referenced and is populated, then return it.
|
||||
*/
|
||||
Vector & ValidPop() const
|
||||
{
|
||||
Validate();
|
||||
if (mC->empty())
|
||||
{
|
||||
STHROWF("Container is empty");
|
||||
}
|
||||
return *mC;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Check if a container instance is referenced.
|
||||
*/
|
||||
SQMOD_NODISCARD bool IsNull() const
|
||||
{
|
||||
return static_cast< bool >(mC);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve a value from the container.
|
||||
*/
|
||||
SQMOD_NODISCARD typename std::add_const< ReturnType >::type Get(SQInteger i) const { return ValidIdx(i).at(ConvTo< size_t >::From(i)); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify a value from the container.
|
||||
*/
|
||||
void Set(SQInteger i, OptimalArg v)
|
||||
{
|
||||
SqVectorOpt< T >::Put(ValidIdx(i), i, v);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the first element in the container.
|
||||
*/
|
||||
SQMOD_NODISCARD typename std::add_const< ReturnType >::type Front() const { return ValidPop().front(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the last element in the container.
|
||||
*/
|
||||
SQMOD_NODISCARD typename std::add_const< ReturnType >::type Back() const { return ValidPop().back(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Check if the container has no elements.
|
||||
*/
|
||||
SQMOD_NODISCARD bool Empty() const { return Valid().empty(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the number of elements in the container.
|
||||
*/
|
||||
SQMOD_NODISCARD SQInteger Size() const { return static_cast< SQInteger >(Valid().size()); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the number of elements that the container has currently allocated space for.
|
||||
*/
|
||||
SQMOD_NODISCARD SQInteger Capacity() const { return static_cast< SQInteger >(Valid().capacity()); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Resize the container to contain a specific amount of elements.
|
||||
*/
|
||||
void Resize(SQInteger n)
|
||||
{
|
||||
return Valid().resize(ConvTo< size_t >::From(n), T());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Resize the container to contain a specific amount of elements.
|
||||
*/
|
||||
void ResizeEx(SQInteger n, OptimalArg v)
|
||||
{
|
||||
return Valid().resize(ConvTo< size_t >::From(n), SqVectorOpt< T >::Get(v));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Increase the capacity of the vector to a value that's greater or equal to the one specified.
|
||||
*/
|
||||
void Reserve(SQInteger n) { return Valid().reserve(ConvTo< size_t >::From(n)); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Request the removal of unused capacity.
|
||||
*/
|
||||
void Compact() { return Valid().shrink_to_fit(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Erase all elements from the container.
|
||||
*/
|
||||
void Clear() { return Valid().clear(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Push a value at the back of the container.
|
||||
*/
|
||||
void Push(OptimalArg v) { return Valid().push_back(SqVectorOpt< T >::Get(v)); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Pop the last element in the container.
|
||||
*/
|
||||
void Pop() { ValidPop().pop_back(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Erase the element at a certain position.
|
||||
*/
|
||||
void EraseAt(SQInteger i)
|
||||
{
|
||||
Validate();
|
||||
mC->erase(ValidIdx(i).begin() + static_cast< size_t >(i));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Erase a certain amount of elements starting from a specific position.
|
||||
*/
|
||||
void EraseFrom(SQInteger i, SQInteger n)
|
||||
{
|
||||
Validate();
|
||||
mC->erase(ValidIdx(i).begin() + static_cast< size_t >(i),
|
||||
ValidIdx(i + n).begin() + static_cast< size_t >(i + n));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Erase all occurrences of value from the container.
|
||||
*/
|
||||
void EraseValue(OptimalArg v)
|
||||
{
|
||||
Validate();
|
||||
mC->erase(std::remove(mC->begin(), mC->end(), SqVectorOpt< T >::Get(v)), mC->end());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a specific value starting from a certain position.
|
||||
*/
|
||||
void InsertAt(SQInteger i, OptimalArg v)
|
||||
{
|
||||
Validate();
|
||||
mC->insert(ValidIdx(i).begin() + static_cast< size_t >(i), SqVectorOpt< T >::Get(v));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a certain amount of copies of a value starting from a specific position.
|
||||
*/
|
||||
void Insert(SQInteger i, SQInteger n, OptimalArg v)
|
||||
{
|
||||
Validate();
|
||||
mC->insert(ValidIdx(i).begin() + static_cast< size_t >(i), ConvTo< size_t >::From(n), SqVectorOpt< T >::Get(v));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Locate the position of a value.
|
||||
*/
|
||||
SQMOD_NODISCARD SQInteger Locate(OptimalArg v) const
|
||||
{
|
||||
auto itr = std::find(Valid().begin(), Valid().end(), SqVectorOpt< T >::Get(v));
|
||||
return itr == mC->end() ? -1 : static_cast< SQInteger >(std::distance(mC->begin(), itr));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Locate the position of a value starting from an offset.
|
||||
*/
|
||||
SQMOD_NODISCARD SQInteger LocateFrom(SQInteger p, OptimalArg v) const
|
||||
{
|
||||
Validate();
|
||||
auto itr = std::find(ValidIdx(p).begin() + static_cast< size_t >(p),
|
||||
Valid().end(), SqVectorOpt< T >::Get(v));
|
||||
return itr == mC->end() ? -1 : static_cast< SQInteger >(std::distance(mC->begin(), itr));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Count the occurrences of a value in the container.
|
||||
*/
|
||||
SQMOD_NODISCARD SQInteger Count(OptimalArg v) const
|
||||
{
|
||||
return static_cast< SQInteger >(std::count(Valid().begin(), Valid().end(), SqVectorOpt< T >::Get(v)));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See if values are the same as another container.
|
||||
*/
|
||||
SQMOD_NODISCARD bool Equal(SqVector & o) const { return Valid() == o.Valid(); }
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Iterate all values.
|
||||
*/
|
||||
void Each(Function & fn) const
|
||||
{
|
||||
Validate();
|
||||
for (const auto & e : *mC)
|
||||
{
|
||||
fn.Execute(e);
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Iterate values in range.
|
||||
*/
|
||||
void EachRange(SQInteger p, SQInteger n, Function & fn) const
|
||||
{
|
||||
Validate();
|
||||
std::for_each(ValidIdx(p).begin() + static_cast< size_t >(p),
|
||||
ValidIdx(p + n).begin() + static_cast< size_t >(p + n),
|
||||
[&](const T & e) {
|
||||
fn.Execute(e);
|
||||
});
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Iterate all values until stopped.
|
||||
*/
|
||||
void While(Function & fn) const
|
||||
{
|
||||
Validate();
|
||||
for (const auto & e : *mC)
|
||||
{
|
||||
auto ret = fn.Eval(e);
|
||||
// (null || true) == continue & false == break
|
||||
if (!ret.IsNull() || !ret.template Cast< bool >())
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Iterate values in range until stopped.
|
||||
*/
|
||||
void WhileRange(SQInteger p, SQInteger n, Function & fn) const
|
||||
{
|
||||
Validate();
|
||||
auto itr = ValidIdx(p).begin() + static_cast< size_t >(p);
|
||||
auto end = ValidIdx(p + n).begin() + static_cast< size_t >(p + n);
|
||||
for (; itr != end; ++itr)
|
||||
{
|
||||
auto ret = fn.Eval(*itr);
|
||||
// (null || true) == continue & false == break
|
||||
if (!ret.IsNull() || !ret.template Cast< bool >())
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Create a script array with the elements from the container.
|
||||
*/
|
||||
SQMOD_NODISCARD Array AsArray() const
|
||||
{
|
||||
Validate();
|
||||
// Create a script array
|
||||
Array arr(SqVM());
|
||||
// Reserve space in advance
|
||||
arr.Reserve(static_cast< SQInteger >(mC->size()));
|
||||
// Make sure to preserve the stack
|
||||
StackGuard sg(SqVM());
|
||||
// Populate the array with vector elements
|
||||
arr.AppendFromCounted([](HSQUIRRELVM vm, SQInteger i, const Vector & v) -> bool {
|
||||
if (static_cast< size_t >(i) < v.size())
|
||||
{
|
||||
Var< T >::push(vm, v[static_cast< size_t >(i)]);
|
||||
// There's a value on the stack
|
||||
return true;
|
||||
}
|
||||
// No more elements
|
||||
return false;
|
||||
}, *mC);
|
||||
// Return the array
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Reverse the order of elements in the container.
|
||||
*/
|
||||
void Reverse()
|
||||
{
|
||||
std::reverse(Valid().begin(), Valid().end());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Generate new elements at the back of the container.
|
||||
*/
|
||||
void Generate(LightObj & ctx, Function & fn)
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
auto ret = fn.Eval(ctx);
|
||||
// null == break
|
||||
if (ret.IsNull())
|
||||
{
|
||||
break;
|
||||
}
|
||||
// Extract the value from object
|
||||
mC->push_back(ret.Cast< T >());
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Generate new elements at the back of the container.
|
||||
*/
|
||||
void GenerateSome(SQInteger n, LightObj & ctx, Function & fn)
|
||||
{
|
||||
while (n--)
|
||||
{
|
||||
auto ret = fn.Eval(ctx);
|
||||
// Extract the value from object
|
||||
mC->push_back(ret.Cast< T >());
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Generate new elements at specified position.
|
||||
*/
|
||||
void GenerateFrom(SQInteger p, SQInteger n, LightObj & ctx, Function & fn)
|
||||
{
|
||||
Validate();
|
||||
if (static_cast< size_t >(p) >= mC->size())
|
||||
{
|
||||
STHROWF("Invalid container index");
|
||||
}
|
||||
for (auto i = static_cast< size_t >(p); n--; ++i)
|
||||
{
|
||||
auto ret = fn.Eval(ctx);
|
||||
// Extract the value from object and insert it
|
||||
mC->insert(mC->begin() + i, ret.Cast< T >());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
Reference in New Issue
Block a user