source: main/trunk/greenstone2/build-src/packages/isis-gdl/Fdt.h@ 26668

/**********************************************************************
 *
 * Fdt.h
 * Copyright (C) 2003  UNESCO
 *
 * A component of the Greenstone digital library software
 * from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *********************************************************************/

////////////////////////////////////////////////////////////////////////////////////
// Fdt.h

#ifndef __FDT_H__
#define __FDT_H__

#include <vector>
#include "mytchar.h"

#define FDT_NAME_LENG    30     // maximum name length in FDT_FILE
#define FDT_SFLD_LENG    20    // maximum subfield length in FDT_FILE

#ifndef __CFIELDDEF__
#define __CFIELDDEF__

class CFieldDef
{
public:
    enum FieldType {
        charField       = 'C',
        dateField       = 'D',
        numericField    = 'N',
        logicalField    = 'L',
        memoField       = 'M'
    };

    char  name[31];   // dbf field names are 10 chars long max.
        // If this application is compiled with _UNICODE switch,
        // the field name will be converted to wide chars
        // when the column header is displayed in the grid.
    char  type;
    short len;
    short width;
    short decimals;
    int   offset;
    short display_width;
};
#endif // __CFIELDDEF__



class CFdtEntry
{
public:
    CFdtEntry() :  tag(0), len(0), type(0), rep(0) 
    { name[0] = '\0'; subfields[0] = '\0'; }
    void Clear()
    {
        tag = len = type = rep = 0;
        name[0] = '\0'; subfields[0] = '\0';
    }
    char    name[FDT_NAME_LENG+1];
    char    subfields[FDT_SFLD_LENG+1];
    int      tag;
    int      len;
    int      type;     //X=0
    int      rep;      //repeatable 1, non rep. 0
   CFdtEntry& operator=(const CFdtEntry& rhs)
   {
       if (&name[0] != &rhs.name[0])
       {
           Copy(rhs);
       }
       return *this;
   }

   void Copy(const CFdtEntry &rhs)
   {
       strcpy(name, rhs.name);
       strcpy(subfields, rhs.subfields);
       tag  = rhs.tag;
       len  = rhs.len;
       type = rhs.type;
       rep  = rhs.rep;
   }
};


void FormatFdtEntry(CFdtEntry &e, ustring &s);



class CFdt
{
protected:
    std::vector<CFdtEntry>  m_aFdt;
    int                     m_nFieldCount;       // Num. of fields
    std::vector<CFieldDef*> m_fieldArray;        // Array with fields

    long        m_iCurrentRecord;    // Current read record stored in
    CFdtEntry   m_fdtEntry;
    bool        m_bReadOnly;
    bool        m_bIsEmpty;
    bool        m_bDirty;            // True if m_fdtEntry modified 
    bool        m_bAppend;
public:
    ustring  m_sFileName;              // Fdt full pathname
    std::vector<std::string> m_asPrelude;  // What is bef ***
public:
    CFdt();          
    virtual ~CFdt();

    bool      Load(const _TCHAR *fname);
    int       GetEntryCount() { return m_aFdt.size(); }

    CFdtEntry GetEntryAt(int i) 
    { 
      #ifdef _MSC_VER
         return m_aFdt.at(i); 
      #else
         return m_aFdt[i];
      #endif
    }

    int       GetFieldCount() { return  m_nFieldCount; }

    bool      Open(const char* szFileName, bool readOnly=true);

    void InitData();

    void Close();
 
    void DeleteContents();

    void Store(const char* fileName);
    int InitFields ();

    CFieldDef* GetField(int n) const;

    CFdtEntry GetAt(int i);

    const CFdtEntry GetAt(int i) const;

    int Append(CFdtEntry& e);

    void RemoveAt(int i);
    void SetAt(int i, CFdtEntry& e);

    bool Seek(long iRecord);
    void Flush();
    bool GetValue(int n, std::string& result);
    bool SetValue(int n, const char* pszValue);

    int GetRecordCount() { return m_aFdt.size(); }
};

#endif