bank.h

Go to the documentation of this file.

//******************************************************************************
//*       ██╗  ██╗██╗██████╗  ██████╗     ██╗  ██╗    ██████╗                  *
//*       ██║  ██║██║██╔══██╗██╔═══██╗    ██║  ██║   ██╔═████╗                 *
//*       ███████║██║██████╔╝██║   ██║    ███████║   ██║██╔██║                 *
//*       ██╔══██║██║██╔═══╝ ██║   ██║    ╚════██║   ████╔╝██║                 *
//*       ██║  ██║██║██║     ╚██████╔╝         ██║██╗╚██████╔╝                 *
//*       ╚═╝  ╚═╝╚═╝╚═╝      ╚═════╝          ╚═╝╚═╝ ╚═════╝                  *
//************************ Jefferson National Lab (2017) ***********************
/*
 *   Copyright (c) 2017.  Jefferson Lab (JLab). All rights reserved. Permission
 *   to use, copy, modify, and distribute  this software and its documentation
 *   for educational, research, and not-for-profit purposes, without fee and
 *   without a signed licensing agreement.
 *
 *   IN NO EVENT SHALL JLAB BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL
 *   INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING
 *   OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF JLAB HAS
 *   BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *   JLAB SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 *   PURPOSE. THE HIPO DATA FORMAT SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF
 *   ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". JLAB HAS NO OBLIGATION TO
 *   PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 *   This software was developed under the United States Government license.
 *   For more information contact author at gavalian@jlab.org
 *   Department of Experimental Nuclear Physics, Jefferson Lab.
 */
/*******************************************************************************
 * File:   bank.h
 * Author: gavalian
 *
 * Created on April 12, 2017, 10:14 AM
 */
 
#ifndef HIPO_BANK_H
#define HIPO_BANK_H
#include <iostream>
#include <vector>
#include <cstring>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <functional>
#include <type_traits>
#include "dictionary.h"
#include "node.h"
 
namespace hipo {
 
  class Parser;
 
  class structure {
 
    private:
      
      std::vector<char> structureBuffer;
      char *structureAddress{};
      void setAddress(const char *address);
 
    protected:
 
      void initStructureBySize(int __group, int __item, int __type, int __size);
      std::vector<char>  &getStructureBuffer(){ return structureBuffer;}
      int                 getStructureBufferSize(){ return 8+getSize();}
      int                 dataOffset = 8;
      //std::vector<char> structureBuffer;
      friend class tuple;
 
  public:
 
      structure(){ structureAddress = nullptr;}
      structure(int size){ allocate(size);}
      structure(int __group, int __item, std::string &str);
 
      virtual     ~structure()= default;
      bool         allocate(int size);
      
      int          getSize() const noexcept{
        int length = *reinterpret_cast<uint32_t *>(structureAddress+4);
           return length&STRUCT_SIZE_MASK;
         //return getHeaderSize()+getDataSize();
      }
 
      int         getHeaderSize() const noexcept {
         int length = *reinterpret_cast<uint32_t *>(structureAddress+4);
         return (length>>STRUCT_FORMAT_SHIFT)&STRUCT_FORMAT_BYTE;
      }
      
      int         getDataSize() const noexcept {         
           return getSize()-getHeaderSize();
      }
 
      int          getType() const;
      int          getGroup() const;
      int          getItem() const;
      void         init(const char *buffer, int size);
      void         initNoCopy(const char *buffer, int size);
 
      const char    *getAddress();
      virtual void   show() const;
      void           setSize(int size);
      void           setHeaderSize(int size);
      void           setDataSize(int size);
 
      int          getIntAt   ( int index) const noexcept {
        return *reinterpret_cast<int32_t*>(&structureAddress[index+dataOffset]);
      }
    
      int16_t      getShortAt ( int index) const noexcept {
        return *reinterpret_cast<int16_t*>(&structureAddress[index+dataOffset]);
      }
      int8_t       getByteAt  ( int index) const noexcept {
        return *reinterpret_cast<int8_t*>(&structureAddress[index+dataOffset]);
      }
      float        getFloatAt ( int index) const noexcept {
        return *reinterpret_cast<float*>(&structureAddress[index+dataOffset]);
      }
      double       getDoubleAt( int index) const noexcept {
        return *reinterpret_cast<double*>(&structureAddress[index+dataOffset]);
      }
      long         getLongAt  ( int index) const noexcept {
        return *reinterpret_cast<int64_t*>(&structureAddress[index+dataOffset]);
      }
 
      std::string  getStringAt(int index);
 
      void         putIntAt(int index, int value){
        *reinterpret_cast<int32_t*>(&structureAddress[index+dataOffset]) = value;
      }
 
      void         putShortAt(int index, int16_t value){
        *reinterpret_cast<int16_t*>(&structureAddress[index+dataOffset]) = value;
      }
 
      void         putByteAt(int index, int8_t value){
        *reinterpret_cast<int8_t*>(&structureAddress[index+dataOffset]) = value;
      }
 
      void         putFloatAt(int index, float value){
        *reinterpret_cast<float*>(&structureAddress[index+dataOffset]) = value;
      }
 
      void         putDoubleAt(int index, double value){
        *reinterpret_cast<double*>(&structureAddress[index+dataOffset]) = value;
      }
 
      void         putLongAt(int index, int64_t value){
        *reinterpret_cast<int64_t*>(&structureAddress[index+dataOffset]) = value;
      }
 
      void         putStringAt(int index, std::string &str);
 
      virtual void notify(){}
      friend class event;
  };
 
  class composite : public node {
    private:
 
      std::vector<char>  typeChars;
      std::vector<int>   offsets;
      std::vector<int>   types;
      int                rowOffset = 0;
 
     // void parse(std::string format);
      int  getTypeSize(int type);
 
    public:
 
      composite(){};
      composite(int size){ allocate(size);};
      composite(int group, int item, int size){ /*initStructureBySize(group, item, 10, size);*/};
      composite(const char *format){}
      composite(int group, int item, const char *format, int capacity);
      
      void       parse(std::string format);
      void       parse(int group, int item, std::string format, int maxrows);
      virtual   ~composite(){}
      
      int      getRows() const noexcept { return dataLength()/rowOffset;}
 
      int      getEntries() const noexcept { return offsets.size();}
      int      getEntryType(int index) const noexcept { return types[index];}
      void     setRows(int rows);// { setDataLength(rows*rowOffset);}
      
      int      getRowSize() const noexcept { return rowOffset;}
 
      int      getInt    ( int element, int row) const noexcept;
      int64_t  getLong   ( int element, int row) const noexcept;
      float    getFloat  ( int element, int row) const noexcept;
      void     putInt    ( int element, int row, int value);
      void     putLong   ( int element, int row, int64_t value);
      void     putFloat  ( int element, int row, float value);
      virtual void notify();
      void     print();
      void     reset();
  };
  //typedef std::auto_ptr<hipo::generic_node> node_pointer;
 
    class bank : public structure {
 
    public:
 
      class rowlist {
 
      public:
        using list_t = std::vector<int>;
 
        rowlist()  = default;
        ~rowlist() = default;
 
        void reset(int numRows = -1);
        bool isInitialized() const { return m_init; }
 
        list_t const& getList() const;
        void setList(list_t const& list);
 
        template <typename F,
                  std::enable_if_t<std::is_invocable_r_v<bool, F&, bank&, int>, int> = 0>
        void filter(F&& func);
        void filter(char const* expression);
        void filter(Parser& p);
 
        static list_t createFullList(int num);
 
        void setOwnerBank(bank* const ownerBank) { m_owner_bank = ownerBank; }
 
      private:
        bool m_init{false};
        list_t m_list{};
        bank* m_owner_bank{nullptr};
 
        bool ownerBankIsUnknown(std::string_view caller = "");
 
        void filterByFunction(std::function<bool(bank&, int)> func);
 
      };
 
    private:
 
      schema  bankSchema;
      int     bankRows{-1};
      rowlist bankRowList;
 
    public:
 
        bank();
        // constructor initializes the nodes in the bank
        // and they will be filled automatically by reader.next()
        // method.
        bank(const schema& __schema){
          bankSchema = __schema;
          bankRows   = -1;
        }
 
        bank(const schema& __schema, int __rows){
          bankSchema = __schema;
          bankRows   = __rows;
          int size   = bankSchema.getSizeForRows(__rows);
          initStructureBySize(bankSchema.getGroup(),bankSchema.getItem(), 11, size);
          bankRowList.reset(bankRows);
        }
 
        ~bank() override;
 
        schema  &getSchema() { return bankSchema;}
 
        int    getRows()  const noexcept{ return bankRows;}
        void   setRows(   int rows);
        int    getInt(    int item, int index) const noexcept;
        int    getShort(  int item, int index) const noexcept;
        int    getByte(   int item, int index) const noexcept;
        float  getFloat(  int item, int index) const noexcept;
        double getDouble( int item, int index) const noexcept;
        long   getLong(   int item, int index) const noexcept;
 
        std::vector<int>    getInt(    int item) const noexcept;
        std::vector<float>  getFloat(  int item) const noexcept;
        std::vector<double> getDouble( int item) const noexcept;
 
        template<typename T = double> T get(int item, int index) const noexcept {
          auto type   = bankSchema.getEntryType(item);
          auto offset = bankSchema.getOffset(item, index, bankRows);
          switch(type) {
            case kByte:   return (int) getByteAt(offset);
            case kShort:  return (int) getShortAt(offset);
            case kInt:    return getIntAt(offset);
            case kFloat:  return getFloatAt(offset);
            case kDouble: return getDoubleAt(offset);
            case kLong:   return getLongAt(offset);
            default:
              printf("---> error(get) : unknown type for [%s] type = %d\n", bankSchema.getEntryName(item).c_str(), type);
          }
          return 0;
        }
 
        int    getInt(    const char *name, int index) const noexcept;
        
        int    getShort(  const char *name, int index) const noexcept;
        int    getByte(   const char *name, int index) const noexcept;
        float  getFloat(  const char *name, int index) const noexcept;
        double getDouble( const char *name, int index) const noexcept;
        long   getLong(   const char *name, int index) const noexcept;
        
        std::vector<int>    getInt(    const char *name) const noexcept;
        std::vector<float>  getFloat(  const char *name) const noexcept;
        std::vector<double> getDouble( const char *name) const noexcept;
 
        template<typename T = double> T get(const char *name, int index) const noexcept {
          return get<T>(bankSchema.getEntryOrder(name), index);
        }
 
        void    putInt(    const char *name, int index, int32_t value);
        void    putShort(  const char *name, int index, int16_t value);
        void    putByte(   const char *name, int index, int8_t value);
        void    putFloat(  const char *name, int index, float value);
        void    putDouble( const char *name, int index, double value);
        void    putLong(   const char *name, int index, int64_t value);
        template<typename T> void put(const char *name, int index, T value) {
          put(bankSchema.getEntryOrder(name), index, value);
        }
 
        void    putInt(int item, int index, int32_t value);
        void    putShort(int item, int index, int16_t value);
        void    putByte(int item, int index, int8_t value);
        void    putFloat(int item, int index, float value);
        void    putDouble(int item, int index, double value);
        void    putLong(int item, int index, int64_t value);
        template<typename T> void put(int item, int index, T value) {
          auto type = bankSchema.getEntryType(item);
          switch(type) {
            case kByte:   putByte(item,   index, static_cast<int8_t>(value));  break;
            case kShort:  putShort(item,  index, static_cast<int16_t>(value)); break;
            case kInt:    putInt(item,    index, static_cast<int32_t>(value)); break;
            case kFloat:  putFloat(item,  index, static_cast<float>(value));   break;
            case kDouble: putDouble(item, index, static_cast<double>(value));  break;
            case kLong:   putLong(item,   index, static_cast<int64_t>(value)); break;
            default:
              printf("---> error(put) : unknown type for [%s] type = %d\n", bankSchema.getEntryName(item).c_str(), type);
          }
        }
 
        rowlist::list_t const& getRowList() const;
 
        rowlist::list_t const getFullRowList() const;
 
        rowlist& getMutableRowList();
 
        rowlist::list_t const getRowListLinked(int const row, int const column) const;
 
        void show() const override;
 
        void show(bool const showAllRows) const;
 
        void printValue(int schemaEntry, int row) const;
 
        std::size_t checksum(bool checkAllRows=false) const;
 
        void reset();
 
        void notify() override;
 
  };
 
    // compile-time check that a `filter` callable takes its `bank` argument by lvalue reference
    //
    // `std::is_invocable` alone cannot tell `bank` (by value) from `bank const&` -- both accept every
    // argument category. So two complementary detections are used, see `bank_takes_bank_by_ref` below.
    namespace detail {
      struct sealed_bank : bank {
        sealed_bank(sealed_bank const&) = delete;
        sealed_bank(sealed_bank&&)      = delete;
      };
 
      // the first parameter type of a callable's signature, recovered directly from its type. We
      // avoid `std::function` CTAD here: deducing a signature via `decltype(std::function{...})` in
      // an unevaluated context is rejected by GCC for block-scope lambdas ("local type ... used but
      // never defined"), so we introspect the signature without ever forming a `std::function`.
      template <typename Sig> struct sig_first_param;                                       // primary: undefined
      template <typename R, typename A0, typename... As>                                    // plain function type
      struct sig_first_param<R(A0, As...)>                  { using type = A0; };
      template <typename R, typename A0, typename... As>                                    // function pointer
      struct sig_first_param<R(*)(A0, As...)>               { using type = A0; };
      template <typename C, typename R, typename A0, typename... As>                        // member operator() (mutable)
      struct sig_first_param<R(C::*)(A0, As...)>            { using type = A0; };
      template <typename C, typename R, typename A0, typename... As>                        // member operator() (const)
      struct sig_first_param<R(C::*)(A0, As...) const>      { using type = A0; };
 
      // a class with a *non-generic* operator() (concrete lambda, functor, or `std::function`) exposes a
      // single `&F::operator()`; a generic lambda's operator() is templated, so taking its address is ill-formed
      template <typename F, typename = void> struct call_signature { using type = F; };     // fn ptr / fn type
      template <typename F>
      struct call_signature<F, std::void_t<decltype(&F::operator())>> { using type = decltype(&F::operator()); };
 
      // the bank parameter type of F, if F has an inspectable single signature (else ill-formed -> SFINAE)
      template <typename F>
      using bank_param_t = typename sig_first_param<typename call_signature<F>::type>::type;
 
      // primary template: a generic lambda has a *templated* operator() and thus no single signature,
      // so `bank_param_t` is ill-formed -> probe with the non-copyable `sealed_bank`
      template <typename F, typename = void>
      struct bank_takes_bank_by_ref
        : std::bool_constant<std::is_invocable_r<bool, F&, sealed_bank&, int>::value> {};
 
      // inspectable callable (concrete lambda/functor, std::function, or function pointer): we recover its
      // signature -- including the bank parameter's reference-ness -- and check it directly. This catches
      // by-value `bank`/`bank const` (which copying could never reveal).
      template <typename F>
      struct bank_takes_bank_by_ref<F, std::void_t<bank_param_t<F>>>
        : std::is_lvalue_reference<bank_param_t<F>> {};
 
      template <typename F>
      inline constexpr bool bank_takes_bank_by_ref_v = bank_takes_bank_by_ref<std::decay_t<F>>::value;
 
    } // namespace detail
 
    // out-of-line definition of the constrained `filter`, now that `bank` is a complete type
    template <typename F, std::enable_if_t<std::is_invocable_r_v<bool, F&, bank&, int>, int>>
    void bank::rowlist::filter(F&& func) {
      static_assert(detail::bank_takes_bank_by_ref_v<F>,
        "hipo::bank::rowlist::filter: the callable's bank parameter must be an lvalue reference "
        "(bank& / bank const& / auto& / auto const&), never by value -- a by-value bank is copied "
        "per row and the copy shallow-aliases the original's buffer, which can cause a data race "
        "under multithreaded RDataFrame use.");
      filterByFunction(std::forward<F>(func));
    }
 
    //inlined getters
 
    inline float  bank::getFloat(int item, int index) const noexcept{
      if(bankSchema.getEntryType(item)==kFloat){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getFloatAt(offset);
      }
      return 0.0;
    }
 
    inline double  bank::getDouble(int item, int index) const noexcept{
      if(bankSchema.getEntryType(item)==kDouble){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getDoubleAt(offset);
      }
      if(bankSchema.getEntryType(item)==kFloat){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getFloatAt(offset);
      }
      return 0.0;
    }
 
    inline long bank::getLong(int item, int index) const noexcept{
      if(bankSchema.getEntryType(item)==kLong){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getLongAt(offset);
      }
      return 0;
    }
 
    inline int    bank::getInt(int item, int index) const noexcept{
      int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      switch(type){
      case kByte:  return (int) getByteAt(offset);
      case kShort: return (int) getShortAt(offset);
      case kInt:   return getIntAt(offset);
      default: printf("---> error : requested INT for [%s] type = %d\n",
              bankSchema.getEntryName(item).c_str(),type); break;
      }
      return 0;
    }
 
  inline std::vector<int>    bank::getInt(int item) const noexcept{
      int type = bankSchema.getEntryType(item);
      
      std::vector<int> row;
      int nrows = getRows();
 
      for(int j = 0; j < nrows; j++){
        int offset = bankSchema.getOffset(item, j, bankRows);
      switch(type){
          case kByte:  row.push_back((int) getByteAt(offset)); break;
          case kShort: row.push_back((int) getShortAt(offset)); break; 
          case kInt:   row.push_back((int) getIntAt(offset)); break;
      default: printf("---> error : requested INT for [%s] type = %d\n",
              bankSchema.getEntryName(item).c_str(),type); break;
      }
      }
      return row;
    }
 
    inline int    bank::getShort(int item, int index) const noexcept{
      int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      switch(type){
      case kByte:  return (int) getByteAt(offset);
      case kShort: return (int) getShortAt(offset);
      default: printf("---> error : requested SHORT for [%s] type = %d\n",
              bankSchema.getEntryName(item).c_str(),type); break;
      }
      return 0;
    }
 
    inline int    bank::getByte(int item, int index) const noexcept{
      int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      switch(type){
      case kByte: return (int) getByteAt(offset);
      default: printf("---> error : requested BYTE for [%s] type = %d\n",
              bankSchema.getEntryName(item).c_str(),type); break;
      }
      return 0;
    }
    inline int    bank::getInt(const char *name, int index) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      switch(type){
      case kByte:  return (int) getByteAt(offset);
      case kShort: return (int) getShortAt(offset);
      case kInt:   return getIntAt(offset);
      default: printf("---> error : requested INT for [%s] type = %d\n",name,type); break;
      }
      return 0;
    }
 
    inline std::vector<int>    bank::getInt(const char *name) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      int type = bankSchema.getEntryType(item);
      std::vector<int> row;
 
      int nrows = getRows();
      for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
         switch(type){
             case kByte:  row.push_back((int) getByteAt(offset)); break;
             case kShort: row.push_back((int) getShortAt(offset)); break; 
             case kInt:   row.push_back((int) getIntAt(offset)); break;
             default: printf("---> error : requested INT for [%s] type = %d\n",name,type); break;
         }
      }
      return row;
    }
 
    inline int    bank::getShort(const char *name, int index) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      switch(type){
      case kByte:  return (int) getByteAt(offset);
      case kShort: return (int) getShortAt(offset);
      default: printf("---> error : requested SHORT for [%s] type = %d\n",
              bankSchema.getEntryName(item).c_str(),type); break;
      }
      return 0;
    }
    inline int    bank::getByte(const char *name, int index) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      switch(type){
      case kByte: return (int) getByteAt(offset);
      default: printf("---> error : requested BYTE for [%s] type = %d\n",
              bankSchema.getEntryName(item).c_str(),type); break;
      }
      return 0;
    }
 
    inline float  bank::getFloat(const char *name, int index) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      if(bankSchema.getEntryType(item)==kFloat){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getFloatAt(offset);
      }
      return 0.0;
    }
 
  inline std::vector<float>  bank::getFloat(const char *name) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      std::vector<float> row;
      int nrows = getRows();
      if(bankSchema.getEntryType(item)==kFloat){
        for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
          row.push_back( getFloatAt(offset));
        }
      }
      return row;
    }
    
    inline std::vector<float>  bank::getFloat(int item) const noexcept{
      std::vector<float> row;
      int nrows = getRows();
      if(bankSchema.getEntryType(item)==kFloat){
        for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
          row.push_back( getFloatAt(offset));
        }
      }
      return row;
    }
    inline double  bank::getDouble(const char *name, int index) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      if(bankSchema.getEntryType(item)==kDouble){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getDoubleAt(offset);
      }
      if(bankSchema.getEntryType(item)==kFloat){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return (double) getFloatAt(offset);
      }
      return 0.0;
    }
 
    inline std::vector<double>  bank::getDouble(int item) const noexcept{
      std::vector<double> row;
      int nrows = getRows();      
 
      if(bankSchema.getEntryType(item)==kDouble){
        for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
          row.push_back(getDoubleAt(offset));
        }
      }
      if(bankSchema.getEntryType(item)==kFloat){
        for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
          row.push_back((double) getFloatAt(offset));
        }
      }
      return row;
    }
 
    inline std::vector<double>  bank::getDouble(const char *name) const noexcept{
      std::vector<double> row;
      int nrows = getRows();
      int item = bankSchema.getEntryOrder(name);
 
      if(bankSchema.getEntryType(item)==kDouble){
        for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
          row.push_back(getDoubleAt(offset));
        }
      }
      if(bankSchema.getEntryType(item)==kFloat){
        for(int j = 0; j < nrows; j++){
          int offset = bankSchema.getOffset(item, j, bankRows);
          row.push_back((double) getFloatAt(offset));
        }
      }
      return row;
    }
    
    inline long bank::getLong(const char *name, int index) const noexcept{
      int item = bankSchema.getEntryOrder(name);
      if(bankSchema.getEntryType(item)==kLong){
        int offset = bankSchema.getOffset(item, index, bankRows);
        return getLongAt(offset);
      }
      return 0;
    }
  inline void    bank::putInt(int item, int index, int32_t value){
    //int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      putIntAt(offset,value);
    }
    inline void    bank::putShort(int item, int index, int16_t value){
      //int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      putShortAt(offset,value);
    }
    inline void    bank::putByte(int item, int index, int8_t value){
      //int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      putByteAt(offset,value);
    }
    inline  void    bank::putFloat(int item, int index, float value){
      //int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      //printf("---- put float %f at position = %d\n",value,offset);
      putFloatAt(offset,value);
    }
    inline void    bank::putDouble(int item, int index, double value){
      //int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      putDoubleAt(offset,value);
    }
    inline void    bank::putLong(int item, int index, int64_t value){
      //int type = bankSchema.getEntryType(item);
      int offset = bankSchema.getOffset(item, index, bankRows);
      putLongAt(offset,value);
    }
 
    using banklist=std::vector<bank>;
 
    // @returns the index of the bank in `banklist` `banks` which has the name `bankName`; if there is more
    // than one, only the index of the first such bank will be returned. A runtime exception is thrown
    // if the bank is not found
    // @param banks the `banklist` to search
    // @param bankName the bank name
    banklist::size_type getBanklistIndex(banklist& banks, std::string const& bankName) noexcept(false);
 
}
#endif /* BANK_H */