SAGA API  v9.8
table.cpp
Go to the documentation of this file.
1 
3 // //
4 // SAGA //
5 // //
6 // System for Automated Geoscientific Analyses //
7 // //
8 // Application Programming Interface //
9 // //
10 // Library: SAGA_API //
11 // //
12 //-------------------------------------------------------//
13 // //
14 // table.cpp //
15 // //
16 // Copyright (C) 2005 by Olaf Conrad //
17 // //
18 //-------------------------------------------------------//
19 // //
20 // This file is part of 'SAGA - System for Automated //
21 // Geoscientific Analyses'. //
22 // //
23 // This library is free software; you can redistribute //
24 // it and/or modify it under the terms of the GNU Lesser //
25 // General Public License as published by the Free //
26 // Software Foundation, either version 2.1 of the //
27 // License, or (at your option) any later version. //
28 // //
29 // This library is distributed in the hope that it will //
30 // be useful, but WITHOUT ANY WARRANTY; without even the //
31 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
32 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
33 // License for more details. //
34 // //
35 // You should have received a copy of the GNU Lesser //
36 // General Public License along with this program; if //
37 // not, see <http://www.gnu.org/licenses/>. //
38 // //
39 //-------------------------------------------------------//
40 // //
41 // contact: Olaf Conrad //
42 // Institute of Geography //
43 // University of Goettingen //
44 // Goldschmidtstr. 5 //
45 // 37077 Goettingen //
46 // Germany //
47 // //
48 // e-mail: oconrad@saga-gis.org //
49 // //
51 
52 //---------------------------------------------------------
53 #include "table.h"
54 #include "shapes.h"
55 #include "tool_library.h"
56 
57 
59 // //
60 // //
61 // //
63 
64 //---------------------------------------------------------
65 CSG_Table * SG_Create_Table(void)
66 {
67  return( new CSG_Table );
68 }
69 
70 //---------------------------------------------------------
71 CSG_Table * SG_Create_Table(const CSG_Table &Table)
72 {
73  switch( Table.Get_ObjectType() )
74  {
75  case SG_DATAOBJECT_TYPE_Table :
76  return( new CSG_Table(Table) );
77 
78  case SG_DATAOBJECT_TYPE_Shapes :
79  case SG_DATAOBJECT_TYPE_PointCloud:
80  return( SG_Create_Shapes(*((CSG_Shapes *)&Table)) );
81 
82  default:
83  return( NULL );
84  }
85 }
86 
87 //---------------------------------------------------------
88 CSG_Table * SG_Create_Table(CSG_Table *pTemplate)
89 {
90  if( pTemplate )
91  {
92  switch( pTemplate->Get_ObjectType() )
93  {
94  case SG_DATAOBJECT_TYPE_Table :
95  return( new CSG_Table(pTemplate) );
96 
97  case SG_DATAOBJECT_TYPE_Shapes :
98  case SG_DATAOBJECT_TYPE_PointCloud:
99  return( SG_Create_Shapes((CSG_Shapes *)pTemplate) );
100 
101  default:
102  break;
103  }
104  }
105 
106  return( new CSG_Table() );
107 }
108 
109 //---------------------------------------------------------
110 CSG_Table * SG_Create_Table(const char *File, TSG_Table_File_Type Format, int Encoding) { return( SG_Create_Table(CSG_String(File), Format, Encoding) ); }
111 CSG_Table * SG_Create_Table(const wchar_t *File, TSG_Table_File_Type Format, int Encoding) { return( SG_Create_Table(CSG_String(File), Format, Encoding) ); }
112 CSG_Table * SG_Create_Table(const CSG_String &File, TSG_Table_File_Type Format, int Encoding)
113 {
114  CSG_Table *pTable = new CSG_Table();
115 
116  if( pTable->Create(File, Format, Encoding) )
117  {
118  return( pTable );
119  }
120 
121  delete(pTable); return( NULL );
122 }
123 
124 //---------------------------------------------------------
125 CSG_Table * SG_Create_Table(const char *File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding) { return( SG_Create_Table(CSG_String(File), Format, Separator, Encoding) ); }
126 CSG_Table * SG_Create_Table(const wchar_t *File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding) { return( SG_Create_Table(CSG_String(File), Format, Separator, Encoding) ); }
127 CSG_Table * SG_Create_Table(const CSG_String &File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding)
128 {
129  CSG_Table *pTable = new CSG_Table();
130 
131  if( pTable->Create(File, Format, Separator, Encoding) )
132  {
133  return( pTable );
134  }
135 
136  delete(pTable); return( NULL );
137 }
138 
139 
141 // //
142 // //
143 // //
145 
146 //---------------------------------------------------------
147 CSG_Table::CSG_Table(void)
148  : CSG_Data_Object()
149 {
150  _On_Construction();
151 }
152 
153 bool CSG_Table::Create(void)
154 {
155  Destroy(); return( true );
156 }
157 
158 //---------------------------------------------------------
159 CSG_Table::CSG_Table(const CSG_Table &Table)
160  : CSG_Data_Object()
161 {
162  _On_Construction(); Create(Table);
163 }
164 
165 bool CSG_Table::Create(const CSG_Table &Table)
166 {
167  return( Assign((CSG_Data_Object *)&Table) );
168 }
169 
170 //---------------------------------------------------------
171 CSG_Table::CSG_Table(const char *File, TSG_Table_File_Type Format, int Encoding) : CSG_Table(CSG_String(File), Format, Encoding) {}
172 CSG_Table::CSG_Table(const wchar_t *File, TSG_Table_File_Type Format, int Encoding) : CSG_Table(CSG_String(File), Format, Encoding) {}
173 CSG_Table::CSG_Table(const CSG_String &File, TSG_Table_File_Type Format, int Encoding)
174  : CSG_Data_Object()
175 {
176  _On_Construction(); Create(File, Format, Encoding);
177 }
178 
179 bool CSG_Table::Create(const char *File, TSG_Table_File_Type Format, int Encoding) { return( Create(CSG_String(File), Format, Encoding) ); }
180 bool CSG_Table::Create(const wchar_t *File, TSG_Table_File_Type Format, int Encoding) { return( Create(CSG_String(File), Format, Encoding) ); }
181 bool CSG_Table::Create(const CSG_String &File, TSG_Table_File_Type Format, int Encoding)
182 {
183  Destroy();
184 
185  SG_UI_Msg_Add(CSG_String::Format("%s %s: %s...", _TL("Loading"), _TL("table"), File.c_str()), true);
186 
187  //-----------------------------------------------------
188  bool bResult = File.BeforeFirst(':').Cmp("PGSQL") && SG_File_Exists(File) && Load(File, (int)Format, '\0', Encoding);
189 
190  if( bResult )
191  {
192  Set_File_Name(File, true);
193  }
194 
195  //-----------------------------------------------------
196  else if( File.BeforeFirst(':').Cmp("PGSQL") == 0 ) // database source
197  {
198  CSG_String s(File);
199 
200  s = s.AfterFirst(':'); CSG_String Host (s.BeforeFirst(':'));
201  s = s.AfterFirst(':'); CSG_String Port (s.BeforeFirst(':'));
202  s = s.AfterFirst(':'); CSG_String DBase(s.BeforeFirst(':'));
203  s = s.AfterFirst(':'); CSG_String Table(s.BeforeFirst(':'));
204 
205  CSG_Tool *pTool = SG_Get_Tool_Library_Manager().Create_Tool("db_pgsql", 12, true); // CPGIS_Table_Load
206 
207  if( pTool )
208  {
209  SG_UI_ProgressAndMsg_Lock(true);
210 
211  CSG_String Connection(DBase + " [" + Host + ":" + Port + "]");
212 
213  bResult = pTool->Set_Manager(NULL) && pTool->On_Before_Execution()
214  && pTool->Set_Parameter("CONNECTION", Connection)
215  && pTool->Set_Parameter("DB_TABLE" , Table )
216  && pTool->Set_Parameter("TABLE" , this )
217  && pTool->Execute();
218 
219  SG_Get_Tool_Library_Manager().Delete_Tool(pTool);
220 
221  SG_UI_ProgressAndMsg_Lock(false);
222  }
223  }
224 
225  //-----------------------------------------------------
226  if( bResult )
227  {
228  Set_Modified(false);
229  Set_Update_Flag();
230 
231  SG_UI_Msg_Add(_TL("okay"), false, SG_UI_MSG_STYLE_SUCCESS);
232 
233  return( true );
234  }
235 
236  Destroy();
237 
238  SG_UI_Msg_Add(_TL("failed"), false, SG_UI_MSG_STYLE_FAILURE);
239 
240  return( false );
241 }
242 
243 //---------------------------------------------------------
244 CSG_Table::CSG_Table(const char *File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding) : CSG_Table(CSG_String(File), Format, Separator, Encoding) {}
245 CSG_Table::CSG_Table(const wchar_t *File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding) : CSG_Table(CSG_String(File), Format, Separator, Encoding) {}
246 CSG_Table::CSG_Table(const CSG_String &File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding)
247  : CSG_Data_Object()
248 {
249  _On_Construction(); Create(File, Format, Separator, Encoding);
250 }
251 
252 bool CSG_Table::Create(const char *File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding) { return( Create(CSG_String(File), Format, Separator, Encoding) ); }
253 bool CSG_Table::Create(const wchar_t *File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding) { return( Create(CSG_String(File), Format, Separator, Encoding) ); }
254 bool CSG_Table::Create(const CSG_String &File, TSG_Table_File_Type Format, const SG_Char Separator, int Encoding)
255 {
256  return( Load(File, (int)Format, Separator, Encoding) );
257 }
258 
259 //---------------------------------------------------------
260 CSG_Table::CSG_Table(const CSG_Table *pTemplate)
261  : CSG_Data_Object()
262 {
263  _On_Construction(); Create(pTemplate);
264 }
265 
266 bool CSG_Table::Create(const CSG_Table *pTemplate)
267 {
268  if( !pTemplate || pTemplate->Get_Field_Count() < 1 )
269  {
270  return( false );
271  }
272 
273  Destroy();
274 
275  Set_Name (pTemplate->Get_Name ());
276  Set_Description (pTemplate->Get_Description());
277  Set_NoData_Value_Range(pTemplate->Get_NoData_Value(), pTemplate->Get_NoData_Value(true));
278 
279  m_Encoding = pTemplate->m_Encoding;
280 
281  for(int i=0; i<pTemplate->Get_Field_Count(); i++)
282  {
283  Add_Field(pTemplate->Get_Field_Name(i), pTemplate->Get_Field_Type(i));
284  }
285 
286  return( true );
287 }
288 
289 
291 // //
293 
294 //---------------------------------------------------------
295 void CSG_Table::_On_Construction(void)
296 {
297  m_nFields = 0;
298  m_Field_Name = NULL;
299  m_Field_Type = NULL;
300  m_Field_Stats = NULL;
301 
302  m_Records = NULL;
303  m_nRecords = 0;
304  m_nBuffer = 0;
305 
306  m_Encoding = SG_FILE_ENCODING_UTF8;
307 
308  m_Selection.Create(sizeof(sLong), 0, TSG_Array_Growth::SG_ARRAY_GROWTH_3);
309 
310  Set_Update_Flag();
311 }
312 
313 
315 // //
317 
318 //---------------------------------------------------------
319 CSG_Table::~CSG_Table(void)
320 {
321  Destroy();
322 }
323 
324 //---------------------------------------------------------
325 bool CSG_Table::Destroy(void)
326 {
327  _Destroy_Selection();
328 
329  Del_Records();
330 
331  if( m_nFields > 0 )
332  {
333  for(int i=0; i<m_nFields; i++)
334  {
335  delete(m_Field_Name [i]);
336  delete(m_Field_Stats[i]);
337  }
338 
339  SG_Free(m_Field_Name );
340  SG_Free(m_Field_Stats);
341  SG_Free(m_Field_Type );
342 
343  m_nFields = 0;
344  m_Field_Name = NULL;
345  m_Field_Type = NULL;
346  m_Field_Stats = NULL;
347  }
348 
349  CSG_Data_Object::Destroy();
350 
351  return( true );
352 }
353 
354 
356 // //
357 // Assign //
358 // //
360 
361 //---------------------------------------------------------
362 CSG_Table & CSG_Table::operator = (const CSG_Table &Table)
363 {
364  Create(Table);
365 
366  return( *this );
367 }
368 
369 //---------------------------------------------------------
370 bool CSG_Table::Assign(CSG_Data_Object *pObject, bool bProgress)
371 {
372  if( pObject && pObject->asTable(true) && CSG_Data_Object::Assign(pObject) )
373  {
374  CSG_Table *pTable = pObject->asTable(true);
375 
376  m_Encoding = pTable->m_Encoding;
377 
378  for(int i=0; i<pTable->Get_Field_Count(); i++)
379  {
380  Add_Field(pTable->Get_Field_Name(i), pTable->Get_Field_Type(i));
381  }
382 
383  for(sLong i=0; i<pTable->Get_Count() && (!bProgress || SG_UI_Process_Set_Progress(i, pTable->Get_Count())); i++)
384  {
385  Add_Record(pTable->Get_Record(i));
386  }
387 
388  return( true );
389  }
390 
391  return( false );
392 }
393 
394 //---------------------------------------------------------
395 bool CSG_Table::Assign_Values(const CSG_Table &Table)
396 {
397  if( is_Compatible(Table) && Set_Count(Table.Get_Count()) )
398  {
399  for(sLong i=0; i<Table.Get_Count(); i++)
400  {
401  Get_Record(i)->Assign(Table.Get_Record(i));
402  }
403 
404  return( true );
405  }
406 
407  return( false );
408 }
409 
410 //---------------------------------------------------------
411 bool CSG_Table::Assign_Values(CSG_Table *pTable)
412 {
413  return( pTable && Assign_Values(*pTable) );
414 }
415 
416 //---------------------------------------------------------
417 bool CSG_Table::Assign_Values(const SG_Char *FileName)
418 {
419  CSG_Table Table; return( Table.Create(FileName) && Assign_Values(&Table) );
420 }
421 
422 
424 // //
425 // Checks //
426 // //
428 
429 //---------------------------------------------------------
430 bool CSG_Table::is_Compatible(const CSG_Table &Table, bool bExactMatch) const
431 {
432  if( Get_Field_Count() == Table.Get_Field_Count() )
433  {
434  if( bExactMatch )
435  {
436  for(int i=0; i<Get_Field_Count(); i++)
437  {
438  if( Get_Field_Type(i) != Table.Get_Field_Type(i) )
439  {
440  return( false );
441  }
442  }
443  }
444 
445  return( true );
446  }
447 
448  return( false );
449 }
450 
451 //---------------------------------------------------------
452 bool CSG_Table::is_Compatible(CSG_Table *pTable, bool bExactMatch) const
453 {
454  return( pTable && is_Compatible(*pTable, bExactMatch) );
455 }
456 
457 
459 // //
460 // Fields //
461 // //
463 
464 //---------------------------------------------------------
465 bool CSG_Table::Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position)
466 {
467  if( Position < 0 || Position > m_nFields )
468  {
469  Position = m_nFields;
470  }
471 
472  //-----------------------------------------------------
473  m_nFields++;
474 
475  m_Field_Name = (CSG_String **)SG_Realloc(m_Field_Name , m_nFields * sizeof(CSG_String *));
476  m_Field_Type = (TSG_Data_Type *)SG_Realloc(m_Field_Type , m_nFields * sizeof(TSG_Data_Type ));
477  m_Field_Stats = (CSG_Simple_Statistics **)SG_Realloc(m_Field_Stats, m_nFields * sizeof(CSG_Simple_Statistics *));
478 
479  //-----------------------------------------------------
480  for(int i=m_nFields-1; i>Position; i--)
481  {
482  m_Field_Name [i] = m_Field_Name [i - 1];
483  m_Field_Type [i] = m_Field_Type [i - 1];
484  m_Field_Stats[i] = m_Field_Stats[i - 1];
485  }
486 
487  //-----------------------------------------------------
488  m_Field_Name [Position] = new CSG_String(!Name.is_Empty() ? Name : CSG_String::Format("FIELD_%d", m_nFields));
489  m_Field_Type [Position] = Type;
490  m_Field_Stats[Position] = new CSG_Simple_Statistics();
491 
492  //-----------------------------------------------------
493  for(sLong i=0; i<m_nRecords; i++)
494  {
495  m_Records[i]->_Add_Field(Position);
496  }
497 
498  Set_Modified();
499 
500  return( true );
501 }
502 
503 //---------------------------------------------------------
504 bool CSG_Table::Del_Field(int del_Field)
505 {
506  if( del_Field < 0 || del_Field >= m_nFields )
507  {
508  return( false );
509  }
510 
511  //-----------------------------------------------------
512  delete(m_Field_Name [del_Field]);
513  delete(m_Field_Stats[del_Field]);
514 
515  //-------------------------------------------------
516  m_nFields--;
517 
518  for(int i=del_Field; i<m_nFields; i++)
519  {
520  m_Field_Name [i] = m_Field_Name [i + 1];
521  m_Field_Type [i] = m_Field_Type [i + 1];
522  m_Field_Stats[i] = m_Field_Stats[i + 1];
523  }
524 
525  //-------------------------------------------------
526  m_Field_Name = (CSG_String **)SG_Realloc(m_Field_Name , m_nFields * sizeof(CSG_String *));
527  m_Field_Type = (TSG_Data_Type *)SG_Realloc(m_Field_Type , m_nFields * sizeof(TSG_Data_Type ));
528  m_Field_Stats = (CSG_Simple_Statistics **)SG_Realloc(m_Field_Stats, m_nFields * sizeof(CSG_Simple_Statistics *));
529 
530  //-------------------------------------------------
531  for(sLong i=0; i<m_nRecords; i++)
532  {
533  m_Records[i]->_Del_Field(del_Field);
534  }
535 
536  Set_Modified();
537 
538  return( true );
539 }
540 
541 //---------------------------------------------------------
542 bool CSG_Table::Mov_Field(int iField, int Position)
543 {
544  if( Position < 0 )
545  {
546  Position = 0;
547  }
548  else if( Position >= m_nFields - 1 )
549  {
550  Position = m_nFields - 1;
551  }
552 
553  if( iField < 0 || iField >= m_nFields || iField == Position )
554  {
555  return( false );
556  }
557 
558  //-----------------------------------------------------
559  if( Position > iField )
560  {
561  Position++;
562  }
563 
564  if( !Add_Field(Get_Field_Name(iField), Get_Field_Type(iField), Position) )
565  {
566  return( false );
567  }
568 
569  if( Position < iField )
570  {
571  iField++;
572  }
573 
574  #pragma omp parallel for
575  for(sLong i=0; i<m_nRecords; i++)
576  {
577  *m_Records[i]->Get_Value(Position) = *m_Records[i]->Get_Value(iField);
578  }
579 
580  if( !Del_Field(iField) )
581  {
582  return( false );
583  }
584 
585  //-----------------------------------------------------
586  return( true );
587 }
588 
589 
591 // //
593 
594 //---------------------------------------------------------
595 bool CSG_Table::Set_Field_Name(int iField, const SG_Char *Name)
596 {
597  if( iField >= 0 && iField < m_nFields && Name && *Name )
598  {
599  *(m_Field_Name[iField]) = Name;
600 
601  Set_Modified();
602 
603  return( true );
604  }
605 
606  return( false );
607 }
608 
609 //---------------------------------------------------------
610 bool CSG_Table::Set_Field_Type(int Field, TSG_Data_Type Type)
611 {
612  if( Field < 0 || Field >= m_nFields )
613  {
614  return( false );
615  }
616 
617  if( m_Field_Type[Field] == Type )
618  {
619  return( true );
620  }
621 
622  #pragma omp parallel for
623  for(sLong i=0; i<m_nRecords; i++)
624  {
625  CSG_Table_Record *pRecord = m_Records[i];
626 
627  bool bNoData = pRecord->is_NoData(Field);
628 
629  CSG_Table_Value *pValue = pRecord->m_Values[Field];
630 
631  pRecord->m_Values[Field] = CSG_Table_Record::_Create_Value(Type);
632 
633  if( bNoData )
634  {
635  if( Type != SG_DATATYPE_String && Type != SG_DATATYPE_Binary )
636  {
637  pRecord->m_Values[Field]->Set_Value(Get_NoData_Value());
638  }
639  }
640  else if( pValue->Get_Type() == SG_TABLE_VALUE_TYPE_String && SG_Data_Type_is_Numeric(Type) )
641  {
642  if( !pRecord->m_Values[Field]->Set_Value(pValue->asString()) )
643  {
644  pRecord->m_Values[Field]->Set_Value(Get_NoData_Value());
645  }
646  }
647  else
648  {
649  *(pRecord->m_Values[Field]) = *pValue;
650  }
651 
652  delete(pValue);
653 
654  pRecord->m_Flags |= SG_TABLE_REC_FLAG_Modified;
655  }
656 
657  m_Field_Type[Field] = Type;
658 
659  Set_Update_Flag(); _Stats_Invalidate(Field); Set_Modified();
660 
661  return( true );
662 }
663 
664 //---------------------------------------------------------
669 //---------------------------------------------------------
670 int CSG_Table::Get_Field_Length(int Field, int Encoding) const
671 {
672  size_t Length = 0;
673 
674  if( Field >= 0 && Field < m_nFields )
675  {
676  switch( m_Field_Type[Field] )
677  {
678  default:
679  Length = SG_Data_Type_Get_Size(m_Field_Type[Field]);
680  break;
681 
682  case SG_DATATYPE_Date:
683  Length = 10; // => YYYY-MM-DD
684  break;
685 
686  case SG_DATATYPE_String:
687  for(sLong i=0; i<m_nRecords; i++)
688  {
689  CSG_String s(m_Records[i]->asString(Field));
690 
691  size_t nBytes;
692 
693  switch( Encoding )
694  {
695  default :
696  case SG_FILE_ENCODING_UTF7 : nBytes = s.Length() ; break;
697  case SG_FILE_ENCODING_UTF8 : nBytes = s.to_UTF8().Get_Size(); break;
698  case SG_FILE_ENCODING_UTF16LE:
699  case SG_FILE_ENCODING_UTF16BE: nBytes = s.Length() * 2 ; break;
700  case SG_FILE_ENCODING_UTF32LE:
701  case SG_FILE_ENCODING_UTF32BE: nBytes = s.Length() * 4 ; break;
702  }
703 
704  if( Length < nBytes )
705  {
706  Length = nBytes;
707  }
708  }
709  break;
710  }
711  }
712 
713  return( (int)Length );
714 }
715 
716 //---------------------------------------------------------
717 int CSG_Table::Get_Field(const char *Name) const { return( Get_Field(CSG_String(Name))); }
718 int CSG_Table::Get_Field(const wchar_t *Name) const { return( Get_Field(CSG_String(Name))); }
719 int CSG_Table::Get_Field(const CSG_String &Name) const
720 {
721  for(int Field=0; Field<Get_Field_Count(); Field++)
722  {
723  if( !Name.Cmp(Get_Field_Name(Field)) )
724  {
725  return( Field );
726  }
727  }
728 
729  return( -1 );
730 }
731 
732 //---------------------------------------------------------
737 int CSG_Table::Find_Field(const CSG_String &Name) const
738 {
739  for(int i=0; i<Get_Field_Count(); i++)
740  {
741  if( !Name.Cmp(Get_Field_Name(i)) )
742  {
743  return( i );
744  }
745  }
746 
747  return( -1 );
748 }
749 
750 //---------------------------------------------------------
755 bool CSG_Table::Find_Field(const CSG_String &Name, int &Index) const
756 {
757  return( (Index = Find_Field(Name)) >= 0 );
758 }
759 
760 
762 // //
763 // Records //
764 // //
766 
767 //---------------------------------------------------------
768 #define GET_GROW_SIZE(n) (n < 256 ? 1 : (n < 8192 ? 128 : 1024))
769 
770 //---------------------------------------------------------
771 bool CSG_Table::_Inc_Array(void)
772 {
773  if( m_nRecords < m_nBuffer )
774  {
775  return( true );
776  }
777 
778  CSG_Table_Record **pRecords = (CSG_Table_Record **)SG_Realloc(m_Records, (m_nBuffer + GET_GROW_SIZE(m_nBuffer)) * sizeof(CSG_Table_Record *));
779 
780  if( pRecords == NULL )
781  {
782  return( false );
783  }
784 
785  m_Records = pRecords;
786  m_nBuffer += GET_GROW_SIZE(m_nBuffer);
787 
788  return( true );
789 }
790 
791 //---------------------------------------------------------
792 bool CSG_Table::_Dec_Array(void)
793 {
794  if( m_nRecords < 0 || m_nRecords >= m_nBuffer - GET_GROW_SIZE(m_nBuffer) )
795  {
796  return( true );
797  }
798 
799  CSG_Table_Record **pRecords = (CSG_Table_Record **)SG_Realloc(m_Records, (m_nBuffer - GET_GROW_SIZE(m_nBuffer)) * sizeof(CSG_Table_Record *));
800 
801  if( pRecords == NULL )
802  {
803  return( false );
804  }
805 
806  m_Records = pRecords;
807  m_nBuffer -= GET_GROW_SIZE(m_nBuffer);
808 
809  return( true );
810 }
811 
812 //---------------------------------------------------------
813 CSG_Table_Record * CSG_Table::_Get_New_Record(sLong Index)
814 {
815  return( new CSG_Table_Record(this, Index) );
816 }
817 
818 //---------------------------------------------------------
819 CSG_Table_Record * CSG_Table::Add_Record(CSG_Table_Record *pCopy)
820 {
821  return( Ins_Record(m_nRecords, pCopy) );
822 }
823 
824 //---------------------------------------------------------
825 CSG_Table_Record * CSG_Table::Ins_Record(sLong iRecord, CSG_Table_Record *pCopy)
826 {
827  if( iRecord < 0 ) { iRecord = 0; } else if( iRecord > m_nRecords ) { iRecord = m_nRecords; }
828 
829  CSG_Table_Record *pRecord = _Inc_Array() ? _Get_New_Record(m_nRecords) : NULL;
830 
831  if( pRecord )
832  {
833  if( pCopy )
834  {
835  pRecord->Assign(pCopy);
836  }
837 
838  //-------------------------------------------------
839  if( iRecord < m_nRecords )
840  {
841  if( Get_Selection_Count() > 0 ) // update selection index
842  {
843  sLong *Selection = (sLong *)m_Selection.Get_Array();
844 
845  for(sLong i=0; i<m_Selection.Get_Size(); i++)
846  {
847  if( Selection[i] > iRecord )
848  {
849  Selection[i]++;
850  }
851  }
852  }
853 
854  for(sLong i=m_nRecords; i>iRecord; i--)
855  {
856  m_Records[i] = m_Records[i - 1]; m_Records[i]->m_Index = i;
857  }
858 
859  pRecord->m_Index = iRecord;
860  }
861 
862  m_Records[iRecord] = pRecord;
863  m_nRecords++;
864 
865  //-------------------------------------------------
866  if( m_Index.is_Okay() )
867  {
868  m_Index.Add_Entry(iRecord);
869  }
870 
871  Set_Modified();
872 
873  Set_Update_Flag();
874 
875  _Stats_Invalidate();
876  }
877 
878  return( pRecord );
879 }
880 
881 //---------------------------------------------------------
882 bool CSG_Table::Set_Record(sLong iRecord, CSG_Table_Record *pCopy)
883 {
884  if( iRecord >= 0 && iRecord < m_nRecords && pCopy )
885  {
886  return( m_Records[iRecord]->Assign(pCopy) );
887  }
888 
889  return( false );
890 }
891 
892 //---------------------------------------------------------
893 bool CSG_Table::Del_Record(sLong iRecord)
894 {
895  if( iRecord >= 0 && iRecord < m_nRecords )
896  {
897  if( m_Records[iRecord]->is_Selected() )
898  {
899  _Del_Selection(iRecord);
900  }
901 
902  delete(m_Records[iRecord]);
903 
904  m_nRecords--;
905 
906  for(sLong i=iRecord; i<m_nRecords; i++)
907  {
908  m_Records[i] = m_Records[i + 1]; m_Records[i]->m_Index = i;
909  }
910 
911  _Dec_Array();
912 
913  //-------------------------------------------------
914  if( m_Index.is_Okay() )
915  {
916  m_Index.Del_Entry(iRecord);
917  }
918 
919  Set_Modified();
920 
921  Set_Update_Flag();
922 
923  _Stats_Invalidate();
924 
925  return( true );
926  }
927 
928  return( false );
929 }
930 
931 //---------------------------------------------------------
932 bool CSG_Table::Del_Records(void)
933 {
934  Del_Index();
935 
936  for(sLong iRecord=0; iRecord<m_nRecords; iRecord++)
937  {
938  delete(m_Records[iRecord]);
939  }
940 
941  SG_FREE_SAFE(m_Records);
942 
943  m_nRecords = 0;
944  m_nBuffer = 0;
945 
946  return( true );
947 }
948 
949 //---------------------------------------------------------
950 bool CSG_Table::Set_Count(sLong nRecords)
951 {
952  if( m_nRecords < nRecords )
953  {
954  while( m_nRecords < nRecords && Add_Record() != NULL ) {}
955  }
956  else if( nRecords >= 0 && m_nRecords > nRecords )
957  {
958  while( m_nRecords > nRecords && Del_Record(m_nRecords - 1) ) {}
959  }
960 
961  return( m_nRecords == nRecords );
962 }
963 
964 
966 // //
968 
969 //---------------------------------------------------------
970 bool CSG_Table::Find_Record(sLong &iRecord, int iField, const CSG_String &Value, bool bCreateIndex)
971 {
972  if( iField < 0 || iField >= m_nFields || m_nRecords < 1 )
973  {
974  return( false );
975  }
976 
977  if( m_nRecords == 1 )
978  {
979  return( Value.Cmp(m_Records[iRecord = 0]->asString(iField)) == 0 );
980  }
981 
982  if( bCreateIndex && iField != Get_Index_Field(0) )
983  {
984  Set_Index(iField, TABLE_INDEX_Ascending);
985  }
986 
987  //-----------------------------------------------------
988  if( iField != Get_Index_Field(0) )
989  {
990  for(iRecord=0; iRecord<m_nRecords; iRecord++)
991  {
992  if( Value.Cmp(m_Records[iRecord]->asString(iField)) == 0 )
993  {
994  return( true );
995  }
996  }
997  }
998 
999  //-----------------------------------------------------
1000  else // indexed search
1001  {
1002  #define GET_RECORD(i) Get_Record_byIndex(bAscending ? (iRecord = i) : m_nRecords - 1 - (iRecord = i))
1003 
1004  double d; bool bAscending = Get_Index_Order(0) == TABLE_INDEX_Ascending;
1005 
1006  if( (d = Value.Cmp(GET_RECORD(0 )->asString(iField))) < 0 ) { return( false ); } else if( d == 0 ) { return( true ); }
1007  if( (d = Value.Cmp(GET_RECORD(m_nRecords - 1)->asString(iField))) > 0 ) { return( false ); } else if( d == 0 ) { return( true ); }
1008 
1009  for(sLong a=0, b=m_nRecords-1; b-a > 1; )
1010  {
1011  d = Value.Cmp(GET_RECORD(a + (b - a) / 2)->asString(iField));
1012 
1013  if( d > 0. )
1014  {
1015  a = iRecord;
1016  }
1017  else if( d < 0. )
1018  {
1019  b = iRecord;
1020  }
1021  else
1022  {
1023  iRecord = Get_Record_byIndex(bAscending ? iRecord : m_nRecords - 1 - iRecord)->Get_Index();
1024 
1025  return( true );
1026  }
1027  }
1028 
1029  iRecord = Get_Record_byIndex(bAscending ? iRecord : m_nRecords - 1 - iRecord)->Get_Index();
1030  }
1031 
1032  //-----------------------------------------------------
1033  return( false );
1034 }
1035 
1036 //---------------------------------------------------------
1037 CSG_Table_Record * CSG_Table::Find_Record(int iField, const CSG_String &Value, bool bCreateIndex)
1038 {
1039  sLong iRecord;
1040 
1041  if( Find_Record(iRecord, iField, Value, bCreateIndex) )
1042  {
1043  return( Get_Record(iRecord) );
1044  }
1045 
1046  return( NULL );
1047 }
1048 
1049 //---------------------------------------------------------
1050 bool CSG_Table::Find_Record(sLong &iRecord, int iField, double Value, bool bCreateIndex)
1051 {
1052  if( iField < 0 || iField >= m_nFields || m_nRecords < 1 )
1053  {
1054  return( false );
1055  }
1056 
1057  if( m_nRecords == 1 )
1058  {
1059  return( Value == m_Records[iRecord = 0]->asDouble(iField) );
1060  }
1061 
1062  if( bCreateIndex && iField != Get_Index_Field(0) )
1063  {
1064  Set_Index(iField, TABLE_INDEX_Ascending);
1065  }
1066 
1067  //-----------------------------------------------------
1068  if( iField != Get_Index_Field(0) )
1069  {
1070  for(iRecord=0; iRecord<m_nRecords; iRecord++)
1071  {
1072  if( Value == m_Records[iRecord]->asDouble(iField) )
1073  {
1074  return( true );
1075  }
1076  }
1077  }
1078 
1079  //-----------------------------------------------------
1080  else // indexed search
1081  {
1082  #define GET_RECORD(i) Get_Record_byIndex(bAscending ? (iRecord = i) : m_nRecords - 1 - (iRecord = i))
1083 
1084  double d; bool bAscending = Get_Index_Order(0) == TABLE_INDEX_Ascending;
1085 
1086  if( (d = Value - GET_RECORD(0 )->asDouble(iField)) < 0. ) { return( false ); } else if( d == 0. ) { return( true ); }
1087  if( (d = Value - GET_RECORD(m_nRecords - 1)->asDouble(iField)) > 0. ) { return( false ); } else if( d == 0. ) { return( true ); }
1088 
1089  for(sLong a=0, b=m_nRecords-1; b-a > 1; )
1090  {
1091  d = Value - GET_RECORD(a + (b - a) / 2)->asDouble(iField);
1092 
1093  if( d > 0. )
1094  {
1095  a = iRecord;
1096  }
1097  else if( d < 0. )
1098  {
1099  b = iRecord;
1100  }
1101  else
1102  {
1103  iRecord = Get_Record_byIndex(bAscending ? iRecord : m_nRecords - 1 - iRecord)->Get_Index();
1104 
1105  return( true );
1106  }
1107  }
1108 
1109  iRecord = Get_Record_byIndex(bAscending ? iRecord : m_nRecords - 1 - iRecord)->Get_Index();
1110  }
1111 
1112  //-----------------------------------------------------
1113  return( false );
1114 }
1115 
1116 //---------------------------------------------------------
1117 CSG_Table_Record * CSG_Table::Find_Record(int iField, double Value, bool bCreateIndex)
1118 {
1119  sLong iRecord;
1120 
1121  if( Find_Record(iRecord, iField, Value, bCreateIndex) )
1122  {
1123  return( Get_Record(iRecord) );
1124  }
1125 
1126  return( NULL );
1127 }
1128 
1129 
1131 // //
1132 // Value Access //
1133 // //
1135 
1136 //---------------------------------------------------------
1137 void CSG_Table::Set_Modified(bool bModified)
1138 {
1139  if( bModified != is_Modified() )
1140  {
1141  CSG_Data_Object::Set_Modified(bModified);
1142 
1143  if( bModified == false )
1144  {
1145  #pragma omp parallel for
1146  for(sLong iRecord=0; iRecord<m_nRecords; iRecord++)
1147  {
1148  m_Records[iRecord]->Set_Modified(false);
1149  }
1150  }
1151  }
1152 }
1153 
1154 //---------------------------------------------------------
1155 bool CSG_Table::Set_Value(sLong iRecord, int iField, const SG_Char *Value)
1156 {
1157  if( iField >= 0 && iField < m_nFields )
1158  {
1159  CSG_Table_Record *pRecord = Get_Record(iRecord);
1160 
1161  return( pRecord && pRecord->Set_Value(iField, Value) );
1162  }
1163 
1164  return( false );
1165 }
1166 
1167 //---------------------------------------------------------
1168 bool CSG_Table::Set_Value(sLong iRecord, int iField, double Value)
1169 {
1170  if( iField >= 0 && iField < m_nFields )
1171  {
1172  CSG_Table_Record *pRecord = Get_Record(iRecord);
1173 
1174  return( pRecord && pRecord->Set_Value(iField, Value) );
1175  }
1176 
1177  return( false );
1178 }
1179 
1180 //---------------------------------------------------------
1181 bool CSG_Table::Get_Value(sLong iRecord, int iField, CSG_String &Value) const
1182 {
1183  if( iField >= 0 && iField < m_nFields )
1184  {
1185  CSG_Table_Record *pRecord = Get_Record(iRecord);
1186 
1187  if( pRecord )
1188  {
1189  Value = pRecord->asString(iField);
1190 
1191  return( true );
1192  }
1193  }
1194 
1195  return( false );
1196 }
1197 
1198 //---------------------------------------------------------
1199 bool CSG_Table::Get_Value(sLong iRecord, int iField, double &Value) const
1200 {
1201  if( iField >= 0 && iField < m_nFields )
1202  {
1203  CSG_Table_Record *pRecord = Get_Record(iRecord);
1204 
1205  if( pRecord )
1206  {
1207  Value = pRecord->asDouble(iField);
1208 
1209  return( true );
1210  }
1211  }
1212 
1213  return( false );
1214 }
1215 
1216 
1218 // //
1219 // Statistics //
1220 // //
1222 
1223 //---------------------------------------------------------
1224 bool CSG_Table::_Stats_Invalidate(void) const
1225 {
1226  for(int iField=0; iField<m_nFields; iField++)
1227  {
1228  m_Field_Stats[iField]->Invalidate();
1229  }
1230 
1231  return( true );
1232 }
1233 
1234 //---------------------------------------------------------
1235 bool CSG_Table::_Stats_Invalidate(int iField) const
1236 {
1237  if( iField >= 0 && iField < m_nFields )
1238  {
1239  m_Field_Stats[iField]->Invalidate();
1240 
1241  return( true );
1242  }
1243 
1244  return( false );
1245 }
1246 
1247 //---------------------------------------------------------
1248 bool CSG_Table::_Stats_Update(int iField) const
1249 {
1250  if( iField < 0 || iField >= m_nFields || Get_Count() < 1 )
1251  {
1252  return( false );
1253  }
1254 
1255  CSG_Simple_Statistics &Statistics = *m_Field_Stats[iField];
1256 
1257  if( Statistics.is_Evaluated() )
1258  {
1259  return( true );
1260  }
1261 
1262  if( Get_Max_Samples() > 0 && Get_Max_Samples() < Get_Count() )
1263  {
1264  double d = (double)Get_Count() / (double)Get_Max_Samples();
1265 
1266  for(double i=0; i<(double)Get_Count(); i+=d)
1267  {
1268  CSG_Table_Record *pRecord = m_Records[(sLong)i];
1269 
1270  if( !pRecord->is_NoData(iField) )
1271  {
1272  Statistics += pRecord->asDouble(iField);
1273  }
1274  }
1275 
1276  Statistics.Set_Count(Statistics.Get_Count() >= Get_Max_Samples() ? Get_Count() // any no-data cells ?
1277  : (sLong)(Get_Count() * (double)Statistics.Get_Count() / (double)Get_Max_Samples())
1278  );
1279  }
1280  else
1281  {
1282  for(sLong i=0; i<Get_Count(); i++)
1283  {
1284  CSG_Table_Record *pRecord = m_Records[i];
1285 
1286  if( !pRecord->is_NoData(iField) )
1287  {
1288  Statistics += pRecord->asDouble(iField);
1289  }
1290  }
1291  }
1292 
1293  return( Statistics.Evaluate() ); // evaluate! prevent values to be added more than once!
1294 }
1295 
1296 
1298 // //
1299 // //
1300 // //
1302 
1303 //---------------------------------------------------------
1304 bool CSG_Table::On_NoData_Changed(void)
1305 {
1306  _Stats_Invalidate();
1307 
1308  return( CSG_Data_Object::On_NoData_Changed() );
1309 }
1310 
1311 //---------------------------------------------------------
1312 bool CSG_Table::On_Update(void)
1313 {
1314  _Stats_Invalidate();
1315 
1316  if( m_Index.is_Okay() )
1317  {
1318  _Index_Update();
1319  }
1320 
1321  return( CSG_Data_Object::On_Update() );
1322 }
1323 
1324 
1326 // //
1327 // Sort //
1328 // //
1330 
1331 //---------------------------------------------------------
1332 bool CSG_Table::Sort(const char *Field, bool bAscending) { return( Sort(Get_Field(Field), bAscending) ); }
1333 bool CSG_Table::Sort(const wchar_t *Field, bool bAscending) { return( Sort(Get_Field(Field), bAscending) ); }
1334 bool CSG_Table::Sort(const CSG_String &Field, bool bAscending) { return( Sort(Get_Field(Field), bAscending) ); }
1335 bool CSG_Table::Sort(int Field, bool bAscending)
1336 {
1337  CSG_Index Index; return( Set_Index(Index, Field, bAscending) && Sort(Index) );
1338 }
1339 
1340 //---------------------------------------------------------
1341 bool CSG_Table::Sort(const CSG_Index &Index)
1342 {
1343  if( Get_Count() > 0 && Get_Count() == Index.Get_Count() )
1344  {
1345  CSG_Table_Record **Records = m_Records; m_Records = (CSG_Table_Record **)SG_Malloc(m_nBuffer * sizeof(CSG_Table_Record *));
1346 
1347  for(sLong i=0; i<Get_Count(); i++)
1348  {
1349  m_Records[i] = Records[Index[i]];
1350  }
1351 
1352  SG_Free(Records);
1353 
1354  Del_Index();
1355 
1356  return( true );
1357  }
1358 
1359  return( false );
1360 }
1361 
1362 
1364 // //
1365 // Index //
1366 // //
1368 
1369 //---------------------------------------------------------
1370 bool CSG_Table::Set_Index(int Field_1, TSG_Table_Index_Order Order_1, int Field_2, TSG_Table_Index_Order Order_2, int Field_3, TSG_Table_Index_Order Order_3)
1371 {
1372  m_Index_Fields.Destroy();
1373 
1374  if( Field_1 >= 0 && Field_1 < m_nFields && Order_1 != TABLE_INDEX_None )
1375  {
1376  Field_1++; m_Index_Fields += Order_1 == TABLE_INDEX_Ascending ? Field_1 : -Field_1;
1377 
1378  if( Field_2 >= 0 && Field_2 < m_nFields && Order_2 != TABLE_INDEX_None )
1379  {
1380  Field_2++; m_Index_Fields += Order_2 == TABLE_INDEX_Ascending ? Field_2 : -Field_2;
1381 
1382  if( Field_3 >= 0 && Field_3 < m_nFields && Order_3 != TABLE_INDEX_None )
1383  {
1384  Field_3++; m_Index_Fields += Order_3 == TABLE_INDEX_Ascending ? Field_3 : -Field_3;
1385  }
1386  }
1387 
1388  _Index_Update();
1389  }
1390  else
1391  {
1392  Del_Index();
1393  }
1394 
1395  return( is_Indexed() );
1396 }
1397 
1398 //---------------------------------------------------------
1399 bool CSG_Table::Del_Index(void)
1400 {
1401  m_Index.Destroy();
1402 
1403  m_Index_Fields.Destroy();
1404 
1405  return( true );
1406 }
1407 
1408 //---------------------------------------------------------
1409 bool CSG_Table::Toggle_Index(int iField)
1410 {
1411  if( iField < 0 || iField >= m_nFields )
1412  {
1413  return( false );
1414  }
1415 
1416  if( iField != Get_Index_Field(0) )
1417  {
1418  return( Set_Index(iField, TABLE_INDEX_Ascending) );
1419  }
1420 
1421  if( Get_Index_Order(0) == TABLE_INDEX_Ascending )
1422  {
1423  return( Set_Index(iField, TABLE_INDEX_Descending) );
1424  }
1425 
1426  return( Del_Index() );
1427 }
1428 
1429 
1431 // //
1433 
1434 //---------------------------------------------------------
1435 class CSG_Table_Record_Compare_Field : public CSG_Index::CSG_Index_Compare
1436 {
1437 public:
1438  CSG_Table_Record_Compare_Field(const CSG_Table *pTable, int Field, bool Ascending)
1439  {
1440  m_pTable = pTable;
1441  m_Field = Field;
1442  m_Ascending = Ascending;
1443 
1444  if( !m_pTable || m_Field < 0 || m_Field >= m_pTable->Get_Field_Count() )
1445  {
1446  m_pTable = NULL;
1447  }
1448  }
1449 
1450  bool is_Okay (void) const { return( m_pTable != NULL ); }
1451 
1452  virtual int Compare (const sLong _a, const sLong _b)
1453  {
1454  sLong a = m_Ascending ? _a : _b;
1455  sLong b = m_Ascending ? _b : _a;
1456 
1457  switch( m_pTable->Get_Field_Type(m_Field) )
1458  {
1459  default: {
1460  double d =
1461  m_pTable->Get_Record(a)->asDouble(m_Field) -
1462  m_pTable->Get_Record(b)->asDouble(m_Field);
1463 
1464  return( d < 0. ? -1 : d > 0. ? 1 : 0 );
1465  }
1466 
1467  case SG_DATATYPE_String:
1468  case SG_DATATYPE_Date :
1469  return( SG_STR_CMP(
1470  m_pTable->Get_Record(a)->asString(m_Field),
1471  m_pTable->Get_Record(b)->asString(m_Field))
1472  );
1473  }
1474  }
1475 
1476 
1477 private:
1478 
1479  bool m_Ascending;
1480 
1481  int m_Field;
1482 
1483  const CSG_Table *m_pTable;
1484 
1485 };
1486 
1487 //---------------------------------------------------------
1488 bool CSG_Table::Set_Index(CSG_Index &Index, int Field, bool bAscending) const
1489 {
1490  CSG_Table_Record_Compare_Field Compare(this, Field, bAscending);
1491 
1492  return( Compare.is_Okay() && Index.Create(Get_Count(), &Compare) );
1493 }
1494 
1495 
1497 // //
1499 
1500 //---------------------------------------------------------
1501 class CSG_Table_Record_Compare_Fields : public CSG_Index::CSG_Index_Compare
1502 {
1503 public:
1504  CSG_Table_Record_Compare_Fields(const CSG_Table *pTable, int Fields[], int nFields, bool Ascending)
1505  : m_Fields(Fields), m_nFields(nFields), m_pTable(pTable)
1506  {
1507  m_Ascending.Create(nFields);
1508 
1509  for(int i=0; m_pTable && i<m_nFields; i++)
1510  {
1511  if( m_Fields[i] >= m_pTable->Get_Field_Count() )
1512  {
1513  m_pTable = NULL;
1514  }
1515 
1516  m_Ascending[i] = Ascending ? 1 : 0;
1517  }
1518  }
1519 
1520  CSG_Table_Record_Compare_Fields(const CSG_Table *pTable, int Fields[], int nFields, int Ascending[])
1521  : m_Fields(Fields), m_nFields(nFields), m_pTable(pTable)
1522  {
1523  m_Ascending.Create(nFields);
1524 
1525  for(int i=0; m_pTable && i<m_nFields; i++)
1526  {
1527  if( m_Fields[i] >= m_pTable->Get_Field_Count() )
1528  {
1529  m_pTable = NULL;
1530  }
1531 
1532  m_Ascending[i] = Ascending[i] > 0 ? 1 : 0;
1533  }
1534  }
1535 
1536  bool is_Okay (void) const { return( m_pTable != NULL ); }
1537 
1538  virtual int Compare (const sLong _a, const sLong _b)
1539  {
1540  int Difference = 0;
1541 
1542  for(int i=0; !Difference && i<m_nFields; i++)
1543  {
1544  int Field = m_Fields[i];
1545 
1546  sLong a = m_Ascending[i] ? _a : _b;
1547  sLong b = m_Ascending[i] ? _b : _a;
1548 
1549  switch( m_pTable->Get_Field_Type(Field) )
1550  {
1551  default: {
1552  double d = m_pTable->Get_Record(a)->asDouble(Field);
1553  d -= m_pTable->Get_Record(b)->asDouble(Field);
1554  Difference = d < 0. ? -1 : d > 0. ? 1 : 0;
1555  } break;
1556 
1557  case SG_DATATYPE_String:
1558  case SG_DATATYPE_Date :
1559  CSG_String s (m_pTable->Get_Record(a)->asString(Field));
1560  Difference = s.Cmp(m_pTable->Get_Record(b)->asString(Field));
1561  break;
1562  }
1563  }
1564 
1565  return( Difference );
1566  }
1567 
1568 
1569 private:
1570 
1571  int *m_Fields, m_nFields;
1572 
1573  CSG_Array_Int m_Ascending;
1574 
1575  const CSG_Table *m_pTable;
1576 
1577 };
1578 
1579 //---------------------------------------------------------
1580 bool CSG_Table::Set_Index(CSG_Index &Index, int Fields[], int nFields, bool bAscending) const
1581 {
1582  CSG_Table_Record_Compare_Fields Compare(this, Fields, nFields, bAscending);
1583 
1584  return( Compare.is_Okay() && Index.Create(Get_Count(), &Compare) );
1585 }
1586 
1587 //---------------------------------------------------------
1588 bool CSG_Table::Set_Index(CSG_Index &Index, const CSG_Array_Int &Fields, bool bAscending) const
1589 {
1590  return( Set_Index(Index, Fields.Get_Array(), (int)Fields.Get_Size(), bAscending) );
1591 }
1592 
1593 //---------------------------------------------------------
1594 void CSG_Table::_Index_Update(void)
1595 {
1596  if( m_Index_Fields.Get_Size() < 1 )
1597  {
1598  Del_Index();
1599  }
1600 
1601  CSG_Array_Int Fields, Ascending;
1602 
1603  for(sLong i=0; i<m_Index_Fields.Get_Size(); i++)
1604  {
1605  Fields += abs(m_Index_Fields[i]) - 1;
1606  Ascending += m_Index_Fields[i] > 0 ? 1 : 0;
1607  }
1608 
1609  CSG_Table_Record_Compare_Fields Compare(this, Fields.Get_Array(), (int)Fields.Get_Size(), Ascending.Get_Array());
1610 
1611  if( !Compare.is_Okay() || !m_Index.Create(Get_Count(), &Compare) )
1612  {
1613  Del_Index();
1614  }
1615 }
1616 
1617 
1619 // //
1620 // //
1621 // //
1623 
1624 //---------------------------------------------------------
CSG_Index
Definition: mat_tools.h:200
CSG_Table::CSG_Table_Record
friend class CSG_Table_Record
Definition: table.h:286
CSG_Data_Object::Assign
virtual bool Assign(CSG_Data_Object *pObject, bool bProgress=false)
Definition: dataobject.cpp:797
CSG_String::BeforeFirst
CSG_String BeforeFirst(char Character) const
Definition: api_string.cpp:713
CSG_Table_Record::asDouble
double asDouble(int Field) const
Definition: table_record.cpp:527
CSG_Index::is_Okay
bool is_Okay(void) const
Definition: mat_tools.h:238
CSG_Data_Object::Get_Max_Samples
sLong Get_Max_Samples(void) const
Definition: dataobject.h:263
SG_FREE_SAFE
#define SG_FREE_SAFE(PTR)
Definition: api_core.h:205
SG_Create_Table
CSG_Table * SG_Create_Table(void)
Definition: table.cpp:65
CSG_Table::Get_Field_Type
TSG_Data_Type Get_Field_Type(int Field) const
Definition: table.h:363
CSG_Table::Set_Count
virtual bool Set_Count(sLong nRecords)
Definition: table.cpp:950
SG_DATATYPE_String
@ SG_DATATYPE_String
Definition: api_core.h:1007
SG_TABLE_VALUE_TYPE_String
@ SG_TABLE_VALUE_TYPE_String
Definition: table_value.h:94
_TL
#define _TL(s)
Definition: api_core.h:1556
CSG_Table::Del_Records
virtual bool Del_Records(void)
Definition: table.cpp:932
SG_DATATYPE_Binary
@ SG_DATATYPE_Binary
Definition: api_core.h:1010
CSG_Array::Get_Size
sLong Get_Size(void) const
Definition: api_core.h:327
CSG_Data_Object::Set_File_Name
void Set_File_Name(const CSG_String &FileName)
Definition: dataobject.cpp:366
CSG_String::Length
size_t Length(void) const
Definition: api_string.cpp:172
TABLE_INDEX_None
@ TABLE_INDEX_None
Definition: table.h:104
CSG_Table::Get_Value
virtual bool Get_Value(sLong Index, int Field, CSG_String &Value) const
Definition: table.cpp:1181
CSG_Data_Object::Get_Description
const SG_Char * Get_Description(void) const
Definition: dataobject.cpp:360
CSG_Table_Record
Definition: table.h:130
CSG_Data_Object::Get_NoData_Value
double Get_NoData_Value(bool bUpper=false) const
Definition: dataobject.h:253
CSG_Table::Get_ObjectType
virtual TSG_Data_Object_Type Get_ObjectType(void) const
Returns the object type as defined by TSG_Data_Object_Type. Used for run time type checking.
Definition: table.h:318
SG_UI_MSG_STYLE_SUCCESS
@ SG_UI_MSG_STYLE_SUCCESS
Definition: api_core.h:1572
CSG_Index::CSG_Index_Compare
Definition: mat_tools.h:203
CSG_Table::m_Selection
CSG_Array m_Selection
Definition: table.h:470
CSG_Table::Set_Field_Type
virtual bool Set_Field_Type(int Field, TSG_Data_Type Type)
Definition: table.cpp:610
CSG_Table::is_Selected
virtual bool is_Selected(sLong Index) const
Definition: table.h:429
CSG_Table::Get_Record
virtual CSG_Table_Record * Get_Record(sLong Index) const
Definition: table.h:399
GET_GROW_SIZE
#define GET_GROW_SIZE(n)
Definition: table.cpp:768
SG_Malloc
SAGA_API_DLL_EXPORT void * SG_Malloc(size_t size)
Definition: api_memory.cpp:65
CSG_Array_Int::Get_Size
sLong Get_Size(void) const
Definition: api_core.h:436
CSG_Table::m_Field_Name
CSG_String ** m_Field_Name
Definition: table.h:466
CSG_Table::_Stats_Update
virtual bool _Stats_Update(int Field) const
Definition: table.cpp:1248
SG_Data_Type_Get_Size
size_t SG_Data_Type_Get_Size(TSG_Data_Type Type)
Definition: api_core.h:1062
CSG_Table::operator=
CSG_Table & operator=(const CSG_Table &Table)
Definition: table.cpp:362
CSG_Table_Record::Assign
virtual bool Assign(CSG_Table_Record *pRecord)
Definition: table_record.cpp:543
CSG_Table::~CSG_Table
virtual ~CSG_Table(void)
Definition: table.cpp:319
CSG_Tool
Definition: tool.h:135
CSG_Index::CSG_Index_Compare::Compare
virtual int Compare(const sLong a, const sLong b)=0
CSG_Table::Destroy
virtual bool Destroy(void)
Definition: table.cpp:325
CSG_Data_Object::Get_Name
const SG_Char * Get_Name(void) const
Definition: dataobject.cpp:349
CSG_Tool::Execute
bool Execute(bool bAddHistory=false)
Definition: tool.cpp:258
SG_FILE_ENCODING_UTF32BE
@ SG_FILE_ENCODING_UTF32BE
Definition: api_core.h:556
CSG_Table::CSG_Table
CSG_Table(void)
Definition: table.cpp:147
CSG_Table::Get_Index_Order
TSG_Table_Index_Order Get_Index_Order(int i) const
Definition: table.h:453
CSG_Table::Set_Field_Name
bool Set_Field_Name(int Field, const SG_Char *Name)
Definition: table.cpp:595
CSG_Table::Get_Field_Count
int Get_Field_Count(void) const
Definition: table.h:361
CSG_Array_Int::Get_Array
int * Get_Array(void) const
Definition: api_core.h:439
CSG_Simple_Statistics::Evaluate
bool Evaluate(void)
Definition: mat_tools.cpp:473
SG_Free
SAGA_API_DLL_EXPORT void SG_Free(void *memblock)
Definition: api_memory.cpp:83
SG_STR_CMP
#define SG_STR_CMP(s1, s2)
Definition: api_core.h:544
CSG_Table_Record::m_Values
class CSG_Table_Value ** m_Values
Definition: table.h:258
CSG_Table::Set_Record
virtual bool Set_Record(sLong Index, CSG_Table_Record *pCopy)
Definition: table.cpp:882
CSG_Table_Value
Definition: table_value.h:111
CSG_Table_Record::m_Index
sLong m_Index
Definition: table.h:256
CSG_Tool_Library_Manager::Delete_Tool
bool Delete_Tool(CSG_Tool *pTool) const
Definition: tool_library.cpp:865
CSG_Table::Find_Record
virtual bool Find_Record(sLong &Index, int Field, const CSG_String &Value, bool bCreateIndex=false)
Definition: table.cpp:970
CSG_Data_Object::Set_Update_Flag
void Set_Update_Flag(bool bOn=true)
Definition: dataobject.h:285
CSG_Table_Record::is_NoData
bool is_NoData(int Field) const
Definition: table_record.cpp:416
CSG_Table::Set_Modified
virtual void Set_Modified(bool bModified=true)
Definition: table.cpp:1137
CSG_String::Cmp
int Cmp(const CSG_String &String) const
Definition: api_string.cpp:515
SG_FILE_ENCODING_UTF7
@ SG_FILE_ENCODING_UTF7
Definition: api_core.h:551
CSG_Table::_Stats_Invalidate
bool _Stats_Invalidate(void) const
Definition: table.cpp:1224
CSG_Table::m_Field_Type
TSG_Data_Type * m_Field_Type
Definition: table.h:464
CSG_Table_Record::m_Flags
char m_Flags
Definition: table.h:254
CSG_Table::Find_Field
int Find_Field(const CSG_String &Name) const
Definition: table.cpp:737
CSG_Tool::Set_Parameter
bool Set_Parameter(const CSG_String &ID, CSG_Parameter *pValue)
Definition: tool.cpp:1140
SG_UI_MSG_STYLE_FAILURE
@ SG_UI_MSG_STYLE_FAILURE
Definition: api_core.h:1573
CSG_Table::is_Compatible
bool is_Compatible(const CSG_Table &Table, bool bExactMatch=false) const
Definition: table.cpp:430
SG_File_Exists
SAGA_API_DLL_EXPORT bool SG_File_Exists(const CSG_String &FileName)
Definition: api_file.cpp:1078
CSG_Table::m_Field_Stats
CSG_Simple_Statistics ** m_Field_Stats
Definition: table.h:468
CSG_Table_Value::Get_Type
virtual TSG_Table_Value_Type Get_Type(void) const =0
CSG_Table_Record::asString
const SG_Char * asString(int Field, int Decimals=-99) const
Definition: table_record.cpp:461
CSG_Data_Object
Definition: dataobject.h:180
CSG_Data_Object::On_NoData_Changed
virtual bool On_NoData_Changed(void)
Definition: dataobject.cpp:601
CSG_Simple_Statistics::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:743
CSG_Table::Get_Selection_Count
sLong Get_Selection_Count(void) const
Definition: table.h:425
CSG_Index::Create
bool Create(sLong nValues, CSG_Index_Compare &Compare)
Definition: mat_indexing.cpp:110
SG_TABLE_REC_FLAG_Modified
#define SG_TABLE_REC_FLAG_Modified
Definition: table.h:118
CSG_Table::Get_Field_Name
const SG_Char * Get_Field_Name(int Field) const
Definition: table.h:362
TSG_Table_Index_Order
TSG_Table_Index_Order
Definition: table.h:103
sLong
signed long long sLong
Definition: api_core.h:158
SG_Get_Tool_Library_Manager
CSG_Tool_Library_Manager & SG_Get_Tool_Library_Manager(void)
Definition: tool_library.cpp:286
CSG_Table::Get_Field_Length
virtual int Get_Field_Length(int Field, int Encoding=SG_FILE_ENCODING_UNDEFINED) const
Definition: table.cpp:670
SG_Data_Type_is_Numeric
bool SG_Data_Type_is_Numeric(TSG_Data_Type Type)
Definition: api_core.cpp:198
CSG_Data_Object::On_Update
virtual bool On_Update(void)
Definition: dataobject.h:287
CSG_Table::is_Indexed
bool is_Indexed(void) const
Definition: table.h:451
CSG_Table::On_NoData_Changed
virtual bool On_NoData_Changed(void)
Definition: table.cpp:1304
SG_FILE_ENCODING_UTF32LE
@ SG_FILE_ENCODING_UTF32LE
Definition: api_core.h:555
CSG_Table::Get_Count
sLong Get_Count(void) const
Definition: table.h:397
CSG_Table_Record::_Create_Value
static CSG_Table_Value * _Create_Value(TSG_Data_Type Type)
Definition: table_record.cpp:110
CSG_Table::On_Update
virtual bool On_Update(void)
Definition: table.cpp:1312
CSG_Data_Object::is_Modified
virtual bool is_Modified(void) const
Definition: dataobject.h:228
CSG_Simple_Statistics::Invalidate
void Invalidate(void)
Definition: mat_tools.cpp:447
CSG_Table::Assign_Values
bool Assign_Values(const CSG_Table &Table)
Definition: table.cpp:395
CSG_Array_Int
Definition: api_core.h:423
CSG_Simple_Statistics::is_Evaluated
int is_Evaluated(void) const
Definition: mat_tools.h:739
CSG_Table::Get_Index_Field
int Get_Index_Field(int i) const
Definition: table.h:452
CSG_Table::Del_Index
bool Del_Index(void)
Definition: table.cpp:1399
CSG_Table::m_nBuffer
sLong m_nBuffer
Definition: table.h:462
CSG_Data_Object::Set_Modified
virtual void Set_Modified(bool bOn=true)
Definition: dataobject.h:227
CSG_Array::Create
void * Create(const CSG_Array &Array)
Definition: api_memory.cpp:250
CSG_Table::Toggle_Index
bool Toggle_Index(int Field)
Definition: table.cpp:1409
CSG_Array::Get_Array
void * Get_Array(void) const
Definition: api_core.h:336
CSG_Table::Get_Record_byIndex
CSG_Table_Record * Get_Record_byIndex(sLong Index) const
Definition: table.h:404
CSG_Data_Object::asTable
class CSG_Table * asTable(bool bPolymorph=false) const
Definition: dataobject.cpp:487
SG_DATATYPE_Date
@ SG_DATATYPE_Date
Definition: api_core.h:1008
CSG_Table_Record::_Add_Field
bool _Add_Field(int add_Field)
Definition: table_record.cpp:143
CSG_Data_Object::Set_Name
void Set_Name(const CSG_String &Name)
Definition: dataobject.cpp:300
CSG_Table::m_Encoding
int m_Encoding
Definition: table.h:460
CSG_Table_Record::Set_Modified
void Set_Modified(bool bOn=true)
Definition: table_record.cpp:220
CSG_Index::Add_Entry
bool Add_Entry(sLong Position=-1)
Definition: mat_indexing.cpp:268
CSG_Simple_Statistics::Set_Count
bool Set_Count(sLong Count)
Definition: mat_tools.cpp:424
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition: api_string.cpp:270
CSG_Table::_Del_Selection
bool _Del_Selection(sLong Index)
Definition: table_selection.cpp:87
SG_FILE_ENCODING_UTF16LE
@ SG_FILE_ENCODING_UTF16LE
Definition: api_core.h:553
CSG_Table::Assign
virtual bool Assign(CSG_Data_Object *pTable, bool bProgress=false)
Definition: table.cpp:370
CSG_Table::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position=-1)
Definition: table.cpp:465
CSG_Tool_Library_Manager::Create_Tool
CSG_Tool * Create_Tool(const CSG_String &Library, int Index, bool bWithGUI=false, bool bWithCMD=true) const
Definition: tool_library.cpp:836
CSG_Table
Definition: table.h:285
CSG_String::to_UTF8
size_t to_UTF8(char **pString) const
Definition: api_string.cpp:860
SG_DATAOBJECT_TYPE_Shapes
@ SG_DATAOBJECT_TYPE_Shapes
Definition: dataobject.h:121
TABLE_INDEX_Descending
@ TABLE_INDEX_Descending
Definition: table.h:106
CSG_String::AfterFirst
CSG_String AfterFirst(char Character) const
Definition: api_string.cpp:691
CSG_Table::Del_Record
virtual bool Del_Record(sLong Index)
Definition: table.cpp:893
SG_Char
#define SG_Char
Definition: api_core.h:536
CSG_Table::Load
bool Load(const CSG_String &File, int Format, SG_Char Separator, int Encoding=SG_FILE_ENCODING_UNDEFINED)
Definition: table_io.cpp:99
shapes.h
CSG_String
Definition: api_core.h:563
CSG_Tool::Set_Manager
bool Set_Manager(class CSG_Data_Manager *pManager)
Definition: tool.cpp:570
SG_DATAOBJECT_TYPE_Table
@ SG_DATAOBJECT_TYPE_Table
Definition: dataobject.h:120
CSG_Data_Object::Set_Description
void Set_Description(const CSG_String &Description)
Definition: dataobject.cpp:355
CSG_String::is_Empty
bool is_Empty(void) const
Definition: api_string.cpp:178
SG_UI_Process_Set_Progress
bool SG_UI_Process_Set_Progress(int Position, int Range)
Definition: api_callback.cpp:255
SG_FILE_ENCODING_UTF16BE
@ SG_FILE_ENCODING_UTF16BE
Definition: api_core.h:554
CSG_Table_Value::Set_Value
virtual bool Set_Value(const CSG_Bytes &Value)=0
TSG_Table_File_Type
TSG_Table_File_Type
Definition: table.h:93
CSG_Table_Record::Set_Value
bool Set_Value(int Field, const CSG_String &Value)
Definition: table_record.cpp:270
CSG_Table::Del_Field
virtual bool Del_Field(int Field)
Definition: table.cpp:504
CSG_Table::m_nFields
int m_nFields
Definition: table.h:460
GET_RECORD
#define GET_RECORD(i)
CSG_Table::Ins_Record
virtual CSG_Table_Record * Ins_Record(sLong Index, CSG_Table_Record *pCopy=NULL)
Definition: table.cpp:825
CSG_Table_Record::Get_Index
sLong Get_Index(void) const
Definition: table.h:136
TABLE_INDEX_Ascending
@ TABLE_INDEX_Ascending
Definition: table.h:105
CSG_Table::Set_Value
virtual bool Set_Value(sLong Index, int Field, const SG_Char *Value)
Definition: table.cpp:1155
CSG_Table::Create
bool Create(void)
Definition: table.cpp:153
CSG_Tool::On_Before_Execution
virtual bool On_Before_Execution(void)
Definition: tool.h:229
CSG_Shapes
Definition: shapes.h:773
SG_UI_ProgressAndMsg_Lock
void SG_UI_ProgressAndMsg_Lock(bool bOn)
Definition: api_callback.cpp:589
CSG_String::c_str
const SG_Char * c_str(void) const
Definition: api_string.cpp:236
tool_library.h
CSG_Table_Record::Get_Value
CSG_Table_Value * Get_Value(int Field)
Definition: table.h:239
CSG_Table_Value::asString
virtual const SG_Char * asString(int Decimals=-99) const =0
TSG_Data_Type
TSG_Data_Type
Definition: api_core.h:995
SG_Realloc
SAGA_API_DLL_EXPORT void * SG_Realloc(void *memblock, size_t size)
Definition: api_memory.cpp:77
CSG_Table::Set_Index
bool Set_Index(CSG_Index &Index, int Field, bool bAscending=true) const
Definition: table.cpp:1488
CSG_Index::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:239
CSG_Table::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition: table.cpp:819
CSG_Table::Sort
bool Sort(const char *Field, bool bAscending=true)
Definition: table.cpp:1332
CSG_Index::Del_Entry
bool Del_Entry(sLong Position=-1)
Definition: mat_indexing.cpp:289
CSG_Table::Get_Field
int Get_Field(const CSG_String &Name) const
Definition: table.cpp:719
CSG_Array_Int::Destroy
void Destroy(void)
Definition: api_core.h:431
SG_FILE_ENCODING_UTF8
@ SG_FILE_ENCODING_UTF8
Definition: api_core.h:552
CSG_Simple_Statistics
Definition: mat_tools.h:723
CSG_Data_Object::Set_NoData_Value_Range
virtual bool Set_NoData_Value_Range(double Lower, double Upper)
Definition: dataobject.cpp:578
table.h
CSG_Index::Destroy
bool Destroy(void)
Definition: mat_indexing.cpp:83
CSG_Data_Object::Destroy
virtual bool Destroy(void)
Definition: dataobject.cpp:281
CSG_Table::_Get_New_Record
virtual CSG_Table_Record * _Get_New_Record(sLong Index)
Definition: table.cpp:813
SG_DATAOBJECT_TYPE_PointCloud
@ SG_DATAOBJECT_TYPE_PointCloud
Definition: dataobject.h:123
CSG_Table::m_nRecords
sLong m_nRecords
Definition: table.h:462
SG_UI_Msg_Add
void SG_UI_Msg_Add(const char *Message, bool bNewLine, TSG_UI_MSG_STYLE Style)
Definition: api_callback.cpp:502
CSG_Table_Record::_Del_Field
bool _Del_Field(int del_Field)
Definition: table_record.cpp:167
CSG_Table::_On_Construction
virtual void _On_Construction(void)
Definition: table.cpp:295
SG_Create_Shapes
CSG_Shapes * SG_Create_Shapes(void)
Definition: shapes.cpp:85
CSG_Table::Mov_Field
virtual bool Mov_Field(int Field, int Position)
Definition: table.cpp:542