fixing compiler warning (MuonCablingTools-00-01-04)

MuonSpectrometer/MuonCablings/MuonCablingTools/MuonCablingTools/BaseObject.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LVL1OBJECT_H
+#define LVL1OBJECT_H
+
+
+#define DISP this->lock(); \
+             m_message->init_message();\
+             m_message->message()
+
+#define DISP_DEBUG display_debug(m_message->message()); \
+                   m_message->delete_message(); \
+		   this->unlock();   
+#define DISP_ERROR display_error(m_message->message()); \
+                   m_message->delete_message(); \
+		   this->unlock();
+#define DISP_WARNING display_warning(m_message->message()); \
+                     m_message->delete_message(); \
+		     this->unlock();
+#define DISP_INFO display_info(m_message->message()); \
+                  m_message->delete_message(); \
+		  this->unlock();
+#include <string>
+#include <iostream>
+
+
+#include "MuonCablingTools/OutputDef.h"
+
+
+
+#ifndef LVL1_STANDALONE
+#include "GaudiKernel/MsgStream.h"
+#include "GaudiKernel/IMessageSvc.h"
+#include "GaudiKernel/ISvcLocator.h"
+#include "GaudiKernel/Bootstrap.h"
+#endif
+
+
+
+enum ObjectType {Logic,Data,Hardware,Monitoring};
+
+
+class MessageStream
+{
+    private:
+#if (__GNUC__) && (__GNUC__ > 2)     // put your gcc 3.2 specific code here
+    __osstream* m_display;
+#else                                // put your gcc 2.95 specific code here
+    char* m_buffer_display;
+    __osstream* m_display;
+#endif
+    public:
+    void init_message(void);
+    void delete_message(void);  
+    __osstream& message(void);
+};
+
+inline __osstream&
+MessageStream::message(void)
+{
+    return *m_display;
+}
+
+class BaseObject
+{
+    private:
+    ObjectType  m_tag;
+    std::string m_name;
+
+    protected:
+    MessageStream* m_message;
+
+
+    public:
+    BaseObject (ObjectType,std::string);
+    BaseObject (ObjectType,const char*);
+    BaseObject (const BaseObject&);
+    ~BaseObject();
+
+    BaseObject operator = (const BaseObject&);
+
+    ObjectType  tag(void)  const {return m_tag;}
+    std::string name(void) const {return m_name;}
+
+    void Print(std::ostream&,bool) const {}
+    void display_warning(__osstream&) const;
+    void display_info(__osstream&) const;
+    void display_error(__osstream&) const;
+    void display_debug(__osstream&) const;
+    
+    void lock(void) const;
+    void unlock(void) const;
+
+#ifndef LVL1_STANDALONE
+    //static IMessageSvc* s_message;
+#endif
+};
+
+#endif

MuonSpectrometer/MuonCablings/MuonCablingTools/MuonCablingTools/OutputDef.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef OUTPUTDEF_H
+#define OUTPUTDEF_H
+
+
+// for compatibility between gcc2.95 and gcc3.2
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    #include <sstream>
+    typedef std::ostringstream __osstream;
+    #define COUNT str().size()
+#else
+    // put your gcc 2.95 specific code here
+    #include <strstream>
+    typedef ostrstream __osstream;
+    #define COUNT pcount()
+#endif
+
+
+#endif

MuonSpectrometer/MuonCablings/MuonCablingTools/MuonCablingTools/RPCdecoder.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef RPCDECODER_H
+#define RPCDECODER_H
+
+#include "MuonCablingTools/RPCdef.h"
+
+#include <iostream>
+
+
+// for compatibility between gcc2.95 and gcc3.2
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    #include <sstream>
+    typedef std::ostringstream __osstream;
+#else
+    // put your gcc 2.95 specific code here
+    #include <strstream>
+    typedef ostrstream __osstream;
+#endif
+
+
+class RPCdecoder
+{
+    public:
+    enum value_type {Strip_Type,Logic_Sector,LVL1_Station,RPC_Layer};
+
+    private:
+    static const int value_boundaries[4][2];
+    static const char value_descriptions[4][15];
+
+    private:
+    bool m_fail;
+
+    private:
+    unsigned int m_code;
+
+    int m_strip_type;
+    int m_logic_sector;
+    int m_lvl1_station;
+    int m_rpc_layer;
+    int m_rpc_z_index;
+    int m_strip_number;
+
+    void reset (void);
+    void reset_status(void);
+    void reset_data(void);
+
+    void set_indexes(unsigned int);
+    void set_code(int,int,int,int,int,int);
+    void fault_decoding(int,value_type);
+
+    public:
+    RPCdecoder();
+    RPCdecoder(unsigned int);
+    RPCdecoder(int,int,int,int,int,int);
+    RPCdecoder(ViewType,int,int,int,int,int);
+
+    RPCdecoder(const RPCdecoder& deco);
+    RPCdecoder operator = (const RPCdecoder& deco);
+
+    ~RPCdecoder() {}
+
+    public:
+    RPCdecoder& operator ()(unsigned int);
+    RPCdecoder& operator ()(ViewType,int,int,int,int,int);
+    RPCdecoder& operator ()(int,int,int,int,int,int);
+
+    public:
+    operator bool() {return !m_fail;}
+
+    public:
+    bool OK(int,value_type) const;
+
+    unsigned int code(void) const {return m_code;}
+    int strip_type(void)    const {return m_strip_type;}
+    int logic_sector(void)  const {return m_logic_sector;}
+    int lvl1_station(void)  const {return m_lvl1_station;}
+    int rpc_layer(void)     const {return m_rpc_layer;}
+    int rpc_z_index(void)   const {return m_rpc_z_index;}
+    int strip_number(void)  const {return m_strip_number;}
+    int cabling_code(void)  const 
+        {return m_strip_number + m_rpc_z_index*100 + m_rpc_layer*10000;}
+
+    ViewType view(void) const;
+    HalfType half_barrel(void) const;
+    int side2type(ViewType side) const;
+
+    void Print(std::ostream&,bool) const;
+};
+
+/*                                                
+template <class X> X& operator<<(X& stream,const RPCdecoder& decoder)
+{
+
+// for compatibility between gcc2.95 and gcc3.2
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    __osstream display;
+#else
+    // put your gcc 2.95 specific code here
+    char buffer[10000];
+    for (int i=0;i<10000;++i) buffer[i] = '\0';
+    __osstream display(buffer,10000);
+#endif
+
+    decoder.Print(display,false);
+    stream << display.str();
+    return stream;
+}
+*/
+
+#endif

MuonSpectrometer/MuonCablings/MuonCablingTools/MuonCablingTools/RPCdef.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef RPCDEF_H
+#define RPCDEF_H
+
+enum ViewType {Eta,Phi,NoView};
+enum HalfType {Negative,Positive,NoHalf};
+
+#endif

MuonSpectrometer/MuonCablings/MuonCablingTools/MuonCablingTools/ShowRequest.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef PRINTREQ_H
+#define PRINTREQ_H
+
+#include <iostream>
+
+// for compatibility between gcc2.95 and gcc3.2
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    #include <sstream>
+    typedef std::ostringstream __osstream;
+#else
+    // put your gcc 2.95 specific code here
+    #include <strstream>
+    typedef ostrstream __osstream;
+#endif
+
+
+template <class Type>
+class ShowRequest
+{
+    public:
+    const Type* m_object;
+    bool  m_detail;
+
+    public:
+    ShowRequest(const Type&,bool);
+    ShowRequest(const Type*,bool);
+    ~ShowRequest() {}
+    /*
+    friend ostream& operator<< <Type> (ostream&,const ShowRequest<Type>&);
+#ifndef LVL1_STANDALONE
+    friend MsgStream& operator<< <Type> (MsgStream&,const ShowRequest<Type>&);
+#endif
+    */
+};
+
+template <class Type>
+ShowRequest<Type>::ShowRequest(const Type& obj,bool detail) : 
+    m_object(&obj),m_detail(detail) {}
+
+
+template <class Type>
+ShowRequest<Type>::ShowRequest(const Type* obj,bool detail) : 
+    m_object(obj),m_detail(detail) {}
+
+
+
+template <class Type> std::ostream& operator<<
+    (std::ostream& stream,const ShowRequest<Type>& print)
+{
+
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    __osstream display;
+#else
+    // put your gcc 2.95 specific code here
+    char buffer[50000];
+    for (int i=0;i<50000;++i) buffer[i] = '\0';
+    __osstream display(buffer,50000);
+#endif
+
+    print.m_object->Print(display,print.m_detail);
+    stream << display.str();
+    return stream;
+}
+
+#ifndef LVL1_STANDALONE
+#include "GaudiKernel/MsgStream.h"
+
+template <class Type> MsgStream& operator<<
+    (MsgStream& stream,const ShowRequest<Type>& print)
+{
+
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    __osstream display;
+#else
+    // put your gcc 2.95 specific code here
+    char buffer[50000];
+    for (int i=0;i<50000;++i) buffer[i] = '\0';
+    __osstream display(buffer,50000);
+#endif
+
+    print.m_object->Print(display,print.m_detail);
+    stream << display.str();
+    return stream;
+}
+#endif
+
+
+#endif

MuonSpectrometer/MuonCablings/MuonCablingTools/MuonCablingTools/dbline.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// INTRODUCTION
+//
+// DBline is a generic class which provides an easy interface to access 
+// formatted data from an input stream. The purpose is to facilitate the 
+// development of the reading routine (for an ASCII database) and, at the same
+// time, to increase its robustness against the varoius changes to which the
+// the database undergoes during the development phase. The flexibility needed
+// to deal with each kind of database, was achieved implementing a set of basic
+// functionalities which can be componed in a easy way to build a generic 
+// reading routine.
+//
+// Considering a generic database whose data are input line by line, each line
+// can be decomposed into a set of small blocks having the following pattern:
+//
+//     <Token>  <set of data>
+//
+// where <Token> can be any character sequence (including the space character)
+// and <set of data> can be one ore more data of different nature that have to
+// be read. DBline implements an "extraction" mechanism which allows to select
+// a <Token> and to read the releted data (only if the token is found) just in 
+// one command line. Since the data input is perfomed line by line, such 
+// "extraction" mechanism requires that the token and the data has to be found
+// in the same line of the database. This matches very well the case in which
+// the database is made of a set of control directives given in any order (i.e.
+// a DATACARD file). 
+// In order to allow the reading of more complex structures of data which can
+// be spanned on more than one line, each "extraction" returns a boolean value
+// that can be checked in logical expresssion. Thus, it is possible to activate
+// a particular reading schema if a Token is found or to read with it until  
+// another Token is found. Moreover is also possible to build logical 
+// expression only with "extraction" procedures:
+//
+//
+// OPERATION MODE
+//
+// DBline receives an input line from a generic istream and held it into an 
+// internal buffer to be processed during the extraction of data. The data 
+// requests are send to DBline and are fulfilled only if the PATTERN (i.e. a 
+// Token, or a set of Tokens) specified by the user is found into the internal
+// buffer. At each succesfull "extraction" the corresponding data (i.e. the 
+// <Token> and the <related data>) are deleted from the internal buffer. 
+//
+// The implemented operation mode, in which the user can read and process data 
+// using this class, is made of three sequential step:
+// 
+// 1 - Input request. On each input request only a data line is read (i.e. 
+//     data are read until the carriage return character) and is subsequently
+//     stored into an internal buffer for further analysis. This operation 
+//     cause the deletation of data previously present into the internal 
+//     buffer. If the input stream is a file it will be automatically connected
+//     to the DBline class to allow incremental input line controlled via class
+//     operators. It is also possible to get input until a token is found; in 
+//     this case the token is only checked but not extracted (deleted) from the
+//     internal  buffer.
+// 
+// 2 - Extraction of data. An extraction request is made of a Token request 
+//     plus a data request. When a Token is found it is extraced from the 
+//     internal buffer and the starting position from which the subsequent data
+//     are extraced is updated to the actual Token position inside the line. If
+//     something goes  wrong (no Token found, or line become empty before all 
+//     the requested data are extracted), the extraction stops returning a 
+//     FALSE status, and all the data extracted from the last succesfull Token
+//     request are restored into the internal buffer. It is possible to request
+//     data without specifying a pattern before; in this case the data are
+//     extracted in a sequential way from the position in which the last 
+//     requested Token was found (if no Token has been succesfully found, the
+//     starting position is the beginning of the line). Finally it is also
+//     implemented a mechanism to request more complex pattern, i.e. pattren 
+//     like  <TOKEN> <data> <SUBTOKEN1> <data> <SUBTOKEN2> <data> .....
+//
+// 3 - Check for error. Before a new input request the internal buffer is 
+//     checked and if there are still data inside an error message is output 
+//     showing the data that are going to be deleted. Such data directives
+//     not understood by the reading routine.
+//
+//
+// SYNTAX
+//
+//              ********      INSTANTIATION      ********
+//----------------------------------------------------------------------------+
+// DBline data              normal instantiantion, no file connected.         |
+//----------------------------------------------------------------------------+
+// DBline data(file)        where file is an ifstream object. Instantiate     |
+//                          DBline object and connect a file to it.           |
+//                          04/08/2009 L. Bellagamba -> updated to works in   |  
+//                          the same way with ifstream and generic istream    |
+//----------------------------------------------------------------------------+
+//              ******** DATA INPUT FROM ISTREAM ********
+//----------------------------------------------------------------------------+
+// data << input            where input is a generic istream. If input is a   |
+//   .. or ..               file, it will be automatically connected with the |
+// input >> data            DBline object.                                    |
+//----------------------------------------------------------------------------+
+// data.connect(file)       connect an ifstream to the DBline object.         |
+//----------------------------------------------------------------------------+
+// data++                   input of 1 more line. Works only with a connected |
+//   .. or ..               input file. Return FALSE if the END OF FILE is    |
+// ++data                   reached                                           |
+//                          04/08/2009 L. Bellagamba -> updated to works also |
+//                          with a generic istream                            |
+//----------------------------------------------------------------------------+
+// data + n                 input of n lines. Works only with a connected     |
+//                          input file.Return FALSE if the END OF FILE is     |
+//                          reached                                           |
+//                          04/08/2009 L. Bellagamba -> updated to works also |
+//                          with a generic istream                            |
+//----------------------------------------------------------------------------+
+//              ********      TOKEN REQUEST      ********
+//----------------------------------------------------------------------------+
+// data.token("TOKEN")      seek the position of the word "TOKEN" into the    |
+//    ... or ...            database line stored internal buffer. If "TOKEN"  |
+//   data("TOKEN")          is found it will return a TRUE value.             |
+//----------------------------------------------------------------------------+
+// data.token("TOKEN #",t)  multiple token seek. Substitute the character #   |
+//       ... or ...         into the string "TOKEN #" with the ASCII type of  |
+//   data("TOKEN #",t)      object t and then look for an occurrence of such  |
+//                          token.                                            |
+//----------------------------------------------------------------------------+
+//              ********       DATA REQUEST      ********
+//----------------------------------------------------------------------------+
+// data >> type             use of extractor operator like in an I/O stream.  |
+//                          Supported type are: (normal/unsigned) int/long int|
+//                          float, double, string. Other type can be added,   |
+//                          but are not currently supported.                  |
+//----------------------------------------------------------------------------+
+// data.setf( .... )        use of the ios flags like in an I/O stream and    |
+//                          setf( ) function works in the same way.           |
+//----------------------------------------------------------------------------+
+// data.hex()               set format flags to get data from an hexadec. base|
+//----------------------------------------------------------------------------+
+// data.oct()               set format flags to get data from an octal base   |
+//----------------------------------------------------------------------------+
+// data.dec()               set format flags to get data from a decimal base  |
+//----------------------------------------------------------------------------+
+// data.reset_fmt()         reset the format flags to default value           |
+//----------------------------------------------------------------------------+
+// data >> hex()            same as data.hex() but can be used in I/O sequence|
+//----------------------------------------------------------------------------+
+// data >> oct()            same as data.oct() but can be used in I/O sequence|
+//----------------------------------------------------------------------------+
+// data >> dec()            same as data.dec() but can be used in I/O sequence|
+//----------------------------------------------------------------------------+
+// data >> setflags ( ..)   same as setf( .. ) but can be used in I/O sequence|
+//----------------------------------------------------------------------------+
+// data >> resetflags()     same as data.reset_fmt()                          |
+//----------------------------------------------------------------------------+
+//                                                                            |
+// Lorenzo Bellagamba: 8 March 2011                                           |
+//                                                                            |
+// data >> data.dbhex()     to be used in I/O sequence as hex(), dec() and    |
+// data >> data.dboct()     oct() but avoids creation and subsequent          |
+// data >> data.dbdec()     destruction of objects for each I/O operation.    |
+//                          Such methods return a pointer to DBfmt* objects   |
+//                          created once for ever when the DBline object is   |
+//                          instantiated. To preserve the previous            |
+//                          functionality a further method                    |
+// data.setdbfmtflag(int)   has been introduced. Such method sets a bool      |
+//                          private variable (del_dbfmt) which controls the   |
+//                          deletion of the DBfmt object in the >> operator.  |
+//                          Such bool variable must be false to use these new |
+//                          methods. By default the old functionality is      |
+//                          preserved and del_dbfmt=true:                     |
+//                          setdbfmtflag(0/1) -> del_dbfmt=false/true         |
+//----------------------------------------------------------------------------+
+//              ********    LOGICAL EXPRESSION    ********                    |
+//----------------------------------------------------------------------------+
+// operators ||, &&         combine the results from several extraction       |
+//                          requests. Keep in mind that, in a logic expression|
+//                          it is possible that some terms are not evaluated  |
+//                          (i.e. some of the extraction requests are not     |
+//                          performed); this depends on the result of the     |
+//                          previos terms in the logic sequence.              |
+//----------------------------------------------------------------------------+
+// operators |, &           combine the results from several extraction       |
+//                          requests forcing all the terms present in the     |
+//                          expression to be evaluated.                       |
+//----------------------------------------------------------------------------+
+//
+//
+// EXAMPLES
+//
+// to read a file until the end:
+//
+//    --| ifstream file("name",0);
+//    --| DBline data(file);
+//    --| while (data++)
+//    --| {
+//    --|     ..... process line ......
+//    --| }
+//
+// to read the folowing line:  < LABEL 1: 12.6 43 "this is a string" >
+//   
+//    --| float fl; int in; string str;
+//    --| data("LABEL 1:") >> fl >> in >> str;
+//
+// in the following line:
+//  
+//        < FIRST 12.6  SECOND 12  "this is a string"  THIRD 8 >
+//
+// each token can be read in an indipendent way with:
+//
+//    --| float fl; int i1,i2; string str;
+//    --| data("FIRST") >> fl;  
+//    --| data("SECOND") >> i1 >> str;
+//    --| data("THIRD") >> i2;
+//
+// or as a whole (i.e. researching the entire sequence in a given order):
+//
+//    --| float fl; int i1,i2; string str;
+//    --| data("FIRST") >> fl >> "SECOND" >> i1 >> str >> "THIRD" >> i2;
+//
+// to read until the occurrence of a TOKEN:
+//
+//    --| do
+//    --| {
+//    --|     ..... process line ......
+//    --|     data++;
+//    --| } while (data("TOKEN"));
+//
+// increase line until the occurrence of a TOKEN:
+//
+//    --| data.go_until("TOKEN");
+//
+// to read complex structure like:
+//           
+//      < START: "new sequence of data" {                      >
+//      <   Token 1  <data>                                    >
+//      <   Token 2  <data>                                    >
+//      < }                                                    >
+//
+//    --| if(data("START:") >> str >> "{")
+//    --| {
+//    --|     data("Token 1") >> <data>;
+//    --|     data("Token 2") >> <data>;
+//    --|     data++;
+//    --| } while (data("}"));
+//
+// to read hexadecimel values:
+//
+//        < value   ff >
+//
+//    --| unsigned long int i1;
+//    --| data("value").hex() >> i1;
+//    --| data.reset_fmt();
+//
+//            OR
+//
+//    --| unsigned long int i1;
+//    --| data("value") >> hex() >> i1 >> resetflags();
+
+
+
+
+
+#ifndef DBLINE_H
+#define DBLINE_H
+
+
+#include <ctype.h>
+#include <iostream>
+#include <iomanip> 
+#include <string>
+#include <fstream>
+#include <typeinfo>
+#include <stdint.h>
+
+// for compatibility between gcc2.95 and gcc3.2
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    #include <sstream>
+    typedef std::ostringstream __osstream;
+    typedef std::istringstream __isstream;
+#else
+    // put your gcc 2.95 specific code here
+    #include <strstream>
+    typedef ostrstream __osstream;
+    typedef istrstream __isstream;
+#endif
+
+
+typedef enum result_extraction {not_extracted,extracted} DBstatus;
+
+class DBfmt: virtual public std::ios {
+    public:
+    DBfmt();
+};
+
+class DBline: virtual public std::ios
+{
+ 
+    private:
+
+    typedef enum exist_quote {no_quote,begin_quote,end_quote,error} quote;
+
+    std::ios::fmtflags     m_default;
+    std::ifstream*         m_file;
+    std::istream*          m_stream;
+    std::string            m_data,m_backup,m_store;
+    unsigned long int      m_pos;
+    int                    m_line;
+    bool                   m_fail;
+    bool                   m_empty;
+    DBstatus               m_extraction;
+
+
+    // Private member functions for setting internal status
+    void reset_data(void);
+    void reset_status(void);
+    void reset(void);
+
+    // Private member functions for setting extraction status
+    void GoodExtraction(void);
+    void BadExtraction(void);
+
+    // Private member functions for managing the internal buffer
+    void erase_comment(void); 
+    void GetToken(unsigned long int pos,const std::string &token);
+    void GetLine(std::istream& input);
+
+    // Private member functions for extracting data
+    template <class type> void GetValue(type &value);
+    quote check_quote(std::string &);
+    void GetStr(std::string &);
+
+    // Check if internal buffer is empty
+    bool check_data(void);
+
+    // Private member to manage the I/O format
+    DBfmt* dbfmt_hex;
+    DBfmt* dbfmt_oct;
+    DBfmt* dbfmt_dec;
+    bool del_dbfmt;
+
+    public:
+
+    DBline();
+    DBline(std::ifstream& file);
+    DBline(std::istream& stream);
+    ~DBline() {delete dbfmt_hex; delete dbfmt_oct; delete dbfmt_dec;}
+    
+    // Function to connect input file/stream
+    void connect(std::ifstream& file);
+    void connect(std::istream& stream);
+
+    // Function to get the token
+    DBline& token (const std::string &);
+    template <class type> DBline& token (const std::string &,type t);
+    template <class type> DBline& token (const std::string &,type t, int size);
+    void go_until (const std::string &token);
+
+    // Check if exits data into the internal buffer
+    bool empty (void);
+
+    // Dump the processed directives
+    const char* dump(void);
+
+    // Public functions to set the I/O format
+    DBline& hex(void);
+    DBline& dec(void);
+    DBline& oct(void);
+    DBline& reset_fmt(void);
+    DBfmt* dbhex();
+    DBfmt* dboct();
+    DBfmt* dbdec();
+    void setdbfmtflag(int);
+
+    // Operators for extracting data
+    //DBline& operator>> (unsigned long int &i);
+    DBline& operator>> (unsigned long int *i);
+    //DBline& operator>> (long int &i);
+    DBline& operator>> (long int *i);
+    //DBline& operator>> (unsigned int &i);
+    DBline& operator>> (unsigned int *i);
+    //DBline& operator>> (unsigned short &i);
+    DBline& operator>> (unsigned short *i);
+    DBline& operator>> (int &i);
+    DBline& operator>> (int *i);
+    DBline& operator>> (float &f);
+    DBline& operator>> (float *f);
+    DBline& operator>> (double &f);
+    DBline& operator>> (double *f);
+    DBline& operator>> (std::string &str);
+    DBline& operator>> (std::string *str);
+    DBline& operator>> (char &c);
+    //DBline& operator>> (unsigned char &c);
+    
+    DBline& operator>> (uint8_t &i8);
+    DBline& operator>> (uint16_t &i16);
+    DBline& operator>> (uint32_t &i32);
+    DBline& operator>> (uint64_t &i64);
+
+
+    // Operator for allowing external manipulation of data
+    DBline& operator>> (DBfmt* f);
+
+    // Operator for subtoken searching
+    DBline& operator>> (const std::string &token);
+
+    // Operators for incremental input
+    DBline& operator++();
+    DBline& operator++(int i);
+    DBline& operator+ (int i);
+
+    // Internal status operators
+    operator bool ();
+    bool operator !();
+    operator DBstatus();
+
+    // Operators for extracting tokens
+    DBline& operator()(const std::string &str);
+    DBline& operator()(const std::string&,int);
+    DBline& operator()(const std::string&,int,int);
+
+    // Member function for unsing input from streams
+    DBline& operator << (std::istream& input);
+    DBline& operator << (std::ifstream& file);
+    
+    // Friend functions for using I/O whit streams
+    friend std::ifstream &operator >> (std::ifstream  &file, DBline &db);
+    friend std::istream  &operator >> (std::istream &stream, DBline &db);
+    friend std::ostream  &operator << (std::ostream &stream, DBline &db);
+
+};
+
+
+DBfmt* hex (void);
+DBfmt* oct(void);
+DBfmt* dec(void);
+DBfmt* resetflags(void);
+DBfmt* setflags(std::ios::fmtflags);
+DBfmt* setflags(std::ios::fmtflags,std::ios::fmtflags);
+
+
+#endif

MuonSpectrometer/MuonCablings/MuonCablingTools/README

+This package contains the base classes of common utility for the MuonCabling
+packages. Moreover the BaseObject class is also inerithed by the classes 
+performing the Level-1 muon trigger simulation. Two sets of library are built:
+MuonCablingTools to be used into the ATHENA framework, and CablingTools to be 
+used into a standalone application.
+
+
+Basic components:
+
+BaseObject : is the base class from which most of the other classes are built.
+             It handles data member of geral use (name,object type) plus the
+             interface with the messaging services.
+
+dbline     : utility class for building a modular reading routine. The
+             type of serch pattern is: <Token> <set of data>.
+
+MessageStream : class that handles the characters set used for composing a 
+                message

MuonSpectrometer/MuonCablings/MuonCablingTools/cmt/requirements

+package MuonCablingTools
+
+author Alessandro Di Mattia <alessandro.dimattia@roma1.infn.it>
+
+use AtlasPolicy            AtlasPolicy-*
+
+private 
+#use AthenaKernel  	   AthenaKernel-*          Control
+use GaudiInterface         GaudiInterface-*        External
+
+
+#########################################################
+# ATHENA librariy build                                 #
+#########################################################
+
+public
+macro_append CablingTools_pp_cppflags " -DLVL1_STANDALONE "
+library CablingTools -no_share -suffix=STN *.cxx
+macro_append CablingTools_dependencies " install_includes"
+
+apply_pattern installed_library
+
+library MuonCablingTools *.cxx -s=../src/components *.cxx
+
+apply_pattern declare_runtime
+
+#apply_pattern declare_runtime_extras extras=*.data
+
+

MuonSpectrometer/MuonCablings/MuonCablingTools/src/BaseObject.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "MuonCablingTools/BaseObject.h"
+
+#include <pthread.h>
+
+
+static pthread_mutex_t StopDisplayStream = PTHREAD_MUTEX_INITIALIZER;
+
+using namespace std;
+
+
+void
+MessageStream::init_message()
+{
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    m_display = new __osstream;
+#else
+    // put your gcc 2.95 specific code here
+    const int buffer_length=10000;
+    m_buffer_display = new char[buffer_length];
+    for(int i=0;i<buffer_length;++i) m_buffer_display[i]='\0';
+    m_display = new __osstream(m_buffer_display,buffer_length);
+#endif
+}
+
+void
+MessageStream::delete_message()
+{
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    delete m_display;
+#else
+    // put your gcc 2.95 specific code here
+    delete []m_buffer_display;
+    delete m_display;
+#endif
+}
+
+
+
+BaseObject::BaseObject(ObjectType tag,std::string name) : 
+    m_tag(tag),m_name(name) 
+{
+    m_message = new MessageStream;
+}
+
+BaseObject::BaseObject(ObjectType tag,const char* name) : 
+    m_tag(tag)
+{
+    int i=0;
+    while(name[i]!='\0') ++i;
+    m_name.resize(i);
+    i=0;
+    while(name[i]!='\0')
+    {
+        m_name[i] = name[i];
+	++i;
+    }
+    m_message = new MessageStream;
+}
+
+BaseObject::BaseObject(const BaseObject& obj)
+{
+    m_tag  = obj.tag();
+    m_name = obj.name();
+    m_message = new MessageStream;
+}
+
+BaseObject::~BaseObject()
+{
+    delete m_message;
+}
+
+
+void
+BaseObject::display_error(__osstream& display) const
+{
+#ifdef LVL1_STANDALONE
+    cout << display.str() << endl;
+#else
+    StatusCode sc;    
+    IMessageSvc*  msgSvc;
+    ISvcLocator* svcLoc = Gaudi::svcLocator( );
+    sc = svcLoc->service( "MessageSvc", msgSvc );
+    if(sc.isSuccess()) {
+        MsgStream log(msgSvc, name() );
+        log << MSG::ERROR << display.str() <<endreq; 
+    }
+#endif
+}
+
+void
+BaseObject::display_debug(__osstream& display) const
+{
+#ifdef LVL1_STANDALONE
+    cout << display.str() << endl;
+#else
+    StatusCode sc;
+    IMessageSvc*  msgSvc;
+    ISvcLocator* svcLoc = Gaudi::svcLocator( );
+    sc = svcLoc->service( "MessageSvc", msgSvc );
+    if(sc.isSuccess()) {
+        MsgStream log(msgSvc, name() );
+        log << MSG::DEBUG << display.str() <<endreq; 
+    }
+#endif
+}
+
+void
+BaseObject::display_warning(__osstream& display) const
+{
+#ifdef LVL1_STANDALONE
+    cout << display.str() << endl;
+#else
+    StatusCode sc;    
+    IMessageSvc*  msgSvc;
+    ISvcLocator* svcLoc = Gaudi::svcLocator( );
+    sc = svcLoc->service( "MessageSvc", msgSvc );
+    if(sc.isSuccess()) {
+        MsgStream log(msgSvc, name() );
+        log << MSG::WARNING << display.str() <<endreq; 
+    }
+#endif
+}
+
+void
+BaseObject::display_info(__osstream& display) const
+{
+#ifdef LVL1_STANDALONE
+    cout << display.str() << endl;
+#else
+    StatusCode sc;
+    IMessageSvc*  msgSvc;
+    ISvcLocator* svcLoc = Gaudi::svcLocator( );
+    sc = svcLoc->service( "MessageSvc", msgSvc );
+    if(sc.isSuccess()) {
+        MsgStream log(msgSvc, name() );
+        log << MSG::INFO << display.str() <<endreq; 
+    }
+#endif
+}
+
+void
+BaseObject::lock() const
+{
+    pthread_mutex_lock(&StopDisplayStream);
+}
+
+
+void
+BaseObject::unlock() const
+{
+    pthread_mutex_unlock(&StopDisplayStream);
+}
+
+BaseObject
+BaseObject::operator=(const BaseObject& obj)
+{
+    m_tag  = obj.tag();
+    m_name = obj.name();
+    return*this;
+}

MuonSpectrometer/MuonCablings/MuonCablingTools/src/RPCdecoder.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include <string>
+//#include <strstream>
+#include "MuonCablingTools/RPCdecoder.h"
+
+using namespace std;
+
+///////////////////////////////////////////////////////////////////////////////
+
+const int RPCdecoder::value_boundaries[4][2] = {
+        {  1 ,  2 },  // Min-Max of strip_type value
+        {  0 , 63 },  // Min-Max of logic_sector value
+        {  1 ,  3 },  // Min-Max of station value
+        {  0 ,  1 }   // Min_max of rpc_layer value
+    };
+const char RPCdecoder::value_descriptions[4][15] =
+        {{"strip_type"},{"logic_sector"},{"lvl1_station"},{"rpc_layer"}};
+
+///////////////////////////////////////////////////////////////////////////////
+RPCdecoder::RPCdecoder() {this->reset_status();}
+
+RPCdecoder::RPCdecoder(unsigned int code)
+{
+    this->reset();
+    this->set_indexes(code);
+}
+
+RPCdecoder::RPCdecoder(int strip_type,int logic_sector,int lvl1_station, 
+int rpc_layer,int rpc_z_index, int strip_number)
+{
+    this->reset();
+    this->set_code(strip_type,logic_sector,lvl1_station,rpc_layer,rpc_z_index,
+                   strip_number);
+}
+
+RPCdecoder::RPCdecoder(ViewType side,int logic_sector,int lvl1_station, 
+int rpc_layer,int rpc_z_index, int strip_number)
+{
+    this->reset();
+    int strip_type = this->side2type(side);
+    this->set_code(strip_type,logic_sector,lvl1_station,rpc_layer,rpc_z_index,
+                   strip_number);
+}
+
+RPCdecoder::RPCdecoder(const RPCdecoder& deco)
+{
+    this->reset();
+    this->set_indexes(deco.code());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+RPCdecoder RPCdecoder::operator = (const RPCdecoder& deco)
+{
+    this->reset();
+    this->set_indexes(deco.code());
+    return *this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void
+RPCdecoder::reset()
+{
+    this->reset_status();
+    this->reset_data();
+}
+
+void
+RPCdecoder::reset_data()
+{
+    m_code = 0;
+    m_strip_type = -1;
+    m_logic_sector = -1;
+    m_lvl1_station = -1;
+    m_rpc_layer = -1;
+    m_rpc_z_index = -1;
+    m_strip_number = -1;
+}
+
+void
+RPCdecoder::reset_status()
+{
+    m_fail = false;
+}
+
+void
+RPCdecoder::fault_decoding(int value,value_type type)
+{
+#if (__GNUC__) && (__GNUC__ > 2) 
+    // put your gcc 3.2 specific code here
+    __osstream disp;
+#else
+    // put your gcc 2.95 specific code here
+    char buffer[5000];
+    for (int i=0;i<5000;++i) buffer[i] = '\0';
+    __osstream disp(buffer,5000);
+#endif
+    disp << " RPC decoder error: received " << value_descriptions[type]
+         << " = " << value << "  (min = " << value_boundaries[type][0]
+         << ", max = " << value_boundaries[type][1] << ")"<< endl;
+#ifdef LVL1_STANDALONE
+    cout << disp.str();
+#else
+#endif
+    m_fail = true; 
+}
+
+bool
+RPCdecoder::OK(int value,value_type type) const
+{
+    if(value >= value_boundaries[type][0] &&
+       value <= value_boundaries[type][1]   ) return true; 
+    return false;
+}
+
+void
+RPCdecoder::set_code(int strip_type,int logic_sector,int lvl1_station,
+		     int rpc_layer,int rpc_z_index,int strip_number)
+{
+  if(!OK(strip_type,Strip_Type)) fault_decoding(strip_type,Strip_Type);
+  if(!OK(logic_sector,Logic_Sector)) fault_decoding(logic_sector,Logic_Sector);
+  if(!OK(lvl1_station,LVL1_Station)) fault_decoding(lvl1_station,LVL1_Station);
+  if(!OK(rpc_layer,RPC_Layer)) fault_decoding(rpc_layer,RPC_Layer); 
+
+  if(m_fail) { this->reset_data(); return; }
+
+  m_code = strip_type   * 100000000 +
+           logic_sector * 1000000   +
+           lvl1_station * 100000    +
+           rpc_layer    * 10000     +
+           rpc_z_index  * 100       +
+           strip_number;
+
+  m_strip_type   = strip_type;
+  m_logic_sector = logic_sector;
+  m_lvl1_station = lvl1_station;
+  m_rpc_layer    = rpc_layer;
+  m_rpc_z_index  = rpc_z_index;
+  m_strip_number = strip_number;
+}
+
+void
+RPCdecoder::set_indexes(unsigned int code)
+{    
+
+    m_strip_number = code%100;
+    m_rpc_z_index  = (code/100)%100;
+    m_rpc_layer    = (code/10000)%10;
+    m_lvl1_station = (code/100000)%10;
+    m_logic_sector = (code/1000000)%100;
+    m_strip_type   =  code/100000000;
+
+    if(!OK(m_strip_type,Strip_Type)) fault_decoding(m_strip_type,Strip_Type);
+    if(!OK(m_logic_sector,Logic_Sector)) 
+        fault_decoding(m_logic_sector,Logic_Sector);
+    if(!OK(m_lvl1_station,LVL1_Station)) 
+        fault_decoding(m_lvl1_station,LVL1_Station);
+    if(!OK(m_rpc_layer,RPC_Layer)) fault_decoding(m_rpc_layer,RPC_Layer); 
+
+    if(m_fail) { this->reset_data(); return; }
+
+    m_code = code;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+RPCdecoder&
+RPCdecoder::operator()(unsigned int code)
+{
+    this->reset();
+    this->set_indexes(code);
+    return *this;
+}
+
+RPCdecoder&
+RPCdecoder::operator()(int strip_type,int logic_sector,int lvl1_station, 
+int rpc_layer,int rpc_z_index, int strip_number)
+{
+    this->reset();
+    this->set_code(strip_type,logic_sector,lvl1_station,rpc_layer,rpc_z_index,
+                   strip_number);
+    return *this;
+}
+
+RPCdecoder&
+RPCdecoder::operator()(ViewType side,int logic_sector,int lvl1_station, 
+int rpc_layer,int rpc_z_index, int strip_number)
+{
+    this->reset();
+    int strip_type = side2type(side);
+    this->set_code(strip_type,logic_sector,lvl1_station,rpc_layer,rpc_z_index,
+                      strip_number);
+    return *this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+ViewType RPCdecoder::view(void) const 
+{
+    if(m_strip_type == -1) return NoView;
+    return (m_strip_type==1)? Phi : Eta;
+}
+    
+HalfType RPCdecoder::half_barrel(void) const 
+{
+    if(m_logic_sector == -1) return NoHalf;
+    return (m_logic_sector<32)? Negative : Positive;
+}
+
+int RPCdecoder::side2type(ViewType side) const 
+{
+    if(side == NoView) return -1;
+    return (side == Eta)? 2 : 1;
+}
+
+void RPCdecoder::Print(ostream& stream,bool detail) const
+{
+    unsigned int div = 247;
+    std::string half=(half_barrel()==Negative)? "Negative" :"Positive";
+
+    stream << "RPC strip hash code " << code() << ":" << endl;
+    if(detail)
+    {
+        stream << "   half barrel            = " << half << endl;
+        stream << "   type (1=Phi/2=Eta)     = " << strip_type() << endl;
+        stream << "   logic sector (0" << (char)div << "63)    = " 
+               << logic_sector() << endl;
+        stream << "   level-1 station (1" << (char)div << "n)  = "
+               << lvl1_station() << endl;
+        stream << "   RPC layer (0/1)        = " << rpc_layer() << endl;
+        stream << "   RPC z index (0" << (char)div << "n)      = "
+	       << rpc_z_index() << endl;
+        stream << "   RPC strip number (0" << (char)div << "n) = "
+	       << strip_number() << endl;
+        stream << "   strip cabling code     = " << cabling_code() << endl;
+    }
+}
+

MuonSpectrometer/MuonCablings/MuonCablingTools/src/dbline.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "MuonCablingTools/dbline.h"
+
+using namespace std;
+
+///////////////////////////////////////////////////////////////////////////////
+//////////// PRIVATE MEMBER FUNCTIONS FOR SETTING INTERNAL STATUS /////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void DBline::reset_data(void)    {m_data=""; m_pos=0; m_backup="";}
+void DBline::reset_status(void)  {GoodExtraction();m_empty=false;}
+void DBline::reset(void)         {reset_data(); reset_status();}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//////////// PRIVATE MEMBER FUNCTIONS FOR SETTING EXTRACTION STATUS ///////////
+///////////////////////////////////////////////////////////////////////////////
+ 
+void DBline::GoodExtraction(void){m_extraction = extracted;}
+void DBline::BadExtraction(void){m_extraction = not_extracted;m_data=m_backup;}
+
+
+///////////////////////////////////////////////////////////////////////////////
+////////// PRIVATE MEMBER FUNCTIONS FOR MANAGING THE INTERNAL BUFFER //////////
+///////////////////////////////////////////////////////////////////////////////
+
+void
+DBline::erase_comment()
+{
+    unsigned long int pos = m_data.find("#");
+    if(pos != string::npos) m_data.erase(pos);
+}
+
+void
+DBline::GetToken( unsigned long int pos, const string &token)
+{
+    GoodExtraction();
+    m_data.erase(pos,token.length());
+    m_pos = pos;
+}
+
+void
+DBline::GetLine(istream& input)
+{
+    if(!check_data())
+    {
+        cerr << "line " << setw(4) << m_line << " -|" << m_data.c_str();
+        cerr << "  .. not understood!" << endl;
+    }
+    reset();
+    if(input.eof()) {m_fail = true; return;}
+    m_line++;
+    char ch;
+    while(input.get(ch) && ch !='\n') m_data += ch;
+    //std::string tmp = m_store;
+    // m_store = m_store + m_data;// + '\n';
+    m_store += m_data;
+    erase_comment();
+    check_data();
+    if(input.eof()) m_fail = true;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////// PRIVATE MEMBER FUNCTIONS FOR EXTRACTING DATA ////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+template <class type> void
+DBline::GetValue(type &value)
+{
+    if (!m_extraction||m_fail) return;
+    unsigned long int start = m_data.find_first_not_of(" ",m_pos);
+    if(start == string::npos) {BadExtraction();return;}
+    unsigned long int stop = m_data.find_first_of(" ",start+1) - 1;
+
+    __isstream tmp(m_data.substr(start,stop).c_str());
+
+    tmp.flags(flags());
+    tmp >> value;
+
+    unsigned long int del = (stop - start) + (start - m_pos) + 1;
+    m_data.erase(m_pos,del);
+    check_data();
+}
+
+void 
+DBline::GetStr(string &str)
+{
+    GetValue(str);
+    quote pos = check_quote(str);
+    if(!pos) {return;}
+    if(pos == begin_quote)
+    {
+	unsigned long int pos = m_data.find('"',m_pos);
+        if(pos == string::npos) {str=""; BadExtraction(); return;}
+        str += m_data.substr(m_pos,pos);
+        m_data.erase(m_pos,(pos-m_pos)+1);
+    }
+    else {str=""; BadExtraction();}
+}
+
+DBline::quote
+DBline::check_quote(string &str)
+{
+    std::string::size_type pos = str.find('"');
+    if(pos == string::npos) return no_quote;
+    else if(pos == 0) {str.erase(0,1);return begin_quote;}
+    else if(pos == str.length()-1) {str.erase(pos,1);return end_quote;}
+    return error;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/////////////////////// CHECK IF INTERNAL BUFFER IS EMPTY /////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool
+DBline::check_data(void)
+{
+    m_empty = true;
+    int character;
+    const char * ch = m_data.c_str();
+    while ((character = *ch++)) if (!isspace(character)) m_empty = false;
+    return m_empty;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////// FUNCTION TO CONNECT INPUT FILE-STREAM ///////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void
+DBline::connect(ifstream& file)
+{
+    if((&file) != m_file)
+    {
+        m_store = "";
+        m_line  = 0;
+        m_fail  = 0;
+        m_stream= 0;
+	m_file  = &file;
+    }
+}
+
+void
+DBline::connect(istream& stream)
+{
+    if((&stream) != m_stream)
+    {
+        m_store = "";
+        m_line  = 0;
+        m_fail  = 0;
+        m_file  = 0;
+	m_stream  = &stream;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/////////////////////////// FUNCTION TO GET THE TOKEN /////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline&
+DBline::token(const string &token)
+{
+    if(m_extraction) m_backup = m_data;
+    if(check_data()) {BadExtraction();return *this;}
+    unsigned long int pos = m_data.find(token);
+
+    if (pos != string::npos) 
+    {
+        unsigned long int finalpos = pos + token.length();
+        char prev = (pos)? m_data[pos-1] : ' ';
+        char foll = (finalpos < m_data.length())? m_data[finalpos] : ' ';
+        if(prev == ' ' && foll == ' ') GetToken(pos,token);
+        else BadExtraction();
+    }
+    else BadExtraction();
+    return *this;
+}
+
+template <class type> DBline&
+DBline::token(const string &str, type t)
+{
+    string new_token = str;
+    unsigned long int pos = new_token.find('#');
+    if (pos != string::npos)
+    {
+      __osstream tmp;
+#if (__GNUC__) && (__GNUC__ > 2) 
+      // put your gcc 3.2 specific code here
+      tmp << t ;
+      string rep = tmp.str();
+#else
+      // put your gcc 2.95 specific code here
+      tmp << t << ends;
+      string rep(tmp.str());
+#endif
+
+      new_token.replace(pos,rep.length(),rep);
+      token(new_token);
+    } else token(new_token);
+
+    return *this;    
+}
+
+template <class type> DBline&
+DBline::token(const string &str, type t, int /*size*/)
+{
+    //size = 0;
+    string new_token = str;
+    unsigned long int pos = new_token.find('#');
+    if (pos != string::npos)
+    {
+      __osstream tmp;
+#if (__GNUC__) && (__GNUC__ > 2) 
+      // put your gcc 3.2 specific code here
+      tmp << setw(2) << setfill('0') << t ;
+      string rep = tmp.str();
+#else
+      // put your gcc 2.95 specific code here
+      tmp << t << ends;
+      string rep(tmp.str());
+#endif
+
+      new_token.replace(pos,rep.length(),rep);
+      token(new_token);
+    } else token(new_token);
+
+    return *this;    
+}    
+
+void 
+DBline::go_until (const string &token)
+{
+    if(m_file) do GetLine(*m_file);while(m_data.find(token) == string::npos);
+    if(m_stream) do GetLine(*m_stream);while(m_data.find(token) == string::npos);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////// CHECKS IF DATA EXIST INTO THE INTERNAL BUFFER ///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool DBline::empty (void) {return m_empty;}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////// DUMP THE PROCESSED DIRECTIVES ///////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const char* DBline::dump(void) {return m_store.c_str();}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//////////////////////// FUNCTIONS TO SET THE I/O FORMAT //////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline& DBline::hex(void){setf(ios::hex,ios::basefield);return*this;}
+DBline& DBline::dec(void){setf(ios::dec,ios::basefield);return*this;}
+DBline& DBline::oct(void){setf(ios::dec,ios::basefield);return*this;}
+DBline& DBline::reset_fmt(void) {flags(m_default);return*this;}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////// OPERATORS FOR EXTRACTING DATA ///////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+//DBline& DBline::operator>> (unsigned long int &i) {GetValue(i);  return*this;}
+DBline& DBline::operator>> (unsigned long int *i) {GetValue(*i); return*this;}
+//DBline& DBline::operator>> (long int &i)          {GetValue(i);  return*this;}
+DBline& DBline::operator>> (long int *i)          {GetValue(*i); return*this;}
+//DBline& DBline::operator>> (unsigned int &i)      {GetValue(i);  return*this;}
+DBline& DBline::operator>> (unsigned int *i)      {GetValue(*i); return*this;}
+//DBline& DBline::operator>> (unsigned short &i)    {GetValue(i);  return*this;}
+DBline& DBline::operator>> (unsigned short *i)    {GetValue(*i); return*this;}
+DBline& DBline::operator>> (int &i)               {GetValue(i);  return*this;}
+DBline& DBline::operator>> (int *i)               {GetValue(*i); return*this;}
+DBline& DBline::operator>> (float &f)             {GetValue(f);  return*this;}
+DBline& DBline::operator>> (float *f)             {GetValue(*f); return*this;}
+DBline& DBline::operator>> (double &f)            {GetValue(f);  return*this;}
+DBline& DBline::operator>> (double *f)            {GetValue(*f); return*this;}
+DBline& DBline::operator>> (string &str)          {GetStr(str);  return*this;}
+DBline& DBline::operator>> (string *str)          {GetStr(*str); return*this;}
+DBline& DBline::operator>> (char &c)              {GetValue(c);  return*this;}
+//DBline& DBline::operator>> (unsigned char &c)     {GetValue(c);  return*this;}
+
+DBline& DBline::operator>> (uint8_t &i8)          {GetValue(i8); return*this;}
+DBline& DBline::operator>> (uint16_t &i16)        {GetValue(i16);return*this;}
+DBline& DBline::operator>> (uint32_t &i32)        {GetValue(i32);return*this;}
+DBline& DBline::operator>> (uint64_t &i64)        {GetValue(i64);return*this;}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////// OPERATOR FOR ALLOWING EXTERNAL MANIPULATION OF DATA /////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline& DBline::operator>> (DBfmt* f) {
+  flags(f->flags());
+  if(del_dbfmt)delete f;
+  return*this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//////////////////////// OPERATOR FOR SUBTOKEN SEARCHING //////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline&
+DBline::operator >>(const string &token)
+{
+    if (!m_extraction || check_data() || m_fail) return *this;
+    unsigned long int pos = m_data.find(token,m_pos);
+    if ( pos != string::npos) GetToken(pos,token);
+    else BadExtraction();
+    return *this;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////// OPERATORS FOR INCREMENTAL INPUT /////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline& 
+DBline::operator++()      
+{
+    if(m_file) GetLine(*m_file);
+    if(m_stream) GetLine(*m_stream);
+    return *this;
+}
+
+DBline& 
+DBline::operator++(int i) 
+{
+    for(int j=-1;j<i;j++) {
+      if(m_file) GetLine(*m_file);
+      if(m_stream) GetLine(*m_stream);
+    }
+    return *this;
+}
+
+DBline& 
+DBline::operator+ (int i) 
+{
+    for(int j=0;j<i;j++) {
+      if(m_file) GetLine(*m_file);
+      if(m_stream) GetLine(*m_stream);
+    }
+    return *this;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//////////////////////////// INTERNAL STATUS OPERATOR /////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline::operator bool ()   {return !(m_fail|!static_cast<bool>(m_extraction));}
+bool DBline::operator !()  {return m_fail|!static_cast<bool>(m_extraction);}
+DBline::operator DBstatus(){return m_extraction;}
+
+
+///////////////////////////////////////////////////////////////////////////////
+//////////////////////// OPERATORS FOR EXTRACTING TOKENS //////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+DBline& DBline::operator()(const string &str) {token(str);return*this;}
+    
+DBline& 
+DBline::operator()(const string& str, int n) {token(str,n);return*this;}
+    
+DBline&
+DBline::operator()(const string& str, int n, int s) {token(str,n,s);return*this;}
+
+///////////////////////////////////////////////////////////////////////////////
+
+DBline::DBline(): 
+  m_file(0),m_stream(0),m_data(""),m_backup(""),m_store(""),
+  m_pos(0), m_line(0), 
+  m_fail(false),m_empty(false),m_extraction(extracted)
+{
+  this->setf  (std::ios::unitbuf |
+               std::ios::dec     );
+  this->unsetf(std::ios::skipws    |
+               std::ios::left      |
+	       std::ios::right     |
+	       std::ios::internal  |
+	       std::ios::oct       |
+	       std::ios::hex       |
+	       std::ios::showbase  |
+	       std::ios::showpoint |
+	       std::ios::uppercase |
+	       std::ios::scientific|
+	       std::ios::fixed     |
+	       std::ios::showpos   |
+	       std::ios::boolalpha  );
+  m_default = flags();
+  dbfmt_hex = new DBfmt();
+  dbfmt_hex->setf(std::ios::hex,std::ios::basefield);
+  dbfmt_oct = new DBfmt();
+  dbfmt_oct->setf(std::ios::oct,std::ios::basefield);
+  dbfmt_dec = new DBfmt();
+  dbfmt_dec->setf(std::ios::dec,std::ios::basefield);
+  del_dbfmt = true;
+}
+
+DBline::DBline(ifstream& file): 
+  m_file(&file),m_stream(0),m_data(""),m_backup(""),m_store(""),
+  m_pos(0), m_line(0), 
+  m_fail(false),m_empty(false),m_extraction(extracted)
+{
+  this->setf  (std::ios::unitbuf |
+               std::ios::dec     );
+  this->unsetf(std::ios::skipws    |
+               std::ios::left      |
+	       std::ios::right     |
+	       std::ios::internal  |
+	       std::ios::oct       |
+	       std::ios::hex       |
+	       std::ios::showbase  |
+	       std::ios::showpoint |
+	       std::ios::uppercase |
+	       std::ios::scientific|
+	       std::ios::fixed     |
+	       std::ios::showpos   |
+	       std::ios::boolalpha  );
+	       
+  m_default = flags();
+  dbfmt_hex = new DBfmt();
+  dbfmt_hex->setf(std::ios::hex,std::ios::basefield);
+  dbfmt_oct = new DBfmt();
+  dbfmt_oct->setf(std::ios::oct,std::ios::basefield);
+  dbfmt_dec = new DBfmt();
+  dbfmt_dec->setf(std::ios::dec,std::ios::basefield);
+  del_dbfmt = true;
+}
+
+DBline::DBline(istream& stream): 
+  m_file(0),m_stream(&stream),m_data(""),m_backup(""),m_store(""),
+  m_pos(0), m_line(0), 
+  m_fail(false),m_empty(false),m_extraction(extracted)
+{
+  this->setf  (std::ios::unitbuf |
+               std::ios::dec     );
+  this->unsetf(std::ios::skipws    |
+               std::ios::left      |
+	       std::ios::right     |
+	       std::ios::internal  |
+	       std::ios::oct       |
+	       std::ios::hex       |
+	       std::ios::showbase  |
+	       std::ios::showpoint |
+	       std::ios::uppercase |
+	       std::ios::scientific|
+	       std::ios::fixed     |
+	       std::ios::showpos   |
+	       std::ios::boolalpha  );
+	       
+  m_default = flags();
+  dbfmt_hex = new DBfmt();
+  dbfmt_hex->setf(std::ios::hex,std::ios::basefield);
+  dbfmt_oct = new DBfmt();
+  dbfmt_oct->setf(std::ios::oct,std::ios::basefield);
+  dbfmt_dec = new DBfmt();
+  dbfmt_dec->setf(std::ios::dec,std::ios::basefield);
+  del_dbfmt = true;
+}
+
+DBline&
+DBline::operator <<(ifstream &file)
+{
+    connect(file);
+    GetLine(file);
+    return *this;
+}
+
+DBline&
+DBline::operator <<(istream &input)
+{
+    connect(input);
+    GetLine(input);
+    return *this;
+}
+
+// LB 29/03/2011 new methods to avoid 
+// continues creation and destruction of DBfmt objects
+
+DBfmt* DBline::dbhex()
+{
+  return dbfmt_hex;
+}
+
+DBfmt* DBline::dboct()
+{
+  return dbfmt_oct;
+}
+
+DBfmt* DBline::dbdec()
+{
+  return dbfmt_dec;
+}
+
+void DBline::setdbfmtflag(int delfl)
+{
+  if(delfl==0)del_dbfmt = false;
+  else del_dbfmt = true;
+  return; 
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ifstream &operator>>(ifstream &file, DBline &db)
+{ 
+    db.connect(file);
+    db.GetLine(file);
+    return file;
+}
+
+istream &operator>>(istream &stream, DBline &db)
+{ 
+  //    db.m_file = 0;
+  //    db.m_fail = 0;
+    db.connect(stream);
+    db.GetLine(stream);
+    return stream;
+}
+
+ostream &operator<<(ostream &stream, DBline &db) 
+{
+    stream << db.m_data.c_str();
+    return stream;
+}
+
+DBstatus operator |(DBstatus s1, DBstatus s2)
+{
+    if(s1 || s2) return extracted;
+    return not_extracted;
+}
+
+DBstatus operator &(DBstatus s1, DBstatus s2)
+{
+    if(s1 && s2) return extracted;
+    return not_extracted;
+}
+
+
+DBfmt::DBfmt()
+{  
+  this->setf  (std::ios::unitbuf |
+               std::ios::dec     );
+  this->unsetf(std::ios::skipws    |
+               std::ios::left      |
+	       std::ios::right     |
+	       std::ios::internal  |
+	       std::ios::oct       |
+	       std::ios::hex       |
+	       std::ios::showbase  |
+	       std::ios::showpoint |
+	       std::ios::uppercase |
+	       std::ios::scientific|
+	       std::ios::fixed     |
+	       std::ios::showpos   |
+	       std::ios::boolalpha  );
+}
+
+
+DBfmt* hex(void)
+{
+    DBfmt* fmt = new (DBfmt);
+    fmt->setf(ios::hex,ios::basefield);
+    return fmt;
+}
+
+DBfmt* oct(void)
+{
+    DBfmt* fmt = new (DBfmt);
+    fmt->setf(ios::oct,ios::basefield);
+    return fmt;
+}
+DBfmt* dec(void)
+{
+    DBfmt* fmt = new (DBfmt);
+    fmt->setf(ios::dec,ios::basefield);
+    return fmt;
+}
+
+
+DBfmt* resetflags(void)
+{
+  DBfmt* fmt = new (DBfmt);
+  return fmt; 
+}
+
+DBfmt* setflags(ios::fmtflags f)
+{
+  DBfmt* fmt = new (DBfmt);
+  fmt->setf(f);
+  return fmt;
+}
+
+DBfmt* setflags(ios::fmtflags f1,ios::fmtflags f2)
+{
+  DBfmt* fmt = new (DBfmt);
+  fmt->setf(f1,f2);
+  return fmt;
+}