middatafile.cpp

linux下一款GIS程序源码

// middatafile.cpp: implementation of the MIDDATAFile class.
//
//////////////////////////////////////////////////////////////////////

#include "middatafile.h"

#include "ugk_memopr.h"
#include "ugk_string.h"


MIDDATAFile::MIDDATAFile()
{
    m_fp = NULL;
    m_szLastRead[0] = '\0';
    m_szSavedLine[0] = '\0';
    m_pszDelimiter = NULL;
    
    m_dfXMultiplier = 1.0;
    m_dfYMultiplier = 1.0;
    m_dfXDisplacement = 0.0;
    m_dfYDisplacement = 0.0;
}

MIDDATAFile::~MIDDATAFile()
{
	Close();
}


void MIDDATAFile::SaveLine(const char *pszLine)
{
    if (pszLine == NULL)
    {
        m_szSavedLine[0] = '\0';
    }
    else
    {
        strncpy(m_szSavedLine,pszLine,MIDMAXCHAR);
    }
}


const char *MIDDATAFile::GetSavedLine()
{
    return m_szSavedLine;
}


int MIDDATAFile::Open(const char *pszFname, const char *pszAccess)
{
   if (m_fp)
   {
       return -1;
   }

    /*-----------------------------------------------------------------
     * Validate access mode and make sure we use Text access.
     *----------------------------------------------------------------*/
    if (EQUALN(pszAccess, "r", 1))
    {
        m_eAccessMode = TABRead;
        pszAccess = "rt";
    }
    else if (EQUALN(pszAccess, "w", 1))
    {
        m_eAccessMode = TABWrite;
        pszAccess = "wt";
    }
    else
    {
        return -1;
    }

    /*-----------------------------------------------------------------
     * Open file for reading
     *----------------------------------------------------------------*/
    m_pszFname = UGKStrdup(pszFname);
    m_fp = fopen(m_pszFname, pszAccess);

    if (m_fp == NULL)
    {
        UGK_Free(m_pszFname);
        m_pszFname = NULL;
        return -1;
    }

    SetEof(feof(m_fp));
    return 0;
}



int MIDDATAFile::Rewind()
{
    if (m_fp == NULL || m_eAccessMode == TABWrite) 
        return -1;

    else
    {
        rewind(m_fp);
        SetEof(feof(m_fp));
    }
    return 0;
}



int MIDDATAFile::Close()
{
    if (m_fp == NULL)
        return 0;
   
    // Close file
    fclose(m_fp);
    m_fp = NULL;

    // clear readline buffer.
    ReadLineFromTxt( NULL );

    UGK_Free(m_pszFname);
    m_pszFname = NULL;

    return 0;

}


const char *MIDDATAFile::GetLine()
{
    const char *pszLine;
    
    if (m_eAccessMode == TABRead)
    {
        
        pszLine = ReadLineFromTxt(m_fp);

        SetEof(feof(m_fp));

        if (pszLine == NULL)
        {
            m_szLastRead[0] = '\0';
        }
        else
        {
            strncpy(m_szLastRead,pszLine,MIDMAXCHAR);
        }
        //if (pszLine)
        //  printf("%s\n",pszLine);
        return pszLine;
    }
    else
      assert(FALSE);
    
    return NULL;
}


const char *MIDDATAFile::GetLastLine()
{
    // Return NULL if EOF
    if(GetEof())
    {
        return NULL;
    }
    else if (m_eAccessMode == TABRead)
    {
        // printf("%s\n",m_szLastRead);
        return m_szLastRead;
    }

    // We should never get here (Read/Write mode not implemented)
    assert(FALSE);
    return NULL;
}


void MIDDATAFile::WriteLine(const char *pszFormat,...)
{
    va_list args;

    if (m_eAccessMode == TABWrite  && m_fp)
    {
        va_start(args, pszFormat);
         vfprintf( m_fp, pszFormat, args );
        va_end(args);
    } 
    else
    {
        assert(FALSE);
    }
}



void MIDDATAFile::SetTranslation(double dfXMul,double dfYMul, 
                                 double dfXTran,
                                 double dfYTran)
{
    m_dfXMultiplier = dfXMul;
    m_dfYMultiplier = dfYMul;
    m_dfXDisplacement = dfXTran;
    m_dfYDisplacement = dfYTran;
}


double MIDDATAFile::GetXTrans(double dfX)
{
    return (dfX * m_dfXMultiplier) + m_dfXDisplacement;
}

double MIDDATAFile::GetYTrans(double dfY)
{
    return (dfY * m_dfYMultiplier) + m_dfYDisplacement;
}


UGKBool MIDDATAFile::IsValidFeature(const char *pszString)
{
    char **papszToken ;

    papszToken = TokenizeString(pszString);
    
    //   printf("%s\n",pszString);

    if (CountOfList(papszToken) == 0)
    {
        FreeStrList(papszToken);
        return FALSE;
    }

    if (EQUAL(papszToken[0],"NONE")||EQUAL(papszToken[0],"POINT")||
        EQUAL(papszToken[0],"LINE")||EQUAL(papszToken[0],"PLINE")||
        EQUAL(papszToken[0],"REGION")||EQUAL(papszToken[0],"ARC")||
        EQUAL(papszToken[0],"TEXT")||EQUAL(papszToken[0],"RECT")||
        EQUAL(papszToken[0],"ROUNDRECT")||EQUAL(papszToken[0],"ELLIPSE")||
        EQUAL(papszToken[0],"MULTIPOINT"))
    {
        FreeStrList(papszToken);
        return TRUE;
    }

    FreeStrList(papszToken);
    return FALSE;

}


UGKBool MIDDATAFile::GetEof()
{
    return m_bEof;
}



void MIDDATAFile::SetEof(UGKBool bEof)
{
    m_bEof = bEof;
}