CConversionProvider.h

//========================================================================================
// 
// $File$
// 
// Owner: Robin Briggs
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// ADOBE CONFIDENTIAL
// 
// Purpose of Interface:
// Helper base class for writing file format converters.
// 
// Interfaces -----
// 
//========================================================================================

#include "IConversionProvider.h"

// ----- Includes -----

#include "CPMUnknown.h"
#include "K2Vector.h"

// ----- ID.h files -----

#include "VersionID.h"




//---------------------------------------------------------------------------------------
// CConversionProvider
//---------------------------------------------------------------------------------------

class CConversionProvider : public CPMUnknown<IConversionProvider>
{
public:
 CConversionProvider(PluginID plugin, IPMUnknown *boss);
 virtual ~CConversionProvider();
 
 virtual int32 CountConversions() const = 0;
 virtual void GetNthConversion(int32 n, VersionID *fromVersion, VersionID *toVersion) const = 0;

 virtual int32 CountRemovedPlugins(const VersionID &fromVersion, const VersionID &toVersion) const;
 virtual PluginID GetNthRemovedPlugin(const VersionID &fromVersion, const VersionID &toVersion, int32 n) const;
 virtual int32 CountIgnoredPlugins(const VersionID &fromVersion, const VersionID &toVersion) const;
 virtual PluginID GetNthIgnoredPlugin(const VersionID &fromVersion, const VersionID &toVersion, int32 n) const;
 
 virtual int32 CountClassAliases() const;
 virtual int32 CountImplementationAliases() const;
 virtual void GetNthClassAlias(int32 n, ClassID &fromID, VersionID &fromVersion, ClassID &toID, VersionID &toVersion) const;
 virtual void GetNthImplementationAlias(int32 n, ImplementationID &fromID, VersionID &fromVersion, ImplementationID &toID, VersionID &toVersion) const;

 virtual int32 CountPlugins() const;
 virtual PluginID GetNthPlugin(int32 n) const;

 virtual bool16 DoesConversionRenumberClass(int32 conversionIndex) const;
 virtual bool16 DoesConversionRenumberImplementation(int32 conversionIndex) const;

 virtual IConversionProvider::ConversionStatus ShouldConvertImplementation(ImplementationID tag, ClassID context, int32 conversionIndex) const;
 virtual IConversionProvider::ConversionStatus ShouldConvertClass(ClassID clsID, ImplementationID context, int32 conversionIndex) const;

 virtual ImplementationID ConvertTag(ImplementationID tag, ClassID forClass, int32 conversionIndex, 
 int32 inLength, IPMStream *oldData, IPMStream *newData, IterationStatus whichIteration);

 virtual ClassID ConvertClass(ClassID clsID, ImplementationID embeddedContext, int32 conversionIndex, 
 int32 inLength, IPMStream *oldData, IPMStream *newData, IterationStatus whichIteration);

protected:
 void RemoveImplementation(ImplementationID implID, ClassID classID, int32 majorFormat, int32 minorFormat);

 void RemoveClass(ClassID classID, int32 majorFormat, int32 minorFormat)
 {RemoveImplementation(kInvalidImpl, classID, majorFormat, minorFormat);}

 void RemovePlugin(PluginID plugin, int32 majorFormat, int32 minorFormat);

 void IgnorePlugin(PluginID plugin, int32 majorFormat, int32 minorFormat);
 
 void MoveClass(ClassID fromClass, PluginID fromPlugin, int32 fromMajorFormat, int32 fromMinorFormat,
 ClassID toClass, int32 toMajorFormat, int32 toMinorFormat);
 
 void MoveImplementation(ImplementationID fromImpl, PluginID fromPlugin, int32 fromMajorFormat, int32 fromMinorFormat,
 ImplementationID toImpl, int32 toMajorFormat, int32 toMinorFormat);

private:
 static bool InRange(const VersionID &fromV, const VersionID &testV, const VersionID &toV)
 {return ((testV > fromV) && (testV <= toV));}

private:
 class ImplInfo
 {
 public:
 typedef base_type data_type;
 ImplInfo()
 : fImplID(kInvalidImpl), fBossID(kInvalidClass), fFormat()
 {}
 ImplInfo(ImplementationID implID, ClassID bossID, const FormatID &format)
 : fImplID(implID), fBossID(bossID), fFormat(format)
 {}
 ImplInfo(const ImplInfo &other)
 : fImplID(other.fImplID), fBossID(other.fBossID), fFormat(other.fFormat)
 {}

 ImplementationID GetImplementation() const
 {return fImplID;}
 ClassID GetBoss() const
 {return fBossID;}
 const FormatID &GetFormat() const
 {return fFormat;}

 bool operator==(const ImplInfo &other) const
 {return((fImplID == other.fImplID) && (fBossID == other.fBossID) && (fFormat == other.fFormat));}

 private:
 ImplementationID fImplID; // Which Implementation was added or removed
 ClassID fBossID; // Boss was it added or removed to/from
 FormatID fFormat; // Format number when the implementation was added/removed
 };


 class PluginInfo
 {
 public:
 typedef base_type data_type;

 PluginInfo()
 : fPlugin(kInvalidPlugin), fFormat()
 {}
 PluginInfo(PluginID plugin)
 : fPlugin(plugin), fFormat()
 {}
 PluginInfo(PluginID plugin, const FormatID &format)
 : fPlugin(plugin), fFormat(format)
 {}
 PluginInfo(const PluginInfo &other)
 : fPlugin(other.fPlugin), fFormat(other.fFormat)
 {}

 PluginID GetPlugin() const
 {return fPlugin;}
 const FormatID &GetFormat() const
 {return fFormat;}

 bool16 operator==(const PluginInfo &other) const
 {return (fPlugin == other.fPlugin);}

 private:
 PluginID fPlugin; // Removed plugin
 FormatID fFormat; // Format number when it was removed
 };


 template <class T>
 class AliasInfo
 {
 public:
 typedef base_type data_type;
 
 AliasInfo(T fromID, const VersionID &from, T toID, const VersionID &to)
 : fFromID(fromID), fFromVersion(from), fToID(toID), fToVersion(to)
 {}
 
 T GetFromID() const
 {return fFromID;}
 T GetToID() const
 {return fToID;}
 const VersionID &GetFromVersion() const
 {return fFromVersion;}
 const VersionID &GetToVersion() const
 {return fToVersion;}
 
 bool operator ==(const AliasInfo &other) const
 {return (fFromID == other.fFromID) && (fFromVersion == other.fFromVersion) &&
 (fToID == other.fToID) && (fToVersion == other.fToVersion);}
 
 private:
 T fFromID; // Former Class or Implementation ID
 VersionID fFromVersion; // Where did the ID move from?
 T fToID; // New Class or Implementation ID
 VersionID fToVersion; // Where did it move to?
 };

 typedef K2Vector<ImplInfo> ImplInfoVector;
 typedef AliasInfo<ClassID> ClassAliasInfo;
 typedef K2Vector<ClassAliasInfo> ClassAliasVector;
 typedef AliasInfo<ImplementationID> ImplAliasInfo;
 typedef K2Vector<ImplAliasInfo> ImplAliasVector;
 typedef K2Vector<PluginInfo> PluginInfoVector;

private:
 PluginID fPlugin;
 ImplInfoVector fImplList;
 ClassAliasVector fClassAliasList;
 ImplAliasVector fImplAliasList;
 PluginInfoVector fRemoveList;
 PluginInfoVector fIgnoreList;
};