SAGA API  v9.8
•All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
table_dbase.cpp
Go to the documentation of this file.
1 /**********************************************************
2  * Version $Id$
3  *********************************************************/
4 
6 // //
7 // SAGA //
8 // //
9 // System for Automated Geoscientific Analyses //
10 // //
11 // Application Programming Interface //
12 // //
13 // Library: SAGA_API //
14 // //
15 //-------------------------------------------------------//
16 // //
17 // table_dbase.cpp //
18 // //
19 // Copyright (C) 2005 by Olaf Conrad //
20 // //
21 //-------------------------------------------------------//
22 // //
23 // This file is part of 'SAGA - System for Automated //
24 // Geoscientific Analyses'. //
25 // //
26 // This library is free software; you can redistribute //
27 // it and/or modify it under the terms of the GNU Lesser //
28 // General Public License as published by the Free //
29 // Software Foundation, either version 2.1 of the //
30 // License, or (at your option) any later version. //
31 // //
32 // This library is distributed in the hope that it will //
33 // be useful, but WITHOUT ANY WARRANTY; without even the //
34 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
35 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
36 // License for more details. //
37 // //
38 // You should have received a copy of the GNU Lesser //
39 // General Public License along with this program; if //
40 // not, see <http://www.gnu.org/licenses/>. //
41 // //
42 //-------------------------------------------------------//
43 // //
44 // contact: Olaf Conrad //
45 // Institute of Geography //
46 // University of Goettingen //
47 // Goldschmidtstr. 5 //
48 // 37077 Goettingen //
49 // Germany //
50 // //
51 // e-mail: oconrad@saga-gis.org //
52 // //
54 
55 //---------------------------------------------------------
56 
57 
59 // //
60 // //
61 // //
63 
64 //---------------------------------------------------------
65 #include <stdlib.h>
66 #include <string.h>
67 #include <time.h>
68 
69 #include "api_core.h"
70 #include "table_dbase.h"
71 #include "table.h"
72 #include "datetime.h"
73 
74 
76 // //
77 // //
78 // //
80 
81 //---------------------------------------------------------
82 CSG_Table_DBase::CSG_Table_DBase(int Encoding)
83 {
84  m_hFile = NULL;
85  m_Record = NULL;
86  m_Fields = NULL;
87  m_nFields = 0;
88  m_Encoding = Encoding;
89 }
90 
91 //---------------------------------------------------------
92 CSG_Table_DBase::~CSG_Table_DBase(void)
93 {
94  Close();
95 }
96 
97 //---------------------------------------------------------
98 void CSG_Table_DBase::Close(void)
99 {
100  if( m_hFile )
101  {
102  Flush_Record();
103  Header_Write();
104 
105  fclose(m_hFile);
106  m_hFile = NULL;
107  }
108 
109  SG_FREE_SAFE(m_Record);
110  SG_FREE_SAFE(m_Fields);
111 
112  m_nFields = 0;
113  m_nRecords = 0;
114  m_nHeaderBytes = 0;
115  m_nRecordBytes = 0;
116  m_nFileBytes = 0;
117 
118  m_bModified = false;
119 }
120 
121 
123 // //
125 
126 //---------------------------------------------------------
127 bool CSG_Table_DBase::Open_Read(const SG_Char *FileName, CSG_Table *pTable, bool bRecords_Load)
128 {
129  Close();
130 
131  if( (m_hFile = fopen(CSG_String(FileName), "rb")) == NULL )
132  {
133  SG_UI_Msg_Add_Error(_TL("dbf read: could not open file"));
134 
135  return( false );
136  }
137 
138  m_bReadOnly = true;
139 
140  if( !Header_Read() )
141  {
142  SG_UI_Msg_Add_Error(_TL("dbf read: could not read header"));
143 
144  Close();
145 
146  return( false );
147  }
148 
149  fseek(m_hFile, 0, SEEK_END);
150  m_nFileBytes = ftell(m_hFile);
151  fseek(m_hFile, 0, SEEK_SET);
152 
153  //-----------------------------------------------------
154  if( pTable )
155  {
156  int iField;
157 
158  pTable->Destroy();
159 
160  for(iField=0; iField<Get_Field_Count(); iField++)
161  {
162  switch( Get_Field_Type(iField) )
163  {
164  case DBF_FT_LOGICAL:
165  pTable->Add_Field(Get_Field_Name(iField), SG_DATATYPE_Char);
166  break;
167 
168  case DBF_FT_CHARACTER: default:
169  pTable->Add_Field(Get_Field_Name(iField), SG_DATATYPE_String);
170  break;
171 
172  case DBF_FT_DATE:
173  pTable->Add_Field(Get_Field_Name(iField), SG_DATATYPE_Date);
174  break;
175 
176  case DBF_FT_FLOAT:
177  pTable->Add_Field(Get_Field_Name(iField), SG_DATATYPE_Double);
178  break;
179 
180  case DBF_FT_NUMERIC:
181  pTable->Add_Field(Get_Field_Name(iField), Get_Field_Decimals(iField) > 0
182  ? SG_DATATYPE_Double
183  : SG_DATATYPE_Long
184  );
185  }
186  }
187 
188  //-------------------------------------------------
189  if( bRecords_Load && Get_Count() > 0 && Move_First() )
190  {
191  for(int iRecord=0; iRecord<Get_Count() && SG_UI_Process_Set_Progress(iRecord, Get_Count()); iRecord++)
192  {
193  CSG_Table_Record *pRecord = pTable->Add_Record();
194 
195  for(iField=0; iField<Get_Field_Count(); iField++)
196  {
197  switch( Get_Field_Type(iField) )
198  {
199  default:
200  pRecord->Set_Value(iField, asString(iField));
201  break;
202 
203  case DBF_FT_FLOAT:
204  case DBF_FT_NUMERIC:
205  {
206  double Value;
207 
208  if( asDouble(iField, Value) )
209  pRecord->Set_Value(iField, Value);
210  else
211  pRecord->Set_NoData(iField);
212  }
213  break;
214  }
215  }
216 
217  Move_Next();
218  }
219 
220  SG_UI_Process_Set_Ready();
221  }
222  }
223 
224  return( true );
225 }
226 
227 //---------------------------------------------------------
228 inline bool CSG_Table_DBase::Read(void *buffer, size_t size, size_t count)
229 {
230  return( m_hFile && fread(buffer, size, count, m_hFile) == size * count );
231 }
232 
233 //---------------------------------------------------------
234 inline bool CSG_Table_DBase::Write(void *buffer, size_t size, size_t count)
235 {
236  return( m_hFile && fwrite(buffer, size, count, m_hFile) == size * count );
237 }
238 
239 //---------------------------------------------------------
240 bool CSG_Table_DBase::Header_Read(void)
241 {
242  if( !m_hFile )
243  {
244  return( false );
245  }
246 
247  //-----------------------------------------------------
248  char buffer[16]; TDBF_Header h;
249 
250  fseek(m_hFile, 0, SEEK_SET);
251 
252  //-----------------------------------------------------
253  // Bytes 0-31: File Header...
254  Read(&h.FileType , sizeof(char), 1); // 00 FoxBase+, FoxPro, dBaseIII+, dBaseIV, no memo - 0x03
255  // FoxBase+, dBaseIII+ with memo - 0x83
256  // FoxPro with memo - 0xF5
257  // dBaseIV with memo - 0x8B
258  // dBaseIV with SQL Table - 0x8E
259  Read(&h.LastUpdate , sizeof(char), 3); // 01-03 Last update, format YYYYMMDD **correction: it is YYMMDD**
260  Read(&m_nRecords , sizeof(char), 4); // 04-07 Number of records in file (32-bit number)
261  Read(&m_nHeaderBytes , sizeof(char), 2); // 08-09 Number of bytes in header (16-bit number)
262  Read(&m_nRecordBytes , sizeof(char), 2); // 10-11 Number of bytes in record (16-bit number)
263  Read(buffer , sizeof(char), 2); // 12-13 Reserved, fill with 0x00
264  Read(&h.Transaction , sizeof(char), 1); // 14 dBaseIV flag, incomplete transaction
265  // Begin Transaction sets it to - 0x01
266  // End Transaction or RollBack reset it to - 0x00
267  Read(&h.bEncrypted , sizeof(char), 1); // 15 Encryption flag, encrypted 0x01 else 0x00
268  // Changing the flag does not encrypt or decrypt the records
269  Read(buffer , sizeof(char), 12); // 16-27 dBaseIV multi-user environment use
270  Read(&h.ProductionIdx, sizeof(char), 1); // 28 Production index exists - 0x01 else 0x00
271  Read(&h.LanguageDrvID, sizeof(char), 1); // 29 dBaseIV language driver ID
272  Read(buffer , sizeof(char), 2); // 30-31 Reserved fill with - 0x00
273 
274  //-----------------------------------------------------
275  // Bytes 32-n: Field Descriptor Array...
276  while( ftell(m_hFile) < (long)m_nHeaderBytes - 1 && !feof(m_hFile) )
277  {
278  m_Fields = (TDBF_Field *)SG_Realloc(m_Fields, (m_nFields + 1) * sizeof(TDBF_Field));
279 
280  Read( m_Fields[m_nFields].Name , sizeof(char), 11); // 0-10 Field Name ASCII padded with 0x00
281  Read(&m_Fields[m_nFields].Type , sizeof(char), 1); // 11 Field Type Identifier (see table)
282  Read(&m_Fields[m_nFields].Displacement , sizeof(char), 4); // 12-15 Displacement of field in record
283  Read(&m_Fields[m_nFields].Width , sizeof(char), 1); // 16 Field length in bytes
284  Read(&m_Fields[m_nFields].Decimals , sizeof(char), 1); // 17 Field decimal places
285  Read(buffer , sizeof(char), 2); // 18-19 Reserved
286  Read(&m_Fields[m_nFields].WorkAreaID , sizeof(char), 1); // 20 dBaseIV work area ID
287  Read(buffer , sizeof(char), 10); // 21-30 Reserved
288  Read(&m_Fields[m_nFields].ProductionIdx, sizeof(char), 1); // 31 Field is part of production index - 0x01 else 0x00
289 
290  m_Fields[m_nFields].Name[11] = '\0';
291 
292  m_nFields++;
293  }
294 
295  //-----------------------------------------------------
296  // Byte n+1: Header m_Record Terminator (0x0D)...
297  Read(buffer, sizeof(char), 1);
298 
299  if( buffer[0] == 0x0d )
300  {
301  Init_Record();
302  Move_First();
303 
304  return( true );
305  }
306 
307  Close();
308 
309  return( false );
310 }
311 
312 
314 // //
316 
317 //---------------------------------------------------------
318 bool CSG_Table_DBase::Open_Write(const SG_Char *FileName, CSG_Table *pTable, bool bRecords_Save)
319 {
320  Close();
321 
322  if( pTable == NULL || pTable->Get_Field_Count() <= 0 )
323  {
324  SG_UI_Msg_Add_Error(_TL("dbf write: invalid table"));
325 
326  return( false );
327  }
328 
329  if( (m_hFile = fopen(CSG_String(FileName), "w+b")) == NULL )
330  {
331  SG_UI_Msg_Add_Error(_TL("dbf write: could open file"));
332 
333  return( false );
334  }
335 
336  m_bReadOnly = false;
337 
338  //-----------------------------------------------------
339  m_nFields = pTable->Get_Field_Count();
340  m_Fields = (TDBF_Field *)SG_Calloc(m_nFields, sizeof(TDBF_Field)); // init all bytes with 0x00
341 
342  for(int iField=0; iField<Get_Field_Count(); iField++)
343  {
344  CSG_String Name(pTable->Get_Field_Name(iField)); int nBytes;
345 
346  for(int j=0; j<11 && j<(int)Name.Length(); j++)
347  {
348  m_Fields[iField].Name[j] = Name.b_str()[j];
349  }
350 
351  switch( pTable->Get_Field_Type(iField) )
352  {
353  case SG_DATATYPE_String: default:
354  m_Fields[iField].Type = DBF_FT_CHARACTER;
355  m_Fields[iField].Width = (BYTE)((nBytes = pTable->Get_Field_Length(iField, m_Encoding)) > 255 ? 255 : nBytes < 1 ? 1 : nBytes);
356  break;
357 
358  case SG_DATATYPE_Date :
359  m_Fields[iField].Type = DBF_FT_DATE;
360  m_Fields[iField].Width = (BYTE)8;
361  break;
362 
363  case SG_DATATYPE_Char :
364  m_Fields[iField].Type = DBF_FT_CHARACTER;
365  m_Fields[iField].Width = (BYTE)1;
366  break;
367 
368  case SG_DATATYPE_Bit :
369  m_Fields[iField].Type = DBF_FT_NUMERIC;
370  m_Fields[iField].Width = (BYTE)1;
371  break;
372 
373  case SG_DATATYPE_Byte :
374  m_Fields[iField].Type = DBF_FT_NUMERIC;
375  m_Fields[iField].Width = (BYTE)3;
376  break;
377 
378  case SG_DATATYPE_Word :
379  case SG_DATATYPE_Short :
380  m_Fields[iField].Type = DBF_FT_NUMERIC;
381  m_Fields[iField].Width = (BYTE)6;
382  break;
383 
384  case SG_DATATYPE_DWord :
385  case SG_DATATYPE_Int :
386  case SG_DATATYPE_ULong :
387  case SG_DATATYPE_Long :
388  case SG_DATATYPE_Color :
389  m_Fields[iField].Type = DBF_FT_NUMERIC;
390  m_Fields[iField].Width = (BYTE)16;
391  break;
392 
393  case SG_DATATYPE_Float:
394  m_Fields[iField].Type = DBF_FT_NUMERIC;
395  m_Fields[iField].Width = (BYTE)16;
396  m_Fields[iField].Decimals = (BYTE)8;
397  break;
398 
399  case SG_DATATYPE_Double:
400  m_Fields[iField].Type = DBF_FT_FLOAT;
401  m_Fields[iField].Width = (BYTE)19;
402  m_Fields[iField].Decimals = (BYTE)10;
403  break;
404  }
405  }
406 
407  Header_Write();
408 
409  m_nFileBytes = m_nHeaderBytes;
410 
411  //-----------------------------------------------------
412  if( bRecords_Save )
413  {
414  for(sLong iRecord=0; iRecord<pTable->Get_Count() && SG_UI_Process_Set_Progress(iRecord, pTable->Get_Count()); iRecord++)
415  {
416  CSG_Table_Record *pRecord = pTable->Get_Record(iRecord);
417 
418  Add_Record();
419 
420  for(int iField=0; iField<Get_Field_Count(); iField++)
421  {
422  if( pRecord->is_NoData(iField) )
423  {
424  Set_NoData(iField);
425  }
426  else switch( Get_Field_Type(iField) )
427  {
428  default:
429  Set_Value(iField, pRecord->asString(iField));
430  break;
431 
432  case DBF_FT_FLOAT:
433  case DBF_FT_NUMERIC:
434  Set_Value(iField, pRecord->asDouble(iField));
435  break;
436  }
437  }
438 
439  Flush_Record();
440  }
441 
442  SG_UI_Process_Set_Ready();
443  }
444 
445  return( true );
446 }
447 
448 //---------------------------------------------------------
449 void CSG_Table_DBase::Header_Write(void)
450 {
451  if( !m_hFile || m_bReadOnly )
452  {
453  return;
454  }
455 
456  //-----------------------------------------------------
457  char buffer[16]; TDBF_Header h;
458 
459  time_t ltime; time(&ltime); struct tm *pTime = localtime(&ltime);
460 
461  h.FileType = 0x03;
462  h.Transaction = 0;
463  h.bEncrypted = 0;
464  h.LanguageDrvID = 0;
465  h.ProductionIdx = 0;
466  h.LastUpdate[0] = (unsigned char)pTime->tm_year;
467  h.LastUpdate[1] = (unsigned char)pTime->tm_mon + 1;
468  h.LastUpdate[2] = (unsigned char)pTime->tm_mday;
469 
470  m_nHeaderBytes = (m_nFields + 1) * 32 + 1;
471  m_nRecordBytes = 1; // Delete-Flag = Byte 0...
472 
473  for(int iField=0; iField<m_nFields; iField++)
474  {
475  if( m_Fields[iField].Type == DBF_FT_CHARACTER )
476  {
477  if( m_Fields[iField].Width < 1 )
478  {
479  m_Fields[iField].Width = 1;
480  }
481  else if( m_Fields[iField].Width > 255 )
482  {
483  m_Fields[iField].Width = 255;
484  }
485  }
486 
487  m_nRecordBytes += m_Fields[iField].Width;
488  }
489 
490  Init_Record();
491 
492  fseek(m_hFile, 0, SEEK_SET);
493 
494  memset(buffer, 0, 16 * sizeof(char));
495 
496  //-----------------------------------------------------
497  // Bytes 0-31: File Header...
498  Write(&h.FileType , sizeof(char), 1); // 00 FoxBase+, FoxPro, dBaseIII+, dBaseIV, no memo - 0x03
499  // FoxBase+, dBaseIII+ with memo - 0x83
500  // FoxPro with memo - 0xF5
501  // dBaseIV with memo - 0x8B
502  // dBaseIV with SQL Table - 0x8E
503  Write(&h.LastUpdate , sizeof(char), 3); // 01-03 Last update, format YYYYMMDD **correction: it is YYMMDD**
504  Write(&m_nRecords , sizeof(char), 4); // 04-07 Number of records in file (32-bit number)
505  Write(&m_nHeaderBytes , sizeof(char), 2); // 08-09 Number of bytes in header (16-bit number)
506  Write(&m_nRecordBytes , sizeof(char), 2); // 10-11 Number of bytes in record (16-bit number)
507  Write(buffer , sizeof(char), 2); // 12-13 Reserved, fill with 0x00
508  Write(&h.Transaction , sizeof(char), 1); // 14 dBaseIV flag, incomplete transaction
509  // Begin Transaction sets it to - 0x01
510  // End Transaction or RollBack reset it to - 0x00
511  Write(&h.bEncrypted , sizeof(char), 1); // 15 Encryption flag, encrypted 0x01 else 0x00
512  // Changing the flag does not encrypt or decrypt the records
513  Write(buffer , sizeof(char), 12); // 16-27 dBaseIV multi-user environment use
514  Write(&h.ProductionIdx, sizeof(char), 1); // 28 Production index exists 0x01 else 0x00
515  Write(&h.LanguageDrvID, sizeof(char), 1); // 29 dBaseIV language driver ID
516  Write(buffer , sizeof(char), 2); // 30-31 Reserved fill with 0x00
517 
518  //-----------------------------------------------------
519  // Bytes 32-n: Field Descriptor Array...
520  for(int iField=0; iField<m_nFields; iField++)
521  {
522  Write( m_Fields[iField].Name , sizeof(char), 11); // 00-10 Field Name ASCII padded with 0x00
523  Write(&m_Fields[iField].Type , sizeof(char), 1); // 11 Field Type Identifier (see table)
524  Write(&m_Fields[iField].Displacement , sizeof(char), 4); // 12-15 Displacement of field in record
525  Write(&m_Fields[iField].Width , sizeof(char), 1); // 16 Field length in bytes
526  Write(&m_Fields[iField].Decimals , sizeof(char), 1); // 17 Field decimal places
527  Write(buffer , sizeof(char), 2); // 18-19 Reserved
528  Write(&m_Fields[iField].WorkAreaID , sizeof(char), 1); // 20 dBaseIV work area ID
529  Write(buffer , sizeof(char), 10); // 21-30 Reserved
530  Write(&m_Fields[iField].ProductionIdx, sizeof(char), 1); // 31 Field is part of production index - 0x01 else 0x00
531  }
532 
533  //-----------------------------------------------------
534  // Byte n+1: Header m_Record Terminator (0x0D)...
535  buffer[0] = 0x0D;
536  Write(buffer, sizeof(char), 1);
537 }
538 
539 
541 // //
543 
544 //---------------------------------------------------------
545 void CSG_Table_DBase::Init_Record(void)
546 {
547  m_Record = (char *)SG_Realloc(m_Record, m_nRecordBytes * sizeof(char));
548  m_Record[0] = ' '; // Data records are preceded by one byte, that is, a space (0x20) if the record is not deleted, an asterisk (0x2A) if the record is deleted.
549 
550  for(int iField=0, iPos=1; iField<m_nFields; iPos+=m_Fields[iField++].Width)
551  {
552  m_Fields[iField].Offset = iPos;
553  }
554 }
555 
556 //---------------------------------------------------------
557 int CSG_Table_DBase::Get_File_Position(void)
558 {
559  return( m_hFile ? ftell(m_hFile) : 0 );
560 }
561 
562 
564 // //
566 
567 //---------------------------------------------------------
568 bool CSG_Table_DBase::Move_First(void)
569 {
570  bool Result = false;
571 
572  if( m_hFile )
573  {
574  Flush_Record();
575 
576  fseek(m_hFile, m_nHeaderBytes, SEEK_SET);
577 
578  if( Read(m_Record, sizeof(char), (size_t)m_nRecordBytes) )
579  {
580  Result = true;
581  }
582 
583  fseek(m_hFile, m_nHeaderBytes, SEEK_SET);
584  }
585 
586  return( Result );
587 }
588 
589 //---------------------------------------------------------
590 bool CSG_Table_DBase::Move_Next(void)
591 {
592  bool Result = false;
593 
594  if( m_hFile )
595  {
596  Flush_Record();
597 
598  fseek(m_hFile, m_nRecordBytes, SEEK_CUR);
599 
600  if( Read(m_Record, sizeof(char), (size_t)m_nRecordBytes) )
601  {
602  Result = true;
603  }
604 
605  fseek(m_hFile, -m_nRecordBytes, SEEK_CUR);
606  }
607 
608  return( Result );
609 }
610 
611 
613 // //
615 
616 //---------------------------------------------------------
617 void CSG_Table_DBase::Add_Record(void)
618 {
619  if( m_hFile )
620  {
621  m_bModified = true;
622 
623  memset(m_Record, ' ', m_nRecordBytes);
624 
625  fseek(m_hFile, 0, SEEK_END);
626  Write(m_Record, m_nRecordBytes, sizeof(char));
627  fseek(m_hFile, -m_nRecordBytes, SEEK_END);
628 
629  m_nRecords ++;
630  m_nFileBytes += m_nRecordBytes;
631  }
632 }
633 
634 //---------------------------------------------------------
635 void CSG_Table_DBase::Flush_Record(void)
636 {
637  if( m_hFile && !m_bReadOnly && m_bModified )
638  {
639  m_bModified = false;
640  Write(m_Record, m_nRecordBytes, sizeof(char));
641  fseek(m_hFile, -m_nRecordBytes, SEEK_CUR);
642  }
643 }
644 
645 
647 // //
649 
650 //---------------------------------------------------------
651 bool CSG_Table_DBase::isDeleted(void)
652 {
653  return( m_hFile && *m_Record == '*' );
654 }
655 
656 //---------------------------------------------------------
657 bool CSG_Table_DBase::asInt(int iField, int &Value)
658 {
659  double d;
660 
661  if( asDouble(iField, d) )
662  {
663  Value = (int)d;
664 
665  return( true );
666  }
667 
668  return( false );
669 }
670 
671 //---------------------------------------------------------
672 bool CSG_Table_DBase::asDouble(int iField, double &Value)
673 {
674  if( !m_hFile || iField < 0 || iField >= m_nFields )
675  {
676  return( false );
677  }
678 
679  //-----------------------------------------------------
680  CSG_String s;
681 
682  char *c = m_Record + m_Fields[iField].Offset;
683 
684  for(int i=0; i<m_Fields[iField].Width && *c; i++, c++)
685  {
686  s += *c;
687  }
688 
689  //-----------------------------------------------------
690  if( m_Fields[iField].Type == DBF_FT_FLOAT
691  || m_Fields[iField].Type == DBF_FT_NUMERIC )
692  {
693  s.Replace(",", ".");
694 
695  return( s.asDouble(Value) );
696  }
697 
698  //-----------------------------------------------------
699  if( m_Fields[iField].Type == DBF_FT_DATE )
700  {
701  if( s.Length() < 8 )
702  {
703  return( false );
704  }
705 
706  int d = s.Mid(6, 2).asInt(); if( d < 1 ) d = 1; else if( d > 31 ) d = 31;
707  int m = s.Mid(4, 2).asInt(); if( m < 1 ) m = 1; else if( m > 12 ) m = 12;
708  int y = s.Mid(0, 4).asInt();
709 
710  Value = 10000 * y + 100 * m + d;
711  }
712 
713  //-----------------------------------------------------
714  return( true );
715 }
716 
717 //---------------------------------------------------------
718 CSG_String CSG_Table_DBase::asString(int iField)
719 {
720  CSG_String Value;
721 
722  if( !m_hFile || iField < 0 || iField >= m_nFields )
723  {
724  return( Value );
725  }
726 
727  //-----------------------------------------------------
728  if( m_Fields[iField].Type != DBF_FT_DATE )
729  {
730  switch( m_Encoding )
731  {
732  case SG_FILE_ENCODING_ANSI: default:
733  { char *s = m_Record + m_Fields[iField].Offset;
734 
735  for(int i=0; i<m_Fields[iField].Width && *s; i++, s++)
736  {
737  Value += *s > 0 ? *s : '?';
738  }
739  } break;
740 
741  case SG_FILE_ENCODING_UTF8:
742  Value = CSG_String::from_UTF8(m_Record + m_Fields[iField].Offset, m_Fields[iField].Width);
743  break;
744  }
745 
746  Value.Trim(true);
747  }
748 
749  //-----------------------------------------------------
750  if( m_Fields[iField].Type == DBF_FT_DATE ) // SAGA(DD.MM.YYYY) from DBASE(YYYYMMDD)
751  {
752  char *s = m_Record + m_Fields[iField].Offset;
753 
754  Value += s[0]; // Y1
755  Value += s[1]; // Y2
756  Value += s[2]; // Y3
757  Value += s[3]; // Y4
758  Value += '-';
759  Value += s[4]; // M1
760  Value += s[5]; // M2
761  Value += '-';
762  Value += s[6]; // D1
763  Value += s[7]; // D2
764  }
765 
766  //-----------------------------------------------------
767  return( Value );
768 }
769 
770 
772 // //
774 
775 //---------------------------------------------------------
776 bool CSG_Table_DBase::Set_Value(int iField, double Value)
777 {
778  if( !m_hFile || iField < 0 || iField >= m_nFields || m_Fields[iField].Width < 1 )
779  {
780  return( false );
781  }
782 
783  //-----------------------------------------------------
784  if( m_Fields[iField].Type == DBF_FT_DATE )
785  { // Value is expected to be Julian Day Number
786  CSG_DateTime d(Value);
787 
788  return( Set_Value(iField, CSG_String::Format("%04d-%02d-%02d",
789  d.Get_Year (),
790  1 + (int)d.Get_Month(),
791  1 + d.Get_Day ()
792  )));
793  }
794 
795  //-----------------------------------------------------
796  if( m_Fields[iField].Type == DBF_FT_FLOAT )
797  { // Number stored as a string, right justified, and padded with blanks to the width of the field.
798  char s[256];
799 
800  sprintf(s, "%*.*e", m_Fields[iField].Width, m_Fields[iField].Decimals, Value);
801 
802  size_t n = strlen(s); if( n > m_Fields[iField].Width ) { n = m_Fields[iField].Width; }
803 
804  memset(m_Record + m_Fields[iField].Offset, ' ', m_Fields[iField].Width);
805  memcpy(m_Record + m_Fields[iField].Offset, s , M_GET_MIN(strlen(s), m_Fields[iField].Width));
806 
807  m_bModified = true;
808 
809  return( true );
810  }
811 
812  //-----------------------------------------------------
813  if( m_Fields[iField].Type == DBF_FT_NUMERIC )
814  { // Number stored as a string, right justified, and padded with blanks to the width of the field.
815  char s[256];
816 
817  if( m_Fields[iField].Decimals > 0 )
818  {
819  sprintf(s, "%*.*f", m_Fields[iField].Width, m_Fields[iField].Decimals, Value);
820  }
821  else
822  {
823  sprintf(s, "%*d" , m_Fields[iField].Width, (int)Value);
824  }
825 
826  memset(m_Record + m_Fields[iField].Offset, ' ', m_Fields[iField].Width);
827  memcpy(m_Record + m_Fields[iField].Offset, s , M_GET_MIN(strlen(s), m_Fields[iField].Width));
828 
829  m_bModified = true;
830 
831  return( true );
832  }
833 
834  //-----------------------------------------------------
835  return( false );
836 }
837 
838 //---------------------------------------------------------
839 bool CSG_Table_DBase::Set_Value(int iField, const CSG_String &Value)
840 {
841  if( !m_hFile || iField < 0 || iField >= m_nFields || m_Fields[iField].Width < 1 )
842  {
843  return( false );
844  }
845 
846  //-----------------------------------------------------
847  if( m_Fields[iField].Type == DBF_FT_CHARACTER )
848  { // All OEM code page characters - padded with blanks to the width of the field.
849  if( Value.Length() < 1 )
850  {
851  memset(m_Record + m_Fields[iField].Offset, ' ', m_Fields[iField].Width);
852 
853  m_bModified = true;
854 
855  return( true );
856  }
857 
858  CSG_Buffer s;
859 
860  switch( m_Encoding )
861  {
862  case SG_FILE_ENCODING_ANSI: default:
863  s = Value.to_ASCII();
864  break;
865 
866  case SG_FILE_ENCODING_UTF8:
867  s = Value.to_UTF8 ();
868  break;
869  }
870 
871  if( s.Get_Size() >= Value.Length() )
872  {
873  memset(m_Record + m_Fields[iField].Offset, ' ', m_Fields[iField].Width);
874  memcpy(m_Record + m_Fields[iField].Offset, s.Get_Data(), M_GET_MIN(s.Get_Size(), m_Fields[iField].Width));
875 
876  m_bModified = true;
877 
878  return( true );
879  }
880  }
881 
882  //-----------------------------------------------------
883  if( m_Fields[iField].Type == DBF_FT_DATE ) // SAGA(YYYY-MM-DD) to DBASE(YYYYMMDD)
884  { // 8 bytes - date stored as a string in the format YYYYMMDD
885  if( Value.Length() >= 10 )
886  {
887  char *s = m_Record + m_Fields[iField].Offset;
888 
889  s[0] = Value.b_str()[0]; // Y1
890  s[1] = Value.b_str()[1]; // Y2
891  s[2] = Value.b_str()[2]; // Y3
892  s[3] = Value.b_str()[3]; // Y4
893  s[4] = Value.b_str()[5]; // M1
894  s[5] = Value.b_str()[6]; // M2
895  s[6] = Value.b_str()[8]; // D1
896  s[7] = Value.b_str()[9]; // D2
897 
898  m_bModified = true;
899 
900  return( true );
901  }
902  }
903 
904  //-----------------------------------------------------
905  return( false );
906 }
907 
908 //---------------------------------------------------------
909 bool CSG_Table_DBase::Set_NoData(int iField)
910 {
911  if( !m_hFile || iField < 0 || iField >= m_nFields || m_Fields[iField].Width < 1 )
912  {
913  return( false );
914  }
915 
916  //-----------------------------------------------------
917  memset(m_Record + m_Fields[iField].Offset, ' ', m_Fields[iField].Width);
918 
919  m_bModified = true;
920 
921  return( true );
922 }
923 
924 
926 // //
927 // //
928 // //
930 
931 //---------------------------------------------------------
SG_DATATYPE_Color
@ SG_DATATYPE_Color
Definition: api_core.h:1009
SG_DATATYPE_Int
@ SG_DATATYPE_Int
Definition: api_core.h:1002
CSG_Table_Record::asDouble
double asDouble(int Field) const
Definition: table_record.cpp:527
DBF_FT_FLOAT
#define DBF_FT_FLOAT
Definition: table_dbase.h:77
SG_FREE_SAFE
#define SG_FREE_SAFE(PTR)
Definition: api_core.h:205
CSG_Table::Get_Field_Type
TSG_Data_Type Get_Field_Type(int Field) const
Definition: table.h:363
SG_DATATYPE_String
@ SG_DATATYPE_String
Definition: api_core.h:1007
_TL
#define _TL(s)
Definition: api_core.h:1556
SG_DATATYPE_DWord
@ SG_DATATYPE_DWord
Definition: api_core.h:1001
CSG_String::to_ASCII
bool to_ASCII(char **pString, char Replace='_') const
Definition: api_string.cpp:956
CSG_String::Length
size_t Length(void) const
Definition: api_string.cpp:172
CSG_String::b_str
const char * b_str(void) const
Definition: api_string.cpp:242
CSG_String::Mid
CSG_String Mid(size_t first, size_t count=0) const
Definition: api_string.cpp:746
CSG_Table_Record
Definition: table.h:130
CSG_Table_DBase::~CSG_Table_DBase
virtual ~CSG_Table_DBase(void)
Definition: table_dbase.cpp:92
CSG_String::asInt
int asInt(void) const
Definition: api_string.cpp:769
CSG_Table::Get_Record
virtual CSG_Table_Record * Get_Record(sLong Index) const
Definition: table.h:399
CSG_String::from_UTF8
static CSG_String from_UTF8(const char *String, size_t Length=0)
Definition: api_string.cpp:834
SG_DATATYPE_Byte
@ SG_DATATYPE_Byte
Definition: api_core.h:997
CSG_Table_DBase::asInt
bool asInt(int iField, int &Value)
Definition: table_dbase.cpp:657
CSG_Table::Destroy
virtual bool Destroy(void)
Definition: table.cpp:325
CSG_Table_DBase::Get_File_Position
int Get_File_Position(void)
Definition: table_dbase.cpp:557
CSG_Table_DBase::isDeleted
bool isDeleted(void)
Definition: table_dbase.cpp:651
CSG_Table_DBase::Get_Field_Count
int Get_Field_Count(void)
Definition: table_dbase.h:105
CSG_Table_DBase::Get_Field_Decimals
int Get_Field_Decimals(int iField)
Definition: table_dbase.h:117
api_core.h
DBF_FT_CHARACTER
#define DBF_FT_CHARACTER
Definition: table_dbase.h:75
CSG_Table_DBase::Open_Write
bool Open_Write(const SG_Char *FileName, class CSG_Table *pTable, bool bRecords_Save=true)
Definition: table_dbase.cpp:318
CSG_Table::Get_Field_Count
int Get_Field_Count(void) const
Definition: table.h:361
CSG_DateTime::Get_Year
int Get_Year(void) const
Definition: datetime.cpp:384
CSG_Table_DBase::Move_Next
bool Move_Next(void)
Definition: table_dbase.cpp:590
SG_Calloc
SAGA_API_DLL_EXPORT void * SG_Calloc(size_t num, size_t size)
Definition: api_memory.cpp:71
CSG_Table_Record::is_NoData
bool is_NoData(int Field) const
Definition: table_record.cpp:416
CSG_Table_DBase::asString
CSG_String asString(int iField)
Definition: table_dbase.cpp:718
CSG_DateTime::Get_Month
Month Get_Month(void) const
Definition: datetime.cpp:379
CSG_Table_DBase::Move_First
bool Move_First(void)
Definition: table_dbase.cpp:568
SG_DATATYPE_Long
@ SG_DATATYPE_Long
Definition: api_core.h:1004
CSG_Buffer
Definition: api_core.h:224
CSG_Table_DBase::Open_Read
bool Open_Read(const SG_Char *FileName, class CSG_Table *pTable, bool bRecords_Load=true)
Definition: table_dbase.cpp:127
CSG_Table_Record::asString
const SG_Char * asString(int Field, int Decimals=-99) const
Definition: table_record.cpp:461
CSG_String::Trim
int Trim(bool fromRight=false)
Definition: api_string.cpp:637
DBF_FT_LOGICAL
#define DBF_FT_LOGICAL
Definition: table_dbase.h:79
CSG_Table_DBase::Get_Count
int Get_Count(void)
Definition: table_dbase.h:124
CSG_Table::Get_Field_Name
const SG_Char * Get_Field_Name(int Field) const
Definition: table.h:362
sLong
signed long long sLong
Definition: api_core.h:158
CSG_Table_DBase::Get_Field_Type
char Get_Field_Type(int iField)
Definition: table_dbase.h:111
CSG_Table::Get_Field_Length
virtual int Get_Field_Length(int Field, int Encoding=SG_FILE_ENCODING_UNDEFINED) const
Definition: table.cpp:670
CSG_Buffer::Get_Size
size_t Get_Size(void) const
Definition: api_core.h:241
CSG_Table::Get_Count
sLong Get_Count(void) const
Definition: table.h:397
SG_DATATYPE_Float
@ SG_DATATYPE_Float
Definition: api_core.h:1005
CSG_Table_DBase::Add_Record
void Add_Record(void)
Definition: table_dbase.cpp:617
CSG_DateTime
Definition: datetime.h:183
SG_DATATYPE_Date
@ SG_DATATYPE_Date
Definition: api_core.h:1008
SG_DATATYPE_Word
@ SG_DATATYPE_Word
Definition: api_core.h:999
CSG_String::Replace
size_t Replace(const CSG_String &Old, const CSG_String &New, bool bReplaceAll=true)
Definition: api_string.cpp:563
CSG_Buffer::Get_Data
char * Get_Data(int Offset=0) const
Definition: api_core.h:244
CSG_Table::m_Encoding
int m_Encoding
Definition: table.h:460
M_GET_MIN
#define M_GET_MIN(a, b)
Definition: mat_tools.h:141
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
CSG_Table_DBase::Flush_Record
void Flush_Record(void)
Definition: table_dbase.cpp:635
CSG_Table::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position=-1)
Definition: table.cpp:465
CSG_Table
Definition: table.h:285
table_dbase.h
CSG_String::to_UTF8
size_t to_UTF8(char **pString) const
Definition: api_string.cpp:860
SG_Char
#define SG_Char
Definition: api_core.h:536
CSG_Table_DBase::Set_Value
bool Set_Value(int iField, double Value)
Definition: table_dbase.cpp:776
CSG_String
Definition: api_core.h:563
SG_UI_Process_Set_Progress
bool SG_UI_Process_Set_Progress(int Position, int Range)
Definition: api_callback.cpp:255
CSG_Table_DBase::CSG_Table_DBase
CSG_Table_DBase(int Encoding=SG_FILE_ENCODING_ANSI)
Definition: table_dbase.cpp:82
CSG_Table_Record::Set_Value
bool Set_Value(int Field, const CSG_String &Value)
Definition: table_record.cpp:270
SG_DATATYPE_Short
@ SG_DATATYPE_Short
Definition: api_core.h:1000
CSG_Table_DBase::Close
void Close(void)
Definition: table_dbase.cpp:98
DBF_FT_DATE
#define DBF_FT_DATE
Definition: table_dbase.h:76
CSG_Table_DBase::asDouble
bool asDouble(int iField, double &Value)
Definition: table_dbase.cpp:672
CSG_DateTime::Get_Day
unsigned short Get_Day(void) const
Definition: datetime.cpp:377
CSG_Table::m_nFields
int m_nFields
Definition: table.h:460
CSG_Table_DBase::Set_NoData
bool Set_NoData(int iField)
Definition: table_dbase.cpp:909
SG_DATATYPE_Bit
@ SG_DATATYPE_Bit
Definition: api_core.h:996
CSG_Table_DBase::Get_Field_Name
const char * Get_Field_Name(int iField)
Definition: table_dbase.h:108
CSG_String::asDouble
double asDouble(void) const
Definition: api_string.cpp:807
SG_UI_Process_Set_Ready
bool SG_UI_Process_Set_Ready(void)
Definition: api_callback.cpp:305
SG_Realloc
SAGA_API_DLL_EXPORT void * SG_Realloc(void *memblock, size_t size)
Definition: api_memory.cpp:77
SG_UI_Msg_Add_Error
void SG_UI_Msg_Add_Error(const char *Message)
Definition: api_callback.cpp:556
CSG_Table::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition: table.cpp:819
DBF_FT_NUMERIC
#define DBF_FT_NUMERIC
Definition: table_dbase.h:78
SG_FILE_ENCODING_ANSI
@ SG_FILE_ENCODING_ANSI
Definition: api_core.h:550
SG_FILE_ENCODING_UTF8
@ SG_FILE_ENCODING_UTF8
Definition: api_core.h:552
SG_DATATYPE_Char
@ SG_DATATYPE_Char
Definition: api_core.h:998
table.h
CSG_Table_Record::Set_NoData
bool Set_NoData(int Field)
Definition: table_record.cpp:366
SG_DATATYPE_ULong
@ SG_DATATYPE_ULong
Definition: api_core.h:1003
CSG_Table::m_nRecords
sLong m_nRecords
Definition: table.h:462
datetime.h
SG_DATATYPE_Double
@ SG_DATATYPE_Double
Definition: api_core.h:1006