path: root/utils/idftools/idf_outlines.cpp

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014  Cirilo Bernardo
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#include <iostream>
#include <iomanip>
#include <sstream>
#include <cmath>

#include <idf_helpers.h>
#include <idf_outlines.h>
#include <idf_parser.h>

using namespace IDF3;
using namespace std;


static std::string GetOutlineTypeString( IDF3::OUTLINE_TYPE aOutlineType )
{
    switch( aOutlineType )
    {
        case OTLN_BOARD:
            return ".BOARD_OUTLINE";

        case OTLN_OTHER:
            return ".OTHER_OUTLINE";

        case OTLN_PLACE:
            return ".PLACEMENT_OUTLINE";

        case OTLN_ROUTE:
            return ".ROUTE_OUTLINE";

        case OTLN_PLACE_KEEPOUT:
            return ".PLACE_KEEPOUT";

        case OTLN_ROUTE_KEEPOUT:
            return ".ROUTE_KEEPOUT";

        case OTLN_VIA_KEEPOUT:
            return ".VIA_KEEPOUT";

        case OTLN_GROUP_PLACE:
            return ".PLACE_REGION";

        case OTLN_COMPONENT:
            return "COMPONENT OUTLINE";

        default:
            break;
    }

    std::ostringstream ostr;
    ostr << "[INVALID OUTLINE TYPE VALUE]:" << aOutlineType;

    return ostr.str();
}

#ifndef DISABLE_IDF_OWNERSHIP
static bool CheckOwnership( int aSourceLine, const char* aSourceFunc,
                            IDF3_BOARD* aParent, IDF3::KEY_OWNER aOwnerCAD,
                            IDF3::OUTLINE_TYPE aOutlineType, std::string& aErrorString )
{
    if( aParent == NULL )
    {
        ostringstream ostr;
        ostr << "* " << __FILE__ << ":" << aSourceLine << ":" << aSourceFunc << "():\n";
        ostr << "* BUG: outline's parent not set; cannot enforce ownership rules\n";
        ostr << "* outline type: " << GetOutlineTypeString( aOutlineType );
        aErrorString = ostr.str();

        return false;
    }

    // note: component outlines have no owner so we don't care about
    // who modifies them
    if( aOwnerCAD == UNOWNED || aOutlineType == IDF3::OTLN_COMPONENT )
        return true;

    IDF3::CAD_TYPE parentCAD = aParent->GetCadType();

    if( aOwnerCAD == MCAD && parentCAD == CAD_MECH )
        return true;

    if( aOwnerCAD == ECAD && parentCAD == CAD_ELEC )
        return true;

    do
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << aSourceLine << ":" << aSourceFunc << "():\n";
        ostr << "* ownership violation; CAD type is ";

        if( parentCAD == CAD_MECH )
            ostr << "MCAD ";
        else
            ostr << "ECAD ";

        ostr << "while outline owner is " << GetOwnerString( aOwnerCAD ) << "\n";
        ostr << "* outline type: " << GetOutlineTypeString( aOutlineType );
        aErrorString = ostr.str();

    } while( 0 );

    return false;
}
#endif


/*
 * CLASS: BOARD OUTLINE
 */
BOARD_OUTLINE::BOARD_OUTLINE()
{
    outlineType = OTLN_BOARD;
    single = false;
    owner = UNOWNED;
    parent = NULL;
    thickness = 0.0;
    unit = UNIT_MM;
    return;
}

BOARD_OUTLINE::~BOARD_OUTLINE()
{
    clear();
    return;
}

IDF3::OUTLINE_TYPE BOARD_OUTLINE::GetOutlineType( void )
{
    return outlineType;
}

void BOARD_OUTLINE::readOutlines( std::ifstream& aBoardFile, IDF3::IDF_VERSION aIdfVersion )
{
    // reads the outline data from a file
    double x, y, ang;
    double dLoc  = 1e-5;    // distances are equal when closer than 0.1 micron
    bool comment = false;
    bool quoted  = false;
    bool closed  = false;
    int idx      = 0;
    int loopidx  = -1;
    int tmp      = 0;
    int npts     = 0;
    std::string iline;
    std::string entry;
    std::stringstream tstr;
    IDF_OUTLINE* op = NULL;
    IDF_SEGMENT* sp = NULL;
    IDF_POINT prePt;
    IDF_POINT curPt;
    std::streampos pos;

    // destroy any existing outline data
    clearOutlines();

    while( aBoardFile.good() )
    {
        if( !FetchIDFLine( aBoardFile, iline, comment, pos ) )
            continue;

        idx = 0;
        GetIDFString( iline, entry, quoted, idx );

        if( quoted )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 1 of " << GetOutlineTypeString( outlineType );
            ostr << " is quoted\n";
            ostr << "* line: '" << iline << "'";

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        // check for the end of the section
        if( entry.size() >= 5 && CompareToken( ".END_", entry.substr( 0, 5 ) ) )
        {
            // rewind to the start of the last line; the routine invoking
            // this is responsible for checking that the current '.END_ ...'
            // matches the section header.
            if(aBoardFile.eof())
                aBoardFile.clear();

            aBoardFile.seekg( pos );

            if( outlines.size() > 0 )
            {
                if( npts > 0 && !closed )
                {
                    ostringstream ostr;
                    ostr << "invalid outline (not closed)\n";
                    ostr << "* file position: " << pos;

                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                }

                // verify winding
                if( !single )
                {
                    if( !outlines.front()->IsCCW() )
                    {
                        ERROR_IDF << "invalid IDF3 file (BOARD_OUTLINE)\n";
                        cerr << "* WARNING: first outline is not in CCW order\n";
                        return;
                    }

                    if( outlines.size() > 1 && outlines.back()->IsCCW() && !outlines.back()->IsCircle() )
                    {
                        ERROR_IDF << "invalid IDF3 file (BOARD_OUTLINE)\n";
                        cerr << "* WARNING: final cutout does not have points in CW order\n";
                        cerr << "* file position: " << pos << "\n";
                        return;
                    }
                }
            }

            return;
        }

        tstr.clear();
        tstr << entry;

        tstr >> tmp;
        if( tstr.fail() )
        {
            if( outlineType == OTLN_COMPONENT && CompareToken( "PROP", entry ) )
            {
                aBoardFile.seekg( pos );
                return;
            }

            do{
                ostringstream ostr;

                ostr << "\n* invalid outline: RECORD 3, FIELD 1 of " << GetOutlineTypeString( outlineType );
                ostr << " is not numeric\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );

            } while( 0 );
        }

        if( tmp != loopidx )
        {
            // index change
            if( npts > 0 && !closed )
            {
                ostringstream ostr;
                ostr << "invalid outline ( outline # " << loopidx << " not closed)\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            if( tmp < 0 )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: RECORD 3, FIELD 1 of " << GetOutlineTypeString( outlineType );
                ostr << " is invalid\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            if( loopidx == -1 )
            {
                // first outline
                if( single )
                {
                    // outline may have a Loop Index of 0 or 1
                    if( tmp == 0 || tmp == 1 )
                    {
                        op = new IDF_OUTLINE;

                        if( op == NULL )
                        {
                            clearOutlines();
                            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                                              "memory allocation failed" ) );
                        }

                        outlines.push_back( op );
                        loopidx = tmp;
                    }
                    else
                    {
                        ostringstream ostr;

                        ostr << "\n* invalid outline: RECORD 3, FIELD 1 of " << GetOutlineTypeString( outlineType );
                        ostr << " is invalid (must be 0 or 1)\n";
                        ostr << "* line: '" << iline << "'\n";
                        ostr << "* file position: " << pos;

                        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                    }
                }
                else
                {
                    // outline *MUST* have a Loop Index of 0
                    if( tmp != 0 )
                    {
                        ostringstream ostr;

                        ostr << "\n* invalid outline: RECORD 3, FIELD 1 of " << GetOutlineTypeString( outlineType );
                        ostr << " is invalid (must be 0)\n";
                        ostr << "* line: '" << iline << "'\n";
                        ostr << "* file position: " << pos;

                        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                    }

                    op = new IDF_OUTLINE;

                    if( op == NULL )
                    {
                        clearOutlines();
                        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                                          "memory allocation failed" ) );
                    }

                    outlines.push_back( op );
                    loopidx = tmp;
                }
                // end of block for first outline
            }
            else
            {
                // outline for cutout
                if( single )
                {
                    ostringstream ostr;

                    ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType );
                    ostr << " section may only have one outline\n";
                    ostr << "* line: '" << iline << "'\n";
                    ostr << "* file position: " << pos;

                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                }

                if( tmp - loopidx != 1 )
                {
                    ostringstream ostr;

                    ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType );
                    ostr << " section must have cutouts in numeric order from 1 onwards\n";
                    ostr << "* line: '" << iline << "'\n";
                    ostr << "* file position: " << pos;

                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                }

                // verify winding of previous outline
                if( ( loopidx == 0 && !op->IsCCW() )
                    || ( loopidx > 0 && op->IsCCW() && !op->IsCircle() ) )
                {
                    ostringstream ostr;

                    ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                    ostr << "* violation of loop point order rules by Loop Index " << loopidx << "\n";
                    ostr << "* line: '" << iline << "'\n";
                    ostr << "* file position: " << pos;

                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                }

                op = new IDF_OUTLINE;

                if( op == NULL )
                {
                    clearOutlines();
                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                                      "memory allocation failed" ) );
                }

                outlines.push_back( op );
                loopidx = tmp;
            }
            // end of index change code
            npts = 0;
            closed = false;
        }

        if( op == NULL )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 1 of " << GetOutlineTypeString( outlineType );
            ostr << " is invalid\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, entry, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 2 of ";
            ostr << GetOutlineTypeString( outlineType ) << " does not exist\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( quoted )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 2 of ";
            ostr << GetOutlineTypeString( outlineType ) << " must not be in quotes\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        tstr.clear();
        tstr << entry;

        tstr >> x;
        if( tstr.fail() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 2 of ";
            ostr << GetOutlineTypeString( outlineType ) << " is an invalid X value\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, entry, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 3 of ";
            ostr << GetOutlineTypeString( outlineType ) << " does not exist\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( quoted )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 3 of ";
            ostr << GetOutlineTypeString( outlineType ) << " must not be in quotes\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        tstr.clear();
        tstr << entry;

        tstr >> y;
        if( tstr.fail() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 3 of ";
            ostr << GetOutlineTypeString( outlineType ) << " is an invalid Y value\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, entry, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 4 of ";
            ostr << GetOutlineTypeString( outlineType ) << " does not exist\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( quoted )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 4 of ";
            ostr << GetOutlineTypeString( outlineType ) << " must not be in quotes\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        tstr.clear();
        tstr << entry;

        tstr >> ang;
        if( tstr.fail() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: RECORD 3, FIELD 4 of ";
            ostr << GetOutlineTypeString( outlineType ) << " is not a valid angle\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        // the line was successfully read; convert to mm if necessary
        if( unit == UNIT_THOU )
        {
            x *= IDF_THOU_TO_MM;
            y *= IDF_THOU_TO_MM;
        }
        else if( ( aIdfVersion == IDF_V2 ) && ( unit == UNIT_TNM ) )
        {
            x *= IDF_TNM_TO_MM;
            y *= IDF_TNM_TO_MM;
        }
        else if( unit != UNIT_MM )
        {
            ostringstream ostr;
            ostr << "\n* BUG: invalid UNIT type: " << unit;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( npts++ == 0 )
        {
            // first point
            prePt.x = x;
            prePt.y = y;

            // ensure that the first point is not an arc specification
            if( ang < -MIN_ANG || ang > MIN_ANG )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: RECORD 3 of ";
                ostr << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: first point of an outline has a non-zero angle\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }
        }
        else
        {
            // Nth point
            if( closed )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: RECORD 3 of ";
                ostr << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: adding a segment to a closed outline\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            curPt.x = x;
            curPt.y = y;

            if( ang > -MIN_ANG && ang < MIN_ANG )
            {
                sp = new IDF_SEGMENT( prePt, curPt );
            }
            else
            {
                sp = new IDF_SEGMENT( prePt, curPt, ang, false );
            }

            if( sp == NULL )
            {
                clearOutlines();
                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                                  "memory allocation failed" ) );
            }

            if( sp->IsCircle() )
            {
                // this is  a circle; the loop is closed
                if( op->size() != 0 )
                {
                    delete sp;

                    ostringstream ostr;

                    ostr << "\n* invalid outline: RECORD 3 of ";
                    ostr << GetOutlineTypeString( outlineType ) << "\n";
                    ostr << "* violation: adding a circle to a non-empty outline\n";
                    ostr << "* line: '" << iline << "'\n";
                    ostr << "* file position: " << pos;

                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                }

                closed = true;
            }
            else if( op->size() != 0 )
            {
                if( curPt.Matches( op->front()->startPoint, dLoc ) )
                    closed = true;
            }

            op->push( sp );
            prePt.x = x;
            prePt.y = y;
        }
    }   //  while( aBoardFile.good() )

    // NOTE:
    // 1. ideally we would ensure that there are no arcs with a radius of 0

    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                      "problems reading file (premature end of outline)" ) );

    return;
}

bool BOARD_OUTLINE::writeComments( std::ofstream& aBoardFile )
{
    if( comments.empty() )
        return true;

    list< string >::const_iterator itS = comments.begin();
    list< string >::const_iterator itE = comments.end();

    while( itS != itE )
    {
        aBoardFile << "# " << *itS << "\n";
        ++itS;
    }

    return !aBoardFile.fail();
}

bool BOARD_OUTLINE::writeOwner( std::ofstream& aBoardFile )
{
    switch( owner )
    {
        case ECAD:
            aBoardFile << "ECAD\n";
            break;

        case MCAD:
            aBoardFile << "MCAD\n";
            break;

        default:
            aBoardFile << "UNOWNED\n";
            break;
    }

    return !aBoardFile.fail();
}

void BOARD_OUTLINE::writeOutline( std::ofstream& aBoardFile, IDF_OUTLINE* aOutline, size_t aIndex )
{
    std::list<IDF_SEGMENT*>::iterator bo;
    std::list<IDF_SEGMENT*>::iterator eo;

    if( !aOutline )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* BUG: NULL outline pointer" ) );

    if( aOutline->size() == 1 )
    {
        if( !aOutline->front()->IsCircle() )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "bad outline (single segment item, not circle)" ) );

        if( single )
            aIndex = 0;

        // NOTE: a circle always has an angle of 360, never -360,
        // otherwise SolidWorks chokes on the file.
        if( unit != UNIT_THOU )
        {
            aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
            << aOutline->front()->startPoint.x << " "
            << aOutline->front()->startPoint.y << " 0\n";

            aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
            << aOutline->front()->endPoint.x << " "
            << aOutline->front()->endPoint.y << " 360\n";
        }
        else
        {
            aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
            << (aOutline->front()->startPoint.x / IDF_THOU_TO_MM) << " "
            << (aOutline->front()->startPoint.y / IDF_THOU_TO_MM) << " 0\n";

            aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
            << (aOutline->front()->endPoint.x / IDF_THOU_TO_MM) << " "
            << (aOutline->front()->endPoint.y / IDF_THOU_TO_MM) << " 360\n";
        }

        return;
    }

    if( single )
    {
        // only indices 0 (CCW) and 1 (CW) are valid; set the index according to
        // the outline's winding
        if( aOutline->IsCCW() )
            aIndex = 0;
        else
            aIndex = 1;
    }


    // check if we must reverse things
    if( ( aOutline->IsCCW() && ( aIndex > 0 ) )
        || ( ( !aOutline->IsCCW() ) && ( aIndex == 0 ) ) )
    {
        eo  = aOutline->begin();
        bo  = aOutline->end();
        --bo;

        // ensure that the very last point is the same as the very first point
        if( aOutline->size() > 1 )
        {
            std::list<IDF_SEGMENT*>::iterator to = eo;
            ++to;
            (*to)->startPoint = (*eo)->endPoint;
        }

        // for the first item we write out both points
        if( unit != UNIT_THOU )
        {
            if( aOutline->front()->angle < MIN_ANG && aOutline->front()->angle > -MIN_ANG )
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << aOutline->front()->endPoint.x << " "
                << aOutline->front()->endPoint.y << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << aOutline->front()->startPoint.x << " "
                << aOutline->front()->startPoint.y << " 0\n";
            }
            else
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << aOutline->front()->endPoint.x << " "
                << aOutline->front()->endPoint.y << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << aOutline->front()->startPoint.x << " "
                << aOutline->front()->startPoint.y << " "
                << setprecision(3) << -aOutline->front()->angle << "\n";
            }
        }
        else
        {
            if( aOutline->front()->angle < MIN_ANG && aOutline->front()->angle > -MIN_ANG )
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << (aOutline->front()->endPoint.x / IDF_THOU_TO_MM) << " "
                << (aOutline->front()->endPoint.y / IDF_THOU_TO_MM) << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << (aOutline->front()->startPoint.x / IDF_THOU_TO_MM) << " "
                << (aOutline->front()->startPoint.y / IDF_THOU_TO_MM) << " 0\n";
            }
            else
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << (aOutline->front()->endPoint.x / IDF_THOU_TO_MM) << " "
                << (aOutline->front()->endPoint.y / IDF_THOU_TO_MM) << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << (aOutline->front()->startPoint.x / IDF_THOU_TO_MM) << " "
                << (aOutline->front()->startPoint.y / IDF_THOU_TO_MM) << " "
                << setprecision(3) << -aOutline->front()->angle << "\n";
            }
        }

        // for all other segments we only write out the start point
        while( bo != eo )
        {
            if( unit != UNIT_THOU )
            {
                if( (*bo)->angle < MIN_ANG && (*bo)->angle > -MIN_ANG )
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                    << (*bo)->startPoint.x << " "
                    << (*bo)->startPoint.y << " 0\n";
                }
                else
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                    << (*bo)->startPoint.x << " "
                    << (*bo)->startPoint.y << " "
                    << setprecision(3) << -(*bo)->angle << "\n";
                }
            }
            else
            {
                if( (*bo)->angle < MIN_ANG && (*bo)->angle > -MIN_ANG )
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                    << ((*bo)->startPoint.x / IDF_THOU_TO_MM) << " "
                    << ((*bo)->startPoint.y / IDF_THOU_TO_MM) << " 0\n";
                }
                else
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                    << ((*bo)->startPoint.x / IDF_THOU_TO_MM) << " "
                    << ((*bo)->startPoint.y / IDF_THOU_TO_MM) << " "
                    << setprecision(3) << -(*bo)->angle << "\n";
                }
            }

            --bo;
        }
    }
    else
    {
        // ensure that the very last point is the same as the very first point
        if( aOutline->size() > 1 )
            aOutline->back()-> endPoint = aOutline->front()->startPoint;

        bo  = aOutline->begin();
        eo  = aOutline->end();

        // for the first item we write out both points
        if( unit != UNIT_THOU )
        {
            if( (*bo)->angle < MIN_ANG && (*bo)->angle > -MIN_ANG )
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << (*bo)->startPoint.x << " "
                << (*bo)->startPoint.y << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << (*bo)->endPoint.x << " "
                << (*bo)->endPoint.y << " 0\n";
            }
            else
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << (*bo)->startPoint.x << " "
                << (*bo)->startPoint.y << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                << (*bo)->endPoint.x << " "
                << (*bo)->endPoint.y << " "
                << setprecision(3) << (*bo)->angle << "\n";
            }
        }
        else
        {
            if( (*bo)->angle < MIN_ANG && (*bo)->angle > -MIN_ANG )
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << ((*bo)->startPoint.x / IDF_THOU_TO_MM) << " "
                << ((*bo)->startPoint.y / IDF_THOU_TO_MM) << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << ((*bo)->endPoint.x / IDF_THOU_TO_MM) << " "
                << ((*bo)->endPoint.y / IDF_THOU_TO_MM) << " 0\n";
            }
            else
            {
                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << ((*bo)->startPoint.x / IDF_THOU_TO_MM) << " "
                << ((*bo)->startPoint.y / IDF_THOU_TO_MM) << " 0\n";

                aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                << ((*bo)->endPoint.x / IDF_THOU_TO_MM) << " "
                << ((*bo)->endPoint.y / IDF_THOU_TO_MM) << " "
                << setprecision(3) << (*bo)->angle << "\n";
            }
        }

        ++bo;

        // for all other segments we only write out the last point
        while( bo != eo )
        {
            if( unit != UNIT_THOU )
            {
                if( (*bo)->angle < MIN_ANG && (*bo)->angle > -MIN_ANG )
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                    << (*bo)->endPoint.x << " "
                    << (*bo)->endPoint.y << " 0\n";
                }
                else
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(5)
                    << (*bo)->endPoint.x << " "
                    << (*bo)->endPoint.y << " "
                    << setprecision(3) << (*bo)->angle << "\n";
                }
            }
            else
            {
                if( (*bo)->angle < MIN_ANG && (*bo)->angle > -MIN_ANG )
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                    << ((*bo)->endPoint.x / IDF_THOU_TO_MM) << " "
                    << ((*bo)->endPoint.y / IDF_THOU_TO_MM) << " 0\n";
                }
                else
                {
                    aBoardFile << aIndex << " " << setiosflags(ios::fixed) << setprecision(1)
                    << ((*bo)->endPoint.x / IDF_THOU_TO_MM) << " "
                    << ((*bo)->endPoint.y / IDF_THOU_TO_MM) << " "
                    << setprecision(3) << (*bo)->angle << "\n";
                }
            }

            ++bo;
        }
    }

    return;
}

void BOARD_OUTLINE::writeOutlines( std::ofstream& aBoardFile )
{
    if( outlines.empty() )
        return;

    int idx = 0;
    std::list< IDF_OUTLINE* >::iterator itS = outlines.begin();
    std::list< IDF_OUTLINE* >::iterator itE = outlines.end();

    while( itS != itE )
    {
        writeOutline( aBoardFile, *itS, idx++ );
        ++itS;
    }

    return;
}

bool BOARD_OUTLINE::SetUnit( IDF3::IDF_UNIT aUnit )
{
    // note: although UNIT_TNM is accepted here without reservation,
    // this can only affect data being read from a file.
    if( aUnit != UNIT_MM && aUnit != UNIT_THOU && aUnit != UNIT_TNM )
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
        ostr << "* BUG: invalid IDF UNIT (must be one of UNIT_MM or UNIT_THOU): " << aUnit << "\n";
        ostr << "* outline type: " << GetOutlineTypeString( outlineType );
        errormsg = ostr.str();

        return false;
    }

    unit = aUnit;
    return true;
}

IDF3::IDF_UNIT BOARD_OUTLINE::GetUnit( void )
{
    return unit;
}

bool BOARD_OUTLINE::setThickness( double aThickness )
{
    if( aThickness < 0.0 )
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
        ostr << "* BUG: aThickness < 0.0\n";
        ostr << "* outline type: " << GetOutlineTypeString( outlineType );
        errormsg = ostr.str();

        return false;
    }

    thickness = aThickness;
    return true;
}

bool BOARD_OUTLINE::SetThickness( double aThickness )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    return setThickness( aThickness );
}

double BOARD_OUTLINE::GetThickness( void )
{
    return thickness;
}

void BOARD_OUTLINE::readData( std::ifstream& aBoardFile, const std::string& aHeader,
                              IDF3::IDF_VERSION aIdfVersion )
{
    //  BOARD_OUTLINE (PANEL_OUTLINE)
    //      .BOARD_OUTLINE  [OWNER]
    //      [thickness]
    //      [outlines]

    // check RECORD 1
    std::string token;
    bool quoted = false;
    int  idx = 0;
    std::streampos pos;

    pos = aBoardFile.tellg();

    if( !GetIDFString( aHeader, token, quoted, idx ) )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, "invalid invocation: blank header line" ) );

    if( quoted )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: section names may not be in quotes\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !CompareToken( ".BOARD_OUTLINE", token ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: not a board outline\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        if( aIdfVersion > IDF_V2 )
            ERROR_IDF << "no OWNER; setting to UNOWNED\n";

        owner = UNOWNED;
    }
    else
    {
        if( !ParseOwner( token, owner ) )
        {
            ERROR_IDF << "invalid OWNER (reverting to UNOWNED): " << token << "\n";
            owner = UNOWNED;
        }
    }

    // check RECORD 2
    std::string iline;
    bool comment = false;
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( ( !aBoardFile.good() && !aBoardFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within .BOARD_OUTLINE section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no thickness specified\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    std::stringstream teststr;
    teststr << token;

    teststr >> thickness;
    if( teststr.fail() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: invalid RECORD 2 (thickness)\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( unit == UNIT_THOU )
    {
        thickness *= IDF_THOU_TO_MM;
    }
    else if( ( aIdfVersion == IDF_V2 ) && ( unit == UNIT_TNM ) )
    {
        thickness *= IDF_TNM_TO_MM;
    }
    else if( unit != UNIT_MM )
    {
        ostringstream ostr;
        ostr << "\n* BUG: invalid UNIT type: " << unit;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    // for some unknown reason IDF allows 0 or negative thickness, but this
    // is a problem so we fix it here
    if( thickness <= 0.0 )
    {
        if( thickness == 0.0 )
        {
            ERROR_IDF << "\n* WARNING: setting board thickness to default 1.6mm (";
            cerr << thickness << ")\n";
            thickness = 1.6;
        }
        else
        {
            thickness = -thickness;
            ERROR_IDF << "\n* WARNING: setting board thickness to positive number (";
            cerr << thickness << ")\n";
        }
    }

    // read RECORD 3 values
    readOutlines( aBoardFile, aIdfVersion );

    // check RECORD 4
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( ( !aBoardFile.good() && aBoardFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !CompareToken( ".END_BOARD_OUTLINE", iline ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no .END_BOARD_OUTLINE found\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    return;
}


void BOARD_OUTLINE::writeData( std::ofstream& aBoardFile )
{
    writeComments( aBoardFile );

    // note: a BOARD_OUTLINE section is required, even if it is empty
    aBoardFile << ".BOARD_OUTLINE ";

    writeOwner( aBoardFile );

    if( unit != UNIT_THOU )
        aBoardFile << setiosflags(ios::fixed) << setprecision(5) << thickness << "\n";
    else
        aBoardFile << setiosflags(ios::fixed) << setprecision(1) << (thickness / IDF_THOU_TO_MM) << "\n";

    writeOutlines( aBoardFile );

    aBoardFile << ".END_BOARD_OUTLINE\n\n";

    return;
}

void BOARD_OUTLINE::clear( void )
{
    comments.clear();
    clearOutlines();

    owner = UNOWNED;
    return;
}

bool BOARD_OUTLINE::Clear( void )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    clear();

    return true;
}

void BOARD_OUTLINE::setParent( IDF3_BOARD* aParent )
{
    parent = aParent;
}

IDF3_BOARD* BOARD_OUTLINE::GetParent( void )
{
    return parent;
}

bool BOARD_OUTLINE::addOutline( IDF_OUTLINE* aOutline )
{
    std::list< IDF_OUTLINE* >::iterator itS = outlines.begin();
    std::list< IDF_OUTLINE* >::iterator itE = outlines.end();

    try
    {
        while( itS != itE )
        {
            if( *itS == aOutline )
                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                                  "duplicate outline pointer" ) );

            ++itS;
        }

        outlines.push_back( aOutline );

    }
    catch( const std::exception& e )
    {
        errormsg = e.what();

        return false;
    }

    return true;
}

bool BOARD_OUTLINE::AddOutline( IDF_OUTLINE* aOutline )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    return addOutline( aOutline );
}

bool BOARD_OUTLINE::DelOutline( IDF_OUTLINE* aOutline )
{
    std::list< IDF_OUTLINE* >::iterator itS = outlines.begin();
    std::list< IDF_OUTLINE* >::iterator itE = outlines.end();

    if( !aOutline )
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
        ostr << "* BUG: NULL aOutline pointer\n";
        ostr << "* outline type: " << GetOutlineTypeString( outlineType );
        errormsg = ostr.str();

        return false;
    }

    if( outlines.empty() )
    {
        errormsg.clear();
        return false;
    }

    // if there are more than 1 outlines it makes no sense to delete
    // the first outline (board outline) since that would have the
    // undesirable effect of substituting a cutout outline as the board outline
    if( aOutline == outlines.front() )
    {
        if( outlines.size() > 1 )
        {
            ostringstream ostr;
            ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
            ostr << "* BUG: attempting to delete first outline in list\n";
            ostr << "* outline type: " << GetOutlineTypeString( outlineType );
            errormsg = ostr.str();

            return false;
        }

        outlines.clear();
        return true;
    }

    while( itS != itE )
    {
        if( *itS == aOutline )
        {
            outlines.erase( itS );
            return true;
        }

        ++itS;
    }

    errormsg.clear();
    return false;
}


bool BOARD_OUTLINE::DelOutline( size_t aIndex )
{
    std::list< IDF_OUTLINE* >::iterator itS = outlines.begin();

    if( outlines.empty() )
    {
        errormsg.clear();
        return false;
    }

    if( aIndex >= outlines.size() )
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
        ostr << "* BUG: index out of bounds (" << aIndex << " / " << outlines.size() << ")\n";
        ostr << "* outline type: " << GetOutlineTypeString( outlineType );
        errormsg = ostr.str();

        return false;
    }

    if( aIndex == 0 )
    {
        // if there are more than 1 outlines it makes no sense to delete
        // the first outline (board outline) since that would have the
        // undesirable effect of substituting a cutout outline as the board outline
        if( outlines.size() > 1 )
        {
            ostringstream ostr;
            ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
            ostr << "* BUG: attempting to delete first outline in list\n";
            ostr << "* outline type: " << GetOutlineTypeString( outlineType );
            errormsg = ostr.str();

            return false;
        }

        delete *itS;
        outlines.clear();

        return true;
    }

    for( ; aIndex > 0; --aIndex )
        ++itS;

    delete *itS;
    outlines.erase( itS );

    return true;
}

const std::list< IDF_OUTLINE* >*const BOARD_OUTLINE::GetOutlines( void )
{
    return &outlines;
}

size_t BOARD_OUTLINE::OutlinesSize( void )
{
    return outlines.size();
}

IDF_OUTLINE* BOARD_OUTLINE::GetOutline( size_t aIndex )
{
    if( aIndex >= outlines.size() )
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
        ostr <<  "* aIndex (" << aIndex << ") is out of range (" << outlines.size() << ")";
        errormsg = ostr.str();

        return NULL;
    }

    std::list< IDF_OUTLINE* >::iterator itS = outlines.begin();

    for( ; aIndex > 0; --aIndex )
        ++itS;

    return *itS;
}

IDF3::KEY_OWNER BOARD_OUTLINE::GetOwner( void )
{
    return owner;
}

bool BOARD_OUTLINE::SetOwner( IDF3::KEY_OWNER aOwner )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    owner = aOwner;
    return true;
}

bool BOARD_OUTLINE::IsSingle( void )
{
    return single;
}

void BOARD_OUTLINE::clearOutlines( void )
{
    std::list< IDF_OUTLINE* >::iterator itS = outlines.begin();
    std::list< IDF_OUTLINE* >::iterator itE = outlines.end();

    while( itS != itE )
    {
        delete *itS;
        ++itS;
    }

    outlines.clear();
    return;
}

void BOARD_OUTLINE::AddComment( const std::string& aComment )
{
    if( aComment.empty() )
        return;

    comments.push_back( aComment );
    return;
}

size_t BOARD_OUTLINE::CommentsSize( void )
{
    return comments.size();
}

std::list< std::string >* BOARD_OUTLINE::GetComments( void )
{
    return &comments;
}

const std::string* BOARD_OUTLINE::GetComment( size_t aIndex )
{
    if( aIndex >= comments.size() )
        return NULL;

    std::list< std::string >::iterator itS = comments.begin();

    for( ; aIndex > 0; --aIndex )
        ++itS;

    return &(*itS);
}

bool  BOARD_OUTLINE::DeleteComment( size_t aIndex )
{
    if( aIndex >= comments.size() )
        return false;

    std::list< std::string >::iterator itS = comments.begin();

    for( ; aIndex > 0; --aIndex )
        ++itS;

    comments.erase( itS );
    return true;
}

void  BOARD_OUTLINE::ClearComments( void )
{
    comments.clear();
    return;
}


/*
 * CLASS: OTHER_OUTLINE
 */
OTHER_OUTLINE::OTHER_OUTLINE( IDF3_BOARD* aParent )
{
    setParent( aParent );
    outlineType = OTLN_OTHER;
    side = LYR_INVALID;
    single = false;

    return;
}

bool OTHER_OUTLINE::SetOutlineIdentifier( const std::string aUniqueID )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    uniqueID = aUniqueID;

    return true;
}

const std::string& OTHER_OUTLINE::GetOutlineIdentifier( void )
{
    return uniqueID;
}

bool OTHER_OUTLINE::SetSide( IDF3::IDF_LAYER aSide )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    switch( aSide )
    {
        case LYR_TOP:
        case LYR_BOTTOM:
            side = aSide;
            break;

        default:
            do{
                ostringstream ostr;
                ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
                ostr << "* BUG: invalid side (" << aSide << "); must be one of TOP/BOTTOM\n";
                ostr << "* outline type: " << GetOutlineTypeString( outlineType );
                errormsg = ostr.str();
            } while( 0 );

            side = LYR_INVALID;
            return false;

            break;
    }

    return true;
}

IDF3::IDF_LAYER OTHER_OUTLINE::GetSide( void )
{
    return side;
}

void OTHER_OUTLINE::readData( std::ifstream& aBoardFile, const std::string& aHeader,
                              IDF3::IDF_VERSION aIdfVersion )
{
    // OTHER_OUTLINE/VIA_KEEPOUT
    //     .OTHER_OUTLINE  [OWNER]
    //     [outline identifier] [thickness] [board side: Top/Bot] {not present in VA\IA KEEPOUT}
    //     [outline]

    // check RECORD 1
    std::string token;
    bool quoted = false;
    int  idx = 0;
    std::streampos pos = aBoardFile.tellg();

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        ostringstream ostr;
        ostr << "\n* BUG: invalid invocation: blank header line\n";

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( quoted )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: section names must not be in quotes\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( outlineType == OTLN_OTHER )
    {
        if( !CompareToken( ".OTHER_OUTLINE", token ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* BUG: not an .OTHER outline\n";

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }
    else
    {
        if( !CompareToken( ".VIA_KEEPOUT", token ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* BUG: not a .VIA_KEEPOUT outline\n";

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        if( aIdfVersion > IDF_V2 )
            ERROR_IDF << "no OWNER; setting to UNOWNED\n";

        owner = UNOWNED;
    }
    else
    {
        if( !ParseOwner( token, owner ) )
        {
            ERROR_IDF << "invalid OWNER (reverting to UNOWNED): " << token << "\n";
            owner = UNOWNED;
        }
    }

    std::string iline;
    bool comment = false;

    if( outlineType == OTLN_OTHER )
    {
        // check RECORD 2
        // [outline identifier] [thickness] [board side: Top/Bot]
        while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

        if( ( !aBoardFile.good() && aBoardFile.eof() ) || iline.empty() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: premature end\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        idx = 0;
        if( comment )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: comment within .OTHER_OUTLINE section\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no outline identifier\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        uniqueID = token;

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no thickness\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        std::stringstream teststr;
        teststr << token;

        teststr >> thickness;
        if( teststr.fail() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: invalid thickness\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( unit == UNIT_THOU )
        {
            thickness *= IDF_THOU_TO_MM;
        }
        else if( ( aIdfVersion == IDF_V2 ) && ( unit == UNIT_TNM ) )
        {
            thickness *= IDF_TNM_TO_MM;
        }
        else if( unit != UNIT_MM )
        {
            ostringstream ostr;
            ostr << "\n* BUG: invalid UNIT type: " << unit;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( aIdfVersion == IDF_V2 )
        {
            side = LYR_TOP;
        }
        else
        {
            if( !GetIDFString( iline, token, quoted, idx ) )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: no board side\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            if( !ParseIDFLayer( token, side ) || ( side != LYR_TOP && side != LYR_BOTTOM ) )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: invalid side (must be TOP or BOTTOM only)\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }
        }

    }

    // read RECORD 3 values
    readOutlines( aBoardFile, aIdfVersion );

    // check RECORD 4
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( ( !aBoardFile.good() && aBoardFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( outlineType == OTLN_OTHER )
    {
        if( !CompareToken( ".END_OTHER_OUTLINE", iline ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no .END_OTHER_OUTLINE found\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }
    else
    {
        if( !CompareToken( ".END_VIA_KEEPOUT", iline ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no .END_VIA_KEEPOUT found\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }

    return;
}

void OTHER_OUTLINE::writeData( std::ofstream& aBoardFile )
{
    // this section is optional; do not write if not required
    if( outlines.empty() )
        return;

    writeComments( aBoardFile );

    // write RECORD 1
    if( outlineType == OTLN_OTHER )
        aBoardFile << ".OTHER_OUTLINE ";
    else
        aBoardFile << ".VIA_KEEPOUT ";

    writeOwner( aBoardFile );

    // write RECORD 2
    if( outlineType == OTLN_OTHER )
    {
        aBoardFile << "\"" << uniqueID << "\" ";

        if( unit != UNIT_THOU )
            aBoardFile << setiosflags(ios::fixed) << setprecision(5) << thickness << " ";
        else
            aBoardFile << setiosflags(ios::fixed) << setprecision(1) << (thickness / IDF_THOU_TO_MM) << " ";

        switch( side )
        {
            case LYR_TOP:
            case LYR_BOTTOM:
                WriteLayersText( aBoardFile, side );
                break;

            default:
                do{
                    ostringstream ostr;
                    ostr << "\n* invalid OTHER_OUTLINE side (neither top nor bottom): ";
                    ostr << side;
                    throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
                } while( 0 );

                break;
        }
    }

    // write RECORD 3
    writeOutlines( aBoardFile );

    // write RECORD 4
    if( outlineType == OTLN_OTHER )
        aBoardFile << ".END_OTHER_OUTLINE\n\n";
    else
        aBoardFile << ".END_VIA_KEEPOUT\n\n";

    return;
}


bool OTHER_OUTLINE::Clear( void )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    clear();
    side = LYR_INVALID;
    uniqueID.clear();

    return true;
}


/*
 * CLASS: ROUTE_OUTLINE
 */
ROUTE_OUTLINE::ROUTE_OUTLINE( IDF3_BOARD* aParent )
{
    setParent( aParent );
    outlineType = OTLN_ROUTE;
    single = true;
    layers = LYR_INVALID;
}

bool ROUTE_OUTLINE::SetLayers( IDF3::IDF_LAYER aLayer )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    layers = aLayer;

    return true;
}

IDF3::IDF_LAYER ROUTE_OUTLINE::GetLayers( void )
{
    return layers;
}

void ROUTE_OUTLINE::readData( std::ifstream& aBoardFile, const std::string& aHeader,
                              IDF3::IDF_VERSION aIdfVersion )
{
    //  ROUTE_OUTLINE (or ROUTE_KEEPOUT)
    //      .ROUTE_OUTLINE [OWNER]
    //      [layers]
    //      [outline]

    // check RECORD 1
    std::string token;
    bool quoted = false;
    int  idx = 0;
    std::streampos pos = aBoardFile.tellg();

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* BUG: invalid invocation; blank header line" ) );
    }

    if( quoted )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: section names must not be in quotes\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( outlineType == OTLN_ROUTE )
    {
        if( !CompareToken( ".ROUTE_OUTLINE", token ) )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "\n* BUG: not a ROUTE outline" ) );
    }
    else
    {
        if( !CompareToken( ".ROUTE_KEEPOUT", token ) )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "\n* BUG: not a ROUTE KEEPOUT outline" ) );
    }

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        if( aIdfVersion > IDF_V2 )
            ERROR_IDF << "no OWNER; setting to UNOWNED\n";

        owner = UNOWNED;
    }
    else
    {
        if( !ParseOwner( token, owner ) )
        {
            ERROR_IDF << "invalid OWNER (reverting to UNOWNED): " << token << "\n";
            owner = UNOWNED;
        }
    }

    // check RECORD 2
    // [layers: TOP, BOTTOM, BOTH, INNER, ALL]
    std::string iline;
    bool comment = false;

    if( aIdfVersion > IDF_V2 || outlineType == OTLN_ROUTE_KEEPOUT )
    {
        while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

        if( !aBoardFile.good() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: premature end\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        idx = 0;
        if( comment )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: comment within a section\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no layers specification\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( quoted )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: layers specification must not be in quotes\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !ParseIDFLayer( token, layers ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: invalid layers specification\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( aIdfVersion == IDF_V2 )
        {
            if( layers == LYR_INNER || layers == LYR_ALL )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: IDFv2 allows only TOP/BOTTOM/BOTH; layer was '";
                ostr << token << "'\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }
        }

    }   // RECORD 2, conditional > IDFv2 or ROUTE_KO_OUTLINE
    else
    {
        layers = LYR_ALL;
    }

    // read RECORD 3 values
    readOutlines( aBoardFile, aIdfVersion );

    // check RECORD 4
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( ( !aBoardFile.good() && aBoardFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( outlineType == OTLN_ROUTE )
    {
        if( !CompareToken( ".END_ROUTE_OUTLINE", iline ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no .END_ROUTE_OUTLINE found\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }
    else
    {
        if( !CompareToken( ".END_ROUTE_KEEPOUT", iline ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no .END_ROUTE_KEEPOUT found\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }

    return;
}


void ROUTE_OUTLINE::writeData( std::ofstream& aBoardFile )
{
    // this section is optional; do not write if not required
    if( outlines.empty() )
        return;

    if( layers == LYR_INVALID )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "layer not specified" ) );

    writeComments( aBoardFile );

    // write RECORD 1
    if( outlineType == OTLN_ROUTE )
        aBoardFile << ".ROUTE_OUTLINE ";
    else
        aBoardFile << ".ROUTE_KEEPOUT ";

    writeOwner( aBoardFile );

    // write RECORD 2
    WriteLayersText( aBoardFile, layers );
    aBoardFile << "\n";

    // write RECORD 3
    writeOutlines( aBoardFile );

    // write RECORD 4
    if( outlineType == OTLN_ROUTE )
        aBoardFile << ".END_ROUTE_OUTLINE\n\n";
    else
        aBoardFile << ".END_ROUTE_KEEPOUT\n\n";

    return;
}


bool ROUTE_OUTLINE::Clear( void )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    clear();
    layers = LYR_INVALID;

    return true;
}


/*
 * CLASS: PLACE_OUTLINE
 */
PLACE_OUTLINE::PLACE_OUTLINE( IDF3_BOARD* aParent )
{
    setParent( aParent );
    outlineType = OTLN_PLACE;
    single = true;
    thickness = -1.0;
    side = LYR_INVALID;
}


bool PLACE_OUTLINE::SetSide( IDF3::IDF_LAYER aSide )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    switch( aSide )
    {
        case LYR_TOP:
        case LYR_BOTTOM:
        case LYR_BOTH:
            side = aSide;
            break;

        default:
            do{
                side = LYR_INVALID;
                ostringstream ostr;
                ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
                ostr << "* BUG: invalid layer (" << aSide << "): must be one of TOP/BOTTOM/BOTH\n";
                ostr << "* outline type: " << GetOutlineTypeString( outlineType );
                errormsg = ostr.str();

                return false;
            } while( 0 );

            break;
    }

    return true;
}


IDF3::IDF_LAYER PLACE_OUTLINE::GetSide( void )
{
    return side;
}


bool PLACE_OUTLINE::SetMaxHeight( double aHeight )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    if( aHeight < 0.0 )
    {
        thickness = 0.0;

        do{
            ostringstream ostr;
            ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
            ostr << "* BUG: invalid height (" << aHeight << "): must be >= 0.0";
            ostr << "* outline type: " << GetOutlineTypeString( outlineType );
            errormsg = ostr.str();

            return false;
        } while( 0 );
    }

    thickness = aHeight;
    return true;
}

double PLACE_OUTLINE::GetMaxHeight( void )
{
    return thickness;
}

void PLACE_OUTLINE::readData( std::ifstream& aBoardFile, const std::string& aHeader,
                              IDF3::IDF_VERSION aIdfVersion )
{
    //  PLACE_OUTLINE/KEEPOUT
    //      .PLACE_OUTLINE [OWNER]
    //      [board side: Top/Bot/Both] [height]
    //      [outline]

    // check RECORD 1
    std::string token;
    bool quoted = false;
    int  idx = 0;
    std::streampos pos = aBoardFile.tellg();

    if( !GetIDFString( aHeader, token, quoted, idx ) )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* BUG: invalid invocation: blank header line\n" ) );

    if( quoted )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: section name must not be in quotes\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( outlineType == OTLN_PLACE )
    {
        if( !CompareToken( ".PLACE_OUTLINE", token ) )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "\n* BUG: not a .PLACE_OUTLINE" ) );
    }
    else
    {
        if( !CompareToken( ".PLACE_KEEPOUT", token ) )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "\n* BUG: not a .PLACE_KEEPOUT" ) );
    }

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        if( aIdfVersion > IDF_V2 )
            ERROR_IDF << "no OWNER; setting to UNOWNED\n";

        owner = UNOWNED;
    }
    else
    {
        if( !ParseOwner( token, owner ) )
        {
            ERROR_IDF << "invalid OWNER (reverting to UNOWNED): " << token << "\n";
            owner = UNOWNED;
        }
    }

    // check RECORD 2
    // [board side: Top/Bot/Both] [height]
    std::string iline;
    bool comment = false;

    if( aIdfVersion > IDF_V2 || outlineType == OTLN_PLACE_KEEPOUT )
    {
        while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

        if( !aBoardFile.good() )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: premature end\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        idx = 0;
        if( comment )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: comment within the section\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no board side information\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !ParseIDFLayer( token, side ) ||
            ( side != LYR_TOP && side != LYR_BOTTOM && side != LYR_BOTH ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: invalid board side: must be one of TOP/BOTTOM/BOTH\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( GetIDFString( iline, token, quoted, idx ) )
        {
            std::stringstream teststr;
            teststr << token;

            teststr >> thickness;

            if( teststr.fail() )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: invalid height\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            if( thickness < 0.0 )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: thickness < 0\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            if( unit == UNIT_THOU )
            {
                thickness *= IDF_THOU_TO_MM;
            }
            else if( ( aIdfVersion == IDF_V2 ) && ( unit == UNIT_TNM ) )
            {
                thickness *= IDF_TNM_TO_MM;
            }
            else if( unit != UNIT_MM )
            {
                ostringstream ostr;
                ostr << "\n* BUG: invalid UNIT type: " << unit;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            if( thickness < 0.0 )
                thickness = 0.0;

        }
        else
        {
            // for OTLN_PLACE, thickness may be omitted, but is required for OTLN_PLACE_KEEPOUT
            if( outlineType == OTLN_PLACE_KEEPOUT )
            {
                ostringstream ostr;

                ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
                ostr << "* violation: missing thickness\n";
                ostr << "* line: '" << iline << "'\n";
                ostr << "* file position: " << pos;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            }

            thickness = -1.0;
        }
    }
    else
    {
        side = LYR_TOP;
        thickness = 0.0;
    }

    // read RECORD 3 values
    readOutlines( aBoardFile, aIdfVersion );

    // check RECORD 4
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( ( !aBoardFile.good() && aBoardFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( outlineType == OTLN_PLACE )
    {
        if( !GetIDFString( iline, token, quoted, idx )
            || !CompareToken( ".END_PLACE_OUTLINE", token ) )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "invalid .PLACE_OUTLINE section: no .END_PLACE_OUTLINE found" ) );
    }
    else
    {
        if( !GetIDFString( iline, token, quoted, idx )
            || !CompareToken( ".END_PLACE_KEEPOUT", token ) )
            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                              "invalid .PLACE_KEEPOUT section: no .END_PLACE_KEEPOUT found" ) );
    }

    return;
}

void PLACE_OUTLINE::writeData( std::ofstream& aBoardFile )
{
    // this section is optional; do not write if not required
    if( outlines.empty() )
        return;

    writeComments( aBoardFile );

    // write RECORD 1
    if( outlineType == OTLN_PLACE )
        aBoardFile << ".PLACE_OUTLINE ";
    else
        aBoardFile << ".PLACE_KEEPOUT ";

    writeOwner( aBoardFile );

    // write RECORD 2
    switch( side )
    {
        case LYR_TOP:
        case LYR_BOTTOM:
        case LYR_BOTH:
            WriteLayersText( aBoardFile, side );
            break;

        default:
            do
            {
                ostringstream ostr;
                ostr << "\n* invalid PLACE_OUTLINE/KEEPOUT side (";
                ostr << side << "); must be one of TOP/BOTTOM/BOTH";
                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            } while( 0 );

            break;
    }

    // thickness is optional for OTLN_PLACE, but mandatory for OTLN_PLACE_KEEPOUT
    if( thickness < 0.0 && outlineType == OTLN_PLACE_KEEPOUT)
    {
        aBoardFile << "\n";
    }
    else
    {
        aBoardFile << " ";

        if( unit != UNIT_THOU )
            aBoardFile << setiosflags(ios::fixed) << setprecision(5) << thickness << "\n";
        else
            aBoardFile << setiosflags(ios::fixed) << setprecision(1) << (thickness / IDF_THOU_TO_MM) << "\n";
    }

    // write RECORD 3
    writeOutlines( aBoardFile );

    // write RECORD 4
    if( outlineType == OTLN_PLACE )
        aBoardFile << ".END_PLACE_OUTLINE\n\n";
    else
        aBoardFile << ".END_PLACE_KEEPOUT\n\n";

    return;
}


bool PLACE_OUTLINE::Clear( void )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    clear();
    thickness = 0.0;
    side = LYR_INVALID;

    return true;
}


/*
 * CLASS: ROUTE_KEEPOUT
 */
ROUTE_KO_OUTLINE::ROUTE_KO_OUTLINE( IDF3_BOARD* aParent )
    : ROUTE_OUTLINE( aParent )
{
    outlineType = OTLN_ROUTE_KEEPOUT;
    return;
}


/*
 * CLASS: PLACE_KEEPOUT
 */
PLACE_KO_OUTLINE::PLACE_KO_OUTLINE( IDF3_BOARD* aParent )
    : PLACE_OUTLINE( aParent )
{
    outlineType = OTLN_PLACE_KEEPOUT;
    return;
}


/*
 * CLASS: VIA_KEEPOUT
 */
VIA_KO_OUTLINE::VIA_KO_OUTLINE( IDF3_BOARD* aParent )
    : OTHER_OUTLINE( aParent )
{
    single = true;
    outlineType = OTLN_VIA_KEEPOUT;
}


/*
 * CLASS: PLACEMENT GROUP (PLACE_REGION)
 */
GROUP_OUTLINE::GROUP_OUTLINE( IDF3_BOARD* aParent )
{
    setParent( aParent );
    outlineType = OTLN_GROUP_PLACE;
    thickness = 0.0;
    side = LYR_INVALID;
    single = true;
    return;
}


bool GROUP_OUTLINE::SetSide( IDF3::IDF_LAYER aSide )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    switch( aSide )
    {
        case LYR_TOP:
        case LYR_BOTTOM:
        case LYR_BOTH:
            side = aSide;
            break;

        default:
            do{
                ostringstream ostr;
                ostr << "invalid side (" << aSide << "); must be one of TOP/BOTTOM/BOTH\n";
                ostr << "* outline type: " << GetOutlineTypeString( outlineType );
                errormsg = ostr.str();

                return false;
            } while( 0 );

            break;
    }

    return true;
}


IDF3::IDF_LAYER GROUP_OUTLINE::GetSide( void )
{
    return side;
}


bool GROUP_OUTLINE::SetGroupName( std::string aGroupName )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    groupName = aGroupName;

    return true;
}


const std::string& GROUP_OUTLINE::GetGroupName( void )
{
    return groupName;
}


void GROUP_OUTLINE::readData( std::ifstream& aBoardFile, const std::string& aHeader,
                              IDF3::IDF_VERSION aIdfVersion )
{
    //  Placement Group
    //      .PLACE_REGION [OWNER]
    //      [side: Top/Bot/Both ] [component group name]
    //      [outline]

    // check RECORD 1
    std::string token;
    bool quoted = false;
    int  idx = 0;
    std::streampos pos = aBoardFile.tellg();

    if( !GetIDFString( aHeader, token, quoted, idx ) )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* BUG: invalid invocation: blank header line" ) );

    if( quoted )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: section name must not be in quotes\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !CompareToken( ".PLACE_REGION", token ) )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* BUG: not a .PLACE_REGION" ) );

    if( !GetIDFString( aHeader, token, quoted, idx ) )
    {
        if( aIdfVersion > IDF_V2 )
            ERROR_IDF << "no OWNER; setting to UNOWNED\n";

        owner = UNOWNED;
    }
    else
    {
        if( !ParseOwner( token, owner ) )
        {
            ERROR_IDF << "invalid OWNER (reverting to UNOWNED): " << token << "\n";
            owner = UNOWNED;
        }
    }

    std::string iline;
    bool comment = false;

    // check RECORD 2
    // [side: Top/Bot/Both ] [component group name]
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( !aBoardFile.good() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no board side specified\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !ParseIDFLayer( token, side ) ||
        ( side != LYR_TOP && side != LYR_BOTTOM && side != LYR_BOTH ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: invalid board side, must be one of TOP/BOTTOM/BOTH\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no outline identifier\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    groupName = token;

    // read RECORD 3 values
    readOutlines( aBoardFile, aIdfVersion );

    // check RECORD 4
    while( aBoardFile.good() && !FetchIDFLine( aBoardFile, iline, comment, pos ) );

    if( ( !aBoardFile.good() && aBoardFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx )
        || !CompareToken( ".END_PLACE_REGION", token ) )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* invalid .PLACE_REGION section: no .END_PLACE_REGION found" ) );

    return;
}


void GROUP_OUTLINE::writeData( std::ofstream& aBoardFile )
{
    // this section is optional; do not write if not required
    if( outlines.empty() )
        return;

    writeComments( aBoardFile );

    // write RECORD 1
    aBoardFile << ".PLACE_REGION ";

    writeOwner( aBoardFile );

    // write RECORD 2
    switch( side )
    {
        case LYR_TOP:
        case LYR_BOTTOM:
        case LYR_BOTH:
            WriteLayersText( aBoardFile, side );
            break;

        default:
            do{
                ostringstream ostr;
                ostr << "\n* invalid PLACE_REGION side (must be TOP/BOTTOM/BOTH): ";
                ostr << side;

                throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
            } while( 0 );

            break;
    }

    aBoardFile << " \"" << groupName << "\"\n";

    // write RECORD 3
    writeOutlines( aBoardFile );

    // write RECORD 4
    aBoardFile << ".END_PLACE_REGION\n\n";

    return;
}

bool GROUP_OUTLINE::Clear( void )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    clear();
    thickness = 0.0;
    side = LYR_INVALID;
    groupName.clear();

    return true;
}

/*
 * CLASS: COMPONENT OUTLINE
 */
IDF3_COMP_OUTLINE::IDF3_COMP_OUTLINE( IDF3_BOARD* aParent )
{
    setParent( aParent );
    single = true;
    outlineType = OTLN_COMPONENT;
    compType = COMP_INVALID;
    refNum = 0;
    return;
}

void IDF3_COMP_OUTLINE::readProperties( std::ifstream& aLibFile )
{
    bool quoted = false;
    bool comment = false;
    std::string iline;
    std::string token;
    std::streampos pos;
    std::string pname;      // property name
    std::string pval;       // property value
    int idx = 0;

    while( aLibFile.good() )
    {
        if( !FetchIDFLine( aLibFile, iline, comment, pos ) )
            continue;

        idx = 0;

        if( comment )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: comment within section\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: bad property section (no PROP)\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( quoted )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: PROP or .END must not be quoted\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( token.size() >= 5 && CompareToken( ".END_", token.substr( 0, 5 ) ) )
        {
            if(aLibFile.eof())
                aLibFile.clear();

            aLibFile.seekg( pos );
            return;
        }

        if( !CompareToken( "PROP", token ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: expecting PROP or .END_ELECTRICAL\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no PROP name\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        pname = token;

        if( !GetIDFString( iline, token, quoted, idx ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no PROP value\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }

        pval = token;

        if( props.insert( pair< string, string >(pname, pval) ).second == false )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: duplicate property name \"" << pname << "\"\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }

    return;
}


bool IDF3_COMP_OUTLINE::writeProperties( std::ofstream& aLibFile )
{
    if( props.empty() )
        return true;
    std::map< std::string, std::string >::const_iterator itS = props.begin();
    std::map< std::string, std::string >::const_iterator itE = props.end();

    while( itS != itE )
    {
        aLibFile << "PROP " << "\"" << itS->first << "\" \""
        << itS->second << "\"\n";
        ++itS;
    }

    return !aLibFile.fail();
}

void IDF3_COMP_OUTLINE::readData( std::ifstream& aLibFile, const std::string& aHeader,
                                  IDF3::IDF_VERSION aIdfVersion )
{
    //  .ELECTRICAL/.MECHANICAL
    //  [GEOM] [PART] [UNIT] [HEIGHT]
    //  [outline]
    //  [PROP] [prop name] [prop value]
    // check RECORD 1
    std::string token;
    bool quoted = false;
    int  idx = 0;
    std::streampos pos = aLibFile.tellg();

    if( !GetIDFString( aHeader, token, quoted, idx ) )
        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__,
                          "\n* BUG: invalid invocation: blank header line" ) );

    if( quoted )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: section name must not be in quotes\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( CompareToken( ".ELECTRICAL", token ) )
    {
        compType = COMP_ELEC;
    }
    else if( CompareToken( ".MECHANICAL", token ) )
    {
        compType = COMP_MECH;
    }
    else
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: expecting .ELECTRICAL or .MECHANICAL header\n";
        ostr << "* line: '" << aHeader << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    // check RECORD 2
    // [GEOM] [PART] [UNIT] [HEIGHT]
    std::string iline;
    bool comment = false;

    while( aLibFile.good() && !FetchIDFLine( aLibFile, iline, comment, pos ) );

    if( !aLibFile.good() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no GEOMETRY NAME\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    geometry = token;

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no PART NAME\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    part = token;

    if( part.empty() && geometry.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: both GEOMETRY and PART names are empty\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no UNIT type\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( CompareToken( "MM", token ) )
    {
        unit = UNIT_MM;
    }
    else if( CompareToken( "THOU", token ) )
    {
        unit = UNIT_THOU;
    }
    else if( aIdfVersion == IDF_V2 && !CompareToken( "TNM", token ) )
    {
        unit = UNIT_TNM;
    }
    else
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: invalid UNIT '" << token << "': must be one of MM or THOU\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( !GetIDFString( iline, token, quoted, idx ) )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: no height specified\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    std::istringstream teststr;
    teststr.str( token );

    teststr >> thickness;
    if( teststr.fail() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: invalid height '" << token << "'\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( unit == UNIT_THOU )
    {
        thickness *= IDF_THOU_TO_MM;
    }
    else if( ( aIdfVersion == IDF_V2 ) && ( unit == UNIT_TNM ) )
    {
        thickness *= IDF_TNM_TO_MM;
    }
    else if( unit != UNIT_MM )
    {
        ostringstream ostr;
        ostr << "\n* BUG: invalid UNIT type: " << unit;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    // read RECORD 3 values
    readOutlines( aLibFile, aIdfVersion );

    if( compType == COMP_ELEC && aIdfVersion > IDF_V2 )
        readProperties( aLibFile );

    // check RECORD 4
    while( aLibFile.good() && !FetchIDFLine( aLibFile, iline, comment, pos ) );

    if( ( !aLibFile.good() && aLibFile.eof() ) || iline.empty() )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: premature end\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    idx = 0;
    if( comment )
    {
        ostringstream ostr;

        ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
        ostr << "* violation: comment within section\n";
        ostr << "* line: '" << iline << "'\n";
        ostr << "* file position: " << pos;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    if( compType == COMP_ELEC )
    {
        if( !CompareToken( ".END_ELECTRICAL", iline ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no .END_ELECTRICAL found\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }
    else
    {
        if( !CompareToken( ".END_MECHANICAL", iline ) )
        {
            ostringstream ostr;

            ostr << "\n* invalid outline: " << GetOutlineTypeString( outlineType ) << "\n";
            ostr << "* violation: no .END_MECHANICAL found\n";
            ostr << "* line: '" << iline << "'\n";
            ostr << "* file position: " << pos;

            throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
        }
    }

    return;
}


void IDF3_COMP_OUTLINE::writeData( std::ofstream& aLibFile )
{
    if( refNum == 0 )
        return;    // nothing to do

    if( compType != COMP_ELEC && compType != COMP_MECH )
    {
        ostringstream ostr;
        ostr << "\n* component type not set or invalid: " << compType;

        throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
    }

    writeComments( aLibFile );

    // note: the outline section is required, even if it is empty
    if( compType == COMP_ELEC )
        aLibFile << ".ELECTRICAL\n";
    else
        aLibFile << ".MECHANICAL\n";

    // RECORD 2
    // [GEOM] [PART] [UNIT] [HEIGHT]
    aLibFile << "\"" << geometry << "\" \"" << part << "\" ";

    if( unit != UNIT_THOU )
        aLibFile << "MM " << setiosflags(ios::fixed) << setprecision(5) << thickness << "\n";
    else
        aLibFile << "THOU " << setiosflags(ios::fixed) << setprecision(1) << (thickness / IDF_THOU_TO_MM) << "\n";

    writeOutlines( aLibFile );

    if( compType == COMP_ELEC )
    {
        writeProperties( aLibFile );
        aLibFile << ".END_ELECTRICAL\n\n";
    }
    else
    {
        aLibFile << ".END_MECHANICAL\n\n";
    }

    return;
}


bool IDF3_COMP_OUTLINE::Clear( void )
{
#ifndef DISABLE_IDF_OWNERSHIP
    if( !CheckOwnership( __LINE__, __FUNCTION__, parent, owner, outlineType, errormsg ) )
        return false;
#endif

    clear();
    uid.clear();
    geometry.clear();
    part.clear();
    compType = COMP_INVALID;
    refNum = 0;
    props.clear();

    return true;
}

bool IDF3_COMP_OUTLINE::SetComponentClass( IDF3::COMP_TYPE aCompClass )
{
    switch( aCompClass )
    {
        case COMP_ELEC:
        case COMP_MECH:
            compType = aCompClass;
            break;

        default:
            do{
                ostringstream ostr;
                ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
                ostr << "* BUG: invalid component class (must be ELECTRICAL or MECHANICAL): ";
                ostr << aCompClass << "\n";
                errormsg = ostr.str();

                return false;
            } while( 0 );

            break;
    }

    return true;
}


IDF3::COMP_TYPE IDF3_COMP_OUTLINE::GetComponentClass( void )
{
    return compType;
}


void IDF3_COMP_OUTLINE::SetGeomName( const std::string& aGeomName )
{
    geometry = aGeomName;
    uid.clear();
    return;
}

const std::string& IDF3_COMP_OUTLINE::GetGeomName( void )
{
    return geometry;
}

void IDF3_COMP_OUTLINE::SetPartName( const std::string& aPartName )
{
    part = aPartName;
    uid.clear();
    return;
}

const std::string& IDF3_COMP_OUTLINE::GetPartName( void )
{
    return part;
}

const std::string& IDF3_COMP_OUTLINE::GetUID( void )
{
    if( !uid.empty() )
        return uid;

    if( geometry.empty() && part.empty() )
        return uid;

    uid = geometry + "_" + part;

    return uid;
}


int IDF3_COMP_OUTLINE::incrementRef( void )
{
    return ++refNum;
}

int IDF3_COMP_OUTLINE::decrementRef( void )
{
    if( refNum == 0 )
    {
        ostringstream ostr;
        ostr << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "():\n";
        ostr << "* BUG:  decrementing refNum beyond 0";
        errormsg = ostr.str();

        return -1;
    }

    --refNum;
    return refNum;
}

bool IDF3_COMP_OUTLINE::CreateDefaultOutline( const std::string &aGeom, const std::string &aPart )
{
    Clear();

    if( aGeom.empty() && aPart.empty() )
    {
        geometry  = "NOGEOM";
        part      = "NOPART";
        uid       = "NOGEOM_NOPART";
    }
    else
    {
        geometry  = aGeom;
        part      = aPart;
        uid       = aGeom + "_" + aPart;
    }

    compType  = COMP_ELEC;
    thickness = 5.0;
    unit      = UNIT_MM;

    // Create a star shape 5mm high with points on 5 and 3 mm circles
    double a, da;
    da = M_PI / 5.0;
    a = da / 2.0;

    IDF_POINT p1, p2;
    IDF_OUTLINE* ol = new IDF_OUTLINE;
    IDF_SEGMENT* sp;

    p1.x = 1.5 * cos( a );
    p1.y = 1.5 * sin( a );

    if( ol == NULL )
        return false;

    for( int i = 0; i < 10; ++i )
    {
        if( i & 1 )
        {
            p2.x = 2.5 * cos( a );
            p2.y = 2.5 * sin( a );
        }
        else
        {
            p2.x = 1.5 * cos( a );
            p2.y = 1.5 * sin( a );
        }

        sp = new IDF_SEGMENT( p1, p2 );

        if( sp == NULL )
        {
            Clear();
            return false;
        }

        ol->push( sp );
        a += da;
        p1 = p2;
    }

    a = da / 2.0;
    p2.x = 1.5 * cos( a );
    p2.y = 1.5 * sin( a );

    sp = new IDF_SEGMENT( p1, p2 );

    if( sp == NULL )
    {
        Clear();
        return false;
    }

    ol->push( sp );
    outlines.push_back( ol );

    return true;
}