Mercurial > ldforge / file diff

--- a/src/types.cpp	Sat Aug 17 11:48:27 2013 +0300
+++ b/src/types.cpp	Sun Aug 18 15:33:00 2013 +0300
@@ -27,6 +27,8 @@
 #include "ldtypes.h"
 #include "file.h"
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 str DoFormat (List<StringFormatArg> args) {
 	assert (args.size() >= 1);
 	str text = args[0].value();
@@ -37,6 +39,8 @@
 	return text;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 vertex::vertex (double x, double y, double z) {
 	m_coords[X] = x;
 	m_coords[Y] = y;
@@ -44,12 +48,14 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 void vertex::move (const vertex& other) {
 	for (const Axis ax : g_Axes)
 		m_coords[ax] += other[ax];
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 vertex vertex::midpoint (const vertex& other) {
 	vertex mid;
 	
@@ -60,6 +66,7 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 str vertex::stringRep (bool mangled) const {
 	str fmtstr = "%1 %2 %3";
 	if (mangled)
@@ -69,6 +76,7 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 void vertex::transform (matrix matr, vertex pos) {
 	double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X];
 	double y2 = (matr[3] * x()) + (matr[4] * y()) + (matr[5] * z()) + pos[Y];
@@ -79,14 +87,20 @@
 	z() = z2;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 vertex vertex::operator-() const {
 	return vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool vertex::operator!= (const vertex& other) const {
 	return !operator== (other);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 double& vertex::operator[] (const Axis ax) {
 	return coord ((ushort) ax);
 }
@@ -103,12 +117,16 @@
 	return coord (ax);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool vertex::operator== (const vertex& other) const {
 	return coord (X) == other[X] &&
 	       coord (Y) == other[Y] &&
 	       coord (Z) == other[Z];
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 vertex& vertex::operator/= (const double d) {
 	for (const Axis ax : g_Axes)
 		m_coords[ax] /= d;
@@ -116,22 +134,30 @@
 	return *this;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 vertex vertex::operator/ (const double d) const {
 	vertex other (*this);
 	return other /= d;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 vertex& vertex::operator+= (const vertex& other) {
 	move (other);
 	return *this;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 vertex vertex::operator+ (const vertex& other) const {
 	vertex newvert (*this);
 	newvert.move (other);
 	return newvert;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 int vertex::operator< (const vertex& other) const {
 	if (operator== (other))
 		return false;
@@ -152,21 +178,28 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 matrix::matrix (double vals[]) {
 	for (short i = 0; i < 9; ++i)
 		m_vals[i] = vals[i];
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 matrix::matrix (double fillval) {
 	for (short i = 0; i < 9; ++i)
 		m_vals[i] = fillval;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 matrix::matrix (initlist<double> vals) {
 	assert (vals.size() == 9);
 	memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 void matrix::puts() const {
 	for (short i = 0; i < 3; ++i) {
 		for (short j = 0; j < 3; ++j)
@@ -177,6 +210,7 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 str matrix::stringRep() const {
 	str val;
 	
@@ -191,11 +225,13 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 void matrix::zero() {
 	memset (&m_vals[0], 0, sizeof (double) * 9);
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 matrix matrix::mult (matrix other) const {
 	matrix val;
 	val.zero();
@@ -209,12 +245,14 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 matrix& matrix::operator= (matrix other) {
 	memcpy (&m_vals[0], &other.m_vals[0], sizeof (double) * 9);
 	return *this;
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 double matrix::determinant() const {
 	return (val (0) * val (4) * val (8)) +
 	       (val (1) * val (5) * val (6)) +
@@ -225,6 +263,7 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 StringFormatArg::StringFormatArg (const str& v) {
 	m_val = v;
 }
@@ -278,6 +317,7 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 File::File() {
 	// Make a null file
 	m_file = null;
@@ -294,6 +334,8 @@
 	open (fp, rtype);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 File::~File() {
 	if (m_file) {
 		m_file->close();
@@ -304,6 +346,8 @@
 	}
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool File::open (FILE* fp, OpenType rtype) {
 	return open ("", rtype, fp);
 }
@@ -337,6 +381,8 @@
 	return false;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 File::iterator File::begin() {
 	return iterator (this);
 }
@@ -345,10 +391,14 @@
 	return m_endIterator;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 void File::write (str msg) {
 	m_file->write (msg.toUtf8(), msg.length());
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool File::readLine (str& line) {
 	if (!m_textstream || m_textstream->atEnd())
 		return false;
@@ -357,6 +407,8 @@
 	return true;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool File::atEnd() const {
 	if (!m_textstream)
 		fatal ("cannot use atEnd on a null file");
@@ -364,6 +416,8 @@
 	return m_textstream->atEnd();
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool File::isNull() const {
 	return m_file == null;
 }
@@ -372,6 +426,8 @@
 	return isNull();
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 void File::close() {
 	if (!m_file)
 		return;
@@ -385,49 +441,63 @@
 	}
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool File::flush() {
 	return m_file->flush();
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 File::operator bool() const {
 	return !isNull();
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 void File::rewind() {
 	m_file->seek (0);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 File::iterator::iterator (File* f) : m_file (f) {
 	operator++();
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 void File::iterator::operator++() {
 	m_gotdata = m_file->readLine (m_text);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 str File::iterator::operator*() {
 	return m_text;
 }
 
+// =============================================================================
 // The prime contestant for the weirdest operator== 2013 award?
+// -----------------------------------------------------------------------------
 bool File::iterator::operator== (File::iterator& other) {
 	return (other.m_file == null && !m_gotdata);
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 bool File::iterator::operator!= (File::iterator& other) {
 	return !operator== (other);
 }
 
 // =============================================================================
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-// =============================================================================
+// -----------------------------------------------------------------------------
 LDBoundingBox::LDBoundingBox() {
 	reset();
 }
 
 // =============================================================================
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-// =============================================================================
+// -----------------------------------------------------------------------------
 void LDBoundingBox::calculate() {
 	reset();
 	
@@ -439,8 +509,7 @@
 }
 
 // =============================================================================
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-// =============================================================================
+// -----------------------------------------------------------------------------
 void LDBoundingBox::calcObject (LDObject* obj) {
 	switch (obj->getType()) {
 	case LDObject::Line:
@@ -468,19 +537,22 @@
 	}
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 LDBoundingBox& LDBoundingBox::operator<< (const vertex& v) {
 	calcVertex (v);
 	return *this;
 }
 
+// =============================================================================
+// -----------------------------------------------------------------------------
 LDBoundingBox& LDBoundingBox::operator<< (LDObject* obj) {
 	calcObject (obj);
 	return *this;
 }
 
 // =============================================================================
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-// =============================================================================
+// -----------------------------------------------------------------------------
 void LDBoundingBox::calcVertex (const vertex& v) {
 	for (const Axis ax : g_Axes) {
 		if (v[ax] < m_v0[ax])
@@ -494,8 +566,7 @@
 }
 
 // =============================================================================
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-// =============================================================================
+// -----------------------------------------------------------------------------
 void LDBoundingBox::reset() {
 	m_v0[X] = m_v0[Y] = m_v0[Z] = 0x7FFFFFFF;
 	m_v1[X] = m_v1[Y] = m_v1[Z] = 0xFFFFFFFF;
@@ -504,8 +575,7 @@
 }
 
 // =============================================================================
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-// =============================================================================
+// -----------------------------------------------------------------------------
 double LDBoundingBox::size() const {
 	double xscale = (m_v0[X] - m_v1[X]);
 	double yscale = (m_v0[Y] - m_v1[Y]);
@@ -525,6 +595,7 @@
 }
 
 // =============================================================================
+// -----------------------------------------------------------------------------
 vertex LDBoundingBox::center() const {
 	return vertex (
 		(m_v0[X] + m_v1[X]) / 2,