Scanner.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Scanner
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/File.h>
#include <NDEVR/String.h>
 
namespace NDEVR
{
    class TranslatedString;
    class NDEVR_BASE_API Scanner
    {
    public:
        explicit Scanner(const File& file, char delimiter = '|', File::OpenMode mode = File::e_ascii_read);
        explicit Scanner(const StringView& string, char delimiter = '|');
        explicit Scanner(const String& string, char delimiter = '|');
        virtual ~Scanner();
        void setDelimiter(char delimiter);
        uint08 getCurrentLineNumber() const;
        uint08 getCurrentFilePosition();
        fltp04 getFilePercent();
        virtual bool nextLine();
        virtual bool nextLine(String& string, bool clear_string = true);
        const String& currentLine() const { return m_current_line; }
        String& currentLine() { return m_current_line; }
        const char* getCurrent() const;
        void moveForward(uint04 distance = 1);
        bool isComment(char comment) const;
        uint04 getLineLength() const;
        uint04 skip();
        bool skipTo(char location, bool ignore_case = false);
        bool skipTo(const Buffer<char>& locations, bool ignore_case = false);
        bool skipTo(const char* location, bool ignore_case = false);
        uint04 skipWhiteSpace();
        void resetLinePosition();
        void setHasDelimiter(const bool has_delimiter) { m_has_delimiter = has_delimiter; }
        uint04& linePosition() { return m_cur_line_pos; }
        void setQuoteCharacter(char quote_character) { m_quote_character = quote_character; }
        char quoteCharacter() const { return m_quote_character; }
        File file() const { return m_file; }
        template<class t_type>
        t_type getNext();

        template<class t_type>
        t_type peekNext()
        {
            uint04 cur_line_pos = m_cur_line_pos;
            uint04 cur_column = m_cur_column;
            t_type next_val = getNext<t_type>();
            m_cur_line_pos = cur_line_pos;
            m_cur_column = cur_column;
            return next_val;
        }

        StringView getNext();

        void getNext(String& next);

        template<class t_type>
        t_type getNextHex();

        template<class t_type>
        t_type getNext(uint04 count)
        {
            char* start = &m_current_line[m_cur_line_pos];
            if (count == 0)
                return StringView();
            m_cur_line_pos += count;
            return StringView(start, count).getAs<t_type>();
        }

        bool hasNext() const;

        template<class t_type>
        t_type getColumn(uint04 column)
        {
            if (m_cur_column > column)
            {
                m_cur_column = 0;
                m_cur_line_pos = 0;
            }
 
            for (uint04 i = m_cur_column; i < column; i++)
                skip();
            return getNext<t_type>();
        }

        TranslatedString getDebugPosition() const;

        void setIgnoreEmptyLines(bool ignore_new_lines) { m_ignore_empty_lines = ignore_new_lines; }
        void setIgnoreWhiteSpace(bool ignore_white_space) { m_ignore_white_space = ignore_white_space; }
        virtual void setFilePosition(uint08 file_position, bool read_line = true);

        virtual uint01* getByteArray()
        {
            return (uint01*)&m_current_line[m_cur_line_pos];
        }

        uint08 dataSize() const;
    protected:
        String m_current_line; 
        File m_file; 
        String m_time_format; 
        uint08 m_current_line_number; 
        uint08 m_current_file_position; 
        uint08 m_data_size; 
        uint04 m_cur_line_pos; 
        uint04 m_cur_column; 
        uint04 m_current_line_size; 
        char m_delimiter; 
        char m_quote_character; 
        bool m_ignore_empty_lines; 
        bool m_ignore_white_space = false; 
        bool m_has_delimiter; 
    };
}