json_feed.h

Go to the documentation of this file.

// Copyright (C) 2017-2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef JSON_FEED_H
#define JSON_FEED_H

#include <cc/data.h>
#include <exceptions/exceptions.h>
#include <util/state_model.h>
#include <boost/shared_ptr.hpp>
#include <stdint.h>
#include <string>
#include <vector>

namespace isc {
namespace config {

class JSONFeed;

typedef boost::shared_ptr<JSONFeed> JSONFeedPtr;

typedef boost::shared_ptr<const JSONFeed> ConstJSONFeedPtr;

class JSONFeedError : public Exception {
public:
    JSONFeedError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};


class JSONFeed : public util::StateModel {
public:



    static const int RECEIVE_START_ST = SM_DERIVED_STATE_MIN + 1;

    static const int WHITESPACE_BEFORE_JSON_ST = SM_DERIVED_STATE_MIN + 2;

    static const int JSON_START_ST = SM_DERIVED_STATE_MIN + 3;

    static const int INNER_JSON_ST = SM_DERIVED_STATE_MIN + 4;

    static const int STRING_JSON_ST = SM_DERIVED_STATE_MIN + 5;

    static const int ESCAPE_JSON_ST = SM_DERIVED_STATE_MIN + 6;

    static const int JSON_END_ST = SM_DERIVED_STATE_MIN + 7;

    static const int FEED_OK_ST = SM_DERIVED_STATE_MIN + 100;

    static const int FEED_FAILED_ST = SM_DERIVED_STATE_MIN + 101;





    static const int DATA_READ_OK_EVT = SM_DERIVED_EVENT_MIN + 1;

    static const int NEED_MORE_DATA_EVT = SM_DERIVED_EVENT_MIN + 2;

    static const int MORE_DATA_PROVIDED_EVT = SM_DERIVED_EVENT_MIN + 3;

    static const int FEED_OK_EVT = SM_DERIVED_EVENT_MIN + 100;

    static const int FEED_FAILED_EVT = SM_DERIVED_EVENT_MIN + 101;


    JSONFeed();

    void initModel();

    void poll();

    bool needData() const;

    bool feedOk() const;

    std::string getErrorMessage() const {
        return (error_message_);
    }

    std::string getProcessedText() const {
        return (output_);
    }

    data::ElementPtr toElement() const;

    void postBuffer(const void* buf, const size_t buf_size);


private:

    using StateModel::runModel;

    virtual void defineEvents();

    virtual void verifyEvents();

    virtual void defineStates();

    void feedFailure(const std::string& error_msg);

    virtual void onModelFailure(const std::string& explanation);

    char getNextFromBuffer();

    void invalidEventError(const std::string& handler_name,
                           const unsigned int event);

    bool popNextFromBuffer(char& next);



    void receiveStartHandler();

    void whiteSpaceBeforeJSONHandler();

    void innerJSONHandler();

    void stringJSONHandler();

    void escapeJSONHandler();

    void endJSONHandler();


    std::vector<char> buffer_;

    size_t data_ptr_;

    std::string error_message_;

    uint64_t open_scopes_;

    std::string output_;
};

} // end of namespace config
} // end of namespace isc

#endif // JSON_FEED_H