]> git.stg.codes - stg.git/commitdiff
Этот заголовочный файл относится к библиотеке ibpp, удаляем
authorMaxim Mamontov <faust@user-desktop.(none)>
Mon, 8 Nov 2010 14:44:02 +0000 (16:44 +0200)
committerMaxim Mamontov <faust@user-desktop.(none)>
Mon, 8 Nov 2010 14:44:02 +0000 (16:44 +0200)
include/ibpp.h [deleted file]

diff --git a/include/ibpp.h b/include/ibpp.h
deleted file mode 100644 (file)
index 7795c7d..0000000
+++ /dev/null
@@ -1,929 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-//     File    : $Id: ibpp.h,v 1.3 2007/10/28 11:17:44 nobunaga Exp $\r
-//     Subject : IBPP public header file. This is _the_ only file you include in\r
-//                       your application files when developing with IBPP.\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-//     (C) Copyright 2000-2006 T.I.P. Group S.A. and the IBPP Team (www.ibpp.org)\r
-//\r
-//     The contents of this file are subject to the IBPP License (the "License");\r
-//     you may not use this file except in compliance with the License.  You may\r
-//     obtain a copy of the License at http://www.ibpp.org or in the 'license.txt'\r
-//     file which must have been distributed along with this file.\r
-//\r
-//     This software, distributed under the License, is distributed on an "AS IS"\r
-//     basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the\r
-//     License for the specific language governing rights and limitations\r
-//     under the License.\r
-//\r
-//     Contributor(s):\r
-//\r
-//             Olivier Mascia, main coding\r
-//             Matt Hortman, initial linux port\r
-//             Mark Jordan, design contributions\r
-//             Maxim Abrashkin, enhancement patches\r
-//             Torsten Martinsen, enhancement patches\r
-//             Michael Hieke, darwin (OS X) port, enhancement patches\r
-//             Val Samko, enhancement patches and debugging\r
-//             Mike Nordell, invaluable C++ advices\r
-//             Claudio Valderrama, help with not-so-well documented IB/FB features\r
-//             Many others, excellent suggestions, bug finding, and support\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-//\r
-//     COMMENTS\r
-//     Tabulations should be set every four characters when editing this file.\r
-//\r
-//     When compiling a project using IBPP, the following defines should be made\r
-//     on the command-line (or in makefiles) according to the OS platform and\r
-//     compiler used.\r
-//\r
-//     Select the platform:    IBPP_WINDOWS | IBPP_LINUX | IBPP_DARWIN\r
-//\r
-///////////////////////////////////////////////////////////////////////////////\r
-\r
-#ifndef __IBPP_H__\r
-#define __IBPP_H__\r
-\r
-#if !defined(IBPP_WINDOWS) && !defined(IBPP_LINUX) && !defined(IBPP_DARWIN)\r
-#error Please define IBPP_WINDOWS/IBPP_LINUX/IBPP_DARWIN before compiling !\r
-#endif\r
-\r
-#if !defined(__BCPLUSPLUS__) && !defined(__GNUC__) && !defined(_MSC_VER) && !defined(__DMC__)
-#error Your compiler is not recognized.\r
-#endif\r
-\r
-#if defined(IBPP_LINUX) || defined(IBPP_DARWIN)\r
-#define IBPP_UNIX      // IBPP_UNIX stands as a common denominator to *NIX flavours\r
-#endif\r
-\r
-// IBPP is written for 32 bits systems or higher.\r
-// The standard type 'int' is assumed to be at least 32 bits.\r
-// And the standard type 'short' is assumed to be exactly 16 bits.\r
-// Everywhere possible, where the exact size of an integer does not matter,\r
-// the standard type 'int' is used. And where an exact integer size is required\r
-// the standard exact precision types definitions of C 99 standard are used.\r
-\r
-#if defined(_MSC_VER) || defined(__DMC__) || defined(__BCPLUSPLUS__)\r
-// C99 §7.18.1.1 Exact-width integer types (only those used by IBPP)\r
-#if defined(_MSC_VER) && (_MSC_VER < 1300)     // MSVC 6 should be < 1300\r
-       typedef short int16_t;\r
-       typedef int int32_t;\r
-       typedef unsigned int uint32_t;\r
-#else\r
-       typedef __int16 int16_t;\r
-       typedef __int32 int32_t;\r
-       typedef unsigned __int32 uint32_t;\r
-#endif\r
-       typedef __int64 int64_t;\r
-#else\r
-       #include <os_int.h>                     // C99 (§7.18) integer types definitions\r
-#endif\r
-\r
-#if !defined(_)\r
-#define _(s)   s\r
-#endif\r
-\r
-#include <exception>\r
-#include <string>\r
-#include <vector>\r
-\r
-namespace IBPP\r
-{\r
-       //      Typically you use this constant in a call IBPP::CheckVersion as in:\r
-       //      if (! IBPP::CheckVersion(IBPP::Version)) { throw .... ; }\r
-       const uint32_t Version = (2<<24) + (5<<16) + (3<<8) + 0; // Version == 2.5.3.0\r
-\r
-       //      Dates range checking\r
-       const int MinDate = -693594;    //  1 JAN 0001\r
-       const int MaxDate = 2958464;    // 31 DEC 9999\r
-       \r
-       //      Transaction Access Modes\r
-       enum TAM {amWrite, amRead};\r
-\r
-       //      Transaction Isolation Levels\r
-       enum TIL {ilConcurrency, ilReadDirty, ilReadCommitted, ilConsistency};\r
-\r
-       //      Transaction Lock Resolution\r
-       enum TLR {lrWait, lrNoWait};\r
-\r
-       // Transaction Table Reservation\r
-       enum TTR {trSharedWrite, trSharedRead, trProtectedWrite, trProtectedRead};\r
-\r
-       //      Prepared Statement Types\r
-       enum STT {stUnknown, stUnsupported,\r
-               stSelect, stInsert, stUpdate, stDelete, stDDL, stExecProcedure,\r
-               stSelectUpdate, stSetGenerator, stSavePoint};\r
-\r
-       //      SQL Data Types\r
-       enum SDT {sdArray, sdBlob, sdDate, sdTime, sdTimestamp, sdString,\r
-               sdSmallint, sdInteger, sdLargeint, sdFloat, sdDouble};\r
-\r
-       //      Array Data Types\r
-       enum ADT {adDate, adTime, adTimestamp, adString,\r
-               adBool, adInt16, adInt32, adInt64, adFloat, adDouble};\r
-\r
-       // Database::Shutdown Modes\r
-       enum DSM {dsForce, dsDenyTrans, dsDenyAttach};\r
-\r
-       // Service::StartBackup && Service::StartRestore Flags\r
-       enum BRF {\r
-               brVerbose = 0x1,\r
-               // Backup flags\r
-               brIgnoreChecksums = 0x100, brIgnoreLimbo = 0x200,\r
-               brMetadataOnly = 0x400, brNoGarbageCollect = 0x800,\r
-               brNonTransportable = 0x1000, brConvertExtTables = 0x2000,\r
-               // Restore flags\r
-               brReplace = 0x10000, brDeactivateIdx = 0x20000,\r
-               brNoShadow = 0x40000, brNoValidity = 0x80000,\r
-               brPerTableCommit = 0x100000, brUseAllSpace = 0x200000\r
-       };\r
-\r
-       // Service::Repair Flags\r
-       enum RPF\r
-       {\r
-               // Mandatory and mutually exclusives\r
-               rpMendRecords = 0x1, rpValidatePages = 0x2, rpValidateFull = 0x4,\r
-               // Options\r
-               rpReadOnly = 0x100, rpIgnoreChecksums = 0x200, rpKillShadows = 0x400\r
-       };\r
-\r
-       // TransactionFactory Flags\r
-       enum TFF {tfIgnoreLimbo = 0x1, tfAutoCommit = 0x2, tfNoAutoUndo = 0x4};\r
-\r
-       /* IBPP never return any error codes. It throws exceptions.\r
-        * On database engine reported errors, an IBPP::SQLException is thrown.\r
-        * In all other cases, IBPP throws IBPP::LogicException.\r
-        * Also note that the runtime and the language might also throw exceptions\r
-        * while executing some IBPP methods. A failing new operator will throw\r
-        * std::bad_alloc, IBPP does nothing to alter the standard behaviour.\r
-        *\r
-        *                    std::exception\r
-        *                           |\r
-        *                   IBPP::Exception\r
-        *                 /                 \\r
-        *    IBPP::LogicException    IBPP::SQLException\r
-        *             |\r
-        *      IBPP::WrongType\r
-        */\r
-\r
-       class Exception : public std::exception\r
-       {\r
-       public:\r
-               virtual const char* Origin() const throw() = 0;\r
-               virtual const char* ErrorMessage() const throw() = 0;   // Deprecated, use what()\r
-               virtual const char* what() const throw() = 0;\r
-               virtual ~Exception() throw();\r
-       };\r
-\r
-       class LogicException : public Exception\r
-       {\r
-       public:\r
-               virtual ~LogicException() throw();\r
-       };\r
-\r
-       class SQLException : public Exception\r
-       {\r
-       public:\r
-               virtual int SqlCode() const throw() = 0;\r
-               virtual int EngineCode() const throw() = 0;\r
-               \r
-               virtual ~SQLException() throw();\r
-       };\r
-\r
-       class WrongType : public LogicException\r
-       {\r
-       public:\r
-               virtual ~WrongType() throw();\r
-       };\r
-       \r
-       /* Classes Date, Time, Timestamp and DBKey are 'helper' classes.  They help\r
-        * in retrieving or setting some special SQL types. Dates, times and dbkeys\r
-        * are often read and written as strings in SQL scripts. When programming\r
-        * with IBPP, we handle those data with these specific classes, which\r
-        * enhance their usefullness and free us of format problems (M/D/Y, D/M/Y,\r
-        * Y-M-D ?, and so on...). */\r
-\r
-       /* Class Date represent purely a Date (no time part specified). It is\r
-        * usefull in interactions with the SQL DATE type of Interbase.  You can add\r
-        * or substract a number from a Date, that will modify it to represent the\r
-        * correct date, X days later or sooner. All the Y2K details taken into\r
-        * account.\r
-        * The full range goes from integer values IBPP::MinDate to IBPP::MaxDate\r
-        * which means from 01 Jan 0001 to 31 Dec 9999. ( Which is inherently\r
-        * incorrect as this assumes Gregorian calendar. ) */\r
-       \r
-       class Timestamp;        // Cross-reference between Timestamp, Date and Time\r
-       \r
-       class Date\r
-       {\r
-       protected:\r
-               int mDate;      // The date : 1 == 1 Jan 1900\r
-\r
-       public:\r
-               void Clear()    { mDate = MinDate - 1; };\r
-               void Today();\r
-               void SetDate(int year, int month, int day);\r
-               void SetDate(int dt);\r
-               void GetDate(int& year, int& month, int& day) const;\r
-               int GetDate() const     { return mDate; }\r
-               int Year() const;\r
-               int Month() const;\r
-               int Day() const;\r
-               void Add(int days);\r
-               void StartOfMonth();\r
-               void EndOfMonth();\r
-       \r
-               Date()                  { Clear(); };\r
-               Date(int dt)    { SetDate(dt); }\r
-               Date(int year, int month, int day);\r
-               Date(const Date&);                                                      // Copy Constructor\r
-               Date& operator=(const Timestamp&);                      // Timestamp Assignment operator\r
-               Date& operator=(const Date&);                           // Date Assignment operator\r
-\r
-               bool operator==(const Date& rv) const { return mDate == rv.GetDate(); }\r
-               bool operator!=(const Date& rv) const { return mDate != rv.GetDate(); }\r
-               bool operator<(const Date& rv) const { return mDate < rv.GetDate(); }\r
-               bool operator>(const Date& rv) const { return mDate > rv.GetDate(); }\r
-\r
-               virtual ~Date() { };\r
-       };\r
-\r
-       /* Class Time represent purely a Time. It is usefull in interactions\r
-        * with the SQL TIME type of Interbase. */\r
-\r
-       class Time\r
-       {\r
-       protected:\r
-               int mTime;      // The time, in ten-thousandths of seconds since midnight\r
-\r
-       public:\r
-               void Clear()    { mTime = 0; }\r
-               void Now();\r
-               void SetTime(int hour, int minute, int second, int tenthousandths = 0);\r
-               void SetTime(int tm);\r
-               void GetTime(int& hour, int& minute, int& second) const;\r
-               void GetTime(int& hour, int& minute, int& second, int& tenthousandths) const;\r
-               int GetTime() const     { return mTime; }\r
-               int Hours() const;\r
-               int Minutes() const;\r
-               int Seconds() const;\r
-               int SubSeconds() const;         // Actually tenthousandths of seconds\r
-               Time()                  { Clear(); }\r
-               Time(int tm)    { SetTime(tm); }\r
-               Time(int hour, int minute, int second, int tenthousandths = 0);\r
-               Time(const Time&);                                                      // Copy Constructor\r
-               Time& operator=(const Timestamp&);                      // Timestamp Assignment operator\r
-               Time& operator=(const Time&);                           // Time Assignment operator\r
-\r
-               bool operator==(const Time& rv) const { return mTime == rv.GetTime(); }\r
-               bool operator!=(const Time& rv) const { return mTime != rv.GetTime(); }\r
-               bool operator<(const Time& rv) const { return mTime < rv.GetTime(); }\r
-               bool operator>(const Time& rv) const { return mTime > rv.GetTime(); }\r
-\r
-               virtual ~Time() { };\r
-       };\r
-\r
-       /* Class Timestamp represent a date AND a time. It is usefull in\r
-        * interactions with the SQL TIMESTAMP type of Interbase. This class\r
-        * inherits from Date and Time and completely inline implements its small\r
-        * specific details. */\r
-\r
-       class Timestamp : public Date, public Time\r
-       {\r
-       public:\r
-               void Clear()    { Date::Clear(); Time::Clear(); }\r
-               void Today()    { Date::Today(); Time::Clear(); }\r
-               void Now()              { Date::Today(); Time::Now(); }\r
-\r
-               Timestamp()             { Clear(); }\r
-\r
-               Timestamp(int y, int m, int d)\r
-                       { Date::SetDate(y, m, d); Time::Clear(); }\r
-\r
-               Timestamp(int y, int mo, int d, int h, int mi, int s, int t = 0)\r
-                       { Date::SetDate(y, mo, d); Time::SetTime(h, mi, s, t); }\r
-\r
-               Timestamp(const Timestamp& rv)\r
-                       : Date(rv.mDate), Time(rv.mTime) {}     // Copy Constructor\r
-\r
-               Timestamp(const Date& rv)\r
-                       { mDate = rv.GetDate(); mTime = 0; }\r
-\r
-               Timestamp(const Time& rv)\r
-                       { mDate = 0; mTime = rv.GetTime(); }\r
-\r
-               Timestamp& operator=(const Timestamp& rv)       // Timestamp Assignment operator\r
-                       { mDate = rv.mDate; mTime = rv.mTime; return *this; }\r
-\r
-               Timestamp& operator=(const Date& rv)            // Date Assignment operator\r
-                       { mDate = rv.GetDate(); return *this; }\r
-\r
-               Timestamp& operator=(const Time& rv)            // Time Assignment operator\r
-                       { mTime = rv.GetTime(); return *this; }\r
-\r
-               bool operator==(const Timestamp& rv) const\r
-                       { return (mDate == rv.GetDate()) && (mTime == rv.GetTime()); }\r
-\r
-               bool operator!=(const Timestamp& rv) const\r
-                       { return (mDate != rv.GetDate()) || (mTime != rv.GetTime()); }\r
-\r
-               bool operator<(const Timestamp& rv) const\r
-                       { return (mDate < rv.GetDate()) ||\r
-                               (mDate == rv.GetDate() && mTime < rv.GetTime()); }\r
-\r
-               bool operator>(const Timestamp& rv) const\r
-                       { return (mDate > rv.GetDate()) ||\r
-                               (mDate == rv.GetDate() && mTime > rv.GetTime()); }\r
-\r
-               ~Timestamp() { }\r
-       };\r
-\r
-       /* Class DBKey can store a DBKEY, that special value which the hidden\r
-        * RDB$DBKEY can give you from a select statement. A DBKey is nothing\r
-        * specific to IBPP. It's a feature of the Firebird database engine. See its\r
-        * documentation for more information. */\r
-\r
-       class DBKey\r
-       {\r
-       private:\r
-               std::string mDBKey;                     // Stores the binary DBKey\r
-               mutable std::string mString;// String (temporary) representation of it\r
-\r
-       public:\r
-               void Clear();\r
-               int Size() const        { return (int)mDBKey.size(); }\r
-               void SetKey(const void*, int size);\r
-               void GetKey(void*, int size) const;\r
-               const char* AsString() const;\r
-\r
-               DBKey& operator=(const DBKey&); // Assignment operator\r
-               DBKey(const DBKey&);                    // Copy Constructor\r
-               DBKey() { }\r
-               ~DBKey() { }\r
-       };\r
-\r
-       /* Class User wraps all the information about a user that the engine can manage. */\r
-\r
-       class User\r
-       {\r
-       public:\r
-               std::string username;\r
-               std::string password;\r
-               std::string firstname;\r
-               std::string middlename;\r
-               std::string lastname;\r
-               uint32_t userid;                // Only relevant on unixes\r
-               uint32_t groupid;               // Only relevant on unixes\r
-\r
-       private:\r
-               void copyfrom(const User& r);\r
-\r
-       public:\r
-               void clear();\r
-               User& operator=(const User& r)  { copyfrom(r); return *this; }\r
-               User(const User& r)                             { copyfrom(r); }\r
-               User() : userid(0), groupid(0)  { }\r
-               ~User() { };\r
-       };\r
-\r
-       //      Interface Wrapper\r
-       template <class T>\r
-       class Ptr\r
-       {\r
-       private:\r
-               T* mObject;\r
-\r
-       public:\r
-               void clear()\r
-               {\r
-                       if (mObject != 0) { mObject->Release(); mObject = 0; }\r
-               }\r
-\r
-               T* intf() const                                         { return mObject; }\r
-               T* operator->() const                           { return mObject; }\r
-\r
-               bool operator==(const T* p) const       { return mObject == p; }\r
-               bool operator==(const Ptr& r) const     { return mObject == r.mObject; }\r
-               bool operator!=(const T* p) const       { return mObject != p; }\r
-               bool operator!=(const Ptr& r) const     { return mObject != r.mObject; }\r
-\r
-               Ptr& operator=(T* p)\r
-               {\r
-                       // AddRef _before_ Release gives correct behaviour on self-assigns\r
-                       T* tmp = (p == 0 ? 0 : p->AddRef());    // Take care of 0\r
-                       if (mObject != 0) mObject->Release();\r
-                       mObject = tmp; return *this;\r
-               }\r
-\r
-               Ptr& operator=(const Ptr& r)\r
-               {\r
-                       // AddRef _before_ Release gives correct behaviour on self-assigns\r
-                       T* tmp = (r.intf() == 0 ? 0 : r->AddRef());// Take care of 0\r
-                       if (mObject != 0) mObject->Release();\r
-                       mObject = tmp; return *this;\r
-               }\r
-\r
-               Ptr(T* p) : mObject(p == 0 ? 0 : p->AddRef()) { }\r
-               Ptr(const Ptr& r) : mObject(r.intf() == 0 ? 0 : r->AddRef()) {  }\r
-\r
-               Ptr() : mObject(0) { }\r
-               ~Ptr() { clear(); }\r
-       };\r
-\r
-       //      --- Interface Classes --- //\r
-\r
-       /* Interfaces IBlob, IArray, IService, IDatabase, ITransaction and\r
-        * IStatement are at the core of IBPP. Though it is possible to program your\r
-        * applications by using theses interfaces directly (as was the case with\r
-        * IBPP 1.x), you should refrain from using them and prefer the new IBPP\r
-        * Objects Blob, Array, ... (without the I in front). Those new objects are\r
-        * typedef'd right after each interface class definition as you can read\r
-        * below. If you program using the Blob (instead of the IBlob interface\r
-        * itself), you'll never have to care about AddRef/Release and you'll never\r
-        * have to care about deleting your objects. */\r
-\r
-       class IBlob;                    typedef Ptr<IBlob> Blob;\r
-       class IArray;                   typedef Ptr<IArray> Array;\r
-       class IService;                 typedef Ptr<IService> Service;\r
-       class IDatabase;                typedef Ptr<IDatabase> Database;\r
-       class ITransaction;             typedef Ptr<ITransaction> Transaction;\r
-       class IStatement;               typedef Ptr<IStatement> Statement;\r
-       class IEvents;                  typedef Ptr<IEvents> Events;\r
-       class IRow;                             typedef Ptr<IRow> Row;\r
-\r
-       /* IBlob is the interface to the blob capabilities of IBPP. Blob is the\r
-        * object class you actually use in your programming. In Firebird, at the\r
-        * row level, a blob is merely a handle to a blob, stored elsewhere in the\r
-        * database. Blob allows you to retrieve such a handle and then read from or\r
-        * write to the blob, much in the same manner than you would do with a file. */\r
-\r
-       class IBlob\r
-       {\r
-       public:\r
-               virtual void Create() = 0;\r
-               virtual void Open() = 0;\r
-               virtual void Close() = 0;\r
-               virtual void Cancel() = 0;\r
-               virtual int Read(void*, int size) = 0;\r
-               virtual void Write(const void*, int size) = 0;\r
-               virtual void Info(int* Size, int* Largest, int* Segments) = 0;\r
-       \r
-               virtual void Save(const std::string& data) = 0;\r
-               virtual void Load(std::string& data) = 0;\r
-\r
-               virtual Database DatabasePtr() const = 0;\r
-               virtual Transaction TransactionPtr() const = 0;\r
-\r
-               virtual IBlob* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-               virtual ~IBlob() { };\r
-       };\r
-\r
-       /*      IArray is the interface to the array capabilities of IBPP. Array is the\r
-       * object class you actually use in your programming. With an Array object, you\r
-       * can create, read and write Interbase Arrays, as a whole or in slices. */\r
-\r
-       class IArray\r
-       {\r
-       public:\r
-               virtual void Describe(const std::string& table, const std::string& column) = 0;\r
-               virtual void ReadTo(ADT, void* buffer, int elemcount) = 0;\r
-               virtual void WriteFrom(ADT, const void* buffer, int elemcount) = 0;\r
-               virtual SDT ElementType() = 0;\r
-               virtual int ElementSize() = 0;\r
-               virtual int ElementScale() = 0;\r
-               virtual int Dimensions() = 0;\r
-               virtual void Bounds(int dim, int* low, int* high) = 0;\r
-               virtual void SetBounds(int dim, int low, int high) = 0;\r
-\r
-               virtual Database DatabasePtr() const = 0;\r
-               virtual Transaction TransactionPtr() const = 0;\r
-\r
-               virtual IArray* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-               virtual ~IArray() { };\r
-       };\r
-\r
-       /* IService is the interface to the service capabilities of IBPP. Service is\r
-        * the object class you actually use in your programming. With a Service\r
-        * object, you can do some maintenance work of databases and servers\r
-        * (backup, restore, create/update users, ...) */\r
-\r
-       class IService\r
-       {\r
-       public:\r
-           virtual void Connect() = 0;\r
-               virtual bool Connected() = 0;\r
-               virtual void Disconnect() = 0;\r
-\r
-               virtual void GetVersion(std::string& version) = 0;\r
-\r
-               virtual void AddUser(const User&) = 0;\r
-               virtual void GetUser(User&) = 0;\r
-               virtual void GetUsers(std::vector<User>&) = 0;\r
-               virtual void ModifyUser(const User&) = 0;\r
-               virtual void RemoveUser(const std::string& username) = 0;\r
-\r
-               virtual void SetPageBuffers(const std::string& dbfile, int buffers) = 0;\r
-               virtual void SetSweepInterval(const std::string& dbfile, int sweep) = 0;\r
-               virtual void SetSyncWrite(const std::string& dbfile, bool) = 0;\r
-               virtual void SetReadOnly(const std::string& dbfile, bool) = 0;\r
-               virtual void SetReserveSpace(const std::string& dbfile, bool) = 0;\r
-\r
-               virtual void Shutdown(const std::string& dbfile, DSM mode, int sectimeout) = 0;\r
-               virtual void Restart(const std::string& dbfile) = 0;\r
-               virtual void Sweep(const std::string& dbfile) = 0;\r
-               virtual void Repair(const std::string& dbfile, RPF flags) = 0;\r
-\r
-               virtual void StartBackup(const std::string& dbfile,\r
-                       const std::string& bkfile, BRF flags = BRF(0)) = 0;\r
-               virtual void StartRestore(const std::string& bkfile, const std::string& dbfile,\r
-                       int pagesize = 0, BRF flags = BRF(0)) = 0;\r
-\r
-               virtual const char* WaitMsg() = 0;      // With reporting (does not block)\r
-               virtual void Wait() = 0;                        // Without reporting (does block)\r
-\r
-               virtual IService* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-               virtual ~IService() { };\r
-       };\r
-\r
-       /*      IDatabase is the interface to the database connections in IBPP. Database\r
-        * is the object class you actually use in your programming. With a Database\r
-        * object, you can create/drop/connect databases. */\r
-\r
-       class EventInterface;   // Cross-reference between EventInterface and IDatabase\r
-       \r
-       class IDatabase\r
-       {\r
-       public:\r
-               virtual const char* ServerName() const = 0;\r
-               virtual const char* DatabaseName() const = 0;\r
-               virtual const char* Username() const = 0;\r
-               virtual const char* UserPassword() const = 0;\r
-               virtual const char* RoleName() const = 0;\r
-               virtual const char* CharSet() const = 0;\r
-               virtual const char* CreateParams() const = 0;\r
-\r
-               virtual void Info(int* ODS, int* ODSMinor, int* PageSize,\r
-                       int* Pages,     int* Buffers, int* Sweep, bool* Sync,\r
-                       bool* Reserve) = 0;\r
-               virtual void Statistics(int* Fetches, int* Marks,\r
-                       int* Reads, int* Writes) = 0;\r
-               virtual void Counts(int* Insert, int* Update, int* Delete, \r
-                       int* ReadIdx, int* ReadSeq) = 0;\r
-               virtual void Users(std::vector<std::string>& users) = 0;\r
-               virtual int Dialect() = 0;\r
-\r
-               virtual void Create(int dialect) = 0;\r
-               virtual void Connect() = 0;\r
-               virtual bool Connected() = 0;\r
-               virtual void Inactivate() = 0;\r
-               virtual void Disconnect() = 0;\r
-               virtual void Drop() = 0;\r
-\r
-               virtual IDatabase* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-           virtual ~IDatabase() { };\r
-       };\r
-\r
-       /* ITransaction is the interface to the transaction connections in IBPP.\r
-        * Transaction is the object class you actually use in your programming. A\r
-        * Transaction object can be associated with more than one Database,\r
-        * allowing for distributed transactions spanning multiple databases,\r
-        * possibly located on different servers. IBPP is one among the few\r
-        * programming interfaces to Firebird that allows you to support distributed\r
-        * transactions. */\r
-\r
-       class ITransaction\r
-       {\r
-       public:\r
-           virtual void AttachDatabase(Database db, TAM am = amWrite,\r
-                       TIL il = ilConcurrency, TLR lr = lrWait, TFF flags = TFF(0)) = 0;\r
-           virtual void DetachDatabase(Database db) = 0;\r
-               virtual void AddReservation(Database db,\r
-                               const std::string& table, TTR tr) = 0;\r
-\r
-               virtual void Start() = 0;\r
-               virtual bool Started() = 0;\r
-           virtual void Commit() = 0;\r
-           virtual void Rollback() = 0;\r
-           virtual void CommitRetain() = 0;\r
-               virtual void RollbackRetain() = 0;\r
-\r
-               virtual ITransaction* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-           virtual ~ITransaction() { };\r
-       };\r
-\r
-       /*\r
-        *      Class Row can hold all the values of a row (from a SELECT for instance).\r
-        */\r
-\r
-       class IRow\r
-       {\r
-       public:\r
-               virtual void SetNull(int) = 0;\r
-               virtual void Set(int, bool) = 0;\r
-               virtual void Set(int, const void*, int) = 0;            // byte buffers\r
-               virtual void Set(int, const char*) = 0;                         // c-string\r
-               virtual void Set(int, const std::string&) = 0;\r
-               virtual void Set(int, int16_t) = 0;\r
-               virtual void Set(int, int32_t) = 0;\r
-               virtual void Set(int, int64_t) = 0;\r
-               virtual void Set(int, float) = 0;\r
-               virtual void Set(int, double) = 0;\r
-               virtual void Set(int, const Timestamp&) = 0;\r
-               virtual void Set(int, const Date&) = 0;\r
-               virtual void Set(int, const Time&) = 0;\r
-               virtual void Set(int, const DBKey&) = 0;\r
-               virtual void Set(int, const Blob&) = 0;\r
-               virtual void Set(int, const Array&) = 0;\r
-\r
-               virtual bool IsNull(int) = 0;\r
-               virtual bool Get(int, bool&) = 0;\r
-               virtual bool Get(int, void*, int&) = 0; // byte buffers\r
-               virtual bool Get(int, std::string&) = 0;\r
-               virtual bool Get(int, int16_t&) = 0;\r
-               virtual bool Get(int, int32_t&) = 0;\r
-               virtual bool Get(int, int64_t&) = 0;\r
-               virtual bool Get(int, float&) = 0;\r
-               virtual bool Get(int, double&) = 0;\r
-               virtual bool Get(int, Timestamp&) = 0;\r
-               virtual bool Get(int, Date&) = 0;\r
-               virtual bool Get(int, Time&) = 0;\r
-               virtual bool Get(int, DBKey&) = 0;\r
-               virtual bool Get(int, Blob&) = 0;\r
-               virtual bool Get(int, Array&) = 0;\r
-\r
-               virtual bool IsNull(const std::string&) = 0;\r
-               virtual bool Get(const std::string&, bool&) = 0;\r
-               virtual bool Get(const std::string&, void*, int&) = 0;  // byte buffers\r
-               virtual bool Get(const std::string&, std::string&) = 0;\r
-               virtual bool Get(const std::string&, int16_t&) = 0;\r
-               virtual bool Get(const std::string&, int32_t&) = 0;\r
-               virtual bool Get(const std::string&, int64_t&) = 0;\r
-               virtual bool Get(const std::string&, float&) = 0;\r
-               virtual bool Get(const std::string&, double&) = 0;\r
-               virtual bool Get(const std::string&, Timestamp&) = 0;\r
-               virtual bool Get(const std::string&, Date&) = 0;\r
-               virtual bool Get(const std::string&, Time&) = 0;\r
-               virtual bool Get(const std::string&, DBKey&) = 0;\r
-               virtual bool Get(const std::string&, Blob&) = 0;\r
-               virtual bool Get(const std::string&, Array&) = 0;\r
-\r
-               virtual int ColumnNum(const std::string&) = 0;\r
-               virtual const char* ColumnName(int) = 0;\r
-               virtual const char* ColumnAlias(int) = 0;\r
-               virtual const char* ColumnTable(int) = 0;\r
-               virtual SDT ColumnType(int) = 0;\r
-               virtual int ColumnSubtype(int) = 0;\r
-               virtual int ColumnSize(int) = 0;\r
-               virtual int ColumnScale(int) = 0;\r
-               virtual int Columns() = 0;\r
-               \r
-               virtual bool ColumnUpdated(int) = 0;\r
-               virtual bool Updated() = 0;\r
-\r
-               virtual Database DatabasePtr() const = 0;\r
-               virtual Transaction TransactionPtr() const = 0;\r
-\r
-               virtual IRow* Clone() = 0;\r
-               virtual IRow* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-           virtual ~IRow() {};\r
-       };\r
-\r
-       /* IStatement is the interface to the statements execution in IBPP.\r
-        * Statement is the object class you actually use in your programming. A\r
-        * Statement object is the work horse of IBPP. All your data manipulation\r
-        * statements will be done through it. It is also used to access the result\r
-        * set of a query (when the statement is such), one row at a time and in\r
-        * strict forward direction. */\r
-\r
-       class IStatement\r
-       {\r
-       public:\r
-               virtual void Prepare(const std::string&) = 0;\r
-               virtual void Execute() = 0;\r
-               virtual void Execute(const std::string&) = 0;\r
-               virtual void ExecuteImmediate(const std::string&) = 0;\r
-               virtual void CursorExecute(const std::string& cursor) = 0;\r
-               virtual void CursorExecute(const std::string& cursor, const std::string&) = 0;\r
-               virtual bool Fetch() = 0;\r
-               virtual bool Fetch(Row&) = 0;\r
-               virtual int AffectedRows() = 0;\r
-               virtual void Close() = 0;\r
-               virtual std::string& Sql() = 0;\r
-               virtual STT Type() = 0;\r
-\r
-               virtual void SetNull(int) = 0;\r
-               virtual void Set(int, bool) = 0;\r
-               virtual void Set(int, const void*, int) = 0;            // byte buffers\r
-               virtual void Set(int, const char*) = 0;                         // c-string\r
-               virtual void Set(int, const std::string&) = 0;\r
-               virtual void Set(int, int16_t value) = 0;\r
-               virtual void Set(int, int32_t value) = 0;\r
-               virtual void Set(int, int64_t value) = 0;\r
-               virtual void Set(int, float value) = 0;\r
-               virtual void Set(int, double value) = 0;\r
-               virtual void Set(int, const Timestamp& value) = 0;\r
-               virtual void Set(int, const Date& value) = 0;\r
-               virtual void Set(int, const Time& value) = 0;\r
-               virtual void Set(int, const DBKey& value) = 0;\r
-               virtual void Set(int, const Blob& value) = 0;\r
-               virtual void Set(int, const Array& value) = 0;\r
-\r
-               virtual bool IsNull(int) = 0;\r
-               virtual bool Get(int, bool&) = 0;\r
-               virtual bool Get(int, void*, int&) = 0; // byte buffers\r
-               virtual bool Get(int, std::string&) = 0;\r
-               virtual bool Get(int, int16_t&) = 0;\r
-               virtual bool Get(int, int32_t&) = 0;\r
-               virtual bool Get(int, int64_t&) = 0;\r
-               virtual bool Get(int, float&) = 0;\r
-               virtual bool Get(int, double&) = 0;\r
-               virtual bool Get(int, Timestamp& value) = 0;\r
-               virtual bool Get(int, Date& value) = 0;\r
-               virtual bool Get(int, Time& value) = 0;\r
-               virtual bool Get(int, DBKey& value) = 0;\r
-               virtual bool Get(int, Blob& value) = 0;\r
-               virtual bool Get(int, Array& value) = 0;\r
-\r
-               virtual bool IsNull(const std::string&) = 0;\r
-               virtual bool Get(const std::string&, bool&) = 0;\r
-               virtual bool Get(const std::string&, void*, int&) = 0;  // byte buffers\r
-               virtual bool Get(const std::string&, std::string&) = 0;\r
-               virtual bool Get(const std::string&, int16_t&) = 0;\r
-               virtual bool Get(const std::string&, int32_t&) = 0;\r
-               virtual bool Get(const std::string&, int64_t&) = 0;\r
-               virtual bool Get(const std::string&, float&) = 0;\r
-               virtual bool Get(const std::string&, double&) = 0;\r
-               virtual bool Get(const std::string&, Timestamp& value) = 0;\r
-               virtual bool Get(const std::string&, Date& value) = 0;\r
-               virtual bool Get(const std::string&, Time& value) = 0;\r
-               virtual bool Get(const std::string&, DBKey& value) = 0;\r
-               virtual bool Get(const std::string&, Blob& value) = 0;\r
-               virtual bool Get(const std::string&, Array& value) = 0;\r
-\r
-               virtual int ColumnNum(const std::string&) = 0;\r
-               virtual const char* ColumnName(int) = 0;\r
-               virtual const char* ColumnAlias(int) = 0;\r
-               virtual const char* ColumnTable(int) = 0;\r
-               virtual SDT ColumnType(int) = 0;\r
-               virtual int ColumnSubtype(int) = 0;\r
-               virtual int ColumnSize(int) = 0;\r
-               virtual int ColumnScale(int) = 0;\r
-               virtual int Columns() = 0;\r
-\r
-               virtual SDT ParameterType(int) = 0;\r
-               virtual int ParameterSubtype(int) = 0;\r
-               virtual int ParameterSize(int) = 0;\r
-               virtual int ParameterScale(int) = 0;\r
-               virtual int Parameters() = 0;\r
-\r
-               virtual void Plan(std::string&) = 0;\r
-\r
-               virtual Database DatabasePtr() const = 0;\r
-               virtual Transaction TransactionPtr() const = 0;\r
-\r
-               virtual IStatement* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-           virtual ~IStatement() { };\r
-\r
-               // DEPRECATED METHODS (WON'T BE AVAILABLE IN VERSIONS 3.x)\r
-               virtual bool Get(int, char*) = 0;                                       // DEPRECATED\r
-               virtual bool Get(const std::string&, char*) = 0;        // DEPRECATED\r
-               virtual bool Get(int, bool*) = 0;                                       // DEPRECATED\r
-               virtual bool Get(const std::string&, bool*) = 0;        // DEPRECATED\r
-               virtual bool Get(int, int16_t*) = 0;                            // DEPRECATED\r
-               virtual bool Get(const std::string&, int16_t*) = 0;     // DEPRECATED\r
-               virtual bool Get(int, int32_t*) = 0;                            // DEPRECATED\r
-               virtual bool Get(const std::string&, int32_t*) = 0;     // DEPRECATED\r
-               virtual bool Get(int, int64_t*) = 0;                            // DEPRECATED\r
-               virtual bool Get(const std::string&, int64_t*) = 0;     // DEPRECATED\r
-               virtual bool Get(int, float*) = 0;                                      // DEPRECATED\r
-               virtual bool Get(const std::string&, float*) = 0;       // DEPRECATED\r
-               virtual bool Get(int, double*) = 0;                                     // DEPRECATED\r
-               virtual bool Get(const std::string&, double*) = 0;      // DEPRECATED\r
-       };\r
-       \r
-       class IEvents\r
-       {\r
-       public:\r
-               virtual void Add(const std::string&, EventInterface*) = 0;\r
-               virtual void Drop(const std::string&) = 0;\r
-               virtual void List(std::vector<std::string>&) = 0;\r
-               virtual void Clear() = 0;                               // Drop all events\r
-               virtual void Dispatch() = 0;                    // Dispatch events (calls handlers)\r
-\r
-               virtual Database DatabasePtr() const = 0;\r
-\r
-               virtual IEvents* AddRef() = 0;\r
-               virtual void Release() = 0;\r
-\r
-           virtual ~IEvents() { };\r
-       };\r
-       \r
-       /* Class EventInterface is merely a pure interface.\r
-        * It is _not_ implemented by IBPP. It is only a base class definition from\r
-        * which your own event interface classes have to derive from.\r
-        * Please read the reference guide at http://www.ibpp.org for more info. */\r
-\r
-       class EventInterface\r
-       {\r
-       public:\r
-               virtual void ibppEventHandler(Events, const std::string&, int) = 0;\r
-               virtual ~EventInterface() { };\r
-       };\r
-\r
-       //      --- Factories ---\r
-       //      These methods are the only way to get one of the above\r
-       //      Interfaces.  They are at the heart of how you program using IBPP.  For\r
-       //      instance, to get access to a database, you'll write code similar to this:\r
-       //      {\r
-       //              Database db = DatabaseFactory("server", "databasename",\r
-       //                                              "user", "password");\r
-       //              db->Connect();\r
-       //              ...\r
-       //              db->Disconnect();\r
-       //      }\r
-\r
-       Service ServiceFactory(const std::string& ServerName,\r
-               const std::string& UserName, const std::string& UserPassword);\r
-\r
-       Database DatabaseFactory(const std::string& ServerName,\r
-               const std::string& DatabaseName, const std::string& UserName,\r
-                       const std::string& UserPassword, const std::string& RoleName,\r
-                               const std::string& CharSet, const std::string& CreateParams);\r
-\r
-       inline Database DatabaseFactory(const std::string& ServerName,\r
-               const std::string& DatabaseName, const std::string& UserName,\r
-                       const std::string& UserPassword)\r
-               { return DatabaseFactory(ServerName, DatabaseName, UserName, UserPassword, "", "", ""); }\r
-\r
-       Transaction TransactionFactory(Database db, TAM am = amWrite,\r
-               TIL il = ilConcurrency, TLR lr = lrWait, TFF flags = TFF(0));\r
-\r
-       Statement StatementFactory(Database db, Transaction tr,\r
-               const std::string& sql);\r
-\r
-       inline Statement StatementFactory(Database db, Transaction tr)\r
-               { return StatementFactory(db, tr, ""); }\r
-\r
-       Blob BlobFactory(Database db, Transaction tr);\r
-       \r
-       Array ArrayFactory(Database db, Transaction tr);\r
-       \r
-       Events EventsFactory(Database db);\r
-\r
-       /* IBPP uses a self initialization system. Each time an object that may\r
-        * require the usage of the Interbase client C-API library is used, the\r
-        * library internal handling details are automatically initialized, if not\r
-        * already done. You can kick this initialization at the start of an\r
-        * application by calling IBPP::CheckVersion(). This is recommended, because\r
-        * IBPP::CheckVersion will assure you that YOUR code has been compiled\r
-        * against a compatible version of the library. */\r
-\r
-       bool CheckVersion(uint32_t);\r
-       int GDSVersion();\r
-       \r
-       /* On Win32 platform, ClientLibSearchPaths() allows to setup\r
-        * one or multiple additional paths (separated with a ';') where IBPP\r
-        * will look for the client library (before the default implicit search\r
-        * locations). This is usefull for applications distributed with a 'private'\r
-        * copy of Firebird, when the registry is useless to identify the location\r
-        * from where to attempt loading the fbclient.dll / gds32.dll.\r
-        * If called, this function must be called *early* by the application,\r
-        * before *any* other function or object methods of IBPP.\r
-        * Currently, this is a NO-OP on platforms other than Win32. */\r
-        \r
-       void ClientLibSearchPaths(const std::string&);\r
-\r
-       /* Finally, here are some date and time conversion routines used by IBPP and\r
-        * that may be helpful at the application level. They do not depend on\r
-        * anything related to Firebird/Interbase. Just a bonus. dtoi and itod\r
-        * return false on invalid parameters or out of range conversions. */\r
-\r
-       bool dtoi(int date, int* py, int* pm, int* pd);\r
-       bool itod(int* pdate, int year, int month, int day);\r
-       void ttoi(int itime, int* phour, int* pminute, int* psecond, int* ptt);\r
-       void itot(int* ptime, int hour, int minute, int second = 0, int tenthousandths = 0);\r
-\r
-}\r
-\r
-#endif\r
-\r
-//\r
-//     EOF\r
-//\r