vtkDelimitedTextCodecIteratorPrivate.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkDelimitedTextCodecIterator_h
#define vtkDelimitedTextCodecIterator_h
 
#include "vtkTextCodec.h"
 
#include <set> //for set
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkAbstractArray;
class vtkDoubleArray;
class vtkIntArray;
class vtkStringArray;
class vtkTable;
 
class vtkDelimitedTextCodecIteratorPrivate : public vtkTextCodec::OutputIterator
{
public:
  vtkDelimitedTextCodecIteratorPrivate(vtkIdType startRecords, vtkIdType maxRecords,
    const std::string& recordDelimiters, const std::string& fieldDelimiters,
    const std::string& stringDelimiters, const std::string& whitespace, const std::string& comments,
    const std::string& escape, bool haveHeaders, bool mergConsDelimiters, bool useStringDelimiter,
    bool detectNumericColumns, bool forceDouble, int defaultInt, double defaultDouble,
    vtkTable* outputTable);
 
  ~vtkDelimitedTextCodecIteratorPrivate() override;
 
  void ReachedEndOfInput();
 
  vtkDelimitedTextCodecIteratorPrivate& operator=(const vtkTypeUInt32& value) override;
 
private:
  void operator=(const vtkDelimitedTextCodecIteratorPrivate&) = delete;
  vtkDelimitedTextCodecIteratorPrivate(const vtkDelimitedTextCodecIteratorPrivate&) = delete;
 
  template <typename T>
  static vtkSmartPointer<vtkStringArray> ToStringArray(T* array);
 
  static vtkSmartPointer<vtkDoubleArray> ToDoubleArray(vtkIntArray* array);
 
  vtkSmartPointer<vtkAbstractArray> Append(
    vtkIntArray* array, vtkIdType index, const std::string& str);
 
  vtkSmartPointer<vtkAbstractArray> Append(
    vtkDoubleArray* array, vtkIdType index, const std::string& str);
 
  vtkSmartPointer<vtkAbstractArray> Append(
    vtkStringArray* array, vtkIdType index, const std::string& str);
 
  vtkSmartPointer<vtkAbstractArray> Append(
    vtkAbstractArray* array, vtkIdType index, const std::string& str);
 
  void CreateColumn();
 
  void InsertField();
 
  struct RecordsCounter
  {
    RecordsCounter(bool has, vtkIdType max, vtkIdType start)
      : HasMax(has)
      , Max(max)
      , Start(start)
    {
    }
 
    bool HasMax = false;
    vtkIdType Max = 0;
    vtkIdType Start = 0;
    vtkIdType Skipped = 0;
    vtkIdType Current = 0;
 
    // Return true if max records was reached
    bool MaxReached();
 
    // Return true if current records is acceptable, based on its index
    bool AcceptingField();
 
    // Return true if this is the first acceptable records
    bool FirstAccepted();
 
    // Increment current index
    void Next();
 
    // Mark current record as skipped.
    void Skip();
 
    // Return the current number of read record.
    vtkIdType GetNumberOfAcceptedRecords();
  };
 
  RecordsCounter RecordsCount;
 
  std::set<vtkTypeUInt32> RecordDelimiters;
  std::set<vtkTypeUInt32> FieldDelimiters;
  std::set<vtkTypeUInt32> StringDelimiters;
  std::set<vtkTypeUInt32> Whitespace;
  std::set<vtkTypeUInt32> CommentChar = { '#' };
  std::set<vtkTypeUInt32> EscapeDelimiter;
 
  bool HaveHeaders = false;
  bool WhiteSpaceOnlyString = true;
  vtkTable* OutputTable = nullptr;
  vtkIdType CurrentFieldIndex = 0;
  std::string CurrentField;
  bool RecordAdjacent = true;
  bool MergeConsDelims = false;
  bool ProcessEscapeSequence = false;
  bool UseStringDelimiter = true;
  bool DetectNumericColumns = false;
  bool ForceDouble = false;
  int DefaultIntegerValue = 0;
  double DefaultDoubleValue = 0.;
  vtkTypeUInt32 WithinString = 0;
  bool WithinComment = false;
};
 
VTK_ABI_NAMESPACE_END
#endif
/* VTK-HeaderTest-Exclude: INCLUDES:CLASSES */