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 */