Base.hpp

Go to the documentation of this file.

//
// BEGIN_SOFTWARE_AND_SERVICES_COPYRIGHT
//
// Copyright (C) 2010-2012 Software and Services LLC, All Rights Reserved.
//
// NOTICE:
//
// THIS SOURCE CODE BELONGS TO Software and Services LLC.
// THIS CODE IS PROPERTY OF THE COPYRIGHT HOLDER AND IS NOT TO
// BE DIVULGED OR USED BY PARTIES WHO HAVE NOT RECEIVED WRITTEN
// AUTHORIZATION FROM THE OWNER.
//
// THIS SOFTWARE AND MANUAL ARE BOTH PROTECTED BY UNITED STATES
// COPYRIGHT LAW (TITLE 17 UNITED STATES CODE). UNAUTHORIZED REPRODUCTION
// AND/OR SALE MAY RESULT IN IMPRISONMENT OF UP TO ONE YEAR AND FINES
// OF UP TO $100,000 (17 USC 506). COPYRIGHT INFRINGERS MAY ALSO
// BE SUBJECT TO CIVIL LIABILITY.
//
// THIS NOTICE AND THE ABOVE COPYRIGHT NOTICE MUST REMAIN IN ALL
// COPIES AND ANY DERIVED WORK.
//
// ALL OF THIS CODE IS ORIGINAL WORK BY THE COPYRIGHT HOLDER.
//
// THIS  DOCUMENT  AND  THE  INFORMATION  CONTAINED  HEREIN  IS
// PROVIDED  ON  AN "AS IS" BASIS AND Software and Services LLC.
// DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,  INCLUDING  BUT
// NOT  LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
// HEREIN  WILL  NOT  INFRINGE  ANY  RIGHTS  OR   ANY   IMPLIED
// WARRANTIES  OF  MERCHANTABILITY  OR FITNESS FOR A PARTICULAR
// PURPOSE.
//
// END_SOFTWARE_AND_SERVICES_COPYRIGHT
//

#ifndef SOFTWARE_AND_SERVICES_LIBRARY_COMMON_BASE_HPP_
#define SOFTWARE_AND_SERVICES_LIBRARY_COMMON_BASE_HPP_

#ifdef WIN32
#pragma warning (disable : 4251)
#endif


#include <sys/types.h>

#ifdef BUILDING_SAS_COMMON_LIBRARY
#include "osver.h"
#include "File.hpp"
#include "VBase.hpp"
#include "instance.hpp"
#else
#include <SaS/Common/osver.h>
#include <SaS/Common/File.hpp>
#include <SaS/Common/VBase.hpp>
#include <SaS/Common/instance.hpp>
#endif

#ifdef MINGW
#include <mingw.hpp>
#endif

#ifndef EXPORT_COMMON
#ifdef BUILDING_SAS_COMMON_LIBRARY
#define EXPORT_COMMON EXPORT_OUT
#else
#define EXPORT_COMMON EXPORT_IN
#endif
#endif

#ifdef WIN32
#define htonll(u64) _byteswap_uint64(u64)
#define ntohll(u64) _byteswap_uint64(u64)
#undef HAVE_HTONLL
#else

#ifdef Linux
#include <stdint.h>
#undef HAVE_HTONLL
#endif // Linux
uint64_t    htonll(uint64_t host64);
uint64_t    ntohll(uint64_t host64);

#endif // WIN32

namespace SoftwareAndServices
{
    namespace Library
    {
        namespace Common
        {

            class EXPORT_COMMON Base
                : public File
            {

            public:


#ifdef FILE_USE_STD

                Base(std::fstream * fs, const char * aFileName);
#endif

                Base(const int fd, const char * aFileName);


                explicit Base(const char * buffer);

                explicit Base(const wchar_t * buffer);

                Base(File * file = nullptr);

                virtual ~Base();

                bool                open(const char * file, int RWmode);

                bool                close();

                void                        operator delete(void * data);

                enum open_flags {

                    O_CREAT_t   =   O_CREAT,

                    O_RDONLY_t  =   O_RDONLY,

                    O_WRONLY_t  =   O_WRONLY

                    //
                };

                enum endian_t {
                    BigEndian_t         = 4321,     // SPARC
                    LittleEndian_t      = 1234,     // INTEL
                    NetworkByteOrder_t  = BigEndian_t,
                    UnknownEndian_t = 0
                };

                void        DoIoInNetworkByteOrder(bool NetOrder);

                bool        WeAreNetworkByteOrder();

                bool        writeEndian(endian_t Value);

                bool        readEndian(endian_t * Value);

                bool        writeBool(bool Value);

                bool        readBool(bool * Value);

                bool        writeChar(char Value);

                bool        readChar(char * Value);

                bool        writeUChar(unsigned char Value);

                bool        readUChar(unsigned char * Value);

                bool        writeShort(short Value);

                bool        readShort(short * Value);

                bool        writeUShort(unsigned short Value);

                bool        readUShort(unsigned short * Value);

                bool        writeInt(int Value);

                bool        readInt(int * Value);

                bool        writeUInt(unsigned int Value);

                bool        readUInt(unsigned int * Value);

                bool        writeLong(long Value);

                bool        readLong(long * Value);

                bool        writeULong(unsigned long Value);

                bool        readULong(unsigned long * Value);

                bool        readLongLong(long long * Value);

                bool        writeLongLong(long long Value);

                 bool       readULongLong(unsigned long long * Value);

                bool        writeULongLong(unsigned long long Value);

                bool        readFloat(float * Value);

                bool        writeFloat(float Value);

                bool        readDouble(double * Value);

                bool        writeDouble(double Value);

                bool        writeString(const char * Value);

                bool        readString(char ** Value);

                bool        writeToken(const Token_t token);

                bool        readToken(Token_t * token);

                private:

                    bool            _DoIoInNetworkByteOrder;

                    endian_t        _OurByteOrder;

                    endian_t        _GetOurByteOrder();

                    File        *   _File;

                    bool            _WeOpenedFile;
            };
        }
    }
}
#endif  /*SOFTWARE_AND_SERVICES_LIBRARY_COMMON_BASE_HPP_*/