struct BlockInfo
{
      unsigned ObjectID; // Если = 0 значит область ПАП свободна и является кандидатом на объединение
      unsigned PersistAddress; // Адрес в ПАП
      unsigned ObjectSize; // Размер объекта
      unsigned NextBlobk; // Указатель на следующее звено состояния менеджера в ПАП
};

// persist template class for primitive c++ types
template <class _T>
class persist
{
      friend class fptr<_T>;
      typedef _T& _Tref;
      typedef _T* _Tptr;
      //union{
   //    _T val;
    unsigned char _data[sizeof(_T)];
      //};
        
      void get_name( char* faddress )
      {
    //strstreambuf buf( faddress, faddress_size );
    //iostream    bufstream( &buf );
    union convert
          {
     persist<_T>* a;
     unsigned     b;
    } c;
    c.a = this;
    //bufstream << "./" << c.b;
    //bufstream.put(0);

    char    str[10];
    _ultoa( c.b, str, 16 );
    strcpy( faddress, ".\\Obj_" );
    strcat( faddress, str );
    strcat( faddress, ".persist" );
      }

public:
      persist()
      {
    char faddress[faddress_size];
    faddress[0] = 0;
    get_name( faddress );
          //memset( (char*)(&_data[0]), 0, sizeof(_T) ); -- уже не нужно
    // вызываем принудительно конструктор
    new((void*)_data) _T;
    ifstream( faddress ).read( (char*)(&_data[0]), sizeof(_T) );
      }
      persist(const _T& ref) : (*(_T*)_data)(ref) {}
      ~persist()
      {
    char faddress[faddress_size];
    get_name( faddress );
    ofstream( faddress ).write( (char*)(&_data[0]), sizeof(_T) );
    // вызываем принудительно деструктор
    ((_T*)_data)->~_T();
      }

      operator _Tref() { return (*(_T*)_data); }
      operator _Tref() const { return (*(_T*)_data); }
      _T* operator&() { return &(*(_T*)_data); }
      _Tref operator=( const _T& ref ) { return (*(_T*)_data) = ref; }
};

///////////////////////////////////////////////////////////////////////////////
//      Cache
///////////////////////////////////////////////////////////////////////////////

template
<
   class _T,
   unsigned CacheSize = 16,
   unsigned SpaceSize = 8
>
class Cache
{
public:
   Cache()
    : Pool(CacheSize), VMap(1 << SpaceSize)
   {
    LastLoadedIndex = -1;
    // Проинициализируем пул
    for( int i = 0; i < CacheSize; i++ )
    {
     Pool[i].Index = -1;
     Pool[i].Durty = false;
    }
   };

   virtual ~Cache()
   {
    // сливаем кэш
   };

   _T*  GetData( unsigned Index, bool ForWrite )
   {
    if( VMap[Index] != NULL )
    {
     VMap[Index]->Durty |= ForWrite;
     return &VMap[Index]->Obj;
    }
    else
    {
     // найдём место для загрузки
     unsigned PoolPos = (LastLoadedIndex + 1) % CacheSize;

     if( Pool[PoolPos].Index >= 0 )
     {
      if( Pool[PoolPos].Durty )
      {
       if( !Save( Pool[PoolPos].Index, Pool[PoolPos].Obj ) )
       {
        // ошибка сохранения страницы
        return NULL;
       }
       Pool[PoolPos].Durty = false;
      }
      VMap[Pool[PoolPos].Index] = NULL;
     }

     Pool[PoolPos].Index = Index;

     if( Load( Index, Pool[PoolPos].Obj ) )
     {    //    если загрузили страницу
      LastLoadedIndex = PoolPos;
      VMap[Index] = &Pool[PoolPos];
      VMap[Index]->Durty = ForWrite;
      return &Pool[PoolPos].Obj;
     }
     else
     {
      return NULL;
     }
    }
   };

protected:
   virtual bool  Load( unsigned Index, _T& Ref ) = 0;
   virtual bool  Save( unsigned Index, _T& Ref ) = 0;

private:
   template< class __T >
   struct Container
   {
    __T  Obj;
    int  Index;
    bool Durty;
   };
   vector<Container<_T>>  Pool;
   vector<Container<_T>*> VMap;
   int                LastLoadedIndex;
};

///////////////////////////////////////////////////////////////////////////////
//      PageDevice
///////////////////////////////////////////////////////////////////////////////

template < unsigned PageSize = 16 >
class Page
{
public:
   unsigned char Data[1 << PageSize];
};

template
<   
   unsigned PageSize = 16,   
   unsigned PoolSize = 16,
   unsigned SpaceSize = 8,
   template< class, unsigned, unsigned > class CachePolicy
>
class PageDevice : public CachePolicy< Page<PageSize>, PoolSize, SpaceSize >
{
public:
   static const unsigned __PageCount = 1 << SpaceSize;

   PageDevice()
   {
   };

   virtual ~PageDevice()
   {
   };

protected:
   virtual bool  Load( unsigned Index, Page<PageSize>& Ref ){ return false; };
   virtual bool  Save( unsigned Index, Page<PageSize>& Ref ){ return false; };
};