The Able Namespace

This is preliminary documentation. Written mostly for project-member review, you can expect to see something better here as time whimpers along...



Orignally written for the C Standard Library on WIN32. 
Hence the on-going work on Linux and OS X is relatively easy!

Able1 has been built using various compilers and tool sets.  
The list includes:

   NetBeans 7.0 (C++ works great!)
   Microsoft Visual Studio.NET
   Microsoft Visual C++ 6
   Borland C++Builder 6
   Borland Kylix
   Eclipse 3.0 / G++ (CDT)
   Eclipse 3.0 / DJGPP (CDT + a few hacks of my own)

Let us know if you have any trouble.


If you enjoy reading - or otherwise rummaging-thu code such as this - then you might also enjoy learning about this & other projects & services available to you at Soft9000.com






R.A. Nagy



~=*=~




[Project]   
[Package]   
// ****************************************************************************
// Class DFO: Data File Operations.
// --------------------------------
// Puropse is to model the operations that we usually want to perform on a 
// homogeneous collection of records. The goal is to easily allow the pattern 
// to be readily re-used between record types.
//
// PATTERN: This class reads and writes records in the Array<T> format with an 
// optional header record. Overload the Load(File) and Save(File) if that is not 
// what you need.
//
// 03/17/2002: Class created by retro-verifying and extracting operations in
// Phones application, R. Nagy
// 06/10/2002: By adding the Tally() member and using it to pre-allocate, we
// reduced the load time of a 777 PHONES entry file from around 7 seconds to
// sub-second, R. Nagy
// 06/11/2002: Eliminated #define: Split DFO into DFO_Array and DFO, R. Nagy
// 07/06/2002: Extracted and publicized Read() and Write(), R. Nagy
// 08/01/2002: Specified array operators =() and ==() for better support, R. Nagy
// 09/02/2002: Added Swap(), R. Nagy
// 09/06/2002: Fixed bug in Swap() and removed !is.eof(), as it was causing strange problems, R. Nagy
// 05/01/2005: Added Query(array), Append(array), better File support, and re-arranged the model, R. Nagy
// 05/16/2005: Added QSort(void), R. Nagy
// 07/19/2005: Added read/write_heap functions - Legacy code uses both fast pre-allocated AND slower heap-rec-io strategies, R. Nagy
// 07/23/2006: Now requiring File::TranslationModes mode on all Load and Save operations, R. Nagy
// 08/20/2006: Added the AsArray parameter for better backwards-compatability (DFO_BLOCK_WRITE support), R. Nagy
//             Fixed a a few bugs in Tally(), R. Nagy
// 09/09/2006: Fixed a few AsArray oversights in ... everything, R. Nagy
//
#ifndef DFO_Happ
#define DFO_Happ


// DFO_BLOCK_WRITE - or pre-processor style serialization in Array<T> format - is
// no longer needed. Instead, specify AsArray = true ...

namespace Able1
   {
   using namespace std;

   class ZStr;


/** Puropse is to model the operations that we usually want to perform on a 
  * homogeneous collection of records. The goal is to easily allow the pattern 
  * to be readily re-used between record types.
  * <br>
  * <i>PATTERN:</i> This class reads and writes records in the Array<T> format with an 
  * optional header record. Overload the Load(File) and Save(File) if that is not 
  * what you need.
  */

template <class T, class SZ = size_t>
class DFO : public DFO_Array<T, SZ>
   {
   protected:
      File pwFile;

   public:
      DFO(void)                                 {}
      virtual ~DFO(void)                        {} // old habits die hard ...

      ZStr      FileName(void)                   {return pwFile.Name();}
      bool           FileName(const ZStr& str)   {return pwFile.Name(str);}
      bool           FileName(const File& file)       {return pwFile.Name(file);}
      bool           Name(const File& file)           {return pwFile.Name(file.Name());}

      bool           Create(File& file, CompArray<T>& data, File::TranslationModes mode, bool AsArray = false);

      bool           Load(File::TranslationModes mode, bool AsArray = false);
      bool           Save(File::TranslationModes mode, bool AsArray = false);

      bool           Load(const ZStr& FilePath, File::TranslationModes mode, bool AsArray = false);
      bool           Save(const ZStr& FilePath, File::TranslationModes mode, bool AsArray = false);

      // Everything i/o gets down to this usage at some point -
      virtual bool   Load(File& file, File::TranslationModes mode = File::AT_BINARY, bool AsArray = false);
      virtual bool   Save(File& file, File::TranslationModes mode = File::AT_BINARY, bool AsArray = false);

      bool           SaveAs(const ZStr& FilePath, File::TranslationModes mode, bool AsArray = false);
      bool           SaveAs(File& FilePath, File::TranslationModes mode, bool AsArray = false);

      // NPOS on ERROR, else number of objects in the file.
      size_t         Tally(const ZStr& sFileName, File::TranslationModes mode, bool AsArray = false);
   };

template <class T, class SZ>
bool DFO<T, SZ>::Create(File& file, CompArray<T>& data, File::TranslationModes mode, bool AsArray)
   {
   DFO_Array<T, SZ>::array = data;
   return Save(file, mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::Load(File::TranslationModes mode, bool AsArray)
   {
   return Load(pwFile.Name(), mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::Save(File::TranslationModes mode, bool AsArray)
   {
   return Save(pwFile, mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::Load(const ZStr& FilePath, File::TranslationModes mode, bool AsArray)
   {
   File file;
   if(file.Name(FilePath) == false)
      return false;
   return Load(file, mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::Save(const ZStr& FilePath, File::TranslationModes mode, bool AsArray)
   {
   File file;
   if(file.Name(FilePath) == false)
      return false;
   return Save(file, mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::SaveAs(const ZStr& FilePath, File::TranslationModes mode, bool AsArray)
   {
   File file;
   if(file.Name(FilePath) == false)
      return false;
   return Save(file, mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::SaveAs(File& file, File::TranslationModes mode, bool AsArray)
   {
   return Save(file, mode, AsArray);
   }
template <class T, class SZ>
bool DFO<T, SZ>::Load(File& file, File::TranslationModes mode, bool AsArray)
   {
   if(pwFile.Name(file.Name()) == false)
      return false;
   if(AsArray)
      {
      bool br = false;
      istream& is = pwFile.OpenRead(mode);
      DFO_Array<T, SZ>::_load_header(is);
      DFO_Array<T, SZ>::array.Read(is);
      if(is)
         br = true;
      pwFile.Close();
      return br;
      }
   return FileObjectHeap<T, SZ>::Load(DFO_Array<T, SZ>::array, pwFile, mode);
   }
template <class T, class SZ>
bool DFO<T, SZ>::Save(File& file, File::TranslationModes mode, bool AsArray)
   {
   if(pwFile.Name(file.Name()) == false)
      return false;
   if(AsArray)
      {
      bool br = false;
      ostream& os = pwFile.OpenWrite(mode);
      DFO_Array<T, SZ>::_save_header(os);
      DFO_Array<T, SZ>::array.Write(os);
      if(os)
         br = true;
      pwFile.Close();
      return br;
      }
   return FileObjectHeap<T, SZ>::Save(DFO_Array<T, SZ>::array, pwFile, mode);
   }
template <class T, class SZ>
size_t DFO<T, SZ>::Tally(const ZStr& FilePath, File::TranslationModes mode, bool AsArray)
   {
   File file;
   if(file.Name(FilePath) == false)
      return NPOS;
   size_t ss   = NULL;
   istream& is = file.OpenRead(mode);
   if(!is)
      return NPOS;
   DFO_Array<T, SZ>::_load_header(is);
   if(!is)
      return NPOS;
   if(AsArray)
      {
      Array<T> array;
      array.Read(is);
      ss = array.Nelem();
      file.Close();
      return ss;
      }
   else
      {
      while(is)
         {
         T rRec;
         if(_load(rRec, is) == true)
            {
            if(is.fail())
               return NPOS;
            if(is)
               ss++;
            }
         }
      file.Close();
      return ss;
      }
   }
// Able1
#endif

~/=\~