TnbShapeFile.h

[詳解]

#pragma once
#include "TnbPointerVector.h"
#include "TnbLikenMemToFile.h"
#include "TnbDBaseFile.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CShapeFile : public CDBaseFile
{
    DEFSUPER(CDBaseFile);
public:
 
    typedef long Integer;   
    typedef double Double;  
 
    #pragma pack(push)
    #pragma pack(1)
 
    class CBeInteger
    {
    public:
        CBeInteger(Integer l = 0) : m_value(m_SwapEndian(l))
        {
        }
        operator Integer() const 
        {
            return m_SwapEndian(m_value);
        }
        Integer operator=(Integer l)
        {
            m_value = m_SwapEndian(l);
            return l;
        }
    private:
        // エンディアン変換
        Integer m_SwapEndian(Integer l) const
        {
            return SwapEndian(DWORD(l));
        }
        Integer m_value;    
    };
 
    struct TBoundingBox
    {
        Double      xMin;   
        Double      yMin;   
        Double      xMax;   
        Double      yMax;   
        Double      zMin;   
        Double      zMax;   
        Double      mMin;   
        Double      mMax;   
        TBoundingBox(void)
        {
            Zero(*this);
        }
    };
 
    struct THead
    {
        CBeInteger      fileCode;   
        CBeInteger      padding[5]; 
        CBeInteger      fileLength; 
        Integer         version;    
        Integer         shapeType;  
        TBoundingBox    bb;         
        THead(void) : fileCode(9994), version(1000), shapeType(0)
        {
        }
    };
 
    #pragma pack(pop)
 
    struct IRecordContent
    {
        virtual ~IRecordContent(void) {}
        virtual Integer GetShapeType(void) const = 0;
        virtual size_t Write(IWriter& _w) const = 0;
        virtual void Read(const IReader& r, size_t size) = 0;
        virtual CStr ToString(void) const = 0;
    };
 
    class CNullShapeRecordContent : public IRecordContent
    {
    public:
        virtual Integer GetShapeType(void) const
        {
            return 0; //Null Shape
        }
        virtual size_t Write(IWriter& _w) const
        {
            return 0;
        }
        virtual void Read(const IReader& r, size_t size)
        {
        }
        virtual CStr ToString(void) const
        {
            return _T("Null Shape");
        }
    };
 
    class CUnknownRecordContent : public IRecordContent
    {
    public:
        CUnknownRecordContent(Integer st) : m_type(st)
        {
        }
        CByteVector& Refer(void)
        {
            return m_data;
        }
        virtual Integer GetShapeType(void) const
        {
            return m_type;
        }
        virtual size_t Write(IWriter& _w) const
        {
            _w.WriteFrom(m_data);
            return m_data.GetSize();
        }
        virtual void Read(const IReader& r, size_t size)
        {
            m_data = r.ReadExactly(size);
        }
        virtual CStr ToString(void) const
        {
            return CStr::Fmt(_T("ShapeType.%d , len = %d"), m_type, m_data.GetSize());
        }
    private:
        Integer     m_type;     
        CByteVector m_data;     
    };
 
 
    //--------
 
 
    CShapeFile(void)
    {
    }
 
    void SetHeadShapeType(Integer type)
    {
        m_shapeHead.shapeType = type;
    }
 
    Integer GetHeadShapeType(void) const
    {
        return m_shapeHead.shapeType;
    }
 
    void SetBoundingBox(const TBoundingBox& bb)
    {
        m_shapeHead.bb = bb;
    }
 
    const TBoundingBox& GetBoundingBox(void) const
    {
        return m_shapeHead.bb;
    }
 
    bool AllDeleteRecord(void)
    {
        m_shapeRecords.RemoveAll();
        return _super::AllDeleteRecord();
    }
 
    INDEX AddRecord(void)
    {
        INDEX r1 = _super::AddRecord();
        INDEX r2 = m_shapeRecords.Add(new CNullShapeRecordContent());
        ASSERT( r1 == r2 );
        return r1;
    }
 
    bool InsertRecord(INDEX record)
    {
        bool r1 = _super::InsertRecord(record);
        bool r2 = m_shapeRecords.Insert(record, new CNullShapeRecordContent());
        ASSERT( r1 == r2 );
        return r1;
    }
 
    bool DeleteRecord(INDEX record)
    {
        bool r1 = _super::DeleteRecord(record);
        bool r2 = m_shapeRecords.Remove(record);
        ASSERT( r1 == r2 );
        return r1;
    }
 
    bool SetShapeRecord(INDEX record, IRecordContent* P)
    {
        return m_shapeRecords.Set(record, P);
    }
 
    const IRecordContent* GetShapeRecord(INDEX record) const
    {
        return m_shapeRecords.Get(record);
    }
 
    bool LoadFile(LPCTSTR lpszBaseFileName, bool withTypeCheck = true)
    {
        AllDeleteRecord();
        CStr mainFn;
        CStr indexFn;
        CStr attrFn;
        m_MakeFileName(mainFn, indexFn, attrFn, lpszBaseFileName);
        CFileReader mainRf;
        CFileReader indexRf;
        Integer oldType = GetHeadShapeType();
        if ( mainRf.Open(mainFn) && indexRf.Open(indexFn) )
        {
            try
            {
                m_LoadMain(mainRf);
            }
            catch ( CTnbException& e )
            {
                e.OnCatch();
                _super::AllDeleteRecord();
                return false;
            }
            catch ( ... )
            {
                throw;
            }
            bool r = _super::LoadFile(attrFn);
            //
            if ( r )
            {
                if ( withTypeCheck && oldType != GetHeadShapeType() )
                {
                    TRACE2(" メインファイルのタイプ[%d]と現在のタイプ[%d]が一致していません！\n", GetHeadShapeType(), oldType);
                    SetHeadShapeType(oldType);
                    _super::AllDeleteRecord();
                    r = false;
                }
                else if ( _super::GetRecordCount() != m_shapeRecords.GetSize() )
                {
                    TRACE0(" メインファイルと属性ファイルのレコードの数が一致していません！\n" );
                    _super::AllDeleteRecord();
                    r = false;
                }
            }
            //
            return r;
        }
        return false;
    }
 
    bool SaveFile(LPCTSTR lpszBaseFileName) const
    {
        CStr mainFn;
        CStr indexFn;
        CStr attrFn;
        m_MakeFileName(mainFn, indexFn, attrFn, lpszBaseFileName);
        CFileWriter mainWf;
        CFileWriter indexWf;
        if ( mainWf.New(mainFn) && indexWf.New(indexFn) )
        {
            try
            {
                m_SaveMain(mainWf, indexWf);
            }
            catch ( CTnbException& e )
            {
                e.OnCatch();
                return false;
            }
            catch ( ... )
            {
                throw;
            }
            bool r = _super::SaveFile(attrFn);
            //
            return r;
        }
        return false;
    }
 
protected:
 
    virtual CShapeFile::IRecordContent* LoadType(Integer type, const IReader& r, size_t sz)
    {
        return NULL;
    }
 
    void Dump(void)
    {
    #ifdef _DEBUG
        TRACE0("-- ShapeFile情報 --\n");
        TRACE1("ShapeType %d\n", m_shapeHead.shapeType);
        TRACE2("BoundingBox X min %g, max %g\n", m_shapeHead.bb.xMin, m_shapeHead.bb.xMax);
        TRACE2("BoundingBox Y min %g, max %g\n", m_shapeHead.bb.yMin, m_shapeHead.bb.yMax);
        TRACE2("BoundingBox Z min %g, max %g\n", m_shapeHead.bb.zMin, m_shapeHead.bb.zMax);
        TRACE2("BoundingBox M min %g, max %g\n", m_shapeHead.bb.mMin, m_shapeHead.bb.mMax);
        loop ( i, m_shapeRecords.GetSize() )
        {
            CStr s = m_shapeRecords[i]->ToString();
            TRACE2("record.%d, %s\n", i + 1, s);
        }
    #endif //_DEBUG
        _super::Dump();
    }
 
private:
 
    void m_MakeFileName(CStr& _mainFn, CStr& _indexFn, CStr& _attrFn, LPCTSTR lpszBase) const
    {
        CStr base = lpszBase;
        base.TrimRight('.');
        base += '.';
        _mainFn = base + _T("shp");
        _indexFn = base + _T("shx");
        _attrFn = base + _T("dbf");
    }
    void m_SaveMain(IWriter& _mainWt, IWriter& _indexWt) const
    {
        CLikenMemToFile dmyWt;
        //== ヘッダを仮に追加
        THead hd = m_shapeHead;
        _mainWt.Write(sizeof(hd), &hd);
        _indexWt.Write(sizeof(hd), &hd);
        //== レコード
        loop ( i, m_shapeRecords.GetSize() )
        {
            // レコードコンテンツ用意
            Integer type = m_shapeRecords[i]->GetShapeType();
            CBeInteger len = down_cast<CShapeFile::Integer>(sizeof(Integer) + m_shapeRecords[i]->Write(dmyWt)) / sizeof(WORD);
            // インデックスデータ作成
            CBeInteger ofs = static_cast<long>(_mainWt.GetSize() / sizeof(WORD));
            _indexWt.Write(sizeof(ofs), &ofs);
            _indexWt.Write(sizeof(len), &len);
            // メインデータ作成
            CBeInteger no = down_cast<CShapeFile::Integer>(i + 1);
            _mainWt.Write(sizeof(no), &no);
            _mainWt.Write(sizeof(len), &len);
            _mainWt.Write(sizeof(type), &type);
            m_shapeRecords[i]->Write(_mainWt);
        }
        //== ヘッダを付加する
        hd.fileLength = static_cast<long>(_mainWt.GetSize() / sizeof(WORD));
        _mainWt.Seek(0);
        _mainWt.Write(sizeof(hd), &hd);
        hd.fileLength = static_cast<long>(_indexWt.GetSize() / sizeof(WORD));
        _indexWt.Seek(0);
        _indexWt.Write(sizeof(hd), &hd);
    }
    void m_LoadMain(const IReader& r)
    {
        THead hd;
        CPointerVectorT<IRecordContent> records; // レコード情報
        r.Read(sizeof(THead), &hd);
        if ( hd.fileCode != 9994  || hd.version != 1000 )
        {
            throw CInvalidParamException();
        }
        while ( r.GetLeftoverSize() > 0 )
        {
            CBeInteger no;
            r.Read(sizeof(no), &no);    //レコード番号
            CBeInteger len;
            r.Read(sizeof(len), &len);  //コンテンツ長
            Integer type;
            r.Read(sizeof(type), &type);    //シェープタイプ
            TRACE3("RecNo.%d, Len = %d, Type = %d\n", long(no), long(len), type);
            size_t sz = len * 2 - sizeof(type);
            //
            IRecordContent* P = LoadType(type, r, sz);
            if ( P != NULL )
            {
                records.Add(P);
            }
            else if ( type == 0 )
            {
                CNullShapeRecordContent rc;
                rc.Read(r, sz);
                records.Add(new CNullShapeRecordContent(rc));
            }
            else
            {
                // その他
                CUnknownRecordContent rc(type);
                rc.Read(r, sz);
                records.Add(new CUnknownRecordContent(rc));
            }
        }
        m_shapeRecords = records;
        m_shapeHead = hd;
    }
 
    C_ASSERT ( sizeof(Integer) == 4 ); // サイズチェック
    C_ASSERT ( sizeof(Double) == 8 ); // サイズチェック
    C_ASSERT ( sizeof(CBeInteger) == 4 ); // サイズチェック
    C_ASSERT ( sizeof(THead) == 100 ); // サイズチェック
 
    THead                           m_shapeHead;    
    CPointerVectorT<IRecordContent> m_shapeRecords; 
 
    friend class CShapeFileTest;
};
 
 
 
class CShapeFileTypePoint : public CShapeFile
{
    DEFSUPER(CShapeFile);
public:
 
    class CPointRecordContent : public CShapeFile::IRecordContent
    {
    public:
        CPointRecordContent(Double x = 0, Double y = 0) : m_x(x), m_y(y)
        {
        }
        Double GetX(void) const { return m_x; }
        Double GetY(void) const { return m_y; }
        void Set(Double x, Double y) { m_x = x; m_y = y; }
        virtual Integer GetShapeType(void) const
        {
            return 1; //Point
        }
        virtual size_t Write(IWriter& _w) const
        {
            _w.Write(sizeof(m_x), &m_x);
            _w.Write(sizeof(m_y), &m_y);
            return sizeof(Double) * 2;
        }
        virtual void Read(const IReader& r, size_t size)
        {
            if ( size < sizeof(m_x) * 2 )
            {
                throw CInvalidLengthException();
            }
            r.ReadExactly(sizeof(m_x), &m_x);
            r.ReadExactly(sizeof(m_y), &m_y);
        }
        virtual CStr ToString(void) const
        {
            return CStr::Fmt(_T("Point x = %g, y = %g"), m_x, m_y);
        }
    private:
        Double  m_x;    
        Double  m_y;    
    };
 
 
    //------------------------------
 
 
    CShapeFileTypePoint(void)
    {
        SetHeadShapeType(1);
    }
 
    bool SetPointShapeRecord(INDEX record, Double x, Double y)
    {
        CPointRecordContent* P = new CPointRecordContent(x, y);
        if ( ! SetShapeRecord(record, P) )
        {
            delete P;
            return false;
        }
        SetHeadShapeType(1);
        return true;
    }
 
    const CPointRecordContent* GetPointShapeRecord(INDEX record) const
    {
        const IRecordContent* P = GetShapeRecord(record);
        if ( P != NULL && P->GetShapeType() == 1 )
        {
            return static_cast<const CPointRecordContent*>(P);
        }
        return NULL;
    }
 
protected:
 
    virtual CShapeFile::IRecordContent* LoadType(Integer type, const IReader& r, size_t sz)
    {
        if ( type == 1 )
        {
            CPointRecordContent rc;
            rc.Read(r, sz);
            return new CPointRecordContent(rc);
        }
        return NULL;
    }
};
 
 
 
}; // TNB