LCOV - code coverage report
Current view: top level - root/contrail/src/contrail-common/base - proto.h (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 238 286 83.2 %
Date: 2026-11-16 02:06:09 Functions: 566 1375 41.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #ifndef ctrlplane_proto_h
       7             : #define ctrlplane_proto_h
       8             : 
       9             : #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
      10             : #define BOOST_MPL_LIMIT_MAP_SIZE 30
      11             : 
      12             : #include <map>
      13             : #include <memory>
      14             : 
      15             : #include <vector>
      16             : 
      17             : #include <boost/ptr_container/ptr_vector.hpp>
      18             : #include <boost/function.hpp>
      19             : #include <boost/type_traits/is_same.hpp>
      20             : #include <boost/type_traits/is_base_of.hpp>
      21             : #include <boost/mpl/equal_to.hpp>
      22             : #include <boost/mpl/for_each.hpp>
      23             : #include <boost/mpl/greater.hpp>
      24             : #include <boost/mpl/list.hpp>
      25             : #include <boost/mpl/map.hpp>
      26             : #include <boost/mpl/or.hpp>
      27             : #include <boost/mpl/vector.hpp>
      28             : #include <boost/mpl/string.hpp>
      29             : 
      30             : #include "base/compiler.h"
      31             : #include "base/logging.h"
      32             : #include "base/parse_object.h"
      33             : 
      34             : namespace mpl = boost::mpl;
      35             : 
      36             : class ParseContext {
      37             : public:
      38             : 
      39             :     ParseContext();
      40             :     ~ParseContext();
      41             : 
      42             :     ParseObject *release();
      43             : 
      44             :     void Push(ParseObject *data);
      45             :     ParseObject *Pop();
      46             : 
      47             :     void SwapData(ParseObject *obj);
      48             :     void ReleaseData();
      49             : 
      50             :     ParseObject *data();
      51             : 
      52             :     void advance(int delta);
      53        9841 :     int offset() const { return offset_; }
      54             : 
      55             :     void set_lensize(int lensize);
      56             :     int lensize() const;
      57             :     void set_size(size_t length);
      58             :     size_t size() const;
      59             :     void set_total_size();
      60             :     size_t total_size() const;
      61             : 
      62             :     void SetError(int error, int subcode, std::string type, const uint8_t *data,
      63             :                   int data_size);
      64           0 :     const ParseErrorContext &error_context() { return error_context_; }
      65             : private:
      66             : 
      67             :     ParseErrorContext error_context_;
      68             :     struct StackFrame;
      69             :     int offset_;
      70             :     std::vector<StackFrame *> stack_;
      71             : };
      72             : 
      73             : class EncodeContext {
      74             : public:
      75             :     typedef boost::function<void(EncodeContext *, uint8_t *, int, int)> CallbackType;
      76             : 
      77             :     EncodeContext();
      78             :     ~EncodeContext();
      79             : 
      80             :     void Push();
      81             :     void Pop(bool callback);
      82             :     void AddCallback(CallbackType cb, uint8_t *data, int arg);
      83             : 
      84             :     void advance(int delta);
      85             :     int length() const;
      86             : 
      87             :     void SaveOffset(std::string);
      88       10386 :     EncodeOffsets &encode_offsets() { return offsets_; }
      89             : private:
      90             :     struct StackFrame;
      91             :     boost::ptr_vector<StackFrame> stack_;
      92             :     EncodeOffsets offsets_;
      93             : };
      94             : 
      95             : template <class C, typename T, T C::* Member>
      96             : struct Accessor {
      97             :     typedef T C::* member_ptr_t;
      98       82520 :     static void set(C *obj, T value) {
      99       82520 :         obj->*Member = value;
     100       82520 :     }
     101       95888 :     static T get(const C *obj) {
     102       95888 :         return obj->*Member;
     103             :     }
     104             : };
     105             : 
     106             : template <class C, std::string C::* Member>
     107             : struct Accessor<C, std::string, Member> {
     108         124 :     static void set(C*obj, const uint8_t *data, size_t elem_size) {
     109         124 :         obj->*Member = std::string((const char *) data, elem_size);
     110         124 :     }
     111         174 :     static int size(const C *obj) {
     112         174 :         return (obj->*Member).size();
     113             :     }
     114         174 :     static std::string::const_iterator begin(const C *obj) {
     115         174 :         return (obj->*Member).begin();
     116             :     }
     117         174 :     static std::string::const_iterator end(const C *obj) {
     118         174 :         return (obj->*Member).end();
     119             :     }
     120             : };
     121             : 
     122             : template <class C, typename T, std::vector<T> C::* Member>
     123             : struct VectorAccessor {
     124       31998 :     static void set(C*obj, const uint8_t *data, size_t elem_size) {
     125       31998 :         obj->*Member = std::vector<T>();
     126       32000 :         size_t size = sizeof(T);
     127      433304 :         for (size_t i = 0; i < elem_size; i += size) {
     128      401309 :             T value = get_value(data, size);
     129      401307 :             data += size;
     130      401307 :             (obj->*Member).push_back(value);
     131             :         }
     132       31995 :     }
     133       36480 :     static int size(const C *obj) {
     134       36480 :         return (obj->*Member).size() * sizeof(T);
     135             :     }
     136       36486 :     static typename std::vector<T>::const_iterator begin(const C *obj) {
     137       36486 :         return (obj->*Member).begin();
     138             :     }
     139       36486 :     static typename std::vector<T>::const_iterator end(const C *obj) {
     140       36486 :         return (obj->*Member).end();
     141             :     }
     142             : };
     143             : 
     144             : // Extract the underlying type for pointer types.
     145             : template <typename T>
     146             : struct ValueType {
     147             :     typedef T type;
     148             : };
     149             : template <typename T>
     150             : struct ValueType<T *> {
     151             :     typedef T type;
     152             : };
     153             : 
     154             : template <typename Obj, typename Col, Col Obj::* Member>
     155             : struct CollectionAccessor {
     156             :     typedef typename ValueType<typename Col::value_type>::type ValueType;
     157             :     typedef Col CollectionType;
     158             :     typedef typename CollectionType::const_iterator iterator;
     159       52073 :     static void insert(Obj *obj, ValueType *element) {
     160       52073 :         (obj->*Member).push_back(element);
     161       52074 :     }
     162       54242 :     static iterator begin(const Obj *obj) {
     163       54242 :         return (obj->*Member).begin();
     164             :     }
     165      112779 :     static iterator end(const Obj *obj) {
     166      112779 :         return (obj->*Member).end();
     167             :     }
     168             : };
     169             : 
     170             : // Interface
     171             : struct ElementBase {
     172             :     static const int kSize = 0;
     173             :     static const int kErrorCode = 0;
     174             :     static const int kErrorSubcode = 0;
     175             :     struct NullCtxInit {
     176      191090 :         void operator()(void *) {
     177      191090 :         }
     178             :     };
     179             :     struct NoMatch {
     180             :         bool match(const void *) {
     181             :             return false;
     182             :         }
     183             :     };
     184      210113 :     static bool Verifier(const void * obj, const uint8_t *data, size_t size,
     185             :                          ParseContext *context) {
     186      210113 :         return true;
     187             :     }
     188             : 
     189             :     typedef void SaveOffset;            // Save the offset in encode context
     190             :     typedef void ContextType;           // push a new context on the stack
     191             :     typedef NullCtxInit ContextInit;    // initialize the context data
     192             :     typedef NoMatch ContextMatch;
     193             :     typedef void Setter;
     194             :     typedef void EncodingCallback;
     195             :     typedef void ContextSwap;           // swap a context with another one
     196             :     typedef void SizeSetter;            // set the size of the element
     197             : };
     198             : 
     199             : struct ChoiceBase : public ElementBase {
     200             :     typedef void ContextStorer; // store the context data on pop.
     201             : };
     202             : 
     203             : class SequenceBase : public ElementBase {
     204             : public:
     205             :     static const int kMinOccurs = 1;
     206             :     static const int kMaxOccurs = 1;
     207             :     typedef void ContextStorer; // store the context data on pop.
     208             : };
     209             : 
     210             : #include "base/proto_impl.h"
     211             : 
     212             : template<class Derived>
     213             : class ProtoElement : public ElementBase {
     214             : public:
     215             :     typedef void SequenceLength;
     216             : 
     217             :     template <typename T>
     218      195617 :     static void Writer(T *msg, uint8_t *data, size_t size) {
     219             :         typedef typename Derived::Setter setter_t;
     220             :         typedef typename mpl::if_<
     221             :             mpl::equal_to<
     222             :                 mpl::int_<Derived::kSize>, mpl::int_<-1> >,
     223             :             detail::VariableLengthWriter<typename Derived::Setter, T>,
     224             :             detail::ApplyGetter<setter_t>
     225             :         >::type writer_t;
     226             :         writer_t writer;
     227      195617 :         writer(data, Derived::kSize, msg);
     228      195671 :     }
     229             : 
     230             :     template <typename T>
     231      191109 :     static int Parse(const uint8_t *data, size_t size, ParseContext *context,
     232             :                      T *obj) {
     233             :         typedef typename mpl::if_<
     234             :             mpl::greater<
     235             :                 mpl::int_<Derived::kSize>, mpl::int_<0> >,
     236             :             detail::SizeComparer<Derived>,
     237             :             detail::NopComparer
     238             :         >::type cmp_t;
     239             : 
     240             :         cmp_t cmp;
     241      191109 :         if (!cmp(size)) {
     242           0 :             PROTO_DEBUG("Error: cmp(size) failed");
     243           0 :             context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     244             :                     TYPE_NAME(Derived), data,
     245           0 :                     Derived::kSize > 0 ? Derived::kSize : context->size());
     246           0 :             return -1;
     247             :         }
     248      191109 :         if (!Derived::Verifier(obj, data, size, context)) {
     249           0 :             PROTO_DEBUG(TYPE_NAME(Derived) << " Verifier failed");
     250           0 :             context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     251             :                     TYPE_NAME(Derived), data,
     252           0 :                     Derived::kSize > 0 ? Derived::kSize : context->size());
     253           0 :             return -1;
     254             :         }
     255             : 
     256             :         typedef typename Derived::ContextInit ctx_init_t;
     257             :         ctx_init_t initializer;
     258      191109 :         initializer(obj);
     259             : 
     260             :         detail::SequenceLengthSetter<typename Derived::SequenceLength, T> slen;
     261      191109 :         int res = slen(context, data, Derived::kSize, size, obj);
     262      191111 :         if (res < 0) {
     263           0 :             PROTO_DEBUG(TYPE_NAME(Derived) << ": error: Length Setter failed");
     264           0 :             context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     265             :                               TYPE_NAME(Derived), data, context->lensize());
     266           0 :             return -1;
     267             :         }
     268             : 
     269             :         typedef typename mpl::if_<boost::is_same<typename Derived::SizeSetter, void>,
     270             :             typename mpl::if_<
     271             :                 mpl::equal_to<mpl::int_<Derived::kSize>, mpl::int_<-1> >,
     272             :                 detail::VariableLengthSetter<typename Derived::Setter, T>,
     273             :                 typename mpl::if_<
     274             :                     mpl::greater<mpl::int_<Derived::kSize>, mpl::int_<0> >,
     275             :                     detail::FixedLengthSetter<Derived, T>,
     276             :                     detail::NopSetter<Derived, T>
     277             :                 >::type
     278             :             >::type,
     279             :             detail::LengthSizeSetter<typename Derived::SizeSetter, T>
     280             :         >::type setter_t;
     281             : 
     282             :         setter_t setter;
     283      191111 :         res = setter(data, size, context, obj);
     284      191110 :         if (res < 0) {
     285           0 :             context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     286             :                     TYPE_NAME(Derived), data,
     287           0 :                     Derived::kSize > 0 ? Derived::kSize : context->size());
     288             :         }
     289      191110 :         return res;
     290             :     }
     291             : 
     292             :     template <typename T>
     293      214502 :     static int Encode(EncodeContext *context, const T *msg, uint8_t *data,
     294             :                       size_t size) {
     295             :         typedef typename
     296             :             mpl::if_<boost::is_same<typename Derived::SizeSetter, void>,
     297             :             typename mpl::if_<mpl::equal_to<mpl::int_<Derived::kSize>, mpl::int_<-1> >,
     298             :                      detail::VarLengthSizeValue<typename Derived::Setter, T>,
     299             :                      detail::FixedLengthSizeValue<Derived> >::type,
     300             :             typename Derived::SizeSetter
     301             :         >::type size_value_t;
     302             : 
     303      214502 :         int element_size = size_value_t::get(msg);
     304      214512 :         if (data == NULL) {
     305           0 :             context->advance(element_size);
     306           0 :             return element_size;
     307             :         }
     308      214513 :         assert(element_size >= 0);
     309      214513 :         if (size < (size_t) element_size) {
     310           0 :             return -1;
     311             :         }
     312             : 
     313             :         // Setter overrides SequenceLength. Do not register a sequence length
     314             :         // callback if the element has defined a Setter.
     315             :         typename mpl::if_<
     316             :             boost::is_same<typename Derived::Setter, void>,
     317             :             detail::SequenceLengthAddCallback<typename Derived::SequenceLength>,
     318             :             detail::SequenceLengthAddCallback<void> >::type slen;
     319      214513 :         slen(&ProtoElement::SequenceLengthWriteLen, context, data, element_size);
     320             : 
     321             :         detail::AddCallback<typename Derived::EncodingCallback> cbadd;
     322      214476 :         cbadd(context, data, element_size);
     323             : 
     324      214487 :         detail::SaveOffset<typename Derived::SaveOffset>()(context);
     325             : 
     326      214501 :         Derived::Writer(msg, data, size);
     327             : 
     328      214556 :         context->advance(element_size);
     329      214353 :         return element_size;
     330             :     }
     331             : 
     332             : private:
     333       52187 :     static void SequenceLengthWriteLen(EncodeContext *context, uint8_t *data,
     334             :                                        int offset, int element_size) {
     335       52187 :         int length = context->length() - offset - element_size;
     336       52151 :         put_value(data, element_size, length);
     337       52155 :     }
     338             : };
     339             : 
     340             : template <typename Setter, typename T>
     341             : struct ChoiceSetter {
     342       42391 :     void operator()(T *obj, int &value) {
     343       42391 :         Setter::set(obj, value);
     344       42391 :     }
     345             : };
     346             : 
     347             : template <typename T>
     348             : struct ChoiceSetter<void, T> {
     349        9939 :     void operator()(T* obj, int value) { }
     350             : };
     351             : 
     352             : template <class Derived>
     353             : class ProtoChoice : public ChoiceBase {
     354             : public:
     355             :     template <typename T>
     356       52330 :     static int Parse(const uint8_t *data, size_t size, ParseContext *context,
     357             :                      T *obj) {
     358       52330 :         int advance = Derived::kSize;
     359       52330 :         int value = -1;
     360             : 
     361       52330 :         if (size < (size_t) advance) {
     362           0 :             context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     363             :                               TYPE_NAME(Derived), data, advance);
     364           0 :             return -1;
     365             :         }
     366             : 
     367       52330 :         value = get_value(data, advance);
     368             : 
     369       52330 :         data += advance;
     370       52330 :         size -= advance;
     371       52330 :         context->advance(advance);
     372             : 
     373             :         typedef typename mpl::if_<
     374             :             boost::is_same<typename Derived::Setter, void>,
     375             :             ChoiceSetter<void, T>,
     376             :             ChoiceSetter<typename Derived::Setter, T>
     377             :         >::type choice_setter_t;
     378             : 
     379             :         choice_setter_t setter;
     380       52330 :         setter(obj, value);
     381             : 
     382       52330 :         int result = ParseChoice(data, size, value, context, obj);
     383       52326 :         if (result < 0) {
     384           0 :             PROTO_DEBUG(TYPE_NAME(Derived) << " ParseChoice failed");
     385           0 :             if (result == -2) {
     386           0 :                 context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     387           0 :                               TYPE_NAME(Derived), data - advance, advance);
     388             :             }
     389           0 :             return result;
     390             :         }
     391       52326 :         advance += result;
     392       52326 :         return advance;
     393             :     }
     394             : 
     395             :     template <typename T>
     396       57839 :     static int Encode(EncodeContext *context, const T *msg, uint8_t *data,
     397             :                       size_t size) {
     398             :         typedef typename Derived::Choice choice_t;
     399       57839 :         int result = 0;
     400       57839 :         ChoiceEncoder<T> encoder(context, msg, data, size, &result);
     401       57859 :         mpl::for_each<choice_t>(encoder);
     402       57989 :         return result;
     403             :     }
     404             : 
     405             : private:
     406             :     template <typename T>
     407             :     struct ChoiceMatcher {
     408       52330 :         ChoiceMatcher(const uint8_t *data, size_t size, int value,
     409             :                       ParseContext *context, T *obj, int *resultp)
     410       52330 :             : data(data), size(size), value(value), context(context),
     411       52330 :               obj(obj), resultp(resultp), found(false) {
     412       52330 :         }
     413             :         template <typename U>
     414      767514 :         void operator()(U x) {
     415      767514 :             if (found) return;
     416      305691 :             if (U::first::value != -1 && U::first::value != value) {
     417      253389 :                 return;
     418             :             }
     419       52324 :             found = true;
     420             :             typedef detail::DescendentParser<Derived, typename U::second>
     421             :                 parser_t;
     422       52324 :             *resultp = parser_t::Parse(data, size, context, obj);
     423             :         }
     424             :         const uint8_t *data;
     425             :         size_t size;
     426             :         int value;
     427             :         ParseContext *context;
     428             :         T *obj;
     429             :         int *resultp;
     430             :         bool found;
     431             :     };
     432             :     template <typename T>
     433       52330 :     static int ParseChoice(const uint8_t *data, size_t size, int value,
     434             :                            ParseContext *context, T *obj) {
     435       52330 :         int result = -2;
     436       52330 :         ChoiceMatcher<T> match(data, size, value, context, obj, &result);
     437       52330 :         mpl::for_each<typename Derived::Choice>(match);
     438       52326 :         return result;
     439             :     }
     440             : 
     441             :     template <typename T>
     442             :     struct ChoiceEncoder {
     443       57853 :         ChoiceEncoder(EncodeContext *context, const T *msg, uint8_t *data, int size,
     444             :                       int *resultp)
     445       57853 :             : context(context), msg(msg), data(data), size(size),
     446       57853 :             resultp(resultp), found(false) {
     447       57853 :         }
     448             :         template <typename U, typename CtxType>
     449             :         struct EncoderTrue {
     450       58022 :             int operator()(int opt, EncodeContext *context, const CtxType *msg,
     451             :                            uint8_t *data, int size) {
     452             :                 if (Derived::kSize) {
     453       47277 :                     if (data != NULL) {
     454       47277 :                         if (size < Derived::kSize) return -1;
     455       47277 :                         put_value(data, Derived::kSize, opt);
     456       47279 :                         data += Derived::kSize;
     457       47279 :                         size -= Derived::kSize;
     458             :                     }
     459       47279 :                     context->advance(Derived::kSize);
     460             :                 }
     461       57991 :                 int result = U::Encode(context, msg, data, size);
     462       58002 :                 if (result >= 0) {
     463       58001 :                     result += Derived::kSize;
     464             :                 }
     465       58002 :                 return result;
     466             :             }
     467             :         };
     468             :         template <typename U, typename CtxType>
     469             :         struct EncoderSetter {
     470       39122 :             int operator()(int opt, EncodeContext *context, const CtxType *msg,
     471             :                     uint8_t *data, int size) {
     472       39122 :                 int value = Derived::Setter::get(msg);
     473       39120 :                 if (value == opt || opt == -1) {
     474       35911 :                     return EncoderTrue<U, CtxType>()(value, context, msg, data, size);
     475             :                 }
     476        3209 :                 return 0;
     477             :             }
     478             :         };
     479             :         template <typename U>
     480             :         struct EncoderMatch {
     481       13521 :             int operator()(int opt, EncodeContext *context, const T *msg,
     482             :                            uint8_t *data, int size) {
     483             :                 typename U::ContextMatch matcher;
     484       13521 :                 if (matcher.match(msg)) {
     485       10933 :                     return EncoderTrue<U, T>()(opt, context, msg, data, size);
     486             :                 }
     487        2588 :                 return 0;
     488             :             }
     489             :         };
     490             :         template <typename U>
     491             :         struct EncoderRunTime {
     492      322989 :             int operator()(int opt, EncodeContext *context, const T *msg,
     493             :                            uint8_t *data, int size) {
     494      322989 :                 if (typeid(*msg) == typeid(typename U::ContextType)) {
     495             :                     typedef typename U::ContextType ctx_t;
     496       50242 :                     const ctx_t *ctx = static_cast<const ctx_t *>(msg);
     497             : 
     498             :                     typedef typename mpl::if_<
     499             :                         boost::is_same<typename Derived::Setter, void>,
     500             :                         EncoderTrue<U, ctx_t>,
     501             :                         EncoderSetter<U, ctx_t>
     502             :                     >::type encoder;
     503       50242 :                     return encoder()(opt, context, ctx, data, size);
     504             :                 }
     505      272746 :                 return 0;
     506             :             }
     507             :         };
     508             :         struct EncoderNil {
     509             :             int operator()(int opt, EncodeContext *context, T *msg,
     510             :                            uint8_t *data, int size) {
     511             :                 return 0;
     512             :             }
     513             :         };
     514             :         template <typename U>
     515      841409 :         void operator()(U x) {
     516      841409 :             if (*resultp < 0 || found) {
     517      504885 :                 return;
     518             :             }
     519             :             // The choice element can be determined by:
     520             :             // 1. ContextType of the descendent or
     521             :             // 2. ContextMatch type of the descendent
     522             :             // In the case of ContextType match, the match can be either
     523             :             // performed at compile type (in case of exact match) or at run
     524             :             // type using RTTI.
     525             :             typedef typename mpl::if_<
     526             :                 boost::is_same<typename U::second::ContextType, T>,
     527             :                 EncoderTrue<typename U::second, T>,
     528             :                 typename mpl::if_<
     529             :                     boost::is_same<typename U::second::ContextType, void>,
     530             :                     EncoderMatch<typename U::second>,
     531             :                     typename mpl::if_<
     532             :                         boost::is_base_of<T, typename U::second::ContextType>,
     533             :                           EncoderRunTime<typename U::second>,
     534             :                           EncoderNil
     535             :                         >::type
     536             :                     >::type
     537             :             >::type choice_t;
     538             :             choice_t choice;
     539      336524 :             int result = choice(U::first::value, context, msg, data, size);
     540      336523 :             if (result < 0) {
     541           0 :                 *resultp = result;
     542      336523 :             } else if (result > 0) {
     543       57645 :                 found = true;
     544       57645 :                 *resultp += result;
     545             :             }
     546             :         }
     547             :     private:
     548             :         EncodeContext *context;
     549             :         const T *msg;
     550             :         uint8_t *data;
     551             :         int size;
     552             :         int *resultp;
     553             :         bool found;
     554             :     };
     555             : };
     556             : 
     557             : template <class Derived>
     558             : class ProtoSequence : public SequenceBase {
     559             : public:
     560             :     template <typename T>
     561             :     struct SequenceParser {
     562      112154 :         SequenceParser(const uint8_t *data, size_t size, ParseContext *context,
     563             :             T *obj, int *resultp)
     564      112154 :             : data(data), size(size), context(context), obj(obj),
     565      112154 :               resultp(resultp) {
     566      112154 :         }
     567             : 
     568             :         template <typename U>
     569      286492 :         void operator()(U x) {
     570      286492 :             if (*resultp < 0) {
     571           0 :                 return;
     572             :             }
     573             :             typedef detail::DescendentParser<Derived, U> parser_t;
     574      286492 :             size_t prev_size = context->size();
     575      286492 :             int result = parser_t::Parse(data, size, context, obj);
     576      286488 :             if (result < 0) {
     577           0 :                 *resultp = result;
     578           0 :                 return;
     579             :             }
     580             : 
     581      286488 :             data += result;
     582      286488 :             size -= result;
     583      286488 :             context->advance(result);
     584      286490 :             *resultp += result;
     585             : 
     586      286490 :             if (context->size() != prev_size) {
     587       91667 :                 size = context->size();
     588       91669 :                 context->set_total_size();
     589             :             } else {
     590      194823 :                 context->set_size(prev_size - result);
     591             :             }
     592             :         }
     593             : 
     594             :         const uint8_t *data;
     595             :         size_t size;
     596             :         ParseContext *context;
     597             :         T *obj;
     598             :         int *resultp;
     599             :     };
     600             : 
     601             :     template <typename T>
     602      105348 :     static int Parse(const uint8_t *data, size_t size, ParseContext *context,
     603             :                      T *obj) {
     604      105348 :         int min = Derived::kMinOccurs;
     605      105348 :         if (min == 0 && size == 0) {
     606        9892 :             return 0;
     607             :         }
     608       95456 :         if (!Derived::Verifier(obj, data, size, context)) {
     609           0 :             PROTO_DEBUG(TYPE_NAME(Derived) << " Verifier failed");
     610           0 :             context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     611             :                     TYPE_NAME(Derived), data,
     612           0 :                     Derived::kSize > 0 ? Derived::kSize : context->size());
     613           0 :             return -1;
     614             :         }
     615       95456 :         int lensize = Derived::kSize;
     616       95456 :         int length = size;
     617       95456 :         if (lensize) {
     618       19273 :             if (size < (size_t) lensize) {
     619           0 :                 PROTO_DEBUG("Error: size = " << size << " lensize = " << lensize);
     620           0 :                 context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     621             :                                   TYPE_NAME(Derived), data, lensize);
     622           0 :                 return -1;
     623             :             }
     624             :             // TODO: options for length (include or exclude length field).
     625       19273 :             length = get_value(data, lensize);
     626       19273 :             assert(length >= 0);
     627       19273 :             size -= lensize;
     628       19273 :             if ((size_t) length > size) {
     629           0 :                 PROTO_DEBUG("Error: length = " << length << " size = " << size);
     630           0 :                 context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     631             :                                   TYPE_NAME(Derived), data, lensize);
     632           0 :                 return -1;
     633             :             }
     634       19273 :             data += lensize;
     635       19273 :             context->advance(lensize);
     636             :         }
     637       95455 :         int result = lensize;
     638       95455 :         int max = Derived::kMaxOccurs;
     639      207604 :         for (int i = 0; (max == -1 || i < max) && (length > 0); i++) {
     640      112154 :             int sublen = 0;
     641             :             typedef typename Derived::ContextStorer ctx_access_t;
     642             :             typedef typename
     643             :             detail::ContextElementType<ctx_access_t>::ValueType child_obj_t;
     644             :             typedef typename mpl::if_<boost::is_same<typename Derived::ContextSwap, void>,
     645             :                     detail::ContextPush<T, child_obj_t>,
     646             :                     detail::NoContextPush<T>
     647             :             >::type ContextPush;
     648             :             ContextPush pushfn;
     649             :             typedef typename mpl::if_<boost::is_same<child_obj_t, void>,
     650             :                         T, child_obj_t>::type ctx_t;
     651      112154 :             ctx_t *child_obj = pushfn(context, obj);
     652             : 
     653      112154 :             SequenceParser<ctx_t> parser(data, length, context, child_obj, &sublen);
     654      112154 :             mpl::for_each<typename Derived::Sequence>(parser);
     655      112152 :             if (sublen < 0) {
     656           0 :                 PROTO_DEBUG(TYPE_NAME(Derived) << ": error: sublen " << sublen);
     657           0 :                 return -1;
     658             :             }
     659      112152 :             if (sublen < (int)(context->size() + context->lensize())) {
     660           0 :                 PROTO_DEBUG(TYPE_NAME(Derived) << ": error: sublen " << sublen
     661             :                         << " < " << context->size() << "+" << context->lensize());
     662           0 :                 context->SetError(Derived::kErrorCode, Derived::kErrorSubcode,
     663             :                         TYPE_NAME(Derived), data,
     664           0 :                         context->size()+context->lensize());
     665           0 :                 return -1;
     666             :             }
     667      112154 :             result += sublen;
     668      112154 :             data += sublen;
     669      112154 :             length -= sublen;
     670             : 
     671             :             typedef typename mpl::if_<boost::is_same<typename Derived::ContextSwap, void>,
     672             :                     detail::ContextPop<Derived, T, child_obj_t>,
     673             :                     detail::ContextPop<Derived, void, void>
     674             :             >::type ContextPop;
     675             :             ContextPop popfn;
     676      112154 :             popfn(context, obj);
     677             :         }
     678       95450 :         return result;
     679             :     }
     680             : 
     681             :     template <typename T>
     682             :     struct SingleEncoder {
     683             :         typedef typename Derived::Sequence sequence_t;
     684       67181 :         int operator()(EncodeContext *context, const T *msg, uint8_t *data,
     685             :                        size_t size) {
     686       67181 :             int result = 0;
     687       67181 :             SequenceEncoder<T> encoder(context, msg, data, size, &result);
     688       67193 :             mpl::for_each<sequence_t>(encoder);
     689       67191 :             return result;
     690             :         }
     691             :     };
     692             : 
     693             :     template <typename T>
     694             :     struct ListEncoder {
     695             :         typedef typename Derived::Sequence sequence_t;
     696       54242 :         int operator()(EncodeContext *context, const T *msg, uint8_t *data,
     697             :                        size_t size) {
     698             :             typedef typename Derived::ContextStorer ctx_access_t;
     699             :             typedef typename
     700             :             detail::ContextElementType<ctx_access_t>::ValueType child_obj_t;
     701       54242 :             int result = 0;
     702             : 
     703       54242 :             detail::ContextIterator<ctx_access_t> iter(msg);
     704      112835 :             while (iter.HasNext(msg)) {
     705       58615 :                 child_obj_t *child_obj = iter.Next();
     706       58612 :                 int subres = 0;
     707       58612 :                 context->Push();
     708       58596 :                 SequenceEncoder<child_obj_t> encoder(context, child_obj,
     709             :                                                      data, size, &subres);
     710       58600 :                 mpl::for_each<sequence_t>(encoder);
     711       58695 :                 if (subres < 0) {
     712           0 :                     result = subres;
     713           0 :                     break;
     714             :                 }
     715       58695 :                 result += subres;
     716       58695 :                 if (data != NULL) {
     717       58693 :                     data += subres;
     718       58693 :                     size -= subres;
     719             :                 }
     720       58695 :                 context->Pop(data != NULL);
     721             :             }
     722       54194 :             return result;
     723             :         }
     724             :     };
     725             : 
     726             :     template <typename T>
     727      121422 :     static int Encode(EncodeContext *context, const T *msg, uint8_t *data,
     728             :                       size_t size) {
     729      121422 :         context->Push();
     730      121400 :         detail::SaveOffset<typename Derived::SaveOffset>()(context);
     731             :         if (Derived::kSize > 0) {
     732             :             // context push callback
     733       21851 :             if (data != NULL) {
     734       21851 :                 context->AddCallback(&SequenceLengthWriteLen, data, Derived::kSize);
     735       21825 :                 data += Derived::kSize;
     736       21825 :                 size -= Derived::kSize;
     737             :             }
     738       21825 :             context->advance(Derived::kSize);
     739             :         }
     740             :         typedef typename mpl::if_<
     741             :             mpl::or_<
     742             :                 mpl::equal_to<mpl::int_<Derived::kMaxOccurs>,
     743             :                               mpl::int_<-1> >,
     744             :                 mpl::greater<mpl::int_<Derived::kMaxOccurs>,
     745             :                              mpl::int_<1> >
     746             :                 >,
     747             :             ListEncoder<T>,
     748             :             SingleEncoder<T> >::type encoder_t;
     749             :         encoder_t encoder;
     750      121421 :         int result = encoder(context, msg, data, size);
     751      121464 :         if (result >= 0) {
     752      121464 :             result += Derived::kSize;
     753      121464 :             context->Pop(data != NULL);
     754             :         }
     755      121457 :         return result;
     756             :     }
     757             : 
     758             : private:
     759             :     template <typename T>
     760             :     struct SequenceEncoder {
     761      125782 :         SequenceEncoder(EncodeContext *context, const T *msg, uint8_t *data,
     762             :                         size_t size, int *resultp)
     763      125782 :         : context(context), msg(msg), data(data), size(size),
     764      125782 :           resultp(resultp) {
     765      125782 :         }
     766             :         template <typename U>
     767      321022 :         void operator()(U element) {
     768      321022 :             if (*resultp < 0) {
     769           0 :                 return;
     770             :             }
     771      321022 :             int res = U::Encode(context, msg, data, size);
     772      321041 :             if (res < 0) {
     773           0 :                 *resultp = res;
     774             :             } else {
     775      321041 :                 *resultp += res;
     776             :             }
     777      321041 :             if (data != NULL) {
     778      321043 :                 data += res;
     779      321043 :                 size -= res;
     780             :             }
     781             :         }
     782             : 
     783             :     private:
     784             :         EncodeContext *context;
     785             :         const T *msg;
     786             :         uint8_t *data;
     787             :         size_t size;
     788             :         int *resultp;
     789             :     };
     790             : 
     791       21841 :     static void SequenceLengthWriteLen(EncodeContext *context, uint8_t *data,
     792             :                                        int offset, int arg) {
     793       21841 :         int length = context->length() - Derived::kSize;
     794       21834 :         put_value(data, Derived::kSize, length);
     795       21834 :     }
     796             : };
     797             : 
     798             : #endif

Generated by: LCOV version 1.14