// $Revision: 1.4 $

    // Copyright (C) 1994-1995 Taligent, Inc. All rights reserved.

#ifndef TaligentSamples_IMPLEMENTATIONON
#define TaligentSamples_IMPLEMENTATIONON

#ifndef Taligent_COREPRIMITIVECLASSES
#include <Taligent/CorePrimitiveClasses.h>
#endif

#ifndef TaligentSamples_PROTOCOLON
#include "ProtocolOn.h"
#endif

#ifndef Taligent_ASSERTIONS
#include <Taligent/Assertions.h>
#endif


//---- TImplementationOn -----------------------------------------------------------

template<class AType>
class TImplementationOn : public MProtocolOn<AType> {
  public:
    TaligentTypeExtensionTemplateDeclarationsMacro(TImplementationOn,AType)
  public:
                                    TImplementationOn(AType* state);
                                    TImplementationOn(const TImplementationOn<AType>& source);
    virtual                         ~TImplementationOn();
                                        
    TImplementationOn<AType>&   operator=(const TImplementationOn<AType>& source);
    virtual TStream&                operator>>=(TStream& toStream) const;
    virtual TStream&                operator<<=(TStream& fromStream);
    
    virtual void                    Do(TStandardFunctorOn<AType>& functor);
    
  private:
                                    TImplementationOn();

  private:
    enum {kOriginalVersion};
    AType*      fState;
};

//---- TImplementationOn -----------------------------------------------------------

TaligentTypeExtensionTemplateMacro(TImplementationOn,AType)

template<class AType>
TImplementationOn<AType>::TImplementationOn()
    : fState(NIL)
{
}

template<class AType>
TImplementationOn<AType>::TImplementationOn(AType* state)
    : fState(state)
{
}

template<class AType>
TImplementationOn<AType>::TImplementationOn(const TImplementationOn<AType>& source)
    : fState(NIL)
{
    fState = ::CopyPointer(source.fState);
}

template<class AType>
TImplementationOn<AType>::~TImplementationOn()
{
    delete fState;
}

template<class AType>
TImplementationOn<AType>&
TImplementationOn<AType>::operator=(const TImplementationOn<AType>& source)
{
    if (&source != this) {
        delete fState;
        fState = ::CopyPointer(source.fState);
    }
    
    return *this;
}

template<class AType>
TStream&
TImplementationOn<AType>::operator>>=(TStream& toStream) const
{
    short version(kOriginalVersion);
    version >>= toStream;
    ::WriteVersion(toStream, kOriginalVersion);
    ::Flatten(fState, toStream);
    return toStream;
}

template<class AType>
TStream&
TImplementationOn<AType>::operator<<=(TStream& fromStream)
{
    ::ReadVersion(fromStream, kOriginalVersion, kOriginalVersion);
    delete fState;
    ::Resurrect(fState, fromStream);
    return fromStream;
}

template<class AType>
void
TImplementationOn<AType>::Do(TStandardFunctorOn<AType>& functor)
{
    ::Assertion(fState != NIL, "\nfState cannot be NIL!\n");
    functor(*fState);
}

#endif