MemoryStorage.hpp
#if !defined(__MEMORYSTORAGE_HPP)
#define __MEMORYSTORAGE_HPP
/*
CoreLinux++
Copyright (C) 1999,2000 CoreLinux Consortium
The CoreLinux++ Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The CoreLinux++ Library Library is distributed in the hope that it will
be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#if !defined(__COMMON_HPP)
#include <Common.hpp>
#endif
#if !defined(__TRANSIENTSTORAGE_HPP)
#include <TransientStorage.hpp>
#endif
#if !defined(__BOUNDSEXCEPTION_HPP)
#include <BoundsException.hpp>
#endif
namespace corelinux
{
DECLARE_CLASS( MemoryStorage );
class MemoryStorage : public TransientStorage, Synchronized
{
public:
//
// Constructors and destructor
//
MemoryStorage( MemoryIdentifierCref , IntCref , VoidPtr );
//
// Operator overloads
//
bool operator==( MemoryStorageCref ) const;
operator MemoryIdentifierCref( void ) const;
//
// Accessors
//
void operator+( Int ) throw( BoundsException );
void operator-( Int ) throw( BoundsException );
template< class T >
operator T( void ) throw( BoundsException )
{
// Bounds check first
if( Dword( ( BytePtr(theCurrentPointer) + sizeof(T) ) -
BytePtr(theBasePointer)) > Dword(theSize) )
{
throw BoundsException( LOCATION );
}
else
{
; // do nothing
}
return ((T *)theCurrentPointer)[0];
}
template< class T >
operator T*( void ) throw( BoundsException )
{
// Bounds check first
if( Dword( ( BytePtr(theCurrentPointer) + sizeof(T) ) -
BytePtr(theBasePointer)) > Dword(theSize) )
{
throw BoundsException( LOCATION );
}
else
{
; // do nothing
}
return ((T *)theCurrentPointer);
}
//
// Mutators
//
template< class T >
T & operator=( T & aT ) throw( BoundsException )
{
if( Dword( ( BytePtr(theCurrentPointer) + sizeof(T) ) -
BytePtr(theBasePointer)) > Dword(theSize) )
{
throw BoundsException( LOCATION );
}
else
{
; // do nothing
}
GUARD;
std::memmove( theCurrentPointer, &aT, sizeof(T) );
return aT;
}
MemoryStorageRef operator[]( Int offset )
throw( BoundsException );
//
// Traversal operations
//
template < class Type, class Xexec >
void forEach( Xexec aExec ) throw ( Assertion )
{
REQUIRE( aExec != NULLPTR );
GUARD;
Type *pType( (Type *)theBasePointer );
Int maxCount( theSize / sizeof( Type ) );
for( Int x = 0; x < maxCount; ++x, ++pType )
{
(*aExec)(pType);
}
}
template < class Type, class Xexec, class Test >
void forEach( Xexec aExec, Test aTest )
throw ( Assertion )
{
REQUIRE( aExec != NULLPTR );
REQUIRE( aTest != NULLPTR );
GUARD;
Type *pType( (Type *)theBasePointer );
Int maxCount( theSize / sizeof( Type ) );
for( Int x = 0; x < maxCount; ++x, ++pType )
{
if( (*aTest)(pType) == true )
{
(*aExec)(pType);
}
else
{
; // do nothing
}
}
}
protected:
friend class Memory;
MemoryStorage( void ) throw( Assertion );
MemoryStorage( MemoryStorageCref );
virtual ~MemoryStorage( void );
MemoryStorageRef operator=( MemoryStorageCref );
VoidPtr getBasePointer( void );
private:
MemoryIdentifier theIdentifier;
Int theSize;
VoidPtr theBasePointer;
VoidPtr theCurrentPointer;
};
}
#endif // if !defined(__MEMORYSTORAGE_HPP)
/*
Common rcs information do not modify
$Author: frankc $
$Revision: 1.4 $
$Date: 2000/06/10 01:32:17 $
$Locker: $
*/
corelinux::MemoryStorage::operator=
T & operator=(T &aT)
Data assignment.
Definition: MemoryStorage.hpp:134
corelinux::MemoryStorage
MemoryStorage is type of Storage characterized as transient and high speed.
Definition: MemoryStorage.hpp:47
corelinux::TransientStorage
TransientStorage type is an area of storage that will not be saved across system initializations.
Definition: TransientStorage.hpp:41
corelinux::MemoryStorage::MemoryStorage
MemoryStorage(void)
Default is never called.
Definition: MemoryStorage.cpp:33
corelinux::MemoryStorage::operator==
bool operator==(MemoryStorageCref) const
Compares identifier.
Definition: MemoryStorage.cpp:95
corelinux::MemoryStorage::forEach
void forEach(Xexec aExec)
forEach invokes the callers method to perform whatever operation they want on the type reference in t...
Definition: MemoryStorage.hpp:168
corelinux::BoundsException
BoundsException is a type of StorageException, characterized when access to a storage object is inval...
Definition: BoundsException.hpp:42
corelinux
Forward reference the various common classes.
Definition: AbstractAllocator.hpp:32
corelinux::ScalarIdentifier
ScalarIdentifier provides a templated interface for declaring CoreLinux Identifiers for simple scalar...
Definition: ScalarIdentifiers.hpp:37
corelinux::MemoryStorage::operator[]
MemoryStorageRef operator[](Int offset)
Subscript offset operator.
Definition: MemoryStorage.cpp:143
corelinux::MemoryStorage::operator-
void operator-(Int)
Decrement current pointer.
Definition: MemoryStorage.cpp:126
corelinux::Assertion
Assertion is-a Exception created when an assertion fails.
Definition: Assertion.hpp:423
corelinux::Synchronized
Synchronized is a mixin which allows class objects to enable monitor functionality.
Definition: Synchronized.hpp:41
corelinux::MemoryStorage::forEach
void forEach(Xexec aExec, Test aTest)
forEach that invokes the callers method if the callers test method returns true
Definition: MemoryStorage.hpp:192
corelinux::Memory
Memory is high speed transient storage managed by the operating system, for both itself and user proc...
Definition: Memory.hpp:100
corelinux::MemoryStorage::operator+
void operator+(Int)
Increment current pointer.
Definition: MemoryStorage.cpp:109
corelinux::MemoryStorage::getBasePointer
VoidPtr getBasePointer(void)
Internal reference to base.
Definition: MemoryStorage.cpp:153
corelinux::MemoryStorage::~MemoryStorage
virtual ~MemoryStorage(void)
Virtual destructor.
Definition: MemoryStorage.cpp:78

This is the CoreLinux++ reference manual
Provided by The CoreLinux Consortium