  BLOCXX_NAMESPACE::Array< T > | Array<> wraps std::vector<> in COWReference<> adding ref counting and copy on write capability |
  BLOCXX_NAMESPACE::Stack< T > | |
 BLOCXX_NAMESPACE::Array< char const * > | |
| BLOCXX_NAMESPACE::Array< ConverterRef > | |
| BLOCXX_NAMESPACE::Array< LogAppenderRef > | |
| BLOCXX_NAMESPACE::Array< paramEntry > | |
| BLOCXX_NAMESPACE::Array< String > | |
| BLOCXX_NAMESPACE::Atomic_t | |
| BLOCXX_NAMESPACE::AutoDescriptorPolicy | |
| BLOCXX_NAMESPACE::AutoPtr< X > | The AutoPtr class provides a simple class for smart pointers to single objects (for multiple, see AutoPtrVec); it stores a pointer to an object obtained by way of the new operator and deletes that object when the AutoPtr object is destroyed |
| BLOCXX_NAMESPACE::AutoPtr< FormatMsgImpl > | |
| BLOCXX_NAMESPACE::AutoPtr< TempFileBuffer > | |
| BLOCXX_NAMESPACE::AutoPtrVec< X > | The AutoPtrVec class provides a simple class for smart pointers to a dynamically allocated array of objects |
| BLOCXX_NAMESPACE::AutoResource< Policy > | PURPOSE: The AutoResource class template is an analog of std::auto_ptr for managing arbitrary resource handles |
| BLOCXX_NAMESPACE::AutoResourceRef< Policy > | Utility class used in implementing AutoResource operations |
| BLOCXX_NAMESPACE::Bool | Abstraction for the boolean data type |
| BLOCXX_NAMESPACE::Char16 | Abstraction for a double byte character |
| BLOCXX_NAMESPACE::CmdLineParser | Do command line parsing |
| BLOCXX_NAMESPACE::Condition | Synchronization device that allows threads to suspend execution and relinquish the processors until another thread signals the condition |
| BLOCXX_NAMESPACE::COWIntrusiveCountableBase | |
| BLOCXX_NAMESPACE::String::ByteBuf | |
| BLOCXX_NAMESPACE::COWIntrusiveReference< T > | COWIntrusiveReference A smart pointer that uses intrusive reference counting |
| BLOCXX_NAMESPACE::COWIntrusiveReference< ByteBuf > | |
| BLOCXX_NAMESPACE::COWReferenceBase | |
| BLOCXX_NAMESPACE::COWReference< T > | COWReference A smart pointer that uses non-intrusive reference counting |
| BLOCXX_NAMESPACE::COWReference< container_t > | |
| BLOCXX_NAMESPACE::COWReference< L > | |
| BLOCXX_NAMESPACE::COWReference< M > | |
| BLOCXX_NAMESPACE::COWReference< V > | |
| BLOCXX_NAMESPACE::Cstr::CstrArr< SA > | Class for converting values of type S into char const * const * |
| BLOCXX_NAMESPACE::Cstr::CstrArr< Array< S > > | |
| BLOCXX_NAMESPACE::Cstr::CstrArr< EnvVars > | |
| BLOCXX_NAMESPACE::Cstr::CstrStringAux< S, is_char_pointer > | |
| BLOCXX_NAMESPACE::Cstr::CstrStringAux< S, is_char_ptr< S >::value > | |
| BLOCXX_NAMESPACE::Cstr::CstrString< S > | |
| BLOCXX_NAMESPACE::Cstr::CstrStringAux< S, true > | |
| ctassert< b > | |
| ctassert< is_char_ptr< S >::value > | |
| BLOCXX_NAMESPACE::Cstr::CstrArr< S * > | |
| BLOCXX_NAMESPACE::Cstr::CstrArr< S const * > | |
| BLOCXX_NAMESPACE::Cstr::CstrArr< S const [N]> | |
| BLOCXX_NAMESPACE::Cstr::CstrArr< S[N]> | |
| BLOCXX_NAMESPACE::Cstr::ctassert< true > | |
| BLOCXX_NAMESPACE::SelectEngine::Data | |
| BLOCXX_NAMESPACE::DataIStreamBase | |
| BLOCXX_NAMESPACE::DataIStream | |
| BLOCXX_NAMESPACE::DataOStreamBase | |
| BLOCXX_NAMESPACE::DataOStream | |
| BLOCXX_NAMESPACE::DateTime | Abstraction for date time data |
| BLOCXX_NAMESPACE::DefaultConstructorFactory< T > | This class is the default factory for GlobalPtr |
| BLOCXX_NAMESPACE::DefaultVariableConstructorFactory< T, PODType > | |
| BLOCXX_NAMESPACE::DelayedFormat | This is a class similar to the blocxx format, except that all arguments are bound by reference and the formatting is performed at a later point in time |
| BLOCXX_NAMESPACE::DelayedFormatInternals::DelayedFormatReferenceBase | |
| BLOCXX_NAMESPACE::DelayedFormatInternals::DelayedFormatReference< T > | |
| BLOCXX_NAMESPACE::Exec::PreExec::DontCatch | Use this class to allow call() to throw an exception |
| BLOCXX_NAMESPACE::ExceptionDetail::dummy | |
| Enumeration< T > | |
| BLOCXX_NAMESPACE::Enumeration< T > | |
| BLOCXX_NAMESPACE::Enumeration_input_iterator< T > | |
| BLOCXX_NAMESPACE::Enumeration_insert_iterator< T > | |
| BLOCXX_NAMESPACE::EnvVars | Abstraction for a set of environment variables |
| BLOCXX_NAMESPACE::ExceptionDetail::Errno< exType > | |
| BLOCXX_NAMESPACE::Exec::PreExec::Error | |
| exception | |
 BLOCXX_NAMESPACE::Exception | This class is the base of all exceptions thrown by BloCxx code |
 BLOCXX_NAMESPACE::AssertionException | |
| BLOCXX_NAMESPACE::CancellationDeniedException | |
| BLOCXX_NAMESPACE::CmdLineParserException | |
| BLOCXX_NAMESPACE::ConditionLockException | |
| BLOCXX_NAMESPACE::ConditionResourceException | |
| BLOCXX_NAMESPACE::DateTimeException | |
| BLOCXX_NAMESPACE::DeadlockException | |
| BLOCXX_NAMESPACE::EnumerationException | |
| BLOCXX_NAMESPACE::ExecErrorException | |
| BLOCXX_NAMESPACE::ExecBufferFullException | |
| BLOCXX_NAMESPACE::ExecTimeoutException | |
| BLOCXX_NAMESPACE::ExecMockObjectUnimplementedException | |
| BLOCXX_NAMESPACE::FileSystemException | |
| BLOCXX_NAMESPACE::FileSystemMockObjectUnimplementedException | |
| BLOCXX_NAMESPACE::GenericRWLockImplException | |
| BLOCXX_NAMESPACE::InvalidUTF8Exception | |
| BLOCXX_NAMESPACE::IOException | |
| BLOCXX_NAMESPACE::BadSignatureException | |
| BLOCXX_NAMESPACE::LoggerException | |
| BLOCXX_NAMESPACE::LogMessagePatternFormatterException | |
| BLOCXX_NAMESPACE::MD5Exception | |
| BLOCXX_NAMESPACE::NULLValueException | |
| BLOCXX_NAMESPACE::OutOfBoundsException | |
| BLOCXX_NAMESPACE::ProcessErrorException | |
| BLOCXX_NAMESPACE::RegExCompileException | Compilation exception |
| BLOCXX_NAMESPACE::RegExExecuteException | Execution exception |
| BLOCXX_NAMESPACE::RWLockerException | |
| BLOCXX_NAMESPACE::SafeCString::OverflowException | |
| BLOCXX_NAMESPACE::Secure::ProcessAbortException | Secure::ProcessAbortException should be caught only at the top level of the program |
| BLOCXX_NAMESPACE::SelectException | |
| BLOCXX_NAMESPACE::SharedLibraryException | |
| BLOCXX_NAMESPACE::SocketAddressException | |
| BLOCXX_NAMESPACE::SocketException | |
| BLOCXX_NAMESPACE::SSLException | |
| BLOCXX_NAMESPACE::SocketTimeoutException | |
| BLOCXX_NAMESPACE::StringConversionException | |
| BLOCXX_NAMESPACE::ThreadBarrierException | |
| BLOCXX_NAMESPACE::ThreadException | |
| BLOCXX_NAMESPACE::ThreadPoolException | |
| BLOCXX_NAMESPACE::TimeoutException | |
| BLOCXX_NAMESPACE::UnknownHostException | |
| BLOCXX_NAMESPACE::UnnamedPipeException | |
| BLOCXX_NAMESPACE::UUIDException | |
| BLOCXX_NAMESPACE::ExecMockObject | This class can be used to modify/replace the behavior of the Exec functions |
| BLOCXX_NAMESPACE::File | The purpose of the File class is to provide an abstraction layer over the platform dependant functionality related to a file |
| BLOCXX_NAMESPACE::FileSystemMockObject | This class can be used to modify/replace the behavior of the FileSystem functions |
| BLOCXX_NAMESPACE::Format | |
| BLOCXX_NAMESPACE::ExceptionDetail::FormatMsg | |
| BLOCXX_NAMESPACE::ExceptionDetail::FormatMsgImpl | |
| BLOCXX_NAMESPACE::LogMessagePatternFormatterImpl::Formatting | |
| BLOCXX_NAMESPACE::FuncNamePrinter | |
| BLOCXX_NAMESPACE::GenericRWLockImpl< IdT, CompareT > | This class is the implementation of the read/write lock |
| BLOCXX_NAMESPACE::GenericRWLockImpl< Thread_t, ThreadComparer > | |
| BLOCXX_NAMESPACE::GlobalMutexFactory | |
| BLOCXX_NAMESPACE::GlobalPtr< T, FactoryT > | This class can be used to store a global pointer |
| BLOCXX_NAMESPACE::GlobalPtr< T, FactoryT >::InitPtr | |
| BLOCXX_NAMESPACE::LazyGlobal< T, PODType, FactoryT >::InitPtr | |
| BLOCXX_NAMESPACE::Exec::InputCallback | |
| BLOCXX_NAMESPACE::IntrusiveCountableBase | |
| BLOCXX_NAMESPACE::LogAppender | |
| BLOCXX_NAMESPACE::CerrAppender | The CerrAppender is a LogAppender derivative that sends log message to stderr |
| BLOCXX_NAMESPACE::FileAppender | This class sends log messges to a file |
| BLOCXX_NAMESPACE::MultiAppender | This implementation of LogAppender is used to send a Log message to multiple LogAppenders |
| BLOCXX_NAMESPACE::MultiProcessFileAppender | This class sends log messges to a file, for use when there may be multiple processes logging to the same file |
| BLOCXX_NAMESPACE::NullAppender | This class sends log messges to the bit bucket |
| BLOCXX_NAMESPACE::SyslogAppender | This class sends log messges to syslog |
| BLOCXX_NAMESPACE::Logger | Logging interface |
| BLOCXX_NAMESPACE::AppenderLogger | This implementation of Logger is used to send a Log message to multiple LogAppenders |
| BLOCXX_NAMESPACE::CerrLogger | The CerrLogger is a Logger derivative that sends log message to stderr |
| BLOCXX_NAMESPACE::NullLogger | This logger just discards all log messages |
| BLOCXX_NAMESPACE::LogMessagePatternFormatter::Converter | |
| BLOCXX_NAMESPACE::Process | Class for communicating with and managing a child process |
| BLOCXX_NAMESPACE::ProcessImpl | Abstract interface for abstracting details of dealing with a process |
| BLOCXX_NAMESPACE::Runnable | There are two methods for creating a thread of execution in the blocxx systems |
| BLOCXX_NAMESPACE::SelectableCallbackIFC | |
| BLOCXX_NAMESPACE::SelectEngineStopper | |
| BLOCXX_NAMESPACE::SelectableIFC | |
| BLOCXX_NAMESPACE::ServerSocket | |
| BLOCXX_NAMESPACE::ServerSocketImpl | |
| BLOCXX_NAMESPACE::Socket | |
| BLOCXX_NAMESPACE::SocketBaseImpl | |
| BLOCXX_NAMESPACE::SocketImpl | |
| BLOCXX_NAMESPACE::SSLSocketImpl | |
| BLOCXX_NAMESPACE::SharedLibrary | SharedLibrary is a base class for platform classes that implement the functionality of loading and querying shared libraries |
| BLOCXX_NAMESPACE::SharedLibraryLoader | SharedLibraryLoader is the base class for a platform class for loading shared libraries |
| BLOCXX_NAMESPACE::SSLClientCtx | |
| BLOCXX_NAMESPACE::SSLServerCtx | |
| BLOCXX_NAMESPACE::TempFileEnumerationImplBase | |
| BLOCXX_NAMESPACE::TempFileEnumerationImpl< T > | |
| BLOCXX_NAMESPACE::Thread | Descriptions of exceptions thrown assume that the object is used correctly, i.e., method preconditions are satisfied |
| BLOCXX_NAMESPACE::ThreadBarrierImpl | |
| BLOCXX_NAMESPACE::ThreadCounter | |
| BLOCXX_NAMESPACE::ThreadDoneCallback | |
| BLOCXX_NAMESPACE::ThreadCountDecrementer | |
| BLOCXX_NAMESPACE::ThreadPool | Used to coordinate a group of threads |
| BLOCXX_NAMESPACE::ThreadPoolImpl | |
| BLOCXX_NAMESPACE::UnnamedPipe | Abstract interface for an UnnamedPipe |
| BLOCXX_NAMESPACE::PosixUnnamedPipe | |
| BLOCXX_NAMESPACE::IntrusiveReference< T > | |
| BLOCXX_NAMESPACE::IntrusiveReference< IntrusiveCountableBase > | |
| BLOCXX_NAMESPACE::IntrusiveReference< LogAppender > | |
| BLOCXX_NAMESPACE::IntrusiveReference< ProcessImpl > | |
| BLOCXX_NAMESPACE::IntrusiveReference< SelectableCallbackIFC > | |
| BLOCXX_NAMESPACE::IntrusiveReference< ServerSocketImpl > | |
| BLOCXX_NAMESPACE::IntrusiveReference< SharedLibrary > | |
| BLOCXX_NAMESPACE::IntrusiveReference< SocketBaseImpl > | |
| BLOCXX_NAMESPACE::IntrusiveReference< SSLClientCtx > | |
| BLOCXX_NAMESPACE::IntrusiveReference< SSLServerCtx > | |
| BLOCXX_NAMESPACE::IntrusiveReference< TempFileEnumerationImpl< T > > | |
| BLOCXX_NAMESPACE::IntrusiveReference< ThreadBarrierImpl > | |
| BLOCXX_NAMESPACE::IntrusiveReference< ThreadCounter > | |
| BLOCXX_NAMESPACE::IntrusiveReference< ThreadPoolImpl > | |
| BLOCXX_NAMESPACE::IntrusiveReference< UnnamedPipe > | |
| BLOCXX_NAMESPACE::IOIFC | |
| BLOCXX_NAMESPACE::Socket | |
| BLOCXX_NAMESPACE::SocketBaseImpl | |
| BLOCXX_NAMESPACE::UnnamedPipe | Abstract interface for an UnnamedPipe |
| iostream | |
| BLOCXX_NAMESPACE::TempFileStream | TempFileStream is an iostream that uses an underlying temp file to hold its content to reduce memory requirements |
| BLOCXX_NAMESPACE::Cstr::is_char_ptr< S > | |
| BLOCXX_NAMESPACE::Cstr::is_char_ptr< char * > | |
| BLOCXX_NAMESPACE::Cstr::is_char_ptr< char const * > | |
| BLOCXX_NAMESPACE::Cstr::is_char_ptr< char const [N]> | |
| BLOCXX_NAMESPACE::Cstr::is_char_ptr< char[N]> | |
| istream | |
| BLOCXX_NAMESPACE::DataIStream | |
| BLOCXX_NAMESPACE::IFileStream | The purpose of this class is to provide an alternative implementation of std::ifstream that is based on a FILE*, and can be created using a FILE*, a raw file descriptor or an instance of blocxx::File |
| BLOCXX_NAMESPACE::IStringStream | |
| BLOCXX_NAMESPACE::IstreamBufIterator | This class differs from a std::istreambuf_iterator in that dereferncing an eof iterator returns 0 This class is mostly just a replacement for std::istreambuf_iterator<>, since it doesn't exist in the gcc 2.95.x standard lib |
| BLOCXX_NAMESPACE::IStringStreamBase | |
| BLOCXX_NAMESPACE::IStringStream | |
| BLOCXX_NAMESPACE::LazyGlobal< T, PODType, FactoryT > | This class can be used to store a global variable that is lazily initialized in a thread safe manner |
| BLOCXX_NAMESPACE::LazyGlobal< Socket::ShutDownMechanism_t, int, ShutDownMechanismFactory > | |
| less< T > | |
| List< T > | |
| BLOCXX_NAMESPACE::List< T > | This class is a wrapper around std::list<> and adds COW capabilities |
| BLOCXX_NAMESPACE::GenericRWLockImpl< IdT, CompareT >::LockerInfo | |
| BLOCXX_NAMESPACE::LogAppenderScope | The purpose of this class is to change the current thread's global LogAppenderRef during an instance's lifetime |
| BLOCXX_NAMESPACE::LogMessage | |
| BLOCXX_NAMESPACE::LogMessagePatternFormatter | |
| Map< Key, T, Compare > | |
| BLOCXX_NAMESPACE::Map< Key, T, Compare > | |
| BLOCXX_NAMESPACE::Map< String, String > | |
| BLOCXX_NAMESPACE::MD5::MD5_CTX | |
| BLOCXX_NAMESPACE::MD5OStreamBase | |
| BLOCXX_NAMESPACE::MD5 | |
| BLOCXX_NAMESPACE::Mutex | |
| BLOCXX_NAMESPACE::MutexLock | |
| BLOCXX_NAMESPACE::LogConfigOptions::NameAndDefault | |
| BLOCXX_NAMESPACE::NonRecursiveMutex | Note that descriptions of what exceptions may be thrown assumes that object is used correctly, i.e., method preconditions are satisfied |
| BLOCXX_NAMESPACE::NonRecursiveMutexLock | Note that descriptions of what exceptions may be thrown assumes that object is used correctly, i.e., method preconditions are satisfied |
| BLOCXX_NAMESPACE::Exec::Impl::NullFactory | |
| BLOCXX_NAMESPACE::FileSystem::NullFactory | |
| BLOCXX_NAMESPACE::NwIface | |
| BLOCXX_NAMESPACE::CmdLineParser::Option | |
| ostream | |
| BLOCXX_NAMESPACE::DataOStream | |
| BLOCXX_NAMESPACE::MD5 | |
| BLOCXX_NAMESPACE::OStringStream | |
| BLOCXX_NAMESPACE::OStringStreamBase | |
| BLOCXX_NAMESPACE::OStringStream | |
| BLOCXX_NAMESPACE::Exec::OutputCallback | |
| BLOCXX_NAMESPACE::Exec::PreExec | This class is used to specify what spawn() should do between fork and exec |
| BLOCXX_NAMESPACE::PosixExec::StandardPreExec | |
| BLOCXX_NAMESPACE::PosixExec::SystemPreExec | |
| BLOCXX_NAMESPACE::WinExec::WinStandardPreExec | |
| BLOCXX_NAMESPACE::WinExec::WinSystemPreExec | |
| BLOCXX_NAMESPACE::IstreamBufIterator::proxy | |
| BLOCXX_NAMESPACE::RandomNumber | |
| BLOCXX_NAMESPACE::ReadLock | |
| BLOCXX_NAMESPACE::RefCount | |
| BLOCXX_NAMESPACE::RefCountedPimpl< Impl > | PURPOSE: Make it easy to define immutable classes or handle classes, making it inexpensive to copy them, while keeping implementation details out of the header file |
| BLOCXX_NAMESPACE::ReferenceBase | |
| BLOCXX_NAMESPACE::Reference< T > | |
| BLOCXX_NAMESPACE::Reference< DelayedFormat > | |
| BLOCXX_NAMESPACE::RefToValue< T > | Transports a reference as a value Serves to implement the Colvin/Gibbons trick for SmartPtr/ScopeGuard |
| BLOCXX_NAMESPACE::Process::Status::Repr | |
| BLOCXX_NAMESPACE::RWLocker | |
| BLOCXX_NAMESPACE::ScopeGuardImplBase | |
| BLOCXX_NAMESPACE::ObjScopeGuardImpl0< Obj, MemFun > | |
| BLOCXX_NAMESPACE::ObjScopeGuardImpl1< Obj, MemFun, P1 > | |
| BLOCXX_NAMESPACE::ObjScopeGuardImpl2< Obj, MemFun, P1, P2 > | |
| BLOCXX_NAMESPACE::ScopeGuardImpl0< F > | |
| BLOCXX_NAMESPACE::ScopeGuardImpl1< F, P1 > | |
| BLOCXX_NAMESPACE::ScopeGuardImpl2< F, P1, P2 > | |
| BLOCXX_NAMESPACE::ScopeGuardImpl3< F, P1, P2, P3 > | |
| BLOCXX_NAMESPACE::ScopeLogger | This is a fairly simple class that will log a message when created and when destroyed |
| BLOCXX_NAMESPACE::SelectEngine | |
| BLOCXX_NAMESPACE::Select::SelectObject | |
| BLOCXX_NAMESPACE::Semaphore | |
| BLOCXX_NAMESPACE::SharedLibraryReference< T > | |
| BLOCXX_NAMESPACE::Socket::ShutDownMechanismFactory | |
| BLOCXX_NAMESPACE::SignalScope | |
| BLOCXX_NAMESPACE::SocketAddress | |
| SortedVectorMap< Key, T, Compare > | |
| BLOCXX_NAMESPACE::SortedVectorMap< Key, T, Compare > | |
| BLOCXX_NAMESPACE::SortedVectorMap< int, StringArray > | |
| BLOCXX_NAMESPACE::SortedVectorMap< Select_t, Data > | |
| BLOCXX_NAMESPACE::SortedVectorMapDataCompare< Key, T, Compare > | |
| SortedVectorMapDataCompare< Key, T, Compare > | |
| SortedVectorSet< T, Compare > | |
| BLOCXX_NAMESPACE::SortedVectorSet< T, Compare > | |
| BLOCXX_NAMESPACE::SortedVectorSet< String > | |
| StaticAssertionFailure< x > | |
| BLOCXX_NAMESPACE::StaticAssertionFailure< true > | |
| BLOCXX_NAMESPACE::Process::Status | Portable process status |
| streambuf | |
| BLOCXX_NAMESPACE::BaseStreamBuffer | |
| BLOCXX_NAMESPACE::FileBuf | The purpose of this class is to provide an alternative implementation of std::filebuf that is based on a FILE*, and can be created using a FILE*, a raw file descriptor or an instance of blocxx::File |
| BLOCXX_NAMESPACE::IFileStream | The purpose of this class is to provide an alternative implementation of std::ifstream that is based on a FILE*, and can be created using a FILE*, a raw file descriptor or an instance of blocxx::File |
| BLOCXX_NAMESPACE::IOIFCStreamBuffer | DO NOT DERIVE FROM THIS CLASS, as the dtor has to call a virtual fct |
| BLOCXX_NAMESPACE::SocketStreamBuffer | |
| BLOCXX_NAMESPACE::OStringStreamBuf | |
| BLOCXX_NAMESPACE::DataIStreamBuf | |
| BLOCXX_NAMESPACE::DataOStreamBuf | |
| BLOCXX_NAMESPACE::IStringStreamBuf | |
| BLOCXX_NAMESPACE::MD5StreamBuffer | |
| BLOCXX_NAMESPACE::TempFileBuffer | |
| BLOCXX_NAMESPACE::String | This String class is an abstract data type that represents as NULL terminated string of characters |
| BLOCXX_NAMESPACE::StringArrayConstructorFactory | |
| BLOCXX_NAMESPACE::StringBuffer | |
| BLOCXX_NAMESPACE::ThreadBarrierImpl::SubBarrier | This code is inspired by ACE, by Douglas C |
| BLOCXX_NAMESPACE::ThreadBarrier | Used to synchronize threads |
| BLOCXX_NAMESPACE::ThreadCancelledException | In the event a thread has been cancelled, a ThreadCancelledException will be thrown |
| BLOCXX_NAMESPACE::RWLocker::ThreadComparer | |
| BLOCXX_NAMESPACE::Timeout | A timeout can be absolute, which means that it will happen at the specified DateTime |
| BLOCXX_NAMESPACE::TimeoutTimer | A TimeoutTimer is used by an algorithm to determine when a timeout has expired |
| BLOCXX_NAMESPACE::UUID | UUIDs (Universally Unique IDentifiers), also known as GUIDs (Globally Unique IDentifiers), are 128 bits long |
| BLOCXX_NAMESPACE::WriteLock | |
1.8.2