kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Base: modernize C++: return braced init list

Browse Source
This commit is contained in:
wmayer
2023-08-17 13:14:46 +02:00
committed by wwmayer
parent 2636e164f3
commit 2bc90e6090
24 changed files with 117 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Base/BaseClassPyImp.cpp
View File

@@ -32,7 +32,7 @@ using namespace Base;
// returns a string which represent the object e.g. when printed in python
std::string BaseClassPy::representation() const
{
return std::string("<binding object>");
return {"<binding object>"};
}
@@ -62,7 +62,7 @@ PyObject* BaseClassPy::getAllDerivedFrom(PyObject *args)
Py::String BaseClassPy::getTypeId() const
{
return Py::String(std::string(getBaseClassPtr()->getTypeId().getName()));
return {std::string(getBaseClassPtr()->getTypeId().getName())};
}
Py::String BaseClassPy::getModule() const
@@ -75,7 +75,7 @@ Py::String BaseClassPy::getModule() const
else
module.clear();
return Py::String(module);
return {module};
}
PyObject *BaseClassPy::getCustomAttributes(const char* /*attr*/) const

2
src/Base/CoordinateSystemPyImp.cpp
View File

@@ -35,7 +35,7 @@ using namespace Base;
// returns a string which represents the object e.g. when printed in python
std::string CoordinateSystemPy::representation() const
{
return std::string("<CoordinateSystem object>");
return {"<CoordinateSystem object>"};
}
PyObject *CoordinateSystemPy::PyMake(struct _typeobject *, PyObject *, PyObject *) // Python wrapper

26
src/Base/DualNumber.h
View File

@@ -45,48 +45,48 @@ public:
DualNumber(double re, double du = 0.0)
: re(re), du(du)
{}
DualNumber operator-() const {return DualNumber(-re,-du);}
DualNumber operator-() const {return {-re,-du};}
};
inline DualNumber operator+(DualNumber a, DualNumber b){
return DualNumber(a.re + b.re, a.du + b.du);
return {a.re + b.re, a.du + b.du};
}
inline DualNumber operator+(DualNumber a, double b){
return DualNumber(a.re + b, a.du);
return {a.re + b, a.du};
}
inline DualNumber operator+(double a, DualNumber b){
return DualNumber(a + b.re, b.du);
return {a + b.re, b.du};
}
inline DualNumber operator-(DualNumber a, DualNumber b){
return DualNumber(a.re - b.re, a.du - b.du);
return {a.re - b.re, a.du - b.du};
}
inline DualNumber operator-(DualNumber a, double b){
return DualNumber(a.re - b, a.du);
return {a.re - b, a.du};
}
inline DualNumber operator-(double a, DualNumber b){
return DualNumber(a - b.re, -b.du);
return {a - b.re, -b.du};
}
inline DualNumber operator*(DualNumber a, DualNumber b){
return DualNumber(a.re * b.re, a.re * b.du + a.du * b.re);
return {a.re * b.re, a.re * b.du + a.du * b.re};
}
inline DualNumber operator*(double a, DualNumber b){
return DualNumber(a * b.re, a * b.du);
return {a * b.re, a * b.du};
}
inline DualNumber operator*(DualNumber a, double b){
return DualNumber(a.re * b, a.du * b);
return {a.re * b, a.du * b};
}
inline DualNumber operator/(DualNumber a, DualNumber b){
return DualNumber(a.re / b.re, (a.du * b.re - a.re * b.du) / (b.re * b.re));
return {a.re / b.re, (a.du * b.re - a.re * b.du) / (b.re * b.re)};
}
inline DualNumber operator/(DualNumber a, double b){
return DualNumber(a.re / b, a.du / b);
return {a.re / b, a.du / b};
}
inline DualNumber pow(DualNumber a, double pw){
return Base::DualNumber(std::pow(a.re, pw), pw * std::pow(a.re, pw - 1.0) * a.du);
return {std::pow(a.re, pw), pw * std::pow(a.re, pw - 1.0) * a.du};
}
} //namespace

34
src/Base/DualQuaternion.cpp
View File

@@ -28,72 +28,72 @@
Base::DualQuat Base::operator+(Base::DualQuat a, Base::DualQuat b)
{
return DualQuat(
return {
a.x + b.x,
a.y + b.y,
a.z + b.z,
a.w + b.w
);
};
}
Base::DualQuat Base::operator-(Base::DualQuat a, Base::DualQuat b)
{
return DualQuat(
return {
a.x - b.x,
a.y - b.y,
a.z - b.z,
a.w - b.w
);
};
}
Base::DualQuat Base::operator*(Base::DualQuat a, Base::DualQuat b)
{
return DualQuat(
return {
a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
a.w * b.y + a.y * b.w + a.z * b.x - a.x * b.z,
a.w * b.z + a.z * b.w + a.x * b.y - a.y * b.x,
a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
);
};
}
Base::DualQuat Base::operator*(Base::DualQuat a, double b)
{
return DualQuat(
return {
a.x * b,
a.y * b,
a.z * b,
a.w * b
);
};
}
Base::DualQuat Base::operator*(double a, Base::DualQuat b)
{
return DualQuat(
return {
b.x * a,
b.y * a,
b.z * a,
b.w * a
);
};
}
Base::DualQuat Base::operator*(Base::DualQuat a, Base::DualNumber b)
{
return DualQuat(
return {
a.x * b,
a.y * b,
a.z * b,
a.w * b
);
};
}
Base::DualQuat Base::operator*(Base::DualNumber a, Base::DualQuat b)
{
return DualQuat(
return {
b.x * a,
b.y * a,
b.z * a,
b.w * a
);
};
}
Base::DualQuat::DualQuat(Base::DualQuat re, Base::DualQuat du)
@@ -136,7 +136,7 @@ Base::DualQuat Base::DualQuat::pow(double t, bool shorten) const
double le = this->vec().length();
if (le < 1e-12) {
//special case of no rotation. Interpolate position
return DualQuat(this->real(), this->dual()*t);
return {this->real(), this->dual()*t};
}
double normmult = 1.0/le;
@@ -159,8 +159,8 @@ Base::DualQuat Base::DualQuat::pow(double t, bool shorten) const
pitch *= t;
//back to quaternion
return DualQuat(
return {
l * sin(theta/2) + DualQuat(0,0,0,cos(theta/2)),
m * sin(theta/2) + pitch / 2 * cos(theta/2) * l + DualQuat(0,0,0,-pitch/2*sin(theta/2))
);
};
}

12
src/Base/DualQuaternion.h
View File

@@ -60,19 +60,19 @@ public:
DualQuat(DualQuat re, DualQuat du);
///returns dual quaternion for identity placement
static DualQuat identity() {return DualQuat(0.0, 0.0, 0.0, 1.0);}
static DualQuat identity() {return {0.0, 0.0, 0.0, 1.0};}
///return a copy with dual part zeroed out
DualQuat real() const {return DualQuat(x.re, y.re, z.re, w.re);}
DualQuat real() const {return {x.re, y.re, z.re, w.re};}
///return a real-only quaternion made from dual part of this quaternion.
DualQuat dual() const {return DualQuat(x.du, y.du, z.du, w.du);}
DualQuat dual() const {return {x.du, y.du, z.du, w.du};}
///conjugate
DualQuat conj() const {return DualQuat(-x, -y, -z, w);}
DualQuat conj() const {return {-x, -y, -z, w};}
///return vector part (with scalar part zeroed out)
DualQuat vec() const {return DualQuat(x,y,z,0.0);}
DualQuat vec() const {return {x,y,z,0.0};}
///magnitude of the quaternion
double length() const {return sqrt(x.re*x.re + y.re*y.re + z.re*z.re + w.re*w.re);}
@@ -86,7 +86,7 @@ public:
///ScLERP. t=0.0 returns identity, t=1.0 returns this. t can also be outside of 0..1 bounds.
DualQuat pow(double t, bool shorten = true) const;
DualQuat operator-() const {return DualQuat(-x, -y, -z, -w);}
DualQuat operator-() const {return {-x, -y, -z, -w};}
//DEBUG
//void print() const {

4
src/Base/FileInfo.cpp
View File

@@ -295,7 +295,7 @@ std::string FileInfo::extension() const
{
std::string::size_type pos = FileName.find_last_of('.');
if (pos == std::string::npos)
return std::string();
return {};
return FileName.substr(pos+1);
}
@@ -303,7 +303,7 @@ std::string FileInfo::completeExtension() const
{
std::string::size_type pos = FileName.find_first_of('.');
if (pos == std::string::npos)
return std::string();
return {};
return FileName.substr(pos+1);
}

4
src/Base/Interpreter.cpp
View File

@@ -243,7 +243,7 @@ std::string InterpreterSingleton::runString(const char *sCmd)
throw SystemExitException();
else {
PyException::ThrowException();
return std::string(); // just to quieten code analyzers
return {}; // just to quieten code analyzers
//throw PyException();
}
}
@@ -257,7 +257,7 @@ std::string InterpreterSingleton::runString(const char *sCmd)
}
else {
PyErr_Clear();
return std::string();
return {};
}
}

12
src/Base/Parameter.cpp
View File

@@ -980,16 +980,14 @@ std::string ParameterGrp::GetASCII(const char* Name, const char * pPreset) const
// if not return preset
if (!pcElem) {
if (!pPreset)
return std::string("");
else
return std::string(pPreset);
return {};
return {pPreset};
}
// if yes check the value and return
DOMNode *pcElem2 = pcElem->getFirstChild();
if (pcElem2)
return std::string(StrXUTF8(pcElem2->getNodeValue()).c_str());
else
return std::string("");
return {StrXUTF8(pcElem2->getNodeValue()).c_str()};
return {};
}
std::vector<std::string> ParameterGrp::GetASCIIs(const char * sFilter) const
@@ -1517,7 +1515,7 @@ ParameterManager::~ParameterManager()
Base::Reference<ParameterManager> ParameterManager::Create()
{
return Base::Reference<ParameterManager>(new ParameterManager());
return {new ParameterManager()};
}
void ParameterManager::Init()

4
src/Base/PersistencePyImp.cpp
View File

@@ -37,7 +37,7 @@ using namespace Base;
// returns a string which represent the object e.g. when printed in python
std::string PersistencePy::representation() const
{
return std::string("<persistence object>");
return {"<persistence object>"};
}
@@ -48,7 +48,7 @@ Py::String PersistencePy::getContent() const
writer.setForceXML(true);
getPersistencePtr()->Save(writer);
return Py::String (writer.getString());
return {writer.getString()};
}
Py::Int PersistencePy::getMemSize() const

4
src/Base/Placement.cpp
View File

@@ -60,7 +60,7 @@ Placement Placement::fromDualQuaternion(DualQuat qq)
{
Rotation rot(qq.x.re, qq.y.re, qq.z.re, qq.w.re);
DualQuat mvq = 2 * qq.dual() * qq.real().conj();
return Placement(Vector3d(mvq.x.re,mvq.y.re, mvq.z.re), rot);
return {Vector3d(mvq.x.re,mvq.y.re, mvq.z.re), rot};
}
Base::Matrix4D Placement::toMatrix() const
@@ -217,7 +217,7 @@ Placement Placement::slerp(const Placement & p0, const Placement & p1, double t)
{
Rotation rot = Rotation::slerp(p0.getRotation(), p1.getRotation(), t);
Vector3d pos = p0.getPosition() * (1.0-t) + p1.getPosition() * t;
return Placement(pos, rot);
return {pos, rot};
}
Placement Placement::sclerp(const Placement& p0, const Placement& p1, double t, bool shorten)

2
src/Base/PrecisionPyImp.cpp
View File

@@ -33,7 +33,7 @@ using Base::PrecisionPy;
// returns a string which represents the object e.g. when printed in python
std::string PrecisionPy::representation() const
{
return std::string("<Precision object>");
return {"<Precision object>"};
}
PyObject* PrecisionPy::angular(PyObject *args)

2
src/Base/QuantityPyImp.cpp
View File

@@ -604,7 +604,7 @@ void QuantityPy::setUnit(Py::Object arg)
Py::String QuantityPy::getUserString() const
{
return Py::String(getQuantityPtr()->getUserString().toUtf8(),"utf-8");
return {getQuantityPtr()->getUserString().toUtf8(),"utf-8"};
}
Py::Dict QuantityPy::getFormat() const

58
src/Base/Rotation.cpp
View File

@@ -535,12 +535,12 @@ Rotation Rotation::slerp(const Rotation & q0, const Rotation & q1, double t)
double y = scale0 * q0.quat[1] + scale1 * q1.quat[1];
double z = scale0 * q0.quat[2] + scale1 * q1.quat[2];
double w = scale0 * q0.quat[3] + scale1 * q1.quat[3];
return Rotation(x, y, z, w);
return {x, y, z, w};
}
Rotation Rotation::identity()
{
return Rotation(0.0, 0.0, 0.0, 1.0);
return {0.0, 0.0, 0.0, 1.0};
}
Rotation Rotation::makeRotationByAxes(Vector3d xdir, Vector3d ydir, Vector3d zdir, const char* priorityOrder)
@@ -684,7 +684,7 @@ Rotation Rotation::makeRotationByAxes(Vector3d xdir, Vector3d ydir, Vector3d zdi
m[2][i] = finaldirs[i].z;
}
return Rotation(m);
return {m};
}
void Rotation::setYawPitchRoll(double y, double p, double r)
@@ -848,12 +848,12 @@ EulerSequence_Parameters translateEulerSequence (const Rotation::EulerSequence t
switch (theSeq)
{
case Rotation::Extrinsic_XYZ: return Params (1, F, F, T);
case Rotation::Extrinsic_XZY: return Params (1, T, F, T);
case Rotation::Extrinsic_YZX: return Params (2, F, F, T);
case Rotation::Extrinsic_YXZ: return Params (2, T, F, T);
case Rotation::Extrinsic_ZXY: return Params (3, F, F, T);
case Rotation::Extrinsic_ZYX: return Params (3, T, F, T);
case Rotation::Extrinsic_XYZ: return {1, F, F, T};
case Rotation::Extrinsic_XZY: return {1, T, F, T};
case Rotation::Extrinsic_YZX: return {2, F, F, T};
case Rotation::Extrinsic_YXZ: return {2, T, F, T};
case Rotation::Extrinsic_ZXY: return {3, F, F, T};
case Rotation::Extrinsic_ZYX: return {3, T, F, T};
// Conversion of intrinsic angles is made by the same code as for extrinsic,
// using equivalence rule: intrinsic rotation is equivalent to extrinsic
@@ -861,30 +861,30 @@ EulerSequence_Parameters translateEulerSequence (const Rotation::EulerSequence t
// Swapping of angles (Alpha <-> Gamma) is done inside conversion procedure;
// sequence of axes is inverted by setting appropriate parameters here.
// Note that proper Euler angles (last block below) are symmetric for sequence of axes.
case Rotation::Intrinsic_XYZ: return Params (3, T, F, F);
case Rotation::Intrinsic_XZY: return Params (2, F, F, F);
case Rotation::Intrinsic_YZX: return Params (1, T, F, F);
case Rotation::Intrinsic_YXZ: return Params (3, F, F, F);
case Rotation::Intrinsic_ZXY: return Params (2, T, F, F);
case Rotation::Intrinsic_ZYX: return Params (1, F, F, F);
case Rotation::Intrinsic_XYZ: return {3, T, F, F};
case Rotation::Intrinsic_XZY: return {2, F, F, F};
case Rotation::Intrinsic_YZX: return {1, T, F, F};
case Rotation::Intrinsic_YXZ: return {3, F, F, F};
case Rotation::Intrinsic_ZXY: return {2, T, F, F};
case Rotation::Intrinsic_ZYX: return {1, F, F, F};
case Rotation::Extrinsic_XYX: return Params (1, F, T, T);
case Rotation::Extrinsic_XZX: return Params (1, T, T, T);
case Rotation::Extrinsic_YZY: return Params (2, F, T, T);
case Rotation::Extrinsic_YXY: return Params (2, T, T, T);
case Rotation::Extrinsic_ZXZ: return Params (3, F, T, T);
case Rotation::Extrinsic_ZYZ: return Params (3, T, T, T);
case Rotation::Extrinsic_XYX: return {1, F, T, T};
case Rotation::Extrinsic_XZX: return {1, T, T, T};
case Rotation::Extrinsic_YZY: return {2, F, T, T};
case Rotation::Extrinsic_YXY: return {2, T, T, T};
case Rotation::Extrinsic_ZXZ: return {3, F, T, T};
case Rotation::Extrinsic_ZYZ: return {3, T, T, T};
case Rotation::Intrinsic_XYX: return Params (1, F, T, F);
case Rotation::Intrinsic_XZX: return Params (1, T, T, F);
case Rotation::Intrinsic_YZY: return Params (2, F, T, F);
case Rotation::Intrinsic_YXY: return Params (2, T, T, F);
case Rotation::Intrinsic_ZXZ: return Params (3, F, T, F);
case Rotation::Intrinsic_ZYZ: return Params (3, T, T, F);
case Rotation::Intrinsic_XYX: return {1, F, T, F};
case Rotation::Intrinsic_XZX: return {1, T, T, F};
case Rotation::Intrinsic_YZY: return {2, F, T, F};
case Rotation::Intrinsic_YXY: return {2, T, T, F};
case Rotation::Intrinsic_ZXZ: return {3, F, T, F};
case Rotation::Intrinsic_ZYZ: return {3, T, T, F};
default:
case Rotation::EulerAngles : return Params (3, F, T, F); // = Intrinsic_ZXZ
case Rotation::YawPitchRoll: return Params (1, F, F, F); // = Intrinsic_ZYX
case Rotation::EulerAngles : return {3, F, T, F}; // = Intrinsic_ZXZ
case Rotation::YawPitchRoll: return {1, F, F, F}; // = Intrinsic_ZYX
};
}

14
src/Base/Stream.cpp
View File

@@ -264,7 +264,7 @@ ByteArrayOStreambuf::seekoff(std::streambuf::off_type off,
endpos = _buffer->size();
break;
default:
return pos_type(off_type(-1));
return {off_type(-1)};
}
if (endpos != curpos) {
@@ -272,7 +272,7 @@ ByteArrayOStreambuf::seekoff(std::streambuf::off_type off,
endpos = -1;
}
return pos_type(endpos);
return {endpos};
}
std::streambuf::pos_type
@@ -396,7 +396,7 @@ IODeviceOStreambuf::seekoff(std::streambuf::off_type off,
endpos = device->size();
break;
default:
return pos_type(off_type(-1));
return {off_type(-1)};
}
if (endpos != curpos) {
@@ -404,7 +404,7 @@ IODeviceOStreambuf::seekoff(std::streambuf::off_type off,
endpos = -1;
}
return pos_type(endpos);
return {endpos};
}
std::streambuf::pos_type
@@ -496,7 +496,7 @@ IODeviceIStreambuf::seekoff(std::streambuf::off_type off,
endpos = -1;
}
return pos_type(endpos);
return {endpos};
}
std::streambuf::pos_type
@@ -696,7 +696,7 @@ PyStreambuf::seekoff(PyStreambuf::off_type offset, PyStreambuf::seekdir dir, PyS
whence = 2;
break;
default:
return pos_type(off_type(-1));
return {off_type(-1)};
}
try {
@@ -715,7 +715,7 @@ PyStreambuf::seekoff(PyStreambuf::off_type offset, PyStreambuf::seekdir dir, PyS
}
catch(Py::Exception& e) {
e.clear();
return pos_type(off_type(-1));
return {off_type(-1)};
}
}

6
src/Base/Tools.h
View File

@@ -86,12 +86,12 @@ inline std::ostream& blanksN(std::ostream& os, int n)
inline manipulator<int> tabs(int n)
{
return manipulator<int>(&tabsN, n);
return {&tabsN, n};
}
inline manipulator<int> blanks(int n)
{
return manipulator<int>(&blanksN, n);
return {&blanksN, n};
}
// ----------------------------------------------------------------------------
@@ -263,7 +263,7 @@ struct BaseExport Tools
*/
static inline std::string toStdString(const QString& s) {
QByteArray tmp = s.toUtf8();
return std::string(tmp.constData(), static_cast<size_t>(tmp.size()));
return {tmp.constData(), static_cast<size_t>(tmp.size())};
}
/**

2
src/Base/Tools2D.cpp
View File

@@ -245,7 +245,7 @@ Vector2d Line2d::FromPos (double fDistance) const
{
Vector2d clDir(clV2 - clV1);
clDir.Normalize();
return Vector2d(clV1.x + (clDir.x * fDistance), clV1.y + (clDir.y * fDistance));
return {clV1.x + (clDir.x * fDistance), clV1.y + (clDir.y * fDistance)};
}
bool Line2d::IntersectAndContain (const Line2d& rclLine, Vector2d &rclV) const

18
src/Base/Tools2D.h
View File

@@ -229,12 +229,12 @@ inline bool Vector2d::operator== (const Vector2d &v) const
inline Vector2d Vector2d::operator+ () const
{
return Vector2d(x, y);
return {x, y};
}
inline Vector2d Vector2d::operator+ (const Vector2d &v) const
{
return Vector2d(x + v.x, y + v.y);
return {x + v.x, y + v.y};
}
inline Vector2d& Vector2d::operator+= (const Vector2d &v)
@@ -246,12 +246,12 @@ inline Vector2d& Vector2d::operator+= (const Vector2d &v)
inline Vector2d Vector2d::operator- () const
{
return Vector2d(-x, -y);
return {-x, -y};
}
inline Vector2d Vector2d::operator- (const Vector2d &v) const
{
return Vector2d(x - v.x, y - v.y);
return {x - v.x, y - v.y};
}
inline Vector2d& Vector2d::operator-= (const Vector2d &v)
@@ -263,7 +263,7 @@ inline Vector2d& Vector2d::operator-= (const Vector2d &v)
inline Vector2d Vector2d::operator* (double c) const
{
return Vector2d(c * x, c * y);
return {c * x, c * y};
}
inline Vector2d& Vector2d::operator*= (double c)
@@ -280,12 +280,12 @@ inline double Vector2d::operator* (const Vector2d &v) const
inline Vector2d operator* (double c, const Vector2d &v)
{
return Vector2d(c * v.x, c * v.y);
return {c * v.x, c * v.y};
}
inline Vector2d Vector2d::operator/ (double c) const
{
return Vector2d(x / c, y / c);
return {x / c, y / c};
}
inline Vector2d& Vector2d::operator/= (double c)
@@ -363,7 +363,7 @@ inline Vector2d Vector2d::Perpendicular(bool clockwise) const
inline Vector2d Vector2d::FromPolar(double r, double fi)
{
return Vector2d(r * cos(fi), r * sin(fi));
return {r * cos(fi), r * sin(fi)};
}
inline double Vector2d::Distance(const Vector2d& v) const
@@ -549,7 +549,7 @@ inline bool BoundBox2d::Contains(const Vector2d &v, double tolerance) const
inline Vector2d BoundBox2d::GetCenter() const
{
return Vector2d((MinX + MaxX) * 0.5, (MinY + MaxY) * 0.5);
return {(MinX + MaxX) * 0.5, (MinY + MaxY) * 0.5};
}
inline void BoundBox2d::SetVoid()

5
src/Base/Type.cpp
View File

@@ -125,9 +125,8 @@ string Type::getModuleName(const char* ClassName)
std::string::size_type pos = temp.find_first_of("::");
if (pos != std::string::npos)
return string(temp,0,pos);
else
return string();
return {temp,0,pos};
return {};
}
Type Type::badType()

4
src/Base/TypePyImp.cpp
View File

@@ -245,7 +245,7 @@ PyObject* TypePy::createInstanceByName (PyObject *args)
Py::String TypePy::getName() const
{
return Py::String(std::string(getBaseTypePtr()->getName()));
return {std::string(getBaseTypePtr()->getName())};
}
Py::Long TypePy::getKey() const
@@ -263,7 +263,7 @@ Py::String TypePy::getModule() const
else
module.clear();
return Py::String(module);
return {module};
}
PyObject *TypePy::getCustomAttributes(const char* /*attr*/) const

4
src/Base/Unit.cpp
View File

@@ -258,7 +258,7 @@ QString Unit::getString() const
std::stringstream ret;
if (isEmpty())
return QString();
return {};
if (Sig.Length > 0 ||
Sig.Mass > 0 ||
@@ -551,7 +551,7 @@ QString Unit::getTypeString() const
if (*this == Unit::YoungsModulus)
return QString::fromLatin1("YoungsModulus");
return QString();
return {};
}
// SI base units

2
src/Base/UnitPyImp.cpp
View File

@@ -213,7 +213,7 @@ PyObject* UnitPy::richCompare(PyObject *v, PyObject *w, int op)
Py::String UnitPy::getType() const
{
return Py::String(getUnitPtr()->getTypeString().toUtf8(),"utf-8");
return {getUnitPtr()->getTypeString().toUtf8(),"utf-8"};
}
Py::Tuple UnitPy::getSignature() const

2
src/Base/UnitsSchema.h
View File

@@ -73,7 +73,7 @@ public:
virtual bool isMultiUnitAngle() const {return false;}
//return the basic length unit for this schema
virtual std::string getBasicLengthUnit() const { return std::string("mm"); }
virtual std::string getBasicLengthUnit() const { return {"mm"}; }
};

2
src/Base/UnitsSchemaCentimeters.h
View File

@@ -38,7 +38,7 @@ class UnitsSchemaCentimeters: public UnitsSchema
public:
QString schemaTranslate(const Base::Quantity& quant, double &factor, QString &unitString) override;
std::string getBasicLengthUnit() const override { return std::string("cm"); }
std::string getBasicLengthUnit() const override { return {"cm"}; }
};
} // namespace Base

8
src/Base/UnitsSchemaImperial1.h
View File

@@ -41,7 +41,7 @@ public:
//virtual void setSchemaUnits(void);
//virtual void resetSchemaUnits(void);
QString schemaTranslate(const Base::Quantity& quant, double &factor, QString &unitString) override;
std::string getBasicLengthUnit() const override { return std::string("in"); }
std::string getBasicLengthUnit() const override { return {"in"}; }
};
/** The schema class for the imperial unit system
@@ -54,7 +54,7 @@ public:
//virtual void setSchemaUnits(void);
//virtual void resetSchemaUnits(void);
QString schemaTranslate(const Base::Quantity& quant, double &factor, QString &unitString) override;
std::string getBasicLengthUnit() const override { return std::string("in"); }
std::string getBasicLengthUnit() const override { return {"in"}; }
};
/** The schema class for the imperial unit system
@@ -67,7 +67,7 @@ public:
//virtual void setSchemaUnits(void);
//virtual void resetSchemaUnits(void);
QString schemaTranslate(const Base::Quantity& quant, double &factor, QString &unitString) override;
std::string getBasicLengthUnit() const override { return std::string("ft"); }
std::string getBasicLengthUnit() const override { return {"ft"}; }
//return true if this schema uses multiple units for length (ex. Ft/In)
bool isMultiUnitLength() const override {return true;}
@@ -84,7 +84,7 @@ public:
//virtual void setSchemaUnits(void);
//virtual void resetSchemaUnits(void);
QString schemaTranslate(const Base::Quantity& quant, double &factor, QString &unitString) override;
std::string getBasicLengthUnit() const override { return std::string("ft"); }
std::string getBasicLengthUnit() const override { return {"ft"}; }
//return true if this schema uses multiple units for angles (ex. DMS)
bool isMultiUnitAngle() const override {return true;}