Project CMSSW displayed by LXR CMSSW_15_1_X_2025-07-11-2300/​Alignment/​Geners/​interface/​GenericIO.hh	Source navigation Diff markup Identifier search General search
	Version: CMSSW_15_1_X_2025-07-11-2300 CMSSW_15_1_X_2025-07-10-2300 CMSSW_15_1_X_2025-07-08-2300 CMSSW_15_1_X_2025-07-07-2300 CMSSW_15_1_X_2025-07-06-2300 CMSSW_15_0_4 CMSSW_15_0_3_patch1 CMSSW_14_0_21_patch1 Revert   Change

File indexing completed on 2024-04-06 11:56:19

 //
 // Top-level API for serializing and deserializing arbitrary classes
 //
 
 #ifndef GENERS_GENERICIO_HH_
 #define GENERS_GENERICIO_HH_
 
 #include <memory>
 
 #include "Alignment/Geners/interface/IOPointeeType.hh"
 #include "Alignment/Geners/interface/binaryIO.hh"
 
 #include "Alignment/Geners/interface/ArrayAdaptor.hh"
 #include "Alignment/Geners/interface/ClearIfPointer.hh"
 #include "Alignment/Geners/interface/StrippedType.hh"
 
 namespace gs {
   /**
 // Generic top-level function which can be used to write out
 // almost anything. Intended mainly for use inside "write"
 // methods of user-developed classes and templates. Returns
 // "true" if the argument item is successfully written out.
 */
   template <class Stream, class Item>
   inline bool write_item(Stream &os, const Item &item, const bool writeClassId = true) {
     char *ps = nullptr;
     return process_const_item<GenericWriter>(item, os, ps, writeClassId);
   }
 
   /**
 // A function for overwriting existing objects (which usually live
 // on the stack). This function actually skips couple levels of
 // indirection which would be generated by a call to "process_item".
 */
   template <class Stream, class Item>
   inline void restore_item(Stream &is, Item *item, const bool readClassId = true) {
     typedef std::vector<ClassId> State;
     assert(item);
     State state;
     const bool status = GenericReader<Stream, State, Item *, Int2Type<IOTraits<int>::ISPOINTER>>::process(
         item, is, &state, readClassId);
     if (is.fail())
       throw IOReadFailure("In gs::restore_item: input stream failure");
     if (!status)
       throw IOInvalidData("In gs::restore_item: invalid input stream data");
   }
 
   /**
 // Function for returning objects on the heap. This function
 // requires explicit specification of its first template
 // parameter, the type of the item to read. This function
 // either succeeds or throws an exception which inherits
 // from std::exception.
 */
   template <class Item, class Stream>
   inline std::unique_ptr<Item> read_item(Stream &is, const bool readClassId = true) {
     typedef std::vector<ClassId> State;
     Item *item = nullptr;
     State state;
     const bool status = GenericReader<Stream, State, Item *, Int2Type<IOTraits<int>::ISNULLPOINTER>>::process(
         item, is, &state, readClassId);
     std::unique_ptr<Item> ptr(item);
     if (is.fail())
       throw IOReadFailure("In gs::read_item: input stream failure");
     if (!status || item == nullptr)
       throw IOInvalidData("In gs::read_item: invalid input stream data");
     return ptr;
   }
 
   /**
 // Generic top-level function for writing arrays. Note that
 // the length of the array is not written out and that the
 // length must be known in advance in the scope from which
 // the companion function, "read_array", is called. "true"
 // is returned upon success, "false" on failure.
 */
   template <class Stream, class Item>
   inline bool write_array(Stream &os, Item *items, const std::size_t length) {
     char *ps = nullptr;
     return process_const_item<GenericWriter>(ArrayAdaptor<Item>(items, length), os, ps, false);
   }
 
   /**
 // Function for deserializing arrays. The length of the array
 // must be known in the scope from which this function is invoked.
 */
   template <class Stream, class Item>
   inline void read_array(Stream &is, Item *items, const std::size_t length) {
     typedef std::vector<ClassId> State;
     State state;
     ArrayAdaptor<Item> adap(items, length);
     const bool st = process_item<GenericReader>(adap, is, &state, false);
     if (is.fail())
       throw IOReadFailure("In gs::read_array: input stream failure");
     if (!st)
       throw IOInvalidData("In gs::read_array: invalid input stream data");
   }
 }  // namespace gs
 
 namespace gs {
   template <class Stream, class State, class Item, class Stage>
   struct GenericWriter2 : public GenericWriter<Stream, State, Item, Stage> {};
 
   template <class Stream, class State, class Item, class Stage>
   struct GenericReader2 : public GenericReader<Stream, State, Item, Stage> {};
 
   // The reader and writer templates should be specialized
   // (that is, their "process" function should be defined) using
   // the following processing stage types from "ProcessItem.hh":
   //
   // Int2Type<IOTraits<int>::ISPOD>                (+readIntoPtr)
   // InContainerHeader
   // InContainerFooter
   // InContainerSize
   // InPODArray
   // Int2Type<IOTraits<int>::ISWRITABLE>
   // Int2Type<IOTraits<int>::ISPOINTER>
   // Int2Type<IOTraits<int>::ISSHAREDPTR>
   // Int2Type<IOTraits<int>::ISPAIR>               (+readIntoPtr)
   // Int2Type<IOTraits<int>::ISSTRING>             (+readIntoPtr)
   //
   // In addition, the reader should be specialized for the following
   // types:
   //
   // InContainerCycle                              (process     only)
   // Int2Type<IOTraits<int>::ISSTDCONTAINER>       (readIntoPtr only)
   // Int2Type<IOTraits<int>::ISHEAPREADABLE>       (readIntoPtr only)
   // Int2Type<IOTraits<int>::ISPLACEREADABLE>      (readIntoPtr only)
   //
   // The resulting code is essentially one big compile-time state
   // machine with two main switching hubs: "process_item" function
   // from "ProcessItem.hh" and "process" function in GenericReader
   // template specialized for bare pointers.
   //
 
   //===================================================================
   //
   // Processing of a POD
   //
   //===================================================================
   template <class Stream, class State, class T>
   struct GenericWriter<Stream, State, T, Int2Type<IOTraits<int>::ISPOD>> {
     inline static bool process(const T &s, Stream &os, State *, const bool processClassId) {
       static const ClassId current(ClassId::makeId<T>());
       const bool status = processClassId ? current.write(os) : true;
       if (status)
         write_pod(os, s);
       return status && !os.fail();
     }
   };
 
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISPOD>> {
     inline static bool readIntoPtr(T *&ptr, Stream &str, State *, const bool processClassId) {
       std::unique_ptr<T> myptr;
       if (ptr == nullptr)
         myptr = std::unique_ptr<T>(new T());
       if (processClassId) {
         static const ClassId current(ClassId::makeId<T>());
         ClassId id(str, 1);
         current.ensureSameName(id);
       }
       read_pod(str, ptr ? ptr : myptr.get());
       if (str.fail())
         return false;
       if (ptr == nullptr)
         ptr = myptr.release();
       return true;
     }
 
     inline static bool process(T &s, Stream &os, State *st, const bool processClassId) {
       T *ps = &s;
       return readIntoPtr(ps, os, st, processClassId);
     }
   };
 
   //===================================================================
   //
   // Processing of a container header
   //
   //===================================================================
   template <class Stream, class State, class Container>
   struct GenericWriter<Stream, State, Container, InContainerHeader> {
     inline static bool process(const Container &, Stream &os, State *, const bool processClassId) {
       typedef typename Container::value_type T;
 
       static const ClassId current(ClassId::makeId<Container>());
       bool status = processClassId ? current.write(os) : true;
 
       // Maybe we do not have to write out the container class id,
       // but we do have to write out the item class id -- unless the
       // container is just an array of pods. Otherwise we might not
       // be able to read the container items back.
       if (status && !(IOTraits<T>::IsPOD && IOTraits<Container>::IsContiguous)) {
         static const ClassId itemId(ClassId::makeId<T>());
         status = itemId.write(os);
       }
       return status;
     }
   };
 
   template <class Stream, class State, class Container>
   struct GenericReader<Stream, State, Container, InContainerHeader> {
     inline static bool process(Container &a, Stream &is, State *state, const bool processClassId) {
       typedef typename Container::value_type T;
 
       if (processClassId) {
         static const ClassId current(ClassId::makeId<Container>());
         ClassId id(is, 1);
         current.ensureSameName(id);
       }
       a.clear();
       if (!(IOTraits<T>::IsPOD && IOTraits<Container>::IsContiguous)) {
         ClassId id(is, 1);
 
         // Remember the class id of the contained items.
         // We need to do this even if the id is invalid because
         // the id will be popped back when the "InContainerFooter"
         // stage is processed.
         state->push_back(id);
       }
       return true;
     }
   };
 
   //===================================================================
   //
   // Processing of a container footer
   //
   //===================================================================
   template <class Stream, class State, class Container>
   struct GenericWriter<Stream, State, Container, InContainerFooter> {
     inline static bool process(const Container &, Stream &, State *, bool) { return true; }
   };
 
   template <class Stream, class State, class Container>
   struct GenericReader<Stream, State, Container, InContainerFooter> {
     inline static bool process(Container &, Stream &, State *state, bool) {
       typedef typename Container::value_type T;
       if (!(IOTraits<T>::IsPOD && IOTraits<Container>::IsContiguous))
         state->pop_back();
       return true;
     }
   };
 
   //===================================================================
   //
   // Processing of container size
   //
   //===================================================================
   template <class Stream, class State, class Container>
   struct GenericWriter<Stream, State, Container, InContainerSize> {
     inline static bool process(const std::size_t &sz, Stream &os, State *, bool /* processClassId */) {
       write_pod(os, sz);
       return !os.fail();
     }
   };
 
   template <class Stream, class State, class Container>
   struct GenericReader<Stream, State, Container, InContainerSize> {
     inline static bool process(std::size_t &sz, Stream &is, State *, bool /* processClassId */) {
       read_pod(is, &sz);
       return !is.fail();
     }
   };
 
   //===================================================================
   //
   // Processing of data in contiguous POD containers
   //
   //===================================================================
   template <class Stream, class State, class ArrayLike>
   struct GenericWriter<Stream, State, ArrayLike, InPODArray> {
     inline static bool process(const ArrayLike &a, Stream &os, State *, bool) {
       const std::size_t len = a.size();
       write_pod(os, len);
       if (len)
         write_pod_array(os, &a[0], len);
       return !os.fail();
     }
   };
 
   template <class Stream, class State, class ArrayLike>
   struct GenericReader<Stream, State, ArrayLike, InPODArray> {
     inline static bool process(ArrayLike &a, Stream &s, State *, bool) {
       std::size_t len = 0;
       read_pod(s, &len);
       if (s.fail())
         return false;
       a.resize(len);
       if (!len)
         return true;
       read_pod_array(s, &a[0], len);
       return !s.fail();
     }
   };
 
   //===================================================================
   //
   // Processing of "writable" objects
   //
   //===================================================================
   template <class Stream, class State, class T>
   struct GenericWriter<Stream, State, T, Int2Type<IOTraits<int>::ISWRITABLE>> {
     inline static bool process(const T &s, Stream &os, State *, const bool processClassId) {
       return (processClassId ? s.classId().write(os) : true) && s.write(os) && !os.fail();
     }
   };
 
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISWRITABLE>> {
     inline static bool process(T &s, Stream &is, State *st, const bool processClassId) {
       typedef IOTraits<T> M;
       T *ps = &s;
       return GenericReader<Stream, State, T, Int2Type<M::Signature &(M::ISPLACEREADABLE | M::ISHEAPREADABLE)>>::
           readIntoPtr(ps, is, st, processClassId);
     }
   };
 
   //===================================================================
   //
   // Processing of bare pointers.
   //
   // The writer simply dereferences the pointer.
   //
   // In the reader, we want to read stuff into the pointee object,
   // or want to create an item on the heap if the pointer value is 0.
   //
   //===================================================================
   template <class Stream, class State, class Ptr>
   struct GenericWriter<Stream, State, Ptr, Int2Type<IOTraits<int>::ISPOINTER>> {
     inline static bool process(const Ptr &ptr, Stream &os, State *s, const bool processClassId) {
       // Can't have pointers to pointers. This is a design
       // decision which simplifies things considerably.
       typedef typename IOPointeeType<Ptr>::type Pointee;
       typedef IOTraits<Pointee> M;
       static_assert((M::Signature & (M::ISPOINTER | M::ISSHAREDPTR)) == 0, "can not write pointers to pointers");
 
       // Can't have NULL pointers either. But this
       // can be checked at run time only.
       assert(ptr);
       return process_const_item<GenericWriter2>(*ptr, os, s, processClassId);
     }
   };
 
   template <class Stream, class State, class Ptr>
   struct GenericReader<Stream, State, Ptr, Int2Type<IOTraits<int>::ISPOINTER>> {
     inline static bool process(Ptr &ptr, Stream &str, State *s, const bool processClassId) {
       // We need to figure out the type of the pointee
       // and make a swich depending on that type.
       // Note that the pointee itself can not be a pointer.
       typedef typename IOPointeeType<Ptr>::type Pointee;
       typedef IOTraits<Pointee> M;
       static_assert((M::Signature & (M::ISPOINTER | M::ISSHAREDPTR)) == 0, "can not read pointers to pointers");
 
       return GenericReader<
           Stream,
           State,
           Pointee,
           Int2Type<M::Signature &(M::ISPOD | M::ISSTDCONTAINER | M::ISHEAPREADABLE | M::ISPLACEREADABLE | M::ISPAIR |
                                   M::ISTUPLE | M::ISEXTERNAL | M::ISSTRING)>>::readIntoPtr(ptr, str, s, processClassId);
     }
   };
 
   template <class Stream, class State, class Ptr>
   struct GenericReader<Stream, State, Ptr, Int2Type<IOTraits<int>::ISNULLPOINTER>> {
     inline static bool process(Ptr &ptr, Stream &str, State *s, const bool processClassId) {
       // We need to figure out the type of the pointee
       // and make a swich depending on that type.
       // Note that the pointee itself can not be a pointer.
       typedef typename IOPointeeType<Ptr>::type Pointee;
       typedef IOTraits<Pointee> M;
       static_assert((M::Signature & (M::ISNULLPOINTER | M::ISSHAREDPTR)) == 0, "can not read pointers to pointers");
 
       return GenericReader<
           Stream,
           State,
           Pointee,
           Int2Type<M::Signature &(M::ISPOD | M::ISSTDCONTAINER | M::ISPUREHEAPREADABLE | M::ISPLACEREADABLE | M::ISPAIR |
                                   M::ISTUPLE | M::ISEXTERNAL | M::ISSTRING)>>::readIntoPtr(ptr, str, s, processClassId);
     }
   };
 
   //===================================================================
   //
   // Processing of shared pointers -- similar logic to pointers.
   // For the reader, handling of the shared pointer is reduced
   // to handling of a normal pointer with 0 value.
   //
   //===================================================================
   template <class Stream, class State, class Ptr>
   struct GenericWriter<Stream, State, Ptr, Int2Type<IOTraits<int>::ISSHAREDPTR>> {
     inline static bool process(const Ptr &ptr, Stream &os, State *s, const bool processClassId) {
       typedef typename Ptr::element_type Pointee;
       typedef IOTraits<Pointee> M;
       static_assert((M::Signature & (M::ISPOINTER | M::ISSHAREDPTR)) == 0, "can not write pointers to pointers");
       assert(ptr.get());
       return process_const_item<GenericWriter2>(*ptr, os, s, processClassId);
     }
   };
 
   template <class Stream, class State, class ShPtr>
   struct GenericReader<Stream, State, ShPtr, Int2Type<IOTraits<int>::ISSHAREDPTR>> {
     inline static bool process(ShPtr &a, Stream &str, State *s, const bool processClassId) {
       typedef typename ShPtr::element_type Pointee;
       typedef IOTraits<Pointee> M;
       static_assert((M::Signature & (M::ISPOINTER | M::ISSHAREDPTR)) == 0, "can not read pointers to pointers");
       Pointee *ptr = 0;
       const bool status = GenericReader<Stream, State, Pointee *, Int2Type<IOTraits<int>::ISNULLPOINTER>>::process(
           ptr, str, s, processClassId);
       if (status) {
         assert(ptr);
         a = std::shared_ptr<Pointee>(ptr);
         return true;
       } else {
         delete ptr;
         return false;
       }
     }
   };
 
   //===================================================================
   //
   // Processing of std::pair
   //
   //===================================================================
   template <class Stream, class State, class T>
   struct GenericWriter<Stream, State, T, Int2Type<IOTraits<int>::ISPAIR>> {
     inline static bool process(const T &s, Stream &os, State *st, const bool processClassId) {
       // Here is a little problem: in this scope "GenericWriter"
       // means GenericWriter<Stream, State, T,
       //                     Int2Type<IOTraits<int>::ISPAIR> >
       // However, we want to use the whole template, unspecialized.
       // This is why "GenericWriter2" is introduced: a copy of
       // "GenericWriter" via public inheritance.
       static const ClassId current(ClassId::makeId<T>());
       return (processClassId ? current.write(os) : true) &&
              process_const_item<GenericWriter2>(s.first, os, st, false) &&
              process_const_item<GenericWriter2>(s.second, os, st, false);
     }
   };
 
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISPAIR>> {
     inline static bool readIntoPtr(T *&ptr, Stream &str, State *s, const bool processClassId) {
       std::unique_ptr<T> myptr;
       if (ptr == 0) {
         myptr = std::unique_ptr<T>(new T());
         clearIfPointer(myptr.get()->first);
         clearIfPointer(myptr.get()->second);
       }
       std::vector<std::vector<ClassId>> itemIds;
       if (processClassId) {
         static const ClassId current(ClassId::makeId<T>());
         ClassId pairId(str, 1);
         current.ensureSameName(pairId);
         pairId.templateParameters(&itemIds);
         assert(itemIds.size() == 2U);
       } else {
         assert(!s->empty());
         s->back().templateParameters(&itemIds);
         if (itemIds.size() != 2U) {
           std::string err(
               "In gs::GenericReader::readIntoPtr: "
               "bad class id for std::pair on the "
               "class id stack: ");
           err += s->back().id();
           throw IOInvalidData(err);
         }
       }
       if (!(process_item<GenericReader2>((ptr ? ptr : myptr.get())->first, str, &itemIds[0], false) &&
             process_item<GenericReader2>((ptr ? ptr : myptr.get())->second, str, &itemIds[1], false)))
         return false;
       if (ptr == 0)
         ptr = myptr.release();
       return true;
     }
 
     inline static bool process(T &s, Stream &os, State *st, const bool processClassId) {
       T *ps = &s;
       return readIntoPtr(ps, os, st, processClassId);
     }
   };
 
   //===================================================================
   //
   // Processing of std::string
   //
   //===================================================================
   template <class Stream, class State>
   struct GenericWriter<Stream, State, std::string, Int2Type<IOTraits<int>::ISSTRING>> {
     inline static bool process(const std::string &s, Stream &os, State *, const bool processClassId) {
       static const ClassId current(ClassId::makeId<std::string>());
       const bool status = processClassId ? current.write(os) : true;
       if (status)
         write_string<char>(os, s);
       return status && !os.fail();
     }
   };
 
   template <class Stream, class State>
   struct GenericReader<Stream, State, std::string, Int2Type<IOTraits<int>::ISSTRING>> {
     inline static bool readIntoPtr(std::string *&ptr, Stream &is, State *, const bool processClassId) {
       std::unique_ptr<std::string> myptr;
       if (ptr == nullptr)
         myptr = std::make_unique<std::string>();
       if (processClassId) {
         static const ClassId current(ClassId::makeId<std::string>());
         ClassId id(is, 1);
         current.ensureSameName(id);
       }
       read_string<char>(is, ptr ? ptr : myptr.get());
       if (is.fail())
         return false;
       if (ptr == nullptr)
         ptr = myptr.release();
       return true;
     }
 
     inline static bool process(std::string &s, Stream &is, State *st, const bool processClassId) {
       std::string *ptr = &s;
       return readIntoPtr(ptr, is, st, processClassId);
     }
   };
 
   //===================================================================
   //
   // Processing of container readout
   //
   //===================================================================
   template <class Stream, class State, class Container>
   struct GenericReader<Stream, State, Container, InContainerCycle> {
   private:
     typedef typename Container::value_type item_type;
     typedef IOTraits<item_type> M;
 
     // Item is a simple pointer
     inline static bool process2(Container &obj, Stream &is, State *st, const std::size_t itemN, Int2Type<1>) {
       item_type ptr = 0;
       const bool status =
           GenericReader<Stream, State, item_type, Int2Type<IOTraits<int>::ISNULLPOINTER>>::process(ptr, is, st, true);
       if (status) {
         assert(ptr);
         InsertContainerItem<Container>::insert(obj, ptr, itemN);
       } else
         delete ptr;
       return status;
     }
 
     // Item is a shared pointer
     inline static bool process2(Container &obj, Stream &is, State *st, const std::size_t itemN, Int2Type<2>) {
       typedef typename item_type::element_type Pointee;
       Pointee *ptr = 0;
       const bool status =
           GenericReader<Stream, State, Pointee *, Int2Type<IOTraits<int>::ISNULLPOINTER>>::process(ptr, is, st, true);
       if (status) {
         assert(ptr);
         std::shared_ptr<Pointee> sptr(ptr);
         InsertContainerItem<Container>::insert(obj, sptr, itemN);
       } else
         delete ptr;
       return status;
     }
 
     // Item is heap-readable
     inline static bool process2(Container &obj, Stream &is, State *st, const std::size_t itemN, Int2Type<3>) {
       // No class id -- this is a member of a container
       assert(!st->empty());
       item_type *ptr = item_type::read(st->back(), is);
       if (ptr) {
         InsertContainerItem<Container>::insert(obj, *ptr, itemN);
         delete ptr;
       }
       return ptr;
     }
 
     // Item is not a pointer and not heap-readable.
     // Assume that it has a default constructor.
     inline static bool process2(Container &obj, Stream &is, State *st, const std::size_t itemN, Int2Type<4>) {
       typedef typename StrippedType<item_type>::type NCType;
       NCType item;
       NCType *pitem = &item;
       bool status =
           GenericReader<Stream, State, NCType *, Int2Type<IOTraits<int>::ISPOINTER>>::process(pitem, is, st, false);
       if (status)
         InsertContainerItem<Container>::insert(obj, item, itemN);
       return status;
     }
 
   public:
     inline static bool process(Container &obj, Stream &is, State *st, const std::size_t itemN) {
       // By default, we will assume that container starts empty.
       // Here, we need to produce a new item. There are 3 options:
       //   1) make it on the stack, insert a copy into the container
       //   2) make it on the heap, insert a copy, delete original
       //   3) the container contains pointers to begin with, so
       //      we make it on the stack and add a pointer to the container
       return process2(obj,
                       is,
                       st,
                       itemN,
                       Int2Type<M::IsPointer * 1 + M::IsSharedPtr * 2 + M::IsHeapReadable * 3 +
                                !(M::IsPointer || M::IsSharedPtr || M::IsHeapReadable) * 4>());
     }
   };
 
   //===================================================================
   //
   // Reading things when a pointer is given
   //
   //===================================================================
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISSTDCONTAINER>> {
     inline static bool readIntoPtr(T *&ptr, Stream &str, State *s, const bool processClassId) {
       if (ptr)
         return process_item<GenericReader2>(*ptr, str, s, processClassId);
       else {
         std::unique_ptr<T> myptr(new T());
         if (!process_item<GenericReader2>(*myptr, str, s, processClassId))
           return false;
         ptr = myptr.release();
         return true;
       }
     }
   };
 
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISHEAPREADABLE>> {
     inline static bool readIntoPtr(T *&ptr, Stream &str, State *s, const bool processClassId) {
       T *readback = 0;
       if (processClassId) {
         ClassId id(str, 1);
         readback = T::read(id, str);
       } else {
         assert(!s->empty());
         readback = T::read(s->back(), str);
       }
       if (readback) {
         if (ptr) {
           try {
             // We will assume here that the "read"
             // operation takes precedence over constness
             *const_cast<typename StrippedType<T>::type *>(ptr) = *readback;
           } catch (...) {
             delete readback;
             throw;
           }
           delete readback;
         } else
           ptr = readback;
       }
       return readback;
     }
   };
 
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISPUREHEAPREADABLE>> {
     inline static bool readIntoPtr(T *&ptr, Stream &str, State *s, const bool processClassId) {
       T *readback = nullptr;
       if (processClassId) {
         ClassId id(str, 1);
         readback = T::read(id, str);
       } else {
         assert(!s->empty());
         readback = T::read(s->back(), str);
       }
       if (readback) {
         assert(!ptr);
         ptr = readback;
       }
       return readback;
     }
   };
 
   template <class Stream, class State, class T>
   struct GenericReader<Stream, State, T, Int2Type<IOTraits<int>::ISPLACEREADABLE>> {
     inline static bool readIntoPtr(T *&ptr, Stream &str, State *s, const bool processClassId) {
       std::unique_ptr<T> myptr;
       if (ptr == 0)
         myptr = std::unique_ptr<T>(new T());
       if (processClassId) {
         ClassId id(str, 1);
         T::restore(id, str, ptr ? ptr : myptr.get());
       } else {
         assert(!s->empty());
         T::restore(s->back(), str, ptr ? ptr : myptr.get());
       }
       if (ptr == 0)
         ptr = myptr.release();
       return ptr;
     }
   };
 }  // namespace gs
 
 #endif  // GENERS_GENERICIO_HH_

This page was automatically generated by the 2.2.1 LXR engine. The LXR team