libtabula

/***********************************************************************
 beemutex.cpp - Implements the BeecryptMutex class.  The name comes
	from the fact that we lifted this essentially intact from the
	Beecrypt library, which is also LGPL.  See beecrypt.h for the list
	of changes we made on integrating it into libtabula.

 Copyright © 2004 Beeyond Software Holding BV and © 2007 by
 Educational Technology Resources, Inc.  Others may also hold
 copyrights on code in this file.  See the CREDITS.md file in the
 top directory of the distribution for details.

 This file is part of libtabula.

 libtabula is free software; you can redistribute it and/or modify it

#	if defined(LIBTABULA_PLATFORM_WINDOWS)
		static bc_mutex_t impl_val(void* p)
				{ return *static_cast<bc_mutex_t*>(p); }
#	endif
#endif


BeecryptMutex::BeecryptMutex() throw (MutexFailed)
#if defined(ACTUALLY_DOES_SOMETHING)
	: pmutex_(new bc_mutex_t)
#endif
{
#if defined(LIBTABULA_PLATFORM_WINDOWS)
	*impl_ptr(pmutex_) = CreateMutex((LPSECURITY_ATTRIBUTES) 0, FALSE,
			(LPCTSTR) 0);

	delete impl_ptr(pmutex_);
#endif
}


void
BeecryptMutex::lock() throw (MutexFailed)
{
#if defined(LIBTABULA_PLATFORM_WINDOWS)
	if (WaitForSingleObject(impl_val(pmutex_), INFINITE) == WAIT_OBJECT_0)
		return;
	throw MutexFailed("WaitForSingleObject failed");
#else
#	if HAVE_SYNCH_H || HAVE_PTHREAD

			throw MutexFailed(strerror(rc));
#	endif
#endif
}


bool
BeecryptMutex::trylock() throw (MutexFailed)
{
#if defined(ACTUALLY_DOES_SOMETHING)
#	if defined(LIBTABULA_PLATFORM_WINDOWS)
		switch (WaitForSingleObject(impl_val(pmutex_), 0)) {
			case WAIT_TIMEOUT:
				return false;
			case WAIT_OBJECT_0:

#else
	return true;		// no-op build, so always succeed
#endif
}


void
BeecryptMutex::unlock() throw (MutexFailed)
{
#if defined(LIBTABULA_PLATFORM_WINDOWS)
	if (!ReleaseMutex(impl_val(pmutex_)))
		throw MutexFailed("ReleaseMutex failed");
#else
#	if HAVE_SYNCH_H || HAVE_PTHREAD
		register int rc;

///   a .cpp file so we don't have to make the header depend on config.h
///   on autoconf-using systems
/// - made private mutex member a void* so we don't have to define the
///   full type in the .h file, due to previous item
/// - added more Doxygen comments, and changed some existing comments

/***********************************************************************
 Copyright © 2004 Beeyond Software Holding BV and © 2007-2008
 by Educational Technology Resources, Inc.  Others may also hold
 copyrights on code in this file.  See the CREDITS.md file in the
 top directory of the distribution for details.

 This file is part of libtabula.

 libtabula is free software; you can redistribute it and/or modify it

class LIBTABULA_EXPORT BeecryptMutex
{
public:
	/// \brief Create the mutex object
	///
	/// Throws a MutexFailed exception if we can't acquire the lock for
	/// some reason.  The exception contains a message saying why.
	BeecryptMutex() throw (MutexFailed);

	/// \brief Destroy the mutex
	///
	/// Failures are quietly ignored.
	~BeecryptMutex();

	/// \brief Acquire the mutex, blocking if it can't be acquired
	/// immediately.
	void lock() throw (MutexFailed);

	/// \brief Acquire the mutex immediately and return true, or return
	/// false if it would have to block to acquire the mutex.
	bool trylock() throw (MutexFailed);

	/// \brief Release the mutex
	void unlock() throw (MutexFailed);

private:
	void* pmutex_;
};


/// \brief Wrapper around BeecryptMutex to add scope-bound locking

/// \file common.h
/// \brief This file includes top-level definitions for use both
/// internal to the library, and outside it.  Contrast libtabula.h
///
/// This file mostly takes care of platform differences.

/***********************************************************************
 Copyright
   © 1998 by Kevin Atkinson
   © 1999-2001 by MySQL AB
   © 2004-2009, 2015 by Educational Technology Resources, Inc.
   © 2009, 2014 by Warren Young
   
 Others may also hold copyrights on code in this file.  See the
 CREDITS.md file in the top directory of the distribution for details.

 This file is part of libtabula.

	// Make DLL stuff a no-op on this platform.
	#define LIBTABULA_EXPORT

	// Assume POSIX path separator
	#define LIBTABULA_PATH_SEPARATOR '/'
#endif

#if defined(LIBTABULA_MYSQL_HEADERS_BURIED)
#	include <mysql/mysql_version.h>
#else
#	include <mysql_version.h>



#endif

namespace libtabula {

/// \brief Alias for 'true', to make code requesting exceptions more
/// readable.
const bool use_exceptions = true;

/// \file exceptions.h
/// \brief Declares the libtabula-specific exception classes.
///
/// When exceptions are enabled for a given libtabula::OptionalExceptions
/// derivative, any of these exceptions can be thrown on error.

/***********************************************************************
 Copyright © 1998 by Kevin Atkinson, © 1999-2001 by MySQL AB, and
 © 2004-2010 by Educational Technology Resources, Inc.  Others may
 also hold copyrights on code in this file.  See the CREDITS.md file
 in the top directory of the distribution for details.

 This file is part of libtabula.

 libtabula is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published

/// \brief Base class for all libtabula custom exceptions

class LIBTABULA_EXPORT Exception : public std::exception
{
public:
	/// \brief Create exception object as copy of another
	Exception(const Exception& e) throw() :
	std::exception(e),
	what_(e.what_)
	{
	}

	/// \brief Assign another exception object's contents to this one
	Exception& operator=(const Exception& rhs) throw()

/***********************************************************************
 stadapter.cpp - Implements the SQLTypeAdapter class.

 Copyright © 1998 by Kevin Atkinson, © 1999-2001 by MySQL AB, and
 © 2004-2009 by Educational Technology Resources, Inc.  Others may
 also hold copyrights on code in this file.  See the CREDITS.md file
 in the top directory of the distribution for details.

 This file is part of libtabula.

 libtabula is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published

{
	buffer_ = new SQLBuffer(null_str, typeid(void), true);
	is_processed_ = false;
	return *this;
}

char
SQLTypeAdapter::at(size_type i) const throw(std::out_of_range)
{
	if (buffer_) {
		if (i <= length()) {
			return *(buffer_->data() + i);
		}
		else {
			throw BadIndex("Not enough chars in SQLTypeAdapter", int(i),

/// \file stadapter.h
/// \brief Declares the SQLTypeAdapter class

/***********************************************************************
 Copyright © 1998 by Kevin Atkinson, © 1999-2001 by MySQL AB, and
 © 2004-2009 by Educational Technology Resources, Inc.  Others may
 also hold copyrights on code in this file.  See the CREDITS.md file
 in the top directory of the distribution for details.

 This file is part of libtabula.

 libtabula is free software; you can redistribute it and/or modify it
 under the terms of the GNU Lesser General Public License as published

	/// \brief Returns the character at a given position within the
	/// string buffer.
	///
	/// \throw libtabula::BadIndex if the internal buffer is not
	/// initialized (default ctor called, and no subsequent assignment)
	/// or if there are not at least i + 1 characters in the buffer.
	///
	/// WARNING: The throw-spec is incorrect, but it can't be changed
	/// until v4, where we can break the ABI.  Throw-specs shouldn't be
	/// relied on anyway.
	char at(size_type i) const throw(std::out_of_range);

	/// \brief Compare the internal buffer to the given string
	///
	/// Works just like string::compare(const std::string&).
	int compare(const SQLTypeAdapter& other) const;

	/// \brief Compare the internal buffer to the given string