gecko-dev/lib/libaddr/abthumb.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

/* file: abthumb.cpp
** Some portions derive from public domain IronDoc code and interfaces.
**
** Changes:
** <0> 09Mar1998 first implementation
*/

#ifndef _ABTABLE_
#include "abtable.h"
#endif

#ifndef _ABMODEL_
#include "abmodel.h"
#endif

/*3456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678*/

/* ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- */

#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	static const char* ab_Thumb_kClassName /*i*/ = "ab_Thumb";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/

#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	static const char* AB_Thumb_kClassName /*i*/ = "AB_Thumb";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/

/*=============================================================================
 * ab_Thumb: import or export position
 */

// ````` ````` ````` `````   ````` ````` ````` `````  
// virtual ab_Object methods

char* ab_Thumb::ObjectAsString(ab_Env* ev, char* outXmlBuf) const /*i*/
{
	AB_USED_PARAMS_1(ev);
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	const char* conflictsName = mThumb_ConflictReportFileName;
	if ( !conflictsName )
		conflictsName = "";
		
	sprintf(outXmlBuf,
		"<ab_Thumb:str me=\"^%lX\" map=\"^%lX\" fp=\"#%lX\" rp=\"%lu\" rl=\"%lu\" bl=\"%lu\" cf=\"%.16s/^%lX\" form=\"%.4s\" rc=\"%lu\" a=\"%.9s\" u=\"%.9s\"/>",
		(long) this,                      // me=\"^%lX\"
		(long) mThumb_ListPosMap,         // map=\"^%lX\"

		(long) mThumb_FilePos,            // fp=\"#%lX\"
		(long) mThumb_RowPos,             // rp=\"%lu\"
		(long) mThumb_RowCountLimit,      // rl=\"%lu\"
		(long) mThumb_ByteCountLimit,     // bl=\"%lu\"
		
		conflictsName,                    // cf=\"%.16s
		(long) mThumb_ReportFile,         // /^%lX\"
	
		(const char*) &mThumb_FileFormat, // form=\"%.4s\"
		
		(unsigned long) mObject_RefCount,    // rc=\"%lu\"
		this->GetObjectAccessAsString(),     // ac=\"%.9s\"
		this->GetObjectUsageAsString()       // us=\"%.9s\"
		);
#else
	*outXmlBuf = 0; /* empty string */
#endif /*AB_CONFIG_TRACE_orDEBUG_orPRINT*/
	return outXmlBuf;
}

void ab_Thumb::CloseObject(ab_Env* ev) /*i*/
{
	if ( this->IsOpenObject() )
	{
		this->MarkClosing();
		this->CloseThumb(ev);
		this->MarkShut();
	}
}

void ab_Thumb::PrintObject(ab_Env* ev, ab_Printer* ioPrinter) const /*i*/
{
#ifdef AB_CONFIG_PRINT
	ioPrinter->PutString(ev, "<ab_Thumb>");
	char xmlBuf[ ab_Object_kXmlBufSize + 2 ];

	if ( this->IsOpenObject() )
	{
		ioPrinter->PushDepth(ev); // indent all objects in the list

		ioPrinter->NewlineIndent(ev, /*count*/ 1);
		ioPrinter->PutString(ev, this->ObjectAsString(ev, xmlBuf));
		
		if ( mThumb_ListPosMap )
		{
			ioPrinter->NewlineIndent(ev, /*count*/ 1);
			mThumb_ListPosMap->PrintObject(ev, ioPrinter);
		}
		if ( mThumb_ReportFile )
		{
			ioPrinter->NewlineIndent(ev, /*count*/ 1);
			mThumb_ReportFile->PrintObject(ev, ioPrinter);
		}
		
		ioPrinter->PopDepth(ev); // stop indentation
	}
	else // use ab_Object::ObjectAsString() for non-objects:
	{
		ioPrinter->PutString(ev, this->ab_Object::ObjectAsString(ev, xmlBuf));
	}
	ioPrinter->NewlineIndent(ev, /*count*/ 1);
	ioPrinter->PutString(ev, "</ab_Thumb>");
#else /*AB_CONFIG_PRINT*/
	AB_USED_PARAMS_2(ev, ioPrinter);
#endif /*AB_CONFIG_PRINT*/
}

ab_Thumb::~ab_Thumb() /*i*/
{
	AB_ASSERT(mThumb_ListPosMap==0);
	AB_ASSERT(mThumb_ReportFile==0);
	AB_ASSERT(mThumb_ConflictReportFileName==0);
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	ab_Object* obj = mThumb_ListPosMap;
	if ( obj )
		obj->ObjectNotReleasedPanic(ab_Thumb_kClassName);
		
	obj = mThumb_ReportFile;
	if ( obj )
		obj->ObjectNotReleasedPanic(ab_Thumb_kClassName);
#endif /*AB_CONFIG_TRACE_orDEBUG_orPRINT*/
}
    
// ````` ````` ````` `````   ````` ````` ````` `````  
// non-poly ab_Thumb methods

ab_Thumb::ab_Thumb(ab_Env* ev, const ab_Usage& inUsage) /*i*/
	: ab_Object(inUsage)
,	mThumb_ListPosMap( 0 )

,	mThumb_ImportConflictPolicy( 0 )
,	mThumb_ConflictReportFileName( 0 )
,	mThumb_ReportFile( 0 )

,	mThumb_FilePos( 0 )
,	mThumb_RowPos( 0 )
,	mThumb_RowCountLimit( 0xFFFFFFFF ) // very large ("all the rows")
,	mThumb_ByteCountLimit( 0xFFFFFFFF ) // very large ("all the file bytes")

,   mThumb_ImportFileLength( 0 ) // total file bytes to be imported
,   mThumb_ExportTotalRowCount( 0 ) // total rows to be exported

,	mThumb_CurrentPass( 0 ) // have not started first pass yet
,	mThumb_FileFormat( ab_File_kLdifFormat )
	
,   mThumb_ListCountInFirstPass( 0 )
,   mThumb_ListCountInSecondPass( 0 )

,   mThumb_PortingCallCount( 0 ) // times ImportLdif() or ExportLdif() is called
,   mThumb_HavePreparedSecondPass( AB_kFalse )
{
	AB_USED_PARAMS_1(ev);
}

static const char*
ab_Thumb_kDefaultConflictReportFileName = "ab.import.conflicts";

void ab_Thumb::determine_import_conflict_policy(ab_Env* ev) /*i*/
{
	ab_Env_BeginMethod(ev, ab_Thumb_kClassName,
		"determine_import_conflict_policy")
	
	if ( !mThumb_ConflictReportFileName )
	{
		ab_policy policy = (ab_policy) AB_Policy_ImportConflicts_kDefault;
		char nameBuf[ AB_Env_kConflictReportFileNameSize ];
		const char* name = ab_Thumb_kDefaultConflictReportFileName;
		AB_Env* cev = ev->AsSelf();
		AB_Env_mImportConflictPolicy fun = cev->sEnv_ImportConflictPolicy;
		if ( fun )
		{
			policy = (*fun)(cev, nameBuf);
			nameBuf[ AB_Env_kConflictReportFileNameSize - 1 ] = 0; // force end
			if ( ev->Good() )
				name = nameBuf;
				
			if ( policy > (ab_policy) AB_Policy_ImportConflicts_kMax )
				policy = (ab_policy) AB_Policy_ImportConflicts_kDefault;
		}
		mThumb_ImportConflictPolicy = policy;
		mThumb_ConflictReportFileName = ev->CopyString(name);
	}
	
	ab_Env_EndMethod(ev)
}
    	
ab_policy ab_Thumb::GetImportConflictPolicy(ab_Env* ev) /*i*/
{
	ab_policy outPolicy = mThumb_ImportConflictPolicy;
	if ( !outPolicy )
	{
		ab_Env_BeginMethod(ev, ab_Thumb_kClassName, "GetImportConflictPolicy")
		
		this->determine_import_conflict_policy(ev);
		outPolicy = mThumb_ImportConflictPolicy;
		if ( !outPolicy )
			outPolicy = AB_Policy_ImportConflicts_kDefault;

		ab_Env_EndMethod(ev)
	}
	return outPolicy;
}

const char* ab_Thumb::GetConflictReportFileName(ab_Env* ev) /*i*/
{
	const char* outName = mThumb_ConflictReportFileName;
	if ( !outName )
	{
		ab_Env_BeginMethod(ev, ab_Thumb_kClassName, "GetConflictReportFileName")
		
		this->determine_import_conflict_policy(ev);
		outName = mThumb_ConflictReportFileName;
		if ( !outName )
			outName = ab_Thumb_kDefaultConflictReportFileName;
		
		ab_Env_EndMethod(ev)
	}
	return outName;
}

ab_StdioFile* ab_Thumb::GetReportFile(ab_Env* ev) /*i*/
{
	ab_StdioFile* outFile = mThumb_ReportFile;
	if ( !outFile )
	{
		ab_Env_BeginMethod(ev, ab_Thumb_kClassName, "GetReportFile")
		
		const char* fileName = this->GetConflictReportFileName(ev);
		if ( fileName && ev->Good() )
		{
			ab_StdioFile* file = new(*ev)
				ab_StdioFile(ev, ab_Usage::kHeap, fileName, "a+");
			if ( file )
			{
				if ( ev->Good() )
					mThumb_ReportFile = file;
				else
					file->ReleaseObject(ev);
			}
		}
		
		outFile = mThumb_ReportFile;
		ab_Env_EndMethod(ev)
	}
	return outFile;
}

ab_IntMap* ab_Thumb::GetListPosMap(ab_Env* ev) /*i*/
	// Get the hash table that maps list uids to file positions.
	// This method creates this object lazily on the first request, and
	// then keeps the map until the thumb is closed.  If one wishes to
	// know whether there is any content without forcing this table to
	// exist, one can call GetMappedListUidCount() to get the number of
	// lists that have been mapped, which can avoid creating the map.
{
	ab_IntMap* outIntMap = mThumb_ListPosMap;
	if ( !outIntMap )
	{
		ab_Env_BeginMethod(ev, ab_Thumb_kClassName, "GetListPosMap")
		
		ab_IntMap* map = new(*ev)
			ab_IntMap(ev, ab_Usage::kHeap, /*inKeyMethods*/ 0,
			ab_IntMap_kMailingListImportHint);
		
		if ( map )
		{
			if ( ev->Good() )
				mThumb_ListPosMap = outIntMap = map;
			else
				map->ReleaseObject(ev);
		}
		
		ab_Env_EndMethod(ev)
	}
	return outIntMap;
}

ab_num ab_Thumb::PickHeuristicStreamBufferSize() const /*i*/
	// Typically returns ab_Thumb_kNormalSteamBufSize except when values
	// of either (or both) mThumb_RowCountLimit and mThumb_ByteCountLimit
	// imply substantially more or less buffer space might make more sense.
	// Bounded by kMin and kMax values defined near kNormalSteamBufSize.
	// For sizing purposes, average row size is assumed kAverageRowSize.
{
	ab_num outSize = ab_Thumb_kNormalSteamBufSize; // default value
	
	// pick larger of expected bytes or expected row record size
	ab_num expected = mThumb_ByteCountLimit;
	
	ab_num rows = mThumb_RowCountLimit;
	if ( rows < ab_Thumb_kMaxSteamBufSize ) // multiply if not already huge
		rows *= ab_Thumb_kAverageRowSize;
	
	if ( rows > expected )
		expected = rows;
		
	if ( expected < outSize ) // seem to need less buffer space?
	{
		ab_num diff = outSize - expected;
		if ( diff > 1024 ) // difference seems sizeable?
		{
			outSize = expected + 1024; // allow for a bit extra
			if ( outSize < ab_Thumb_kMinSteamBufSize ) // below min?
				outSize = ab_Thumb_kMinSteamBufSize; // no less than this
		}   
	}
	else if ( expected > outSize ) // seem to need more buffer space?
	{
		if ( expected > ab_Thumb_kMaxSteamBufSize )
			outSize = ab_Thumb_kMaxSteamBufSize; // no more than this
		else
		{
			outSize = expected + 1024; // allow for a bit extra
			if ( outSize > ab_Thumb_kMaxSteamBufSize ) // above max?
				outSize = ab_Thumb_kMaxSteamBufSize; // no more than this
		}
	}
	return outSize;
}


void ab_Thumb::CloseThumb(ab_Env* ev) /*i*/
{
	ab_Env_BeginMethod(ev, ab_Thumb_kClassName, "CloseThumb")

	ab_Object* obj = mThumb_ListPosMap;
  	if ( obj )
  	{
  		mThumb_ListPosMap = 0;
  		obj->ReleaseObject(ev);
  	}
  	
  	obj = mThumb_ReportFile;
  	if ( obj )
  	{
  		if ( mThumb_ReportFile->IsOpenAndActiveFile() )
  			mThumb_ReportFile->Flush(ev);
  			
  		mThumb_ReportFile->CloseStdio(ev);
  		
  		mThumb_ReportFile = 0;
  		obj->ReleaseObject(ev);
  	}
  	
  	char* name = mThumb_ConflictReportFileName;
  	if ( name )
  	{
  		mThumb_ConflictReportFileName = 0;
  		ev->FreeString(name);
  	}

	ab_Env_EndMethod(ev)
}


/*=============================================================================
 * ab_IntMap: collection of assocs from key uid to value uid 
 */

/*3456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678*/

/* ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- */

#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	static const char* ab_IntMap_kClassName /*i*/ = "ab_IntMap";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/

#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	static const char* ab_IntMapIter_kClassName /*i*/ = "ab_IntMapIter";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/


// ````` ````` ````` `````   ````` ````` ````` `````  
// public: // virtual ab_Object methods

char* ab_IntMap::ObjectAsString(ab_Env* ev, char* outXmlBuf) const /*i*/
{
	AB_USED_PARAMS_1(ev);
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
	XP_SPRINTF(outXmlBuf,
		"<ab_IntMap:str me=\"^%lX\" chg=\"%lu\" cap:thr=\"%lu:%lu\" cnt=\"%lu\" k:v=\"^%lX:^%lX\" rc=\"%lu\" a=\"%.9s\" u=\"%.9s\"/>",
		(long) this,                             // me=\"^%lX\"
		(long) mIntMap_ChangeCount,              // chg=\"%lu\"
		(long) mIntMap_Capacity,                 // cap:thr=\"%lu
		(long) mIntMap_Threshold,                // :%lu\"
		(long) mIntMap_AssocCount,               // cnt=\"%lu\"
		(long) mIntMap_KeyInts,                  // k:v=\"^%lX
		(long) mIntMap_ValueInts,                // :^%lX\"
		
		(unsigned long) mObject_RefCount,        // rc=\"%lu\"
		this->GetObjectAccessAsString(),         // ac=\"%.9s\"
		this->GetObjectUsageAsString()           // us=\"%.9s\"
		);
#else
	*outXmlBuf = 0; /* empty string */
#endif /*AB_CONFIG_TRACE_orDEBUG_orPRINT*/
	return outXmlBuf;
}

void ab_IntMap::CloseObject(ab_Env* ev) /*i*/
{
	if ( this->IsOpenObject() )
	{
		this->MarkClosing();
		this->CloseIntMap(ev);
		this->MarkShut();
	}
}

void ab_IntMap::PrintObject(ab_Env* ev, ab_Printer* ioPrinter) const /*i*/
{
#ifdef AB_CONFIG_PRINT
	ioPrinter->PutString(ev, "<ab_IntMap>");
	char xmlBuf[ ab_Object_kXmlBufSize + 2 ];

	if ( this->IsOpenObject() )
	{
		ioPrinter->NewlineIndent(ev, /*count*/ 1);
		ioPrinter->PutString(ev, this->ObjectAsString(ev, xmlBuf));
		
		ab_map_int* keys = mIntMap_KeyInts;
		if ( keys ) // any associations?
		{
			ab_map_int* end = keys + mIntMap_Capacity; // one past last bucket
			
			--keys; // prepare for preincrement

			ioPrinter->PushDepth(ev); // indent all buckets
			
			ab_error_count ec = ev->ErrorCount();
			while ( ++keys < end && ec <= ev->ErrorCount() )
			{
				ab_map_int k = *keys;
				if ( k ) // is this bucket in use?
				{
					ab_u4 actual = keys - mIntMap_KeyInts;
					ab_u4 hash = this->hash_bucket(ev, k);

					if ( mIntMap_ValueInts ) // print the value too?
					{
						ab_map_int v = mIntMap_ValueInts[ actual ];
						(*mIntMap_AssocString)(ev, k, v, xmlBuf, hash, actual);
						
						//XP_SPRINTF(xmlBuf,
						//"<ab_IntMap:assoc pair=\"#%lX:#%lX\" bucket=\"%lu->%lu\"/>",
						//	(long) k,             // pair=\"#%lX
						//	(long) v,             // :#%lX\"
						//	(long) hashBucket,    // bucket=\"%lu
						//	(long) actualBucket   // ->%lu\"
						//);
					}
					else // each bucket contains only a key
					{
						ab_map_int v = ab_IntMap_kPretendValue;
						(*mIntMap_AssocString)(ev, k, v, xmlBuf, hash, actual);
						//XP_SPRINTF(xmlBuf,
						//"<ab_IntMap:elem key=\"#%lX\" bucket=\"%lu->%lu\"/>",
						//	(long) k,             // key=\"#%lX\"
						//	(long) hashBucket,  // bucket=\"%lu
						//	(long) actualBucket   // ->%lu\"
						//);
					}
					ioPrinter->NewlineIndent(ev, /*count*/ 1);
					ioPrinter->PutString(ev, xmlBuf);
				}
			}
			ioPrinter->PopDepth(ev); // stop bucket indentation
		}
	}
	else // use ab_Object::ObjectAsString() for non-objects:
	{
		ioPrinter->PutString(ev, this->ab_Object::ObjectAsString(ev, xmlBuf));
	}
	ioPrinter->NewlineIndent(ev, /*count*/ 1);
	ioPrinter->PutString(ev, "</ab_IntMap>");
#else /*AB_CONFIG_PRINT*/
	AB_USED_PARAMS_2(ev,ioPrinter);
#endif /*AB_CONFIG_PRINT*/
}

ab_IntMap::~ab_IntMap() /*i*/
{
	AB_ASSERT(mIntMap_KeyInts==0);
	AB_ASSERT(mIntMap_ValueInts==0);
}

// ````` ````` ````` `````   ````` ````` ````` `````  
// private: // private non-poly ab_IntMap helper methods

void ab_IntMap::grow_int_map(ab_Env* ev) /*i*/
	// increase capacity by some percentage
{
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "grow_int_map")

  	if ( mIntMap_AssocCount >= mIntMap_Threshold )
  	{
  		ab_num oldThreshold = mIntMap_Threshold; // save before we modify 
  		ab_num newSizeHint = ( mIntMap_Threshold * 4 ) / 3; // 33% growth
  		mIntMap_Threshold = newSizeHint; // temporarily bigger during copy:
  		
  		ab_IntMap biggerCopy(ev, ab_Usage::kStack, newSizeHint, *this);
  		mIntMap_Threshold = oldThreshold; // restore original value
 
 #ifdef AB_CONFIG_TRACE
		if ( ev->DoTrace() )
		{
			this->TraceObject(ev);
			biggerCopy.TraceObject(ev);
		}
#endif /*AB_CONFIG_TRACE*/
 		
  		if ( ev->Good() && biggerCopy.mIntMap_KeyInts ) // successful growth?
  		{
  			// swap vital statistics and storage, to become the biggerCopy
  			
  			ab_map_int* oldKeys = mIntMap_KeyInts;            // save for swap
  			ab_map_int* oldValues = mIntMap_ValueInts;        // save for swap
  			
  			mIntMap_KeyInts = biggerCopy.mIntMap_KeyInts;     // transfer
  			mIntMap_ValueInts = biggerCopy.mIntMap_ValueInts; // transfer
  			
  			biggerCopy.mIntMap_KeyInts = oldKeys;             // to be freed
  			biggerCopy.mIntMap_ValueInts = oldValues;         // to be freed
  			
  			mIntMap_ChangeCount++; // note change (don't copy from biggerCopy)
  			
  			mIntMap_Threshold = biggerCopy.mIntMap_Threshold;
  			mIntMap_Capacity = biggerCopy.mIntMap_Capacity;
  			
#ifdef AB_CONFIG_DEBUG
  			if ( mIntMap_AssocCount != biggerCopy.mIntMap_AssocCount ) // drift?!
  			{
				ev->Break(
					"<ab_IntMap::grow_int_map:drift old=\"%lu\" new=\"%lu\"/>",
					(long) mIntMap_AssocCount,
					(long) biggerCopy.mIntMap_AssocCount);
				this->BreakObject(ev);
			}
#endif /*AB_CONFIG_DEBUG*/
  			
  			mIntMap_AssocCount = biggerCopy.mIntMap_AssocCount;
  		}
  		
  		biggerCopy.CloseIntMap(ev); // deallocate vectors in this map
  	}

	ab_Env_EndMethod(ev)
}

ab_bool ab_IntMap::init_with_size(ab_Env* ev, const ab_KeyMethods* inKeyMethods, 
	ab_num inSizeHint) /*i*/
{
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "init_with_size")
	
	if ( inKeyMethods )
	{
		mIntMap_Hash = inKeyMethods->mKeyMethods_Hash;
		mIntMap_Equal = inKeyMethods->mKeyMethods_Equal;
		mIntMap_AssocString = inKeyMethods->mKeyMethods_AssocString;
	}

	if ( mIntMap_KeyInts )
	{
		ev->HeapFree(mIntMap_KeyInts);
		mIntMap_KeyInts = 0;
	}
	if ( mIntMap_ValueInts )
	{
		mIntMap_HasValuesToo = AB_kTrue;
		ev->HeapFree(mIntMap_ValueInts);
		mIntMap_ValueInts = 0;
	}
	mIntMap_AssocCount = 0;
	mIntMap_Capacity = 0;
	mIntMap_Threshold = 0;
	if ( ev->Good() ) // proceed to allocate key and value int arrays?
	{
		ab_num capacity = (inSizeHint * 5) / 4; // one quarter more (25%)
		mIntMap_Threshold = inSizeHint;
		mIntMap_Capacity = capacity;
		
		ab_num volume = capacity * sizeof(ab_map_int); // bytes in each array
		mIntMap_KeyInts = (ab_map_int*) ev->HeapAlloc(volume);
		if ( mIntMap_KeyInts ) // allocated keys?
		{
			AB_MEMSET(mIntMap_KeyInts, 0, volume); // fill with all zeroes
 
			if ( mIntMap_HasValuesToo ) // need to allocate values vector?
			{
				mIntMap_ValueInts = (ab_map_int*) ev->HeapAlloc(volume);
				if ( mIntMap_ValueInts ) // allocated values?
					AB_MEMSET(mIntMap_ValueInts, 0, volume); // zero all
			}
		}
	}

	ab_Env_EndMethod(ev)
	return ev->Good();
}

// ````` ````` ````` `````   ````` ````` ````` `````  
// public: // non-poly ab_IntMap methods

ab_IntMap::ab_IntMap(ab_Env* ev, const ab_Usage& inUsage, /*i*/
	const ab_KeyMethods* inKeyMethods, ab_num inSizeHint)
	: ab_Object(inUsage),
	mIntMap_ChangeCount( 0 ),
	mIntMap_Threshold( 0 ),
	mIntMap_Capacity( 0 ),
	mIntMap_AssocCount( 0 ),
	mIntMap_KeyInts( 0 ),
	mIntMap_ValueInts( 0 ),
	
	mIntMap_Hash( 0 ),
	mIntMap_Equal( 0 ),
	mIntMap_AssocString( 0 ),
	
	mIntMap_HasValuesToo( AB_kFalse )

	// defaults to supporting values in addition to keys.  inSizeHint
	// is capped between kMinSizeHin and kMaxSizeHint, and this becomes
	// the new threshold, with capacity equal to 25% more.
{
	if ( inSizeHint < ab_IntMap_kMinSizeHint )
		inSizeHint = ab_IntMap_kMinSizeHint;
	else if ( inSizeHint > ab_IntMap_kMaxSizeHint )
		inSizeHint = ab_IntMap_kMaxSizeHint;
	
	if ( inKeyMethods )
		this->init_with_size(ev, inKeyMethods, inSizeHint);
	else
	{
		ab_KeyMethods defaults(ab_Env_HashKey, ab_Env_EqualKey, ab_Env_AssocString);
		this->init_with_size(ev, &defaults, inSizeHint);
	}
}

ab_IntMap::ab_IntMap(ab_Env* ev, const ab_Usage& inUsage, /*i*/
	const ab_KeyMethods* inKeyMethods, ab_num inSizeHint, ab_bool inValuesToo)
	: ab_Object(inUsage),
	mIntMap_ChangeCount( 0 ),
	mIntMap_Threshold( 0 ),
	mIntMap_Capacity( 0 ),
	mIntMap_AssocCount( 0 ),
	mIntMap_KeyInts( 0 ),
	mIntMap_ValueInts( 0 ),
	
	mIntMap_Hash( 0 ),
	mIntMap_Equal( 0 ),
	mIntMap_AssocString( 0 ),

	mIntMap_HasValuesToo( inValuesToo )

	// map contains no values when inValuesToo is false, which technically
	// creates a simple set and not a map.  inSizeHint
	// is capped between kMinSizeHin and kMaxSizeHint, and this becomes
	// the new threshold, with capacity equal to 25% more.
{
	if ( inSizeHint < ab_IntMap_kMinSizeHint )
		inSizeHint = ab_IntMap_kMinSizeHint;
	else if ( inSizeHint > ab_IntMap_kMaxSizeHint )
		inSizeHint = ab_IntMap_kMaxSizeHint;
			
	if ( inKeyMethods )
		this->init_with_size(ev, inKeyMethods, inSizeHint);
	else
	{
		ab_KeyMethods defaults(ab_Env_HashKey, ab_Env_EqualKey, ab_Env_AssocString);
		this->init_with_size(ev, &defaults, inSizeHint);
	}
}
    	
ab_IntMap::ab_IntMap(ab_Env* ev, const ab_Usage& inUsage, /*i*/
	ab_num inSizeHint, const ab_IntMap& ioOtherMap)
	: ab_Object(inUsage),
	mIntMap_ChangeCount( 0 ),
	mIntMap_Threshold( 0 ),
	mIntMap_Capacity( 0 ),
	mIntMap_AssocCount( 0 ),
	mIntMap_KeyInts( 0 ),
	mIntMap_ValueInts( 0 ),
	
	mIntMap_Hash( ioOtherMap.mIntMap_Hash ),
	mIntMap_Equal( ioOtherMap.mIntMap_Equal ),
	mIntMap_AssocString( ioOtherMap.mIntMap_AssocString ),

	mIntMap_HasValuesToo( ioOtherMap.mIntMap_ValueInts != 0 )

	// The new map contains values provided ioOtherMap does. inSizeHint is
	// capped between kMinSizeHin and kMaxSizeHint, but is then increased
	// to ioOtherMap.GetThreshold() is this is greater, and then used for
	// the new threshold, with capacity equal to 25% more.  The content in
	// ioOtherMap is copied into this one.  (This constructor is used when
	// a map is grown with grow_int_map(), which makes a larger local map
	// before replacing the old slots when this is successful.)
{
	if ( inSizeHint < ab_IntMap_kMinSizeHint )
		inSizeHint = ab_IntMap_kMinSizeHint;
	else if ( inSizeHint > ab_IntMap_kMaxSizeHint )
		inSizeHint = ab_IntMap_kMaxSizeHint;
	
	if ( inSizeHint < ioOtherMap.GetThreshold() )
		inSizeHint = ioOtherMap.GetThreshold();
	
	if ( this->init_with_size(ev, /*inKeyMethods*/ 0, inSizeHint) )
	{
		this->AddTable(ev, ioOtherMap);
	}
}

void ab_IntMap::CloseIntMap(ab_Env* ev) /*i*/
{
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "CloseIntMap")

	if ( mIntMap_KeyInts )
	{
		ev->HeapFree(mIntMap_KeyInts);
		mIntMap_KeyInts = 0;
	}
	if ( mIntMap_ValueInts )
	{
		ev->HeapFree(mIntMap_ValueInts);
		mIntMap_ValueInts = 0;
	}
	ab_Env_EndMethod(ev)
}

// ````` ````` entire table methods ````` `````  
ab_bool ab_IntMap::AddTable(ab_Env* ev, const ab_IntMap& ioOtherMap) /*i*/
	// add contents of ioOtherMap, and then return ev->Good().
{
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "AddTable")

	if ( this->IsOpenObject() && ioOtherMap.IsOpenObject() )
	{
		if ( this != &ioOtherMap && ev->Good() )
		{
			ab_map_int* keys = ioOtherMap.mIntMap_KeyInts;
			ab_map_int* end = keys + ioOtherMap.mIntMap_Capacity;
			ab_map_int* cursor = --keys; // prepare for preincrement
			ab_map_int* values = ioOtherMap.mIntMap_ValueInts;

			++mIntMap_ChangeCount; // note change in map (fast_add() does not)
			
			while ( ++cursor < end && ev->Good() )
			{
				ab_map_int k = *cursor;
				if ( k ) // another key in the other table?
				{
					if ( values )
						this->fast_add(ev, k, values[ cursor - keys ]);
					else
						this->fast_add(ev, k, ab_IntMap_kPretendValue);
				}
			}
		}
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);
	
	ab_Env_EndMethod(ev)
	return ev->Good();
}

// ````` ````` bucket location ````` `````  

ab_map_int* ab_IntMap::find_bucket(ab_Env* ev, ab_map_int inKey) const /*i*/
{
	ab_map_int* outBucket = 0;
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "find_bucket")
	
	ab_pos pos = this->hash_bucket(ev, inKey);
	ab_map_int* keys = mIntMap_KeyInts;
	ab_map_int* bucket = keys + pos; // first candidate bucket
	
	ab_map_int k = *bucket;
	if ( k && k != inKey ) // first choice already used for some other key?
	{
		ab_map_int* end = keys + mIntMap_Capacity; // one past end, for wrap
		ab_map_int* start = bucket; // where we started, to detect lap
		
		while ( ++bucket != start && ev->Good() ) // have not yet lapped?
		{
			if ( bucket >= end ) // need to wrap?
				bucket = keys; // back to the first bucket in map
				
			k = *bucket;
			if ( !k || this->equal_key(ev, inKey, k) ) // empty? or found key?
			{
				outBucket = bucket;
				break; // use this one, end while loop
			}
		}
	}
	else
		outBucket = bucket;

	ab_Env_EndMethod(ev)
	return outBucket;
}

// ````` ````` adding with less error detection ````` `````  

void ab_IntMap::fast_add(ab_Env* ev, ab_map_int inKey, ab_map_int inValue) /*i*/
{
	if ( mIntMap_AssocCount >= mIntMap_Threshold ) // need bigger map?
		grow_int_map(ev);
		
	if ( ev->Good() ) // no errors?
	{
		ab_map_int* bucket = this->find_bucket(ev, inKey);
		if ( bucket && ( *bucket == inKey || !*bucket ) ) // found key bucket?
		{
			*bucket = inKey;
			ab_map_int* values = mIntMap_ValueInts;
			if ( values ) // also storing values?
				values[ bucket - mIntMap_KeyInts ] = inValue;
				
			++mIntMap_AssocCount; // count additional member
		}
		else ev->NewAbookFault(ab_Map_kFaultNoBucketFound);
	}
}
	
// ````` ````` uid assoc methods ````` `````  

void ab_IntMap::AddAssoc(ab_Env* ev, ab_map_int inKey, ab_map_int inValue) /*i*/
	// add one new association (if an association already exists with 
	// the same key, then the value is simply updated to the new value).
{
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "AddAssoc")

	if ( this->IsOpenObject() )
	{
		if( inKey ) // non-zero key?
		{
			if ( mIntMap_AssocCount >= mIntMap_Threshold ) // need bigger map?
				grow_int_map(ev);
				
			if ( ev->Good() ) // no errors?
			{
				if ( mIntMap_AssocCount < mIntMap_Threshold ) // enough space?
				{
					ab_map_int* bucket = this->find_bucket(ev, inKey);
					if ( bucket ) // found bucket for this key?
					{
						ab_map_int priorKey = *bucket;
						if ( !priorKey || priorKey == inKey ) // new or replace?
						{
							++mIntMap_ChangeCount; // note map changed
							
							*bucket = inKey;
							ab_map_int* values = mIntMap_ValueInts;
							if ( values ) // also storing values?
								values[ bucket - mIntMap_KeyInts ] = inValue;
								
							++mIntMap_AssocCount;  // count additional member
						}
						else ev->NewAbookFault(ab_Map_kFaultNoBucketFound);
					}
					else ev->NewAbookFault(ab_Map_kFaultNoBucketFound);
				}
				else ev->NewAbookFault(ab_Map_kFaultOverThreashold);
			}
		}
		else ev->NewAbookFault(ab_Map_kFaultZeroKey);
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);

	ab_Env_EndMethod(ev)
}
	
ab_map_int ab_IntMap::GetValueForKey(ab_Env* ev, ab_map_int inKey) /*i*/
	// search for one association keyed by inKey, and return the value.
	// Since values cannot be zero, zero is returned to mean "not found".
{
	ab_map_int outValue = 0;
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "GetValueForKey")

	if ( this->IsOpenObject() )
	{
		if ( inKey ) // non-zero key?
		{
			ab_map_int* bucket = this->find_bucket(ev, inKey);
			if ( bucket && *bucket == inKey ) // found a bucket for this key?
			{
				if ( mIntMap_ValueInts ) // values are actually stored?
					outValue = mIntMap_ValueInts[ bucket - mIntMap_KeyInts ];
				else
					outValue = ab_IntMap_kPretendValue; // nominal value
			}
		}
		else
		{
	#ifdef AB_CONFIG_DEBUG
			ev->Break("<ab_IntMap::GetValueForKey:zero:key/>");
	#endif /*AB_CONFIG_DEBUG*/
		}
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);

	ab_Env_EndMethod(ev)
	return outValue;
}
	
void ab_IntMap::CutAllAssocs(ab_Env* ev) /*i*/
	// remove all associations
{
	ab_Env_BeginMethod(ev, ab_IntMap_kClassName, "CutAllAssocs")

	if ( this->IsOpenObject() )
	{
		mIntMap_AssocCount = 0;
		ab_num volume = mIntMap_Capacity * sizeof(ab_map_int); // total bytes
		if ( volume )
		{
			if ( mIntMap_KeyInts )
				AB_MEMSET(mIntMap_KeyInts, 0, volume); // zero all bytes
			if ( mIntMap_ValueInts )
				AB_MEMSET(mIntMap_ValueInts, 0, volume); // zero all bytes
		}
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);

	ab_Env_EndMethod(ev)
}

/*=============================================================================
 * ab_IntMapIter: iterator for  ab_IntMap
 */

// ````` ````` ````` `````   ````` ````` ````` `````  
// public: // non-poly ab_IntMapIter methods

ab_IntMapIter::ab_IntMapIter(ab_Env* ev, const ab_IntMap* ioIntMap)
	: mIntMapIter_Map( ioIntMap ),
	mIntMapIter_BucketPos( 0xFFFFFFF ),
	mIntMapIter_ChangeCount( ioIntMap->GetChangeCount() - 1 ) // not in sync

    // the ioIntMap object is *not* reference counted, because this iter is
    // expected to be only short-lived inside a single method.
{
	ab_Env_BeginMethod(ev, ab_IntMapIter_kClassName, ab_IntMapIter_kClassName)

	ab_Env_EndMethod(ev)
}
	
ab_map_int ab_IntMapIter::Here(ab_Env* ev, ab_map_int* outValue) /*i*/
{
	ab_map_int outKey = 0;
	ab_Env_BeginMethod(ev, ab_IntMapIter_kClassName, "Here")

	ab_map_int val = 0; // eventually written to *outValue

	const ab_IntMap* map = mIntMapIter_Map;
	if ( map && map->IsOpenObject() ) // okay? open?
	{
		if ( mIntMapIter_ChangeCount == map->GetChangeCount() ) // in sync?
		{
			ab_pos bucket = mIntMapIter_BucketPos;
		  	if ( bucket < map->mIntMap_Capacity ) // iteration still going?
		  	{
				ab_map_int* keys = map->mIntMap_KeyInts; 
				if ( keys ) // have key vector?
				{
					outKey = keys[ bucket ];
					if ( outKey ) // current bucket has key?
					{
						ab_map_int* values = map->mIntMap_ValueInts;
						if ( values )
							val = values[ bucket ]; // actual value
						else
							val = ab_IntMap_kPretendValue; // nominal value
					}
					else ev->NewAbookFault(ab_Map_kFaultIterEmptyBucket);
				}
				else ev->NewAbookFault(ab_Map_kFaultMissingVector);
		  	}
		  	// else return zero to show the iteration has concluded
		}
		else ev->NewAbookFault(ab_ObjectSet_kFaultIterOutOfSync);
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);

	if ( outValue )
		*outValue = val;

	ab_Env_EndMethod(ev)
	return outKey;
}
	
ab_map_int ab_IntMapIter::next_assoc(ab_pos inPos, /*i*/
	ab_map_int* outValue)
{
	ab_map_int outKey = 0;
	
	const ab_IntMap* map = mIntMapIter_Map;
	if ( inPos < map->mIntMap_Capacity ) // iteration is not exhaused?
	{
		ab_map_int* keys = map->mIntMap_KeyInts;
		ab_map_int* end = keys + map->mIntMap_Capacity; // one past end
		
		ab_map_int* cursor = ( keys + inPos ) - 1; // less 1 preps preincrement
		
		while ( ++cursor < end ) // table not yet exhausted?
		{
			outKey = *cursor;
			if ( outKey ) // found next occupied bucket
				break; // end while loop
		}
		inPos = cursor - keys; // update to new bucket (need for BucketPos) 
		
		if ( outKey && outValue ) // found assoc? caller wants value?
		{
			ab_map_int* values = map->mIntMap_KeyInts;
			if ( values ) // values are being stored?
				*outValue = values[ inPos ]; // actual value
			else
				*outValue = ab_IntMap_kPretendValue; // nominal value
		}
	}
	mIntMapIter_BucketPos = inPos; // record where we stopped
	
	return outKey;
}

ab_map_int ab_IntMapIter::First(ab_Env* ev, ab_map_int* outValue) /*i*/
{
	ab_map_int outKey = 0;
	ab_Env_BeginMethod(ev, ab_IntMapIter_kClassName, "First")

	if ( outValue )
		*outValue = 0; // init to default zero

	const ab_IntMap* map = mIntMapIter_Map;
	if ( map && map->IsOpenObject() ) // okay? open?
	{
		// when starting an iteration, put the recorded change count in sync:
		mIntMapIter_ChangeCount = map->GetChangeCount(); // sync
		
		outKey = this->next_assoc(/*inPos*/ 0, outValue);
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);

	ab_Env_EndMethod(ev)
	return outKey;
}
	
ab_map_int ab_IntMapIter::Next(ab_Env* ev, ab_map_int* outValue) /*i*/
{
	ab_map_int outKey = 0;
	ab_Env_BeginMethod(ev, ab_IntMapIter_kClassName, "Next")

	if ( outValue )
		*outValue = 0; // init to default zero

	const ab_IntMap* map = mIntMapIter_Map;
	if ( map && map->IsOpenObject() ) // okay? open?
	{
		if ( mIntMapIter_ChangeCount == map->GetChangeCount() ) // in sync?
		{
			ab_pos bucket = mIntMapIter_BucketPos; // (might be 0xFFFFFFFF)
		  	if ( bucket < map->mIntMap_Capacity ) // iteration not yet ended?
				++bucket; // advance the iteration
				
			outKey = this->next_assoc(/*inPos*/ bucket, outValue);
		}
		else ev->NewAbookFault(ab_ObjectSet_kFaultIterOutOfSync);
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);

	ab_Env_EndMethod(ev)
	return outKey;
}

/* ````` ````` ````` C APIs ````` ````` ````` */
	
/* ````` thumb refcounting ````` */

AB_API_IMPL(ab_ref_count) /* abstore.cpp */
AB_Thumb_Acquire(AB_Thumb* self, AB_Env* cev) /*i*/
{
	ab_ref_count outCount = 0;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "Acquire")

	outCount = ((ab_Thumb*) self)->AcquireObject(ev);
	
	ab_Env_EndMethod(ev)
	return outCount;
}

AB_API_IMPL(ab_ref_count) /* abstore.cpp */
AB_Thumb_Release(AB_Thumb* self, AB_Env* cev) /*i*/
{
	ab_ref_count outCount = 0;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "Release")

	outCount = ((ab_Thumb*) self)->ReleaseObject(ev);
	
	ab_Env_EndMethod(ev)
	return outCount;
}

AB_API_IMPL(AB_Thumb*) /* abthumb.cpp */
AB_Store_NewThumb(AB_Store* self, AB_Env* cev, /*i*/
	ab_row_count inRowLimit, ab_num inFileByteCountLimit)
{
	AB_Thumb* outThumb = 0;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, "AB_Store", "NewThumb")

	ab_Thumb* thumb = new(*ev) ab_Thumb(ev, ab_Usage::kHeap);
	if ( thumb )
	{
		if ( ev->Good() )
		{
			outThumb = (AB_Thumb*) thumb;
			thumb->mThumb_FileFormat = ab_File_kLdifFormat;
			if ( !inRowLimit ) 
				inRowLimit = 1;
			
			if ( !inFileByteCountLimit ) 
				inFileByteCountLimit = 256;
				
			thumb->mThumb_RowCountLimit = inRowLimit;
			thumb->mThumb_ByteCountLimit = inFileByteCountLimit;
		}
		else
			thumb->ReleaseObject(ev);
	}
	
	AB_USED_PARAMS_1(ev);

	ab_Env_EndMethod(ev)
	return outThumb;
}

AB_API_IMPL(ab_bool) /* abthumb.cpp */
AB_Thumb_IsProgressFinished(const AB_Thumb* self, AB_Env* cev) /*i*/
{
	ab_bool outBool = AB_kTrue;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "IsProgressFinished")

	ab_Thumb* thumb = (ab_Thumb*) self;
	if ( thumb->IsOpenObject() )
	{
		outBool = thumb->IsProgressFinished();
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);
	
	ab_Env_EndMethod(ev)
	return outBool;
}

AB_API_IMPL(void) /* abthumb.cpp */
AB_Thumb_SetPortingLimits(AB_Thumb* self, AB_Env* cev, /*i*/
	ab_row_count inRowLimit, ab_num inFileByteCountLimit)
{
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "SetPortingLimits")

	ab_Thumb* thumb = (ab_Thumb*) self;
	if ( thumb->IsOpenObject() )
	{
		if ( !inRowLimit ) 
			inRowLimit = 1;
		
		if ( !inFileByteCountLimit ) 
			inFileByteCountLimit = 256;
			
		thumb->mThumb_RowCountLimit = inRowLimit;
		thumb->mThumb_ByteCountLimit = inFileByteCountLimit;
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);
	
	ab_Env_EndMethod(ev)
}

/*| ImportProgress: return the current position in the import file, and also
**| the actual length of the import file in outFileLength, since this can be
**| used to show percentage progress through the import file.  However, we
**| can only show progress through the current pass through the file, which
**| is returned in outPass (typically either 1 or 2 for first or second pass).
**|
**|| Note that when outPass turns over from 1 to 2, the progress through the
**| file will revert back to a smaller percentage of the file, so a progress
**| bar might want to reveal to users which pass is currently in progress.
|*/
AB_API_IMPL(ab_pos) /* abthumb.cpp */
AB_Thumb_ImportProgress(AB_Thumb* self, AB_Env* cev, /*i*/
	ab_pos* outFileLength, ab_count* outPass)
{
	ab_pos outPos = 0;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "ImportProgress")

	ab_Thumb* thumb = (ab_Thumb*) self;
	if ( thumb->IsOpenObject() )
	{
		if ( !thumb->mThumb_ImportFileLength ) // caller might divide by zero?
			thumb->mThumb_ImportFileLength = 1; // avoid potential zero divisor
		
		outPos = thumb->mThumb_FilePos;
		if ( outFileLength )
			*outFileLength = thumb->mThumb_ImportFileLength;
		if ( outPass )
			*outPass = thumb->mThumb_CurrentPass;
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);
	
	ab_Env_EndMethod(ev)
	return outPos;
}

/*| ExportProgress: return the row position of the row that was last exported,
**| and also the total number of rows to be exported in outTotalRows, since this
**| can be used to show percentage progress through the export task.
|*/
AB_API_IMPL(ab_row_pos) /* abthumb.cpp */
AB_Thumb_ExportProgress(AB_Thumb* self, AB_Env* cev, /*i*/
	ab_row_count* outTotalRows)
{
	ab_row_count outPos = 0;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "ExportProgress")

	ab_Thumb* thumb = (ab_Thumb*) self;
	if ( thumb->IsOpenObject() )
	{
		outPos = thumb->mThumb_RowPos;
		if ( outTotalRows )
			*outTotalRows = thumb->mThumb_ExportTotalRowCount;
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);
	
	ab_Env_EndMethod(ev)
	return outPos;
}

/*| ImportFileFormat: describe the current file format being imported
|*/
AB_API_IMPL(AB_File_eFormat) /* abthumb.cpp */
AB_Thumb_ImportFileFormat(AB_Thumb* self, AB_Env* cev) /*i*/
{
	AB_File_eFormat outFormat = AB_File_kUnknownFormat;
	ab_Env* ev = ab_Env::AsThis(cev);
	ab_Env_BeginMethod(ev, AB_Thumb_kClassName, "ImportFileFormat")

	ab_Thumb* thumb = (ab_Thumb*) self;
	if ( thumb->IsOpenObject() )
	{
		outFormat = (AB_File_eFormat) thumb->mThumb_FileFormat;
	}
	else ev->NewAbookFault(ab_Object_kFaultNotOpen);
	
	ab_Env_EndMethod(ev)
	return outFormat;
}