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