def acquire_lock(self, verbose=VERBOSE, raiseError=RAISE_ERROR):
        """
        Try to acquire the lock.

        :Parameters:
            #. verbose (bool): Whether to be verbose about errors when encountered
            #. raiseError (bool): Whether to raise error exception when encountered

        :Returns:
            #. result (boolean): Whether the lock is succesfully acquired.
            #. code (integer, Exception): Integer code indicating the reason how the
               lock was successfully set or unsuccessfully acquired. When setting the
               lock generates an error, this will be caught and returned in a message
               Exception code.

               *  0: Lock is successfully set for normal reasons, In this case result
                  is True.
               *  1: Lock was already set, no need to set it again. In this case result
                  is True.
               *  2: Old and forgotten lock is found and removed. New lock is
                  successfully set, In this case result is True.
               *  3: Lock was not successfully set before timeout. In this case result
                  is False.
               *  Exception: Lock was not successfully set because of an unexpected error.
                  The error is caught and returned in this Exception. In this case
                  result is False.
        """
        #### ON WINDOWS MUST LOOK INTO THAT IN ORDER TO GET RID OF os.rename
        #### http://code.activestate.com/recipes/577794-win32-named-mutex-class-for-system-wide-mutex/
        # set acquire flag
        code         = 0
        acquired     = False
        t0 = t1      = time.time()
        LP           = self.__lockPass+'\n'
        bytesLP      = LP.encode()
        _lockingText = LP+'%.6f'+('\n%s'%self.__pid)
        _timeout     = self.__timeout
        # set general while loop with timeout condition
        while (t1-t0)<=_timeout:
            # try to set acquired to True by reading an empty lock file
            try:
                while not acquired and (t1-t0)<=_timeout:
                    if os.path.isfile(self.__lockPath):
                        try:
                            with open(self.__lockPath, 'rb') as fd:
                                lock = fd.readlines()
                        except:
                            # for the few time when lockPath got deleted or not available for reading
                            pass
                        else:
                            # lock file is empty or wrong
                            if len(lock) != 3:
                                code     = 0
                                acquired = True
                                break
                            if lock[0] == bytesLP:
                                code     = 1
                                acquired = True
                                break
                            if t1-float(lock[1]) > self.__deadLock: # check dead lock
                                acquired = True
                                code     = 2
                                break
                            if not pid_exists(int(lock[2])): # check for dead process which means lock is dead
                                acquired = True
                                code     = 2
                                break
                        # wait a bit
                        if self.__wait:
                            time.sleep(self.__wait)
                        t1 = time.time()
                    else:
                        acquired = True
                        break
            except Exception as err:
                code     = Exception( "Failed to check the lock (%s)"%(str(err),) )
                acquired = False
                if verbose: print(str(code))
                if raiseError: raise code
            # impossible to acquire because of an error or timeout.
            if not acquired:
                break
            # try to write lock
            try:
                tic = time.time()
                tmpFile = self.__lockPath
                # this is how to avoid multiple file writing os lock
                # must be tried on nt (windows) and tested for solution
                # os.rename on nt will crash if destination exists.
                if os.name=='posix':
                    tmpFile = '%s_%s'%(self.__lockPath,self.__uniqueID)
                with open(tmpFile, 'wb') as fd:
                    fd.write( str(_lockingText%t1).encode() )
                    fd.flush()
                    os.fsync(fd.fileno())
                if os.name=='posix':
                    os.rename(tmpFile,self.__lockPath)
                toc = time.time()
                if toc-tic >1:
                    print("PID '%s' writing '%s' is delayed by os for %s seconds. Lock timeout adjusted. MUST FIND A WAY TO FIX THAT"%(self.__pid,self.__lockPath,str(toc-tic)))
                    _timeout += toc-tic
            except Exception as err:
                code     = Exception("Failed to write the lock (%s)"%(str(err),) )
                acquired = False
                if verbose: print(str(code))
                if raiseError: raise code
                break
            # sleep for double tic-toc or 0.1 ms which ever one is bigger
            s = max([(toc-tic), 0.0001])
            time.sleep(s)
            # check if lock is still acquired by the same lock pass
            try:
                with open(self.__lockPath, 'rb') as fd:
                    lock = fd.readlines()
            except:
                lock = []
            if len(lock) >= 1:
                if lock[0] == bytesLP:
                    acquired = True
                    break
                else:
                    acquired = False
                    t1  = time.time()
                    continue
            else:
                acquired = False
                t1 = time.time()
                continue
        # return whether it is acquired or not
        if not acquired and not code:
            code = 3
        return acquired, code