show_table_monitors.h

Go to the documentation of this file.

/*
 *  This file was autogenerated by the Kinetica schema processor.
 *
 *  DO NOT EDIT DIRECTLY.
 */
#ifndef __SHOW_TABLE_MONITORS_H__
#define __SHOW_TABLE_MONITORS_H__

namespace gpudb
{
    struct ShowTableMonitorsRequest
    {
        ShowTableMonitorsRequest() :
            monitorIds(std::vector<std::string>()),
            options(std::map<std::string, std::string>())
        {
        }

        ShowTableMonitorsRequest(const std::vector<std::string>& monitorIds_, const std::map<std::string, std::string>& options_):
            monitorIds( monitorIds_ ),
            options( options_ )
        {
        }

        std::vector<std::string> monitorIds;

        std::map<std::string, std::string> options;
    };
} // end namespace gpudb

namespace avro
{
    template<> struct codec_traits<gpudb::ShowTableMonitorsRequest>
    {
        static void encode(Encoder& e, const gpudb::ShowTableMonitorsRequest& v)
        {
            ::avro::encode(e, v.monitorIds);
            ::avro::encode(e, v.options);
        }

        static void decode(Decoder& d, gpudb::ShowTableMonitorsRequest& v)
        {
            if (::avro::ResolvingDecoder *rd = dynamic_cast< ::avro::ResolvingDecoder*>(&d))
            {
                const std::vector<size_t> fo = rd->fieldOrder();

                for (std::vector<size_t>::const_iterator it = fo.begin(); it != fo.end(); ++it)
                {
                    switch (*it)
                    {
                        case 0:
                            ::avro::decode(d, v.monitorIds);
                            break;

                        case 1:
                            ::avro::decode(d, v.options);
                            break;

                        default:
                            break;
                    }
                }
            }
            else
            {
                ::avro::decode(d, v.monitorIds);
                ::avro::decode(d, v.options);
            }
        }
    };
} // end namespace avro

namespace gpudb
{
    struct ShowTableMonitorsResponse
    {
        ShowTableMonitorsResponse() :
            monitorIds(std::vector<std::string>()),
            tableNames(std::vector<std::string>()),
            events(std::vector<std::string>()),
            increasingColumns(std::vector<std::string>()),
            filterExpressions(std::vector<std::string>()),
            joinTableNames(std::vector<std::string>()),
            joinColumnNames(std::vector<std::string>()),
            joinExpressions(std::vector<std::string>()),
            refreshMethod(std::vector<std::string>()),
            refreshPeriod(std::vector<std::string>()),
            refreshStartTime(std::vector<std::string>()),
            datasinkNames(std::vector<std::string>()),
            additionalInfo(std::vector<std::map<std::string, std::string> >()),
            info(std::map<std::string, std::string>())
        {
        }

        std::vector<std::string> monitorIds;

        std::vector<std::string> tableNames;

        std::vector<std::string> events;

        std::vector<std::string> increasingColumns;

        std::vector<std::string> filterExpressions;

        std::vector<std::string> joinTableNames;

        std::vector<std::string> joinColumnNames;

        std::vector<std::string> joinExpressions;

        std::vector<std::string> refreshMethod;

        std::vector<std::string> refreshPeriod;

        std::vector<std::string> refreshStartTime;

        std::vector<std::string> datasinkNames;

        std::vector<std::map<std::string, std::string> > additionalInfo;

        std::map<std::string, std::string> info;
    };
} // end namespace gpudb

namespace avro
{
    template<> struct codec_traits<gpudb::ShowTableMonitorsResponse>
    {
        static void encode(Encoder& e, const gpudb::ShowTableMonitorsResponse& v)
        {
            ::avro::encode(e, v.monitorIds);
            ::avro::encode(e, v.tableNames);
            ::avro::encode(e, v.events);
            ::avro::encode(e, v.increasingColumns);
            ::avro::encode(e, v.filterExpressions);
            ::avro::encode(e, v.joinTableNames);
            ::avro::encode(e, v.joinColumnNames);
            ::avro::encode(e, v.joinExpressions);
            ::avro::encode(e, v.refreshMethod);
            ::avro::encode(e, v.refreshPeriod);
            ::avro::encode(e, v.refreshStartTime);
            ::avro::encode(e, v.datasinkNames);
            ::avro::encode(e, v.additionalInfo);
            ::avro::encode(e, v.info);
        }

        static void decode(Decoder& d, gpudb::ShowTableMonitorsResponse& v)
        {
            if (::avro::ResolvingDecoder *rd = dynamic_cast< ::avro::ResolvingDecoder*>(&d))
            {
                const std::vector<size_t> fo = rd->fieldOrder();

                for (std::vector<size_t>::const_iterator it = fo.begin(); it != fo.end(); ++it)
                {
                    switch (*it)
                    {
                        case 0:
                            ::avro::decode(d, v.monitorIds);
                            break;

                        case 1:
                            ::avro::decode(d, v.tableNames);
                            break;

                        case 2:
                            ::avro::decode(d, v.events);
                            break;

                        case 3:
                            ::avro::decode(d, v.increasingColumns);
                            break;

                        case 4:
                            ::avro::decode(d, v.filterExpressions);
                            break;

                        case 5:
                            ::avro::decode(d, v.joinTableNames);
                            break;

                        case 6:
                            ::avro::decode(d, v.joinColumnNames);
                            break;

                        case 7:
                            ::avro::decode(d, v.joinExpressions);
                            break;

                        case 8:
                            ::avro::decode(d, v.refreshMethod);
                            break;

                        case 9:
                            ::avro::decode(d, v.refreshPeriod);
                            break;

                        case 10:
                            ::avro::decode(d, v.refreshStartTime);
                            break;

                        case 11:
                            ::avro::decode(d, v.datasinkNames);
                            break;

                        case 12:
                            ::avro::decode(d, v.additionalInfo);
                            break;

                        case 13:
                            ::avro::decode(d, v.info);
                            break;

                        default:
                            break;
                    }
                }
            }
            else
            {
                ::avro::decode(d, v.monitorIds);
                ::avro::decode(d, v.tableNames);
                ::avro::decode(d, v.events);
                ::avro::decode(d, v.increasingColumns);
                ::avro::decode(d, v.filterExpressions);
                ::avro::decode(d, v.joinTableNames);
                ::avro::decode(d, v.joinColumnNames);
                ::avro::decode(d, v.joinExpressions);
                ::avro::decode(d, v.refreshMethod);
                ::avro::decode(d, v.refreshPeriod);
                ::avro::decode(d, v.refreshStartTime);
                ::avro::decode(d, v.datasinkNames);
                ::avro::decode(d, v.additionalInfo);
                ::avro::decode(d, v.info);
            }
        }
    };
} // end namespace avro

#endif // __SHOW_TABLE_MONITORS_H__