luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixing Windows build - template point<C> and vector<C> are fully inlined and 'to_string' function pointer for SFINAE creates duplicate symboles

This commit is contained in:
Matthias Koefferlein 2023-08-22 23:27:10 +02:00
parent aef2979896
commit 9153763a1c
2 changed files with 208 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
src/db/db/dbPoint.h
View File

@ -47,7 +47,7 @@ class ArrayRepository;
*/
template <class C>
class DB_PUBLIC_TEMPLATE point
class DB_PUBLIC point
{
public:
typedef C coord_type;
@ -131,27 +131,48 @@ public:
/**
* @brief Add to operation
*/
point<C> &operator+= (const vector<C> &v);
point<C> &operator+= (const vector<C> &v)
{
m_x += v.x ();
m_y += v.y ();
return *this;
}
/**
* @brief method version of operator+ (mainly for automation purposes)
*/
point<C> add (const vector<C> &v) const;
point<C> add (const vector<C> &v) const
{
point<C> r (*this);
r += v;
return r;
}
/**
* @brief Subtract from operation
*/
point<C> &operator-= (const vector<C> &v);
point<C> &operator-= (const vector<C> &v)
{
m_x -= v.x ();
m_y -= v.y ();
return *this;
}
/**
* @brief method version of operator- (mainly for automation purposes)
*/
point<C> subtract (const vector<C> &v) const;
point<C> subtract (const vector<C> &v) const
{
return *this - v;
}
/**
* @brief method version of operator- (mainly for automation purposes)
*/
vector<C> subtract (const point<C> &p) const;
vector<C> subtract (const point<C> &p) const
{
return *this - p;
}
/**
* @brief "less" comparison operator
@ -159,17 +180,26 @@ public:
* This operator is provided to establish a sorting
* order
*/
bool operator< (const point<C> &p) const;
bool operator< (const point<C> &p) const
{
return m_y < p.m_y || (m_y == p.m_y && m_x < p.m_x);
}
/**
* @brief Equality test operator
*/
bool operator== (const point<C> &p) const;
bool operator== (const point<C> &p) const
{
return m_x == p.m_x && m_y == p.m_y;
}
/**
* @brief Inequality test operator
*/
bool operator!= (const point<C> &p) const;
bool operator!= (const point<C> &p) const
{
return !operator== (p);
}
/**
* @brief Const transform
@ -181,7 +211,10 @@ public:
* @return The transformed point
*/
template <class Tr>
point<typename Tr::target_coord_type> transformed (const Tr &t) const;
point<typename Tr::target_coord_type> transformed (const Tr &t) const
{
return t (*this);
}
/**
* @brief In-place transformation
@ -193,27 +226,43 @@ public:
* @return The transformed point
*/
template <class Tr>
point &transform (const Tr &t);
point &transform (const Tr &t)
{
*this = t (*this);
return *this;
}
/**
* @brief Accessor to the x coordinate
*/
C x () const;
C x () const
{
return m_x;
}
/**
* @brief Accessor to the y coordinate
*/
C y () const;
C y () const
{
return m_y;
}
/**
* @brief Write accessor to the x coordinate
*/
void set_x (C _x);
void set_x (C _x)
{
m_x = _x;
}
/**
* @brief Write accessor to the y coordinate
*/
void set_y (C _y);
void set_y (C _y)
{
m_y = _y;
}
/**
* @brief Scaling self by some factor
@ -313,7 +362,10 @@ public:
/**
* @brief Fuzzy comparison of points
*/
bool equal (const point<C> &p) const;
bool equal (const point<C> &p) const
{
return coord_traits::equal (x (), p.x ()) && coord_traits::equal (y (), p.y ());
}
/**
* @brief Fuzzy comparison of points for inequality
@ -326,7 +378,16 @@ public:
/**
* @brief Fuzzy "less" comparison of points
*/
bool less (const point<C> &p) const;
bool less (const point<C> &p) const
{
if (! coord_traits::equal (y (), p.y ())) {
return y () < p.y ();
}
if (! coord_traits::equal (x (), p.x ())) {
return x () < p.x ();
}
return false;
}
/**
* @brief The (dummy) translation operator
@ -350,131 +411,6 @@ private:
C m_x, m_y;
};
template <class C>
inline point<C> &
point<C>::operator+= (const vector<C> &v)
{
m_x += v.x ();
m_y += v.y ();
return *this;
}
template <class C>
inline point<C>
point<C>::add (const vector<C> &v) const
{
point<C> r (*this);
r += v;
return r;
}
template <class C>
inline point<C> &
point<C>::operator-= (const vector<C> &v)
{
m_x -= v.x ();
m_y -= v.y ();
return *this;
}
template <class C>
inline point<C>
point<C>::subtract (const vector<C> &v) const
{
return *this - v;
}
template <class C>
inline vector<C>
point<C>::subtract (const point<C> &p) const
{
return *this - p;
}
template <class C>
inline bool
point<C>::operator< (const point<C> &p) const
{
return m_y < p.m_y || (m_y == p.m_y && m_x < p.m_x);
}
template <class C>
inline bool
point<C>::less (const point<C> &p) const
{
if (! coord_traits::equal (y (), p.y ())) {
return y () < p.y ();
}
if (! coord_traits::equal (x (), p.x ())) {
return x () < p.x ();
}
return false;
}
template <class C>
inline bool
point<C>::operator== (const point<C> &p) const
{
return m_x == p.m_x && m_y == p.m_y;
}
template <class C>
inline bool
point<C>::equal (const point<C> &p) const
{
return coord_traits::equal (x (), p.x ()) && coord_traits::equal (y (), p.y ());
}
template <class C>
inline bool
point<C>::operator!= (const point<C> &p) const
{
return !operator== (p);
}
template <class C> template <class Tr>
inline point<typename Tr::target_coord_type>
point<C>::transformed (const Tr &t) const
{
return t (*this);
}
template <class C> template <class Tr>
inline point<C> &
point<C>::transform (const Tr &t)
{
*this = t (*this);
return *this;
}
template <class C>
inline C
point<C>::x () const
{
return m_x;
}
template <class C>
inline C
point<C>::y () const
{
return m_y;
}
template <class C>
inline void
point<C>::set_x (C _x)
{
m_x = _x;
}
template <class C>
inline void
point<C>::set_y (C _y)
{
m_y = _y;
}
template <class C>
inline point<double>
operator* (const db::point<C> &p, double s)

360
src/db/db/dbVector.h
View File

@ -45,7 +45,7 @@ template <class C> class point;
*/
template <class C>
class DB_PUBLIC_TEMPLATE vector
class DB_PUBLIC vector
{
public:
typedef C coord_type;
@ -171,22 +171,42 @@ public:
/**
* @brief Add to operation
*/
vector<C> &operator+= (const vector<C> &p);
vector<C> &operator+= (const vector<C> &p)
{
m_x += p.x ();
m_y += p.y ();
return *this;
}
/**
* @brief method version of operator+ (mainly for automation purposes)
*/
vector<C> add (const vector<C> &p) const;
vector<C> add (const vector<C> &p) const
{
vector<C> r (*this);
r += p;
return r;
}
/**
* @brief Subtract from operation
*/
vector<C> &operator-= (const vector<C> &p);
vector<C> &operator-= (const vector<C> &p)
{
m_x -= p.x ();
m_y -= p.y ();
return *this;
}
/**
* @brief method version of operator- (mainly for automation purposes)
*/
vector<C> subtract (const vector<C> &p) const;
vector<C> subtract (const vector<C> &p) const
{
vector<C> r (*this);
r -= p;
return r;
}
/**
* @brief "less" comparison operator
@ -194,17 +214,26 @@ public:
* This operator is provided to establish a sorting
* order
*/
bool operator< (const vector<C> &p) const;
bool operator< (const vector<C> &p) const
{
return m_y < p.m_y || (m_y == p.m_y && m_x < p.m_x);
}
/**
* @brief Equality test operator
*/
bool operator== (const vector<C> &p) const;
bool operator== (const vector<C> &p) const
{
return m_x == p.m_x && m_y == p.m_y;
}
/**
* @brief Inequality test operator
*/
bool operator!= (const vector<C> &p) const;
bool operator!= (const vector<C> &p) const
{
return !operator== (p);
}
/**
* @brief Const transform
@ -217,7 +246,10 @@ public:
* @return The transformed vector
*/
template <class Tr>
vector<typename Tr::target_coord_type> transformed (const Tr &t) const;
vector<typename Tr::target_coord_type> transformed (const Tr &t) const
{
return t (vector<typename Tr::target_coord_type> (*this));
}
/**
* @brief In-place transformation
@ -229,32 +261,51 @@ public:
* @return The transformed vector
*/
template <class Tr>
vector &transform (const Tr &t);
vector &transform (const Tr &t)
{
*this = vector<C> (t (*this));
return *this;
}
/**
* @brief Accessor to the x coordinate
*/
C x () const;
C x () const
{
return m_x;
}
/**
* @brief Accessor to the y coordinate
*/
C y () const;
C y () const
{
return m_y;
}
/**
* @brief Write accessor to the x coordinate
*/
void set_x (C _x);
void set_x (C _x)
{
m_x = _x;
}
/**
* @brief Write accessor to the y coordinate
*/
void set_y (C _y);
void set_y (C _y)
{
m_y = _y;
}
/**
* @brief Fuzzy comparison of vectors
*/
bool equal (const vector<C> &p) const;
bool equal (const vector<C> &p) const
{
return coord_traits::equal (x (), p.x ()) && coord_traits::equal (y (), p.y ());
}
/**
* @brief Fuzzy comparison of vectors for inequality
@ -267,31 +318,56 @@ public:
/**
* @brief Fuzzy "less" comparison of vectors
*/
bool less (const vector<C> &p) const;
bool less (const vector<C> &p) const
{
if (! coord_traits::equal (y (), p.y ())) {
return y () < p.y ();
}
if (! coord_traits::equal (x (), p.x ())) {
return x () < p.x ();
}
return false;
}
/**
* @brief Scaling by some factor
*
* To avoid round effects, the result vector is of double coordinate type.
*/
vector<double> operator* (double s) const;
vector<double> operator* (double s) const
{
return vector<double> (m_x * s, m_y * s);
}
/**
* @brief Scaling by some factor
*/
vector<C> operator* (long s) const;
vector<C> operator* (long s) const
{
return vector<C> (m_x * s, m_y * s);
}
/**
* @brief Scaling self by some factor
*
* Scaling by a double value in general involves rounding when the coordinate type is integer.
*/
vector<C> operator*= (double s);
vector<C> operator*= (double s)
{
m_x = coord_traits::rounded (m_x * s);
m_y = coord_traits::rounded (m_y * s);
return *this;
}
/**
* @brief Scaling self by some integer factor
*/
vector<C> operator*= (long s);
vector<C> operator*= (long s)
{
m_x *= s;
m_y *= s;
return *this;
}
/**
* @brief Division by some divisor.
@ -300,32 +376,60 @@ public:
* with the coord_traits scheme.
*/
vector<C> &operator/= (double s);
vector<C> &operator/= (double s)
{
double mult = 1.0 / static_cast<double>(s);
*this *= mult;
return *this;
}
/**
* @brief Dividing self by some integer divisor
*/
vector<C> &operator/= (long s);
vector<C> &operator/= (long s)
{
double mult = 1.0 / static_cast<double>(s);
*this *= mult;
return *this;
}
/**
* @brief The euclidian length
*/
distance_type length () const;
distance_type length () const
{
double ddx (x ());
double ddy (y ());
return coord_traits::rounded_distance (sqrt (ddx * ddx + ddy * ddy));
}
/**
* @brief The euclidian length of the vector
*/
double double_length () const;
double double_length () const
{
double ddx (x ());
double ddy (y ());
return sqrt (ddx * ddx + ddy * ddy);
}
/**
* @brief The square euclidian length of the vector
*/
area_type sq_length () const;
area_type sq_length () const
{
return coord_traits::sq_length (0, 0, x (), y ());
}
/**
* @brief The square of the euclidian length of the vector
*/
double sq_double_length () const;
double sq_double_length () const
{
double ddx (x ());
double ddy (y ());
return ddx * ddx + ddy * ddy;
}
/**
* @brief String conversion
@ -349,140 +453,6 @@ private:
C m_x, m_y;
};
template <class C>
inline vector<C> &
vector<C>::operator+= (const vector<C> &p)
{
m_x += p.x ();
m_y += p.y ();
return *this;
}
template <class C>
inline vector<C>
vector<C>::add (const vector<C> &p) const
{
vector<C> r (*this);
r += p;
return r;
}
template <class C>
inline vector<C> &
vector<C>::operator-= (const vector<C> &p)
{
m_x -= p.x ();
m_y -= p.y ();
return *this;
}
template <class C>
inline vector<C>
vector<C>::subtract (const vector<C> &p) const
{
vector<C> r (*this);
r -= p;
return r;
}
template <class C>
inline bool
vector<C>::operator< (const vector<C> &p) const
{
return m_y < p.m_y || (m_y == p.m_y && m_x < p.m_x);
}
template <class C>
inline bool
vector<C>::less (const vector<C> &p) const
{
if (! coord_traits::equal (y (), p.y ())) {
return y () < p.y ();
}
if (! coord_traits::equal (x (), p.x ())) {
return x () < p.x ();
}
return false;
}
template <class C>
inline bool
vector<C>::operator== (const vector<C> &p) const
{
return m_x == p.m_x && m_y == p.m_y;
}
template <class C>
inline bool
vector<C>::equal (const vector<C> &p) const
{
return coord_traits::equal (x (), p.x ()) && coord_traits::equal (y (), p.y ());
}
template <class C>
inline bool
vector<C>::operator!= (const vector<C> &p) const
{
return !operator== (p);
}
template <class C> template <class Tr>
inline vector<typename Tr::target_coord_type>
vector<C>::transformed (const Tr &t) const
{
return t (vector<typename Tr::target_coord_type> (*this));
}
template <class C> template <class Tr>
inline vector<C> &
vector<C>::transform (const Tr &t)
{
*this = vector<C> (t (*this));
return *this;
}
template <class C>
inline C
vector<C>::x () const
{
return m_x;
}
template <class C>
inline C
vector<C>::y () const
{
return m_y;
}
template <class C>
inline void
vector<C>::set_x (C _x)
{
m_x = _x;
}
template <class C>
inline void
vector<C>::set_y (C _y)
{
m_y = _y;
}
template <class C>
inline vector<double>
vector<C>::operator* (double s) const
{
return vector<double> (m_x * s, m_y * s);
}
template <class C>
inline vector<C>
vector<C>::operator* (long s) const
{
return vector<C> (m_x * s, m_y * s);
}
template <class C, typename Number>
inline vector<C>
operator/ (const db::vector<C> &p, Number s)
@ -491,76 +461,6 @@ operator/ (const db::vector<C> &p, Number s)
return vector<C> (p.x () * mult, p.y () * mult);
}
template <class C>
inline vector<C> &
vector<C>::operator/= (double s)
{
double mult = 1.0 / static_cast<double>(s);
*this *= mult;
return *this;
}
template <class C>
inline vector<C> &
vector<C>::operator/= (long s)
{
double mult = 1.0 / static_cast<double>(s);
*this *= mult;
return *this;
}
template <class C>
inline vector<C>
vector<C>::operator*= (double s)
{
m_x = coord_traits::rounded (m_x * s);
m_y = coord_traits::rounded (m_y * s);
return *this;
}
template <class C>
inline vector<C>
vector<C>::operator*= (long s)
{
m_x *= s;
m_y *= s;
return *this;
}
template <class C>
inline typename vector<C>::distance_type
vector<C>::length () const
{
double ddx (x ());
double ddy (y ());
return coord_traits::rounded_distance (sqrt (ddx * ddx + ddy * ddy));
}
template <class C>
inline double
vector<C>::double_length () const
{
double ddx (x ());
double ddy (y ());
return sqrt (ddx * ddx + ddy * ddy);
}
template <class C>
inline typename vector<C>::area_type
vector<C>::sq_length () const
{
return coord_traits::sq_length (0, 0, x (), y ());
}
template <class C>
inline double
vector<C>::sq_double_length () const
{
double ddx (x ());
double ddy (y ());
return ddx * ddx + ddy * ddy;
}
/**
* @brief The binary + operator (addition of vectors)
*