// $Revision: 1.2 $
// Copyright (C) 1994, 1995 Taligent, Inc. All rights reserved.

#ifndef TaligentSamples_ATOMICMODELIMP
#define TaligentSamples_ATOMICMODELIMP

#ifndef TaligentSamples_ATOMICMODEL
#error "Don't include this file directly; use AtomicModel.h"
#endif

#ifndef HIDE_TEMPLATE_DEFINITIONS
#define MAKE_MAtomicModelOn_DEFINITIONS_VISIBLE
#define MAKE_MAtomicSelectionOn_DEFINITIONS_VISIBLE
#define MAKE_TAtomicModelOn_DEFINITIONS_VISIBLE
#define MAKE_TAtomicSelectionOn_DEFINITIONS_VISIBLE
#endif

#ifdef MAKE_MAtomicModelOn_DEFINITIONS_VISIBLE

//==============================================================================
// MAtomicModelOn<AType>

TaligentTypeExtensionTemplateMacro_Abstract(MAtomicModelOn,AType);

template <class AType>
MAtomicModelOn<AType>::MAtomicModelOn()
{
}

template <class AType>
MAtomicModelOn<AType>::~MAtomicModelOn()
{
}

template <class AType>
const MAtomicModelOn<AType>*
MAtomicModelOn<AType>::LookupForReading(const TModelReference& reference)
{
	MAtomicModelOn<AType>* atomicModel;
	::DynamicCastTo(atomicModel, TModel::LookupForReading(reference));
	if (atomicModel == NIL) {
		throw TCompoundDocumentException(TCompoundDocumentException::kModelDoesNotExist);
	}
	return atomicModel;
}

template <class AType>
MAtomicModelOn<AType>*
MAtomicModelOn<AType>::LookupForWriting(const TModelReference& reference)
{
	MAtomicModelOn<AType>* atomicModel;
	::DynamicCastTo(atomicModel, TModel::LookupForWriting(reference));
	if (atomicModel == NIL) {
		throw TCompoundDocumentException(TCompoundDocumentException::kModelDoesNotExist);
	}
	return atomicModel;
}

#endif

#ifdef MAKE_MAtomicSelectionOn_DEFINITIONS_VISIBLE
//==============================================================================
// MAtomicSelectionOn<AType>

TaligentTypeExtensionTemplateMacro_Abstract(MAtomicSelectionOn,AType);

template <class AType>
MAtomicSelectionOn<AType>::MAtomicSelectionOn()
{
}

template <class AType>
MAtomicSelectionOn<AType>::~MAtomicSelectionOn()
{
}

template <class AType>
const AType*
MAtomicSelectionOn<AType>::GetValueForReading() const
{
	CheckValueSelected();
	return GetAtomicModelOnForReading()->GetValueForReading();
}

template <class AType>
AType*
MAtomicSelectionOn<AType>::GetValueForWriting()
{
	CheckValueSelected();
	return GetAtomicModelOnForWriting()->GetValueForWriting();
}

template <class AType>
void
MAtomicSelectionOn<AType>::SetValue(const AType& value)
{
	CheckValueSelected();
	GetAtomicModelOnForWriting()->SetValue(value);
}

template <class AType>
AType*
MAtomicSelectionOn<AType>::CopyValue() const
{
	CheckValueSelected();
	return GetAtomicModelOnForReading()->CopyValue();
}

template <class AType>
void
MAtomicSelectionOn<AType>::AdoptValue(AType* value)
{
	CheckValueSelected();
	GetAtomicModelOnForWriting()->AdoptValue(value);
}

template <class AType>
AType*
MAtomicSelectionOn<AType>::SwapValue(AType* value)
{
	CheckValueSelected();
	return GetAtomicModelOnForWriting()->SwapValue(value);
}

template <class AType>
void
MAtomicSelectionOn<AType>::SwapContents(MAtomicModelOn<AType>& other)
{
	CheckValueSelected();
	GetAtomicModelOnForWriting()->SwapContents(other);
}


template <class AType>
void
MAtomicSelectionOn<AType>::CheckValueSelected() const
{
	TModelSelection* thisAsSelection;
	::DynamicCastTo(thisAsSelection, this);
	if (thisAsSelection->IsEmpty() || !thisAsSelection->IsDefined()) {
		throw TAtomicModelException(TAtomicModelException::kNoValueSelected);
	}
}

#endif

#ifdef MAKE_TAtomicModelOn_DEFINITIONS_VISIBLE
//==============================================================================
// TAtomicModelOn<AType>

TaligentTypeExtensionTemplateMacro(TAtomicModelOn,AType);

// We can't make this public because it violates the rep invariant by having a NIL fValue.
// And we can't set a value because we don't know what public constructors AType has
// defined.

template <class AType>
TAtomicModelOn<AType>::TAtomicModelOn()
	: fValue(NIL)
{
}

template <class AType>
TAtomicModelOn<AType>::TAtomicModelOn(AType* adopt)
	: fValue(adopt)
{
	Assertion(adopt != NIL, "TAtomicModelOn can't store NIL.");
}

template <class AType>
TAtomicModelOn<AType>::TAtomicModelOn(const AType& copy)
	: fValue(NIL)
{
	fValue = ::Copy(copy);
}

template <class AType>
TAtomicModelOn<AType>::TAtomicModelOn(const TAtomicModelOn<AType>& other)
	: fValue(NIL)
{
	fValue = ::CopyPointer(other.fValue);
}

template <class AType>
TAtomicModelOn<AType>::~TAtomicModelOn()
{
	delete fValue;
}

template <class AType>
TAtomicModelOn<AType>&
TAtomicModelOn<AType>::operator=(const TAtomicModelOn<AType>& other)
{
	if (&other != this) {
		TModel::operator=(other);
		SetValue(*other.fValue);
	}
	return *this;
}

template <class AType>
TModelSelection*
TAtomicModelOn<AType>::CreateSelection() const
{
	TModelReference reference(*this);
	return new TAtomicSelectionOn<AType>(reference);
}

template <class AType>
MAtomicSelectionOn<AType>*
TAtomicModelOn<AType>::CreateAtomicSelectionOn() const
{
	TModelReference reference(*this);
	return new TAtomicSelectionOn<AType>(reference);
}

template <class AType>
HashResult
TAtomicModelOn<AType>::ContentHash() const
{
	return fValue->Hash();
}

template <class AType>
bool
TAtomicModelOn<AType>::IsContentEqual(const TModel& other) const
{
	bool result = false;
	if (TModel::IsContentEqual(other)) {
		const TAtomicModelOn<AType>& otherModel = (const TAtomicModelOn<AType>&)other;
		result = *GetValueForReading() == *otherModel.GetValueForReading();
	}
	return result;
}

template <class AType>
bool
TAtomicModelOn<AType>::IsOrphanable() const
{
	return false;
}

template <class AType>
const AType*
TAtomicModelOn<AType>::GetValueForReading() const
{
	return fValue;
}

template <class AType>
AType*
TAtomicModelOn<AType>::GetValueForWriting()
{
	return fValue;
}

template <class AType>
void
TAtomicModelOn<AType>::SetValue(const AType& data)
{
	AdoptValue(::Copy(data));
}

template <class AType>
AType*
TAtomicModelOn<AType>::CopyValue() const
{
	return ::Copy(*fValue);
}

template <class AType>
void
TAtomicModelOn<AType>::AdoptValue(AType* adopt)
{
	AType* oldValue = SwapValue(adopt);
	delete oldValue;
}

template <class AType>
AType*
TAtomicModelOn<AType>::SwapValue(AType* swap)
{
	// It all comes down to this one routine.
	Assertion(swap != NIL, "TAtomicModelOn can't store NIL.");
	AType* oldValue = fValue;
	fValue = swap;
	NotifyValueChanged();
	return oldValue;
}

template <class AType>
void
TAtomicModelOn<AType>::SwapContents(MAtomicModelOn<AType>& other)
{
	// This routine swaps the contents of the two AtomicValueOn objects
	// without creating an extra temporary copy.
	if (&other != this) {
		if (other.GetValueForReading() == NIL) {
			throw TAtomicModelException(TAtomicModelException::kCannotStoreNIL);
		}
		fValue = other.SwapValue(fValue);
		if (fValue == NIL) {
			// We've been messed up by the other model
			throw TAtomicModelException(TAtomicModelException::kCannotStoreNIL);
		}
	}
}

template <class AType>
void TAtomicModelOn<AType>::NotifyValueChanged()
{
	// Notify interested clients that the data has changed. This model
	// is asked to create the notification interest so that only clients for this
	// change on this model are notified.

	TModelInterest interest = GetSelectedContentsReplacedInterest();
	TModelSelection* selection = CreateSelection();
	TSelectionNotification notification(interest, *selection);
	delete selection;
	NotifyOfChange(notification);
}

template <class AType>
TStream&
TAtomicModelOn<AType>::operator>>=(TStream& toStream) const
{
	::WriteVersion(toStream, kOriginalVersion);
	TModel::operator>>=(toStream);
	::Flatten(fValue, toStream);
	return toStream;
}

template <class AType>
TStream&
TAtomicModelOn<AType>::operator<<=(TStream& fromStream)
{
	::ReadVersion(fromStream, kOriginalVersion, kOriginalVersion);
	TModel::operator<<=(fromStream);
	AType* data;
	::Resurrect(data, fromStream);
	delete fValue;
	fValue = data;
	return fromStream;
}

template <class AType>
const TAtomicModelOn<AType>*
TAtomicModelOn<AType>::LookupForReading(const TModelReference& reference)
{
	const TAtomicModelOn<AType>* atomicModel;
	::DynamicCastTo(atomicModel, TModel::LookupForReading(reference));
	if (atomicModel == NIL) {
		throw TCompoundDocumentException(TCompoundDocumentException::kModelDoesNotExist);
	}
	return atomicModel;
}

template <class AType>
TAtomicModelOn<AType>*
TAtomicModelOn<AType>::LookupForWriting(const TModelReference& reference)
{
	TAtomicModelOn<AType>* atomicModel;
	::DynamicCastTo(atomicModel, TModel::LookupForWriting(reference));
	if (atomicModel == NIL) {
		throw TCompoundDocumentException(TCompoundDocumentException::kModelDoesNotExist);
	}
	return atomicModel;
}

#endif

#ifdef MAKE_TAtomicSelectionOn_DEFINITIONS_VISIBLE
//==============================================================================
// TAtomicSelectionOn<AType>

TaligentTypeExtensionTemplateMacro(TAtomicSelectionOn,AType);

template <class AType>
const MAtomicModelOn<AType>*
TAtomicSelectionOn<AType>::GetAtomicModelOnForReading() const
{
	return (const TAtomicModelOn<AType>*)GetModelForReading();
}

template <class AType>
MAtomicModelOn<AType>*
TAtomicSelectionOn<AType>::GetAtomicModelOnForWriting()
{
	return (TAtomicModelOn<AType>*)GetModelForWriting();
}

template <class AType>
TModel*
TAtomicSelectionOn<AType>::HandleCopyData(const TTypeDescription&) const
{
	AType* value = GetAtomicModelOnForReading()->CopyValue();
	return new TAtomicModelOn<AType>(value);
}

template <class AType>
void
TAtomicSelectionOn<AType>::HandleCopyDataInto(TModel& model) const
{
	TAtomicModelOn<AType>& otherModel = (TAtomicModelOn<AType>&)model;
	const AType* ourValue = GetAtomicModelOnForReading()->GetValueForReading();
	otherModel.SetValue(*ourValue);
}

template <class AType>
TModel*
TAtomicSelectionOn<AType>::HandleReplaceData(TModel* adoptedNewModelArg)
{
	TAtomicModelOn<AType>* theNewModel = (TAtomicModelOn<AType>*)adoptedNewModelArg;
	MAtomicModelOn<AType>* ourModel = GetAtomicModelOnForWriting();
	ourModel->SwapContents(*theNewModel);
	return theNewModel;
}

template <class AType>
TModel*
TAtomicSelectionOn<AType>::HandleOrphanData()
{
	// This kind of model does not allow orphaning data
	throw TAtomicModelException(TAtomicModelException::kCannotOrphanData);
	return NIL;
}

template <class AType>
TAtomicSelectionOn<AType>::TAtomicSelectionOn(const TModelReference& model)
	: TModelSelection(model), MDataExchanger(this),
	MAtomicSelectionOn<AType>()
{
}

template <class AType>
TAtomicSelectionOn<AType>::TAtomicSelectionOn(const TAtomicSelectionOn<AType>& other)
	: TModelSelection(other), MDataExchanger(this),
	MAtomicSelectionOn<AType>(other)
{
}

template <class AType>
TAtomicSelectionOn<AType>::~TAtomicSelectionOn()
{
}

template <class AType>
TAtomicSelectionOn<AType>::TAtomicSelectionOn()
	: TModelSelection(), MDataExchanger(this),
	MAtomicSelectionOn<AType>()
{
}

template <class AType>
TAtomicSelectionOn<AType>&
TAtomicSelectionOn<AType>::operator=(const TAtomicSelectionOn<AType>& source)
{
	if (&source != this) {
		TModelSelection::operator=(source);
	}
	return *this;
}

#endif
#endif