DelimitedLineParser.hpp

Go to the documentation of this file.

// Copyright 2010 Complete Genomics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you
// may not use this file except in compliance with the License. You
// may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.

#ifndef CGATOOLS_UTIL_DELIMITEDLINEPARSER_HPP_
#define CGATOOLS_UTIL_DELIMITEDLINEPARSER_HPP_ 1


#include "cgatools/core.hpp"
#include "cgatools/util/parse.hpp"
#include "cgatools/util/Exception.hpp"

#include <string>
#include <vector>

#include <boost/shared_ptr.hpp>
#include <boost/array.hpp>

#include <cstring>

namespace cgatools { namespace util {

    class DelimitedFieldParser
    {
    public:
        DelimitedFieldParser(const std::string& name)
            : name_(name)
        {
        }

        virtual ~DelimitedFieldParser()
        {
        }

        const std::string& getName() const
        {
            return name_;
        }

        virtual void parse(const char* first, const char* last) = 0;

    protected:
        std::string name_;
    };

    class IgnoreField : public DelimitedFieldParser
    {
    public:
        IgnoreField(const std::string& name)
            : DelimitedFieldParser(name)
        {
        }

        void parse(const char* first, const char* last)
        {
        }
    };

    template <typename Value>
    class ValueField : public DelimitedFieldParser
    {
    public:
        ValueField(const std::string& name, Value* val)
            : DelimitedFieldParser(name),
              val_(val)
        {
        }

        void parse(const char* first, const char* last)
        {
            for(size_t ii=0; ii<exceptions_.size(); ii++)
            {
                size_t strSize = exceptions_[ii].first.length();
                if (size_t(last-first) == strSize && 
                    0 == std::strncmp(first, exceptions_[ii].first.c_str(), strSize))
                {
                    *val_ = exceptions_[ii].second;
                    return;
                }
            }

            *val_ = parseValue<Value>(first, last);
        }

        ValueField<Value>& exception(const std::string& key, const Value& val)
        {
            exceptions_.push_back(make_pair(key, val));
            return *this;
        }

    private:
        Value* val_;
        std::vector< std::pair<std::string, Value> > exceptions_;
    };

    template <typename Value>
    class ValueVectorField : public DelimitedFieldParser
    {
    public:
        ValueVectorField(const std::string& name, char delimiter, std::vector<Value>* val)
            : DelimitedFieldParser(name),
              delimiter_(delimiter),
              val_(val)
        {
        }

        void parse(const char* first, const char* last)
        {
            val_->clear();

            const char* ii = first;
            while (ii < last)
            {
                const char* jj;
                for (jj = ii; jj < last && *jj != delimiter_; ++jj) ;

                Value v = parseValue<Value>(ii, jj);
                val_->push_back(v);

                ii = jj + 1;
            }
        }
    private:
        char delimiter_;
        std::vector<Value>* val_;
    };

    class StringField : public DelimitedFieldParser
    {
    public:
        StringField(const std::string& name, std::string* val)
            : DelimitedFieldParser(name),
              val_(val)
        {
        }

        void parse(const char* first, const char* last);

    private:
        std::string* val_;
    };

    class CharField : public DelimitedFieldParser
    {
    public:
        CharField(const std::string& name, char* val)
            : DelimitedFieldParser(name),
            val_(val)
        {
        }

        void parse(const char* first, const char* last);

    private:
        char* val_;
    };

    class StrandField : public DelimitedFieldParser
    {
    public:
        StrandField(const std::string& name, bool* val)
            : DelimitedFieldParser(name),
              val_(val)
        {
        }

        void parse(const char* first, const char* last);

    private:
        bool* val_;
    };

    class SideField : public DelimitedFieldParser
    {
    public:
        SideField(const std::string& name, uint8_t* val)
            : DelimitedFieldParser(name),
            val_(val)
        {
        }

        void parse(const char* first, const char* last);

    private:
        uint8_t* val_;
    };

    class DelimitedLineParser
    {
        friend class DelimitedFile;
    public:
        enum EmptyFieldHandling
        {
            PROCESS_EMPTY_FIELDS = 0,
            SKIP_EMPTY_FIELDS = 1
        };

        enum StrictnessChecking
        {
            STRICT_CHECKING = 0,
            RELAXED_CHECKING = 1
        };

        typedef std::vector< boost::shared_ptr<DelimitedFieldParser> > Fields;

        DelimitedLineParser();

        template <class Field>
        DelimitedLineParser& addField(const Field& field)
        {
            boost::shared_ptr<Field> ptr(new Field(field));
            fields_.push_back(ptr);
            return *this;
        }

        template <class Field>
        DelimitedLineParser& setField(size_t offset, const Field& field)
        {
            CGA_ASSERT(offset < fields_.size());
            boost::shared_ptr<Field> ptr(new Field(field));
            fields_[offset] = ptr;
            return *this;
        }

        void parseLine( const char* first, const char* last,
                        char delimiter = '\t',
                        EmptyFieldHandling emptyHandling = PROCESS_EMPTY_FIELDS,
                        StrictnessChecking strictnessChecking = RELAXED_CHECKING);

        void parseLine( const std::string& line,
                        char delimiter = '\t',
                        EmptyFieldHandling emptyHandling = PROCESS_EMPTY_FIELDS,
                        StrictnessChecking strictnessChecking = RELAXED_CHECKING);

        const Fields& getFields() const {return fields_;}

    private:
        Fields fields_;
    };

    class DelimitedField : public DelimitedFieldParser
    {
    public:
        DelimitedField(const std::string& name, char delimiter, const DelimitedLineParser& lineParser)
            : DelimitedFieldParser(name),
            delimiter_(delimiter),
            lineParser_(lineParser)
        {
        }

        void parse(const char* first, const char* last);

    private:
        char delimiter_;
        DelimitedLineParser lineParser_;
    };

} } // cgatools::util

#endif // CGATOOLS_UTIL_DELIMITEDLINEPARSER_HPP_

---