ImageFileImpl.cpp

Go to the documentation of this file.

/*
 * Original work Copyright 2009 - 2010 Kevin Ackley (kackley@gwi.net)
 * Modified work Copyright 2018 - 2020 Andy Maloney <asmaloney@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#include "ImageFileImpl.h"
#include "CheckedFile.h"
#include "E57Version.h"
#include "E57XmlParser.h"
#include "StructureNodeImpl.h"
 
namespace e57
{
   struct NameSpace
   {
      ustring prefix;
      ustring uri;
 
      NameSpace( const ustring &prefix0, const ustring &uri0 ) : prefix( prefix0 ), uri( uri0 )
      {
      }
   };
 
   struct E57FileHeader
   {
      char fileSignature[8] = {};
      uint32_t majorVersion = 0;
      uint32_t minorVersion = 0;
      uint64_t filePhysicalLength = 0;
      uint64_t xmlPhysicalOffset = 0;
      uint64_t xmlLogicalLength = 0;
      uint64_t pageSize = 0;
      //  char        e57LibraryVersion[8];   //Not in V1.0 Standard
 
#ifdef E57_DEBUG
      void dump( int indent = 0, std::ostream &os = std::cout ) const;
#endif
   };
 
#ifdef E57_DEBUG
   void E57FileHeader::dump( int indent, std::ostream &os ) const
   {
      os << space( indent ) << "fileSignature:      ";
      os.write( fileSignature, sizeof( fileSignature ) );
      os << std::endl;
      os << space( indent ) << "majorVersion:       " << majorVersion << std::endl;
      os << space( indent ) << "minorVersion:       " << minorVersion << std::endl;
      os << space( indent ) << "filePhysicalLength: " << filePhysicalLength << std::endl;
      os << space( indent ) << "xmlPhysicalOffset:  " << xmlPhysicalOffset << std::endl;
      os << space( indent ) << "xmlLogicalLength:   " << xmlLogicalLength << std::endl;
      os << space( indent ) << "pageSize:           " << pageSize << std::endl;
   }
#endif
 
   ImageFileImpl::ImageFileImpl( ReadChecksumPolicy policy ) :
      isWriter_( false ), writerCount_( 0 ), readerCount_( 0 ),
      checksumPolicy( std::max( 0, std::min( policy, 100 ) ) ), file_( nullptr ), xmlLogicalOffset_( 0 ),
      xmlLogicalLength_( 0 ), unusedLogicalStart_( 0 )
   {
   }
 
   void ImageFileImpl::construct2( const ustring &fileName, const ustring &mode )
   {
 
#ifdef E57_MAX_VERBOSE
      std::cout << "ImageFileImpl() called, fileName=" << fileName << " mode=" << mode << std::endl;
#endif
      unusedLogicalStart_ = sizeof( E57FileHeader );
      fileName_ = fileName;
 
      ImageFileImplSharedPtr imf = shared_from_this();
 
      // Accept "w" or "r" modes
      isWriter_ = ( mode == "w" );
 
      if ( !isWriter_ && ( mode != "r" ) )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_API_ARGUMENT, "mode=" + ustring( mode ) );
      }
 
      file_ = nullptr;
 
      // Writing
      if ( isWriter_ )
      {
         try
         {
            file_ = new CheckedFile( fileName_, CheckedFile::WriteCreate, checksumPolicy );
 
            std::shared_ptr<StructureNodeImpl> root( new StructureNodeImpl( imf ) );
            root_ = root;
            root_->setAttachedRecursive();
 
            unusedLogicalStart_ = sizeof( E57FileHeader );
            xmlLogicalOffset_ = 0;
            xmlLogicalLength_ = 0;
         }
         catch ( ... )
         {
            delete file_;
            file_ = nullptr;
 
            throw;
         }
 
         return;
      }
 
      // Reading
      try
      {
         file_ = new CheckedFile( fileName_, CheckedFile::ReadOnly, checksumPolicy );
 
         std::shared_ptr<StructureNodeImpl> root( new StructureNodeImpl( imf ) );
         root_ = root;
         root_->setAttachedRecursive();
 
         E57FileHeader header;
         readFileHeader( file_, header );
 
         xmlLogicalOffset_ = file_->physicalToLogical( header.xmlPhysicalOffset );
         xmlLogicalLength_ = header.xmlLogicalLength;
      }
      catch ( ... )
      {
         delete file_;
         file_ = nullptr;
 
         throw;
      }
 
      try
      {
         E57XmlParser parser( imf );
 
         parser.init();
 
         E57XmlFileInputSource xmlSection( file_, xmlLogicalOffset_, xmlLogicalLength_ );
 
         unusedLogicalStart_ = sizeof( E57FileHeader );
 
         parser.parse( xmlSection );
      }
      catch ( ... )
      {
         delete file_;
         file_ = nullptr;
 
         throw;
      }
   }
 
   void ImageFileImpl::construct2( const char *input, const uint64_t size )
   {
 
#ifdef E57_MAX_VERBOSE
      std::cout << "ImageFileImpl() called, fileName=<StreamBuffer> mode=r" << std::endl;
#endif
      unusedLogicalStart_ = sizeof( E57FileHeader );
      fileName_ = "<StreamBuffer>";
 
      ImageFileImplSharedPtr imf = shared_from_this();
 
      isWriter_ = false;
      file_ = nullptr;
 
      try
      {
         file_ = new CheckedFile( input, size, checksumPolicy );
 
         std::shared_ptr<StructureNodeImpl> root( new StructureNodeImpl( imf ) );
         root_ = root;
         root_->setAttachedRecursive();
 
         E57FileHeader header;
         readFileHeader( file_, header );
 
         xmlLogicalOffset_ = file_->physicalToLogical( header.xmlPhysicalOffset );
         xmlLogicalLength_ = header.xmlLogicalLength;
      }
      catch ( ... )
      {
         delete file_;
         file_ = nullptr;
 
         throw;
      }
 
      try
      {
         E57XmlParser parser( imf );
 
         parser.init();
 
         E57XmlFileInputSource xmlSection( file_, xmlLogicalOffset_, xmlLogicalLength_ );
 
         unusedLogicalStart_ = sizeof( E57FileHeader );
 
         parser.parse( xmlSection );
      }
      catch ( ... )
      {
         delete file_;
         file_ = nullptr;
 
         throw;
      }
   }
 
   void ImageFileImpl::incrWriterCount()
   {
      writerCount_++;
   }
 
   void ImageFileImpl::decrWriterCount()
   {
      writerCount_--;
#ifdef E57_MAX_DEBUG
      if ( writerCount_ < 0 )
      {
         throw E57_EXCEPTION2( E57_ERROR_INTERNAL, "fileName=" + fileName_ +
                                                      " writerCount=" + toString( writerCount_ ) +
                                                      " readerCount=" + toString( readerCount_ ) );
      }
#endif
   }
 
   void ImageFileImpl::incrReaderCount()
   {
      readerCount_++;
   }
 
   void ImageFileImpl::decrReaderCount()
   {
      readerCount_--;
#ifdef E57_MAX_DEBUG
      if ( readerCount_ < 0 )
      {
         throw E57_EXCEPTION2( E57_ERROR_INTERNAL, "fileName=" + fileName_ +
                                                      " writerCount=" + toString( writerCount_ ) +
                                                      " readerCount=" + toString( readerCount_ ) );
      }
#endif
   }
 
   std::shared_ptr<StructureNodeImpl> ImageFileImpl::root()
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
      return root_;
   }
 
   void ImageFileImpl::close()
   {
      if ( file_ == nullptr )
      {
         return;
      }
 
      if ( isWriter_ )
      {
         xmlLogicalOffset_ = unusedLogicalStart_;
         file_->seek( xmlLogicalOffset_, CheckedFile::Logical );
         uint64_t xmlPhysicalOffset = file_->position( CheckedFile::Physical );
         *file_ << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
#ifdef E57_OXYGEN_SUPPORT //???                                                             \
                          //???        *file_ << "<?oxygen                                  \
                          // RNGSchema=\"file:/C:/kevin/astm/DataFormat/xif/las_v0_05.rnc\" \
                          // type=\"compact\"?>\n";
#endif
 
         //??? need to add name space attributes to e57Root
         root_->writeXml( shared_from_this(), *file_, 0, "e57Root" );
 
         while ( ( file_->position( CheckedFile::Logical ) - xmlLogicalOffset_ ) % 4 != 0 )
         {
            *file_ << " ";
         }
 
         xmlLogicalLength_ = file_->position( CheckedFile::Logical ) - xmlLogicalOffset_;
 
         E57FileHeader header;
 
         memcpy( &header.fileSignature, "ASTM-E57", 8 );
 
         header.majorVersion = E57_FORMAT_MAJOR;
         header.minorVersion = E57_FORMAT_MINOR;
         header.filePhysicalLength = file_->length( CheckedFile::Physical );
         header.xmlPhysicalOffset = xmlPhysicalOffset;
         header.xmlLogicalLength = xmlLogicalLength_;
         header.pageSize = CheckedFile::physicalPageSize;
#ifdef E57_MAX_VERBOSE
         header.dump();
#endif
 
         file_->seek( 0 );
         file_->write( reinterpret_cast<char *>( &header ), sizeof( header ) );
 
         file_->close();
      }
 
      delete file_;
      file_ = nullptr;
   }
 
   void ImageFileImpl::cancel()
   {
      if ( file_ == nullptr )
      {
         return;
      }
 
      if ( isWriter_ )
      {
         file_->unlink();
      }
      else
      {
         file_->close();
      }
 
      delete file_;
      file_ = nullptr;
   }
 
   bool ImageFileImpl::isOpen() const
   {
      return ( file_ != nullptr );
   }
 
   bool ImageFileImpl::isWriter() const
   {
      return isWriter_;
   }
 
   int ImageFileImpl::writerCount() const
   {
      return writerCount_;
   }
 
   int ImageFileImpl::readerCount() const
   {
      return readerCount_;
   }
 
   ImageFileImpl::~ImageFileImpl()
   {
      try
      {
         cancel();
      }
      catch ( ... )
      {
      };
 
      delete file_;
      file_ = nullptr;
   }
 
   uint64_t ImageFileImpl::allocateSpace( uint64_t byteCount, bool doExtendNow )
   {
      uint64_t oldLogicalStart = unusedLogicalStart_;
 
      unusedLogicalStart_ += byteCount;
 
      if ( doExtendNow )
      {
         file_->extend( unusedLogicalStart_ );
      }
 
      return oldLogicalStart;
   }
 
   CheckedFile *ImageFileImpl::file() const
   {
      return file_;
   }
 
   ustring ImageFileImpl::fileName() const
   {
      // don't checkImageFileOpen, since need to get fileName to report not open
      return fileName_;
   }
 
   void ImageFileImpl::extensionsAdd( const ustring &prefix, const ustring &uri )
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
      //??? check if prefix characters ok, check if uri has a double quote char
      //(others?)
 
      ustring dummy;
 
      if ( extensionsLookupPrefix( prefix, dummy ) )
      {
         throw E57_EXCEPTION2( E57_ERROR_DUPLICATE_NAMESPACE_PREFIX, "prefix=" + prefix + " uri=" + uri );
      }
 
      if ( extensionsLookupUri( uri, dummy ) )
      {
         throw E57_EXCEPTION2( E57_ERROR_DUPLICATE_NAMESPACE_URI, "prefix=" + prefix + " uri=" + uri );
         ;
      }
 
      nameSpaces_.emplace_back( prefix, uri );
   }
 
   bool ImageFileImpl::extensionsLookupPrefix( const ustring &prefix, ustring &uri ) const
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
      std::vector<NameSpace>::const_iterator it;
 
      for ( it = nameSpaces_.begin(); it < nameSpaces_.end(); ++it )
      {
         if ( it->prefix == prefix )
         {
            uri = it->uri;
            return true;
         }
      }
 
      return false;
   }
 
   bool ImageFileImpl::extensionsLookupUri( const ustring &uri, ustring &prefix ) const
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
      std::vector<NameSpace>::const_iterator it;
 
      for ( it = nameSpaces_.begin(); it < nameSpaces_.end(); ++it )
      {
         if ( it->uri == uri )
         {
            prefix = it->prefix;
            return true;
         }
      }
 
      return false;
   }
 
   size_t ImageFileImpl::extensionsCount() const
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
      return nameSpaces_.size();
   }
 
   ustring ImageFileImpl::extensionsPrefix( const size_t index ) const
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
      return nameSpaces_[index].prefix; //??? throw e57 exception here if out of bounds?
   }
 
   ustring ImageFileImpl::extensionsUri( const size_t index ) const
   {
      checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
      return nameSpaces_[index].uri; //??? throw e57 exception here if out of bounds?
   }
 
   bool ImageFileImpl::isElementNameExtended( const ustring &elementName )
   {
 
      size_t found = elementName.find_first_of( '/' );
 
      if ( found != std::string::npos )
      {
         return false;
      }
 
      ustring prefix, localPart;
 
      try
      {
         elementNameParse( elementName, prefix, localPart );
      }
      catch ( E57Exception & /*ex*/ )
      {
         return false;
      }
 
      return ( prefix.length() > 0 );
   }
 
   bool ImageFileImpl::isElementNameLegal( const ustring &elementName, bool allowNumber )
   {
#ifdef E57_MAX_VERBOSE
      // cout << "isElementNameLegal elementName=""" << elementName << """" <<
      // std::endl;
#endif
      try
      {
         checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
         checkElementNameLegal( elementName, allowNumber );
      }
      catch ( E57Exception & /*ex*/ )
      {
         return false;
      }
 
      return true;
   }
 
   bool ImageFileImpl::isPathNameLegal( const ustring &pathName )
   {
#ifdef E57_MAX_VERBOSE
      // cout << "isPathNameLegal elementName=""" << pathName << """" << std::endl;
#endif
      try
      {
         checkImageFileOpen( __FILE__, __LINE__, static_cast<const char *>( __FUNCTION__ ) );
 
         pathNameCheckWellFormed( pathName );
      }
      catch ( E57Exception & /*ex*/ )
      {
         return false;
      }
 
      return true;
   }
 
   void ImageFileImpl::checkElementNameLegal( const ustring &elementName, bool allowNumber )
   {
 
      ustring prefix;
      ustring localPart;
 
      elementNameParse( elementName, prefix, localPart, allowNumber );
 
      ustring uri;
 
      if ( prefix.length() > 0 && !extensionsLookupPrefix( prefix, uri ) )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "elementName=" + elementName + " prefix=" + prefix );
      }
   }
 
   void ImageFileImpl::elementNameParse( const ustring &elementName, ustring &prefix, ustring &localPart,
                                         bool allowNumber )
   {
 
      //??? check if elementName is good UTF-8?
 
      size_t len = elementName.length();
 
      if ( len == 0 )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "elementName=" + elementName );
      }
 
      unsigned char c = elementName[0];
 
      if ( allowNumber && '0' <= c && c <= '9' )
      {
         for ( size_t i = 1; i < len; i++ )
         {
            c = elementName[i];
 
            if ( !( '0' <= c && c <= '9' ) )
            {
               throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "elementName=" + elementName );
            }
         }
 
         return;
      }
 
      if ( c < 128 && !( ( 'a' <= c && c <= 'z' ) || ( 'A' <= c && c <= 'Z' ) || c == '_' ) )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "elementName=" + elementName );
      }
 
      for ( size_t i = 1; i < len; i++ )
      {
         c = elementName[i];
 
         if ( c < 128 && !( ( 'a' <= c && c <= 'z' ) || ( 'A' <= c && c <= 'Z' ) || c == '_' || c == ':' ||
                            ( '0' <= c && c <= '9' ) || c == '-' || c == '.' ) )
         {
            throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "elementName=" + elementName );
         }
      }
 
      size_t found = elementName.find_first_of( ':' );
 
      if ( found != std::string::npos )
      {
         if ( elementName.find_first_of( ':', found + 1 ) != std::string::npos )
         {
            throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "elementName=" + elementName );
         }
 
         prefix = elementName.substr( 0, found );
         localPart = elementName.substr( found + 1 );
 
         if ( prefix.length() == 0 || localPart.length() == 0 )
         {
            throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME,
                                  "elementName=" + elementName + " prefix=" + prefix + " localPart=" + localPart );
         }
      }
      else
      {
         prefix = "";
         localPart = elementName;
      }
   }
 
   void ImageFileImpl::pathNameCheckWellFormed( const ustring &pathName )
   {
 
      bool isRelative = false;
      StringList fields;
 
      pathNameParse( pathName, isRelative, fields );
   }
 
   void ImageFileImpl::pathNameParse( const ustring &pathName, bool &isRelative, StringList &fields )
   {
#ifdef E57_MAX_VERBOSE
      std::cout << "pathNameParse pathname="
                   ""
                << pathName
                << ""
                   ""
                << std::endl;
#endif
 
      fields.clear();
 
      size_t start = 0;
 
      if ( pathName[start] == '/' )
      {
         isRelative = false;
         start = 1;
      }
      else
      {
         isRelative = true;
      }
 
      while ( start < pathName.size() )
      {
         size_t slash = pathName.find_first_of( '/', start );
 
         ustring elementName = pathName.substr( start, slash - start );
 
         if ( !isElementNameLegal( elementName ) )
         {
            throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "pathName=" + pathName + " elementName=" + elementName );
         }
 
         fields.push_back( elementName );
 
         if ( slash == std::string::npos )
         {
            break;
         }
 
         if ( slash == pathName.size() - 1 )
         {
            fields.emplace_back( "" );
            break;
         }
 
         start = slash + 1;
      }
 
      if ( isRelative && fields.empty() )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_PATH_NAME, "pathName=" + pathName );
      }
 
#ifdef E57_MAX_VERBOSE
      std::cout << "pathNameParse returning: isRelative=" << isRelative << " fields.size()=" << fields.size()
                << " fields=";
      for ( size_t i = 0; i < fields.size(); i++ )
      {
         std::cout << fields[i] << ",";
      }
      std::cout << std::endl;
#endif
   }
 
   ustring ImageFileImpl::pathNameUnparse( bool isRelative, const std::vector<ustring> &fields )
   {
      ustring path;
 
      if ( !isRelative )
      {
         path.push_back( '/' );
      }
 
      for ( unsigned i = 0; i < fields.size(); ++i )
      {
         path.append( fields.at( i ) );
 
         if ( i < fields.size() - 1 )
         {
            path.push_back( '/' );
         }
      }
 
      return path;
   }
 
   void ImageFileImpl::readFileHeader( CheckedFile *file, E57FileHeader &header )
   {
      static_assert( sizeof( E57FileHeader ) == 48, "Unexpected size of E57FileHeader" );
 
      file->read( reinterpret_cast<char *>( &header ), sizeof( header ) );
 
#ifdef E57_MAX_VERBOSE
      header.dump();
#endif
 
      if ( strncmp( header.fileSignature, "ASTM-E57", 8 ) != 0 )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_FILE_SIGNATURE, "fileName=" + file->fileName() );
      }
 
      if ( header.majorVersion > E57_FORMAT_MAJOR )
      {
         throw E57_EXCEPTION2( E57_ERROR_UNKNOWN_FILE_VERSION,
                               "fileName=" + file->fileName() +
                                  " header.majorVersion=" + toString( header.majorVersion ) +
                                  " header.minorVersion=" + toString( header.minorVersion ) );
      }
 
      if ( header.majorVersion == E57_FORMAT_MAJOR && header.minorVersion > E57_FORMAT_MINOR )
      {
         throw E57_EXCEPTION2( E57_ERROR_UNKNOWN_FILE_VERSION,
                               "fileName=" + file->fileName() +
                                  " header.majorVersion=" + toString( header.majorVersion ) +
                                  " header.minorVersion=" + toString( header.minorVersion ) );
      }
 
      if ( header.filePhysicalLength != file->length( CheckedFile::Physical ) )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_FILE_LENGTH,
                               "fileName=" + file->fileName() +
                                  " header.filePhysicalLength=" + toString( header.filePhysicalLength ) +
                                  " file->length=" + toString( file->length( CheckedFile::Physical ) ) );
      }
 
      if ( header.majorVersion != 0 && header.pageSize != CheckedFile::physicalPageSize )
      {
         throw E57_EXCEPTION2( E57_ERROR_BAD_FILE_LENGTH, "fileName=" + file->fileName() );
      }
   }
 
   void ImageFileImpl::checkImageFileOpen( const char *srcFileName, int srcLineNumber,
                                           const char *srcFunctionName ) const
   {
      if ( !isOpen() )
      {
         throw E57Exception( E57_ERROR_IMAGEFILE_NOT_OPEN, "fileName=" + fileName(), srcFileName, srcLineNumber,
                             srcFunctionName );
      }
   }
 
   void ImageFileImpl::dump( int indent, std::ostream &os ) const
   {
      os << space( indent ) << "fileName:    " << fileName_ << std::endl;
      os << space( indent ) << "writerCount: " << writerCount_ << std::endl;
      os << space( indent ) << "readerCount: " << readerCount_ << std::endl;
      os << space( indent ) << "isWriter:    " << isWriter_ << std::endl;
      for ( size_t i = 0; i < extensionsCount(); i++ )
      {
         os << space( indent ) << "nameSpace[" << i << "]: prefix=" << extensionsPrefix( i )
            << " uri=" << extensionsUri( i ) << std::endl;
      }
      os << space( indent ) << "root:      " << std::endl;
      root_->dump( indent + 2, os );
   }
 
   unsigned ImageFileImpl::bitsNeeded( int64_t minimum, int64_t maximum )
   {
 
      uint64_t stateCountMinus1 = maximum - minimum;
 
      unsigned log2 = 0;
 
      if ( stateCountMinus1 & 0xFFFFFFFF00000000LL )
      {
         stateCountMinus1 >>= 32;
         log2 += 32;
      }
 
      if ( stateCountMinus1 & 0xFFFF0000LL )
      {
         stateCountMinus1 >>= 16;
         log2 += 16;
      }
 
      if ( stateCountMinus1 & 0xFF00LL )
      {
         stateCountMinus1 >>= 8;
         log2 += 8;
      }
 
      if ( stateCountMinus1 & 0xF0LL )
      {
         stateCountMinus1 >>= 4;
         log2 += 4;
      }
 
      if ( stateCountMinus1 & 0xCLL )
      {
         stateCountMinus1 >>= 2;
         log2 += 2;
      }
 
      if ( stateCountMinus1 & 0x2LL )
      {
         stateCountMinus1 >>= 1;
         log2 += 1;
      }
 
      if ( stateCountMinus1 & 1LL )
      {
         log2++;
      }
 
      return log2;
   }
}