XmlGeometryCacheDesc/XmlGeometryCacheDesc.cpp

//-
// ==========================================================================
// Copyright 2009,2010 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

//
// Description:
//  This plug-in provides an example of the use of MPxCacheFormat.
//
//  In this example, the cache files are written in xml format.
//  Also, the handling of the description file is overridden.
//
//  This example extends the XmlGeometryCache.cpp example.
//

#include <string>
#include <stack>
#include <fstream>
#include <sstream>

#include <assert.h>
#include <stdlib.h>
#include <maya/MCacheFormatDescription.h>
#include <maya/MFnPlugin.h>
#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MPxCacheFormat.h>
#include <maya/MTime.h>
#include <maya/MFloatVectorArray.h>
#include <maya/MDoubleArray.h>
#include <maya/MFloatArray.h>
#include <maya/MIntArray.h>
#include <maya/MVectorArray.h>

using namespace std;

class XmlCacheFormat : public MPxCacheFormat
{
public:
    XmlCacheFormat();
    ~XmlCacheFormat();

    static void*    creator();
    static void     setPluginName( const MString& name );
    static MString  translatorName();

    MStatus         isValid();

    MStatus         open( const MString& fileName, FileAccessMode mode );
    void            close();

    MStatus         readHeader();
    MStatus         writeHeader( const MString& version, MTime& startTime, MTime& endTime );

    void            beginWriteChunk();
    void            endWriteChunk();
    MStatus         beginReadChunk();
    void            endReadChunk();

    MStatus         writeTime( MTime& time );
    MStatus         readTime( MTime& time );
    MStatus         findTime( MTime& time, MTime& foundTime );
    MStatus         readNextTime( MTime& foundTime );

    unsigned        readArraySize();

    MStatus         writeDoubleArray( const MDoubleArray& );
    MStatus         readDoubleArray( MDoubleArray&, unsigned size );
    MStatus         writeFloatArray( const MFloatArray& );
    MStatus         readFloatArray( MFloatArray&, unsigned size );
    MStatus         writeDoubleVectorArray( const MVectorArray& array );
    MStatus         readDoubleVectorArray( MVectorArray&, unsigned arraySize );
    MStatus         writeFloatVectorArray( const MFloatVectorArray& array );
    MStatus         readFloatVectorArray( MFloatVectorArray& array, unsigned arraySize );

    MStatus         writeChannelName( const MString& name );
    MStatus         findChannelName( const MString& name );
    MStatus         readChannelName( MString& name );

    MStatus         writeInt32( int );
    int             readInt32();
    MStatus         rewind();
 
    MString         extension();

    bool            handlesDescription();
    MStatus         readDescription( MCacheFormatDescription& description,
                                     const MString& descriptionFileLocation,
                                     const MString& baseFileName );
    MStatus         writeDescription( const MCacheFormatDescription& description,
                                      const MString& descriptionFileLocation,
                                      const MString& baseFileName );

protected:

    static MString  comment( const MString& text );
    static MString  quote( const MString& text );

    static MString  fExtension;
    static MString  fCacheFormatName;

private:
    void            startXmlBlock( string& t );
    void            endXmlBlock();
    void            writeXmlTagValue( string& tag, string value );
    void            writeXmlTagValue( string& tag, int value );
    bool            readXmlTagValue( string tag, MStringArray& value );
    bool            readXmlTagValueInChunk( string tag, MStringArray& values );
    void            readXmlTag( string& value );
    bool            findXmlStartTag( string& tag );
    bool            findXmlStartTagInChunk( string& tag );
    bool            findXmlEndTag( string& tag );
    void            writeXmlValue( string& value );
    void            writeXmlValue( double value );
    void            writeXmlValue( float value );
    void            writeXmlValue( int value );
        
    MString         fFileName;
    fstream         fFile;
    stack<string>   fXmlStack;
    FileAccessMode  fMode;

};

MString XmlCacheFormat::fExtension = "mc";                  // For files on disk
MString XmlCacheFormat::fCacheFormatName = "xml_no_desc";   // For presentation in GUI

inline MString XmlCacheFormat::translatorName()
{
    return fCacheFormatName;
}

void* XmlCacheFormat::creator()
{
    return new XmlCacheFormat();
}


// ****************************************
//
//  Helper functions

string XMLSTARTTAG( string x ) 
{
    return ( "<" + x + ">" );
}

string XMLENDTAG( string x ) 
{
    return ( "</" + x + ">" );
}

string cacheTag("awGeoCache");
string startTimeTag("startTime");
string endTimeTag("endTime");
string versionTag("version");
string timeTag("time"); 
string sizeTag("size");
string intTag("integer32");
string doubleArrayTag("doubleArray");
string floatArrayTag("floatArray");
string doubleVectorArrayTag("doubleVectorArray");
string floatVectorArrayTag("floatVectorArray");
string channelTag("channel");   
string chunkTag("chunk");           
string Autodesk_Cache_File("Autodesk_Cache_File");
string cacheType_Type("cacheType-Type");
string OneFilePerFrame("OneFilePerFrame");
string OneFile("OneFile");
string cacheType_Format("cacheType-Format");
string time_Range("time-Range");
string cacheTimePerFrame_TimePerFrame("cacheTimePerFrame-TimePerFrame");
string cacheVersion_Version("cacheVersion-Version");
string extra("extra");
string Channels("Channels");
string ChannelName("ChannelName");
string ChannelType("ChannelType");
string ChannelInterpretation("ChannelInterpretation");
string SamplingType("SamplingType");
string Double("Double");
string DoubleArray("DoubleArray");
string DoubleVectorArray("DoubleVectorArray");
string Int32Array("Int32Array");
string FloatArray("FloatArray");
string FloatVectorArray("FloatVectorArray");
string Regular("Regular");
string Irregular("Irregular");
string SamplingRate("SamplingRate");
string StartTime("StartTime");
string EndTime("EndTime");

XmlCacheFormat::XmlCacheFormat()
{
}

XmlCacheFormat::~XmlCacheFormat()
{
    close();    
}

MStatus
XmlCacheFormat::open( const MString& fileName, FileAccessMode mode )
{
    bool rtn = true;

    assert((fileName.length() > 0));

    fFileName = fileName;
    
    if( mode == kWrite ) {
        fFile.open(fFileName.asChar(), ios::out);
    }
    else if (mode == kReadWrite) {
        fFile.open(fFileName.asChar(), ios::app);
    } else {
        fFile.open(fFileName.asChar(), ios::in);
    }

    if (!fFile.is_open()) {
        rtn = false;
    } else {
        if (mode == kRead) {
            rtn = readHeader();
        }
    }

    return rtn ? MS::kSuccess : MS::kFailure ;
}


MStatus
XmlCacheFormat::isValid()
{
    bool rtn = fFile.is_open();
    return rtn ? MS::kSuccess : MS::kFailure ;
}

MStatus
XmlCacheFormat::readHeader() 
{
    bool rtn = false;
    if (kWrite != fMode) {
        if( fFile.is_open() ) {
            string tag;
            readXmlTag( tag );

            if( tag == XMLSTARTTAG(cacheTag) ) 
            {
                MStringArray value;
                readXmlTagValue( versionTag, value );

                readXmlTagValue( startTimeTag, value );

                readXmlTagValue( endTimeTag, value );

                readXmlTag( tag );  // Should be header close tag, check
                if( tag != XMLENDTAG(cacheTag) )
                {
                    // TODO - handle this error case
                }

                rtn = true;
            }
        }
    }

    return rtn ? MS::kSuccess : MS::kFailure ;
}

MStatus
XmlCacheFormat::rewind()
{
    if( fFile.is_open() ) 
    {
        close();
            if(!open(fFileName, kRead ))
        {
            return MS::kFailure;
        }
        return MS::kSuccess;
    }
    else
    {
        return MS::kFailure;
    }
}

void XmlCacheFormat::close() 
{
    if( fFile.is_open() ) {
    fFile.close();
    }
}

MStatus XmlCacheFormat::writeInt32( int i ) 
{
        writeXmlTagValue(intTag, i);
    return MS::kSuccess;
}

int
XmlCacheFormat::readInt32()
{
    MStringArray value;
    readXmlTagValue(intTag, value);
    return atoi( value[0].asChar() );
}


MStatus
XmlCacheFormat::writeHeader( const MString& version, MTime& startTime, MTime& endTime )
{
    stringstream oss;

    startXmlBlock(cacheTag);
    string v(version.asChar());
    writeXmlTagValue(versionTag, v);

    oss << startTime;
    writeXmlTagValue(startTimeTag, oss.str() );

    oss.str("");
    oss.clear();
    oss << endTime;
    writeXmlTagValue(endTimeTag, oss.str() );

    endXmlBlock();
    return MS::kSuccess;
}


MStatus
XmlCacheFormat::readTime( MTime& time )
{
    MStringArray timeValue;
    readXmlTagValue(timeTag, timeValue);
    time.setValue( strtod( timeValue[0].asChar(), NULL ) );

    return MS::kSuccess;
}

MStatus
XmlCacheFormat::writeTime( MTime& time )
{
    stringstream oss;
    oss << time;
    writeXmlTagValue(timeTag, oss.str() );
    return MS::kSuccess;
}


MStatus
XmlCacheFormat::findChannelName( const MString& name )
//  
//  Given that the right time has already been found, find the name
//  of the channel we're trying to read.
//
{
    MStringArray value;
    while (readXmlTagValueInChunk(channelTag, value)) 
    {
        if( value.length() == 1 && value[0] == name )
        {
            return MS::kSuccess;
        }
    }

    return MS::kFailure;
}

MStatus
XmlCacheFormat::readChannelName( MString& name )
//  
//  Given that the right time has already been found, find the name
//  of the channel we're trying to read.
//
//  If no more channels exist, return false. Some callers rely on this false return 
//  value to terminate scanning for channels, thus it's not an error condition.
//
//  TODO: the current implementation assumes there are numChannels of data stored
//  for every time.  This assumption needs to be removed.
//
{
    MStringArray value;
    readXmlTagValueInChunk(channelTag, value);

    name = value[0];

    return name.length() == 0 ? MS::kFailure : MS::kSuccess;
}


MStatus
XmlCacheFormat::readNextTime( MTime& foundTime )
//  
// Read the next time based on the current read position.
//
{   
    MTime readAwTime(0.0, MTime::k6000FPS);
    bool ret = readTime(readAwTime);
    foundTime = readAwTime;

    return ret ? MS::kSuccess : MS::kFailure ;
}

MStatus
XmlCacheFormat::findTime( MTime& time, MTime& foundTime )
//  
// Find the biggest cached time, which is smaller or equal to 
// seekTime and return foundTime
//
{
    MTime timeTolerance(0.0, MTime::k6000FPS);
    MTime seekTime(time);
    MTime preTime( seekTime - timeTolerance );
    MTime postTime( seekTime + timeTolerance );

    bool fileRewound = false;
    while (1)
    {
        bool timeTagFound = beginReadChunk();
        if ( ! timeTagFound && !fileRewound )
        {
            if(!rewind())
            {
                return MS::kFailure;
            }
            fileRewound = true;
            timeTagFound = beginReadChunk();
        }
        if ( timeTagFound ) 
        {
            MTime rTime(0.0, MTime::k6000FPS);
            readTime(rTime);

            if(rTime >= preTime && rTime <= postTime)
            {
                foundTime = rTime;
                return MS::kSuccess;
            }
            if(rTime > postTime ) 
            {
                if (!fileRewound) 
                {
                    if(!rewind())
                    {
                        return MS::kFailure;
                    }
                    fileRewound = true;
                } 
                else 
                {
                    // Time could not be found
                    //
                    return MS::kFailure;
                }
            } 
            else 
            {
                fileRewound = true;
            }
            endReadChunk();
        } 
        else
        {
            // Not a valid disk cache file.
            break;
        }
    }

    return MS::kFailure;
}

MStatus
XmlCacheFormat::writeChannelName( const MString& name )
{
    string chan = name.asChar();
    writeXmlTagValue( channelTag, chan );
    return MS::kSuccess;
}


void XmlCacheFormat::beginWriteChunk()
{
    startXmlBlock(chunkTag);
}


void XmlCacheFormat::endWriteChunk()
{
    endXmlBlock();
}

MStatus XmlCacheFormat::beginReadChunk()
{
    return findXmlStartTag(chunkTag) ? MS::kSuccess : MS::kFailure;
}

void XmlCacheFormat::endReadChunk()
{
    findXmlEndTag(chunkTag);
}

MStatus
XmlCacheFormat::writeDoubleArray( const MDoubleArray& array )
{
    int size = array.length();
    assert(size != 0);

    writeXmlTagValue(sizeTag,size);

    startXmlBlock( doubleArrayTag );
    for(int i = 0; i < size; i++)
    {
        writeXmlValue(array[i]);
    }
    endXmlBlock();
    return MS::kSuccess;
}

MStatus
XmlCacheFormat::writeFloatArray( const MFloatArray& array )
{
    int size = array.length();
    assert(size != 0);

    writeXmlTagValue(sizeTag,size);

    startXmlBlock( floatArrayTag );
    for(int i = 0; i < size; i++)
    {
        writeXmlValue(array[i]);
    }
    endXmlBlock();
    return MS::kSuccess;
}

MStatus
XmlCacheFormat::writeDoubleVectorArray( const MVectorArray& array )
{
    int size = array.length();
    assert(size != 0);

    writeXmlTagValue(sizeTag,size);

    startXmlBlock( doubleVectorArrayTag );
    for(int i = 0; i < size; i++)
    {
        writeXmlValue(array[i][0]);
        writeXmlValue(array[i][1]);
        writeXmlValue(array[i][2]);
        string endl("\n");
        writeXmlValue(endl);
    }
    endXmlBlock();
    return MS::kSuccess;
}


MStatus 
XmlCacheFormat::writeFloatVectorArray( const MFloatVectorArray& array )
{
    int size = array.length();
    assert(size != 0);

    writeXmlTagValue(sizeTag,size);

    startXmlBlock( floatVectorArrayTag );
    for(int i = 0; i < size; i++)
    {
        writeXmlValue(array[i][0]);
        writeXmlValue(array[i][1]);
        writeXmlValue(array[i][2]);
        string endl("\n");
        writeXmlValue(endl);
    }
    endXmlBlock();
    return MS::kSuccess;
}


unsigned
XmlCacheFormat::readArraySize()
{
    MStringArray value;

    if (readXmlTagValue(sizeTag, value))
    {
        unsigned readSize = (unsigned) atoi( value[0].asChar() );
        return readSize;
    }

    return 0;
}

MStatus
XmlCacheFormat::readDoubleArray( MDoubleArray& array, unsigned arraySize )
{
    MStringArray value;
    readXmlTagValue(doubleArrayTag, value);

    assert( value.length() == arraySize );
    array.setLength( arraySize );
    for ( unsigned int i = 0; i < value.length(); i++ )
    {
        array[i] = strtod( value[i].asChar(), NULL );
    }
    
    return MS::kSuccess;
}

MStatus
XmlCacheFormat::readFloatArray( MFloatArray& array, unsigned arraySize )
{
    MStringArray value;
    readXmlTagValue(floatArrayTag, value);

    assert( value.length() == arraySize );
    array.setLength( arraySize );
    for ( unsigned int i = 0; i < value.length(); i++ )
    {
        array[i] = (float)strtod( value[i].asChar(), NULL );
    }
    
    return MS::kSuccess;
}

MStatus
XmlCacheFormat::readDoubleVectorArray( MVectorArray& array, unsigned arraySize )
{
    MStringArray value;
    if( !readXmlTagValue(doubleVectorArrayTag, value) )
    {
        return MS::kFailure;
    }

    assert( value.length() == arraySize * 3 );
    array.setLength( arraySize );
    for (unsigned i = 0; i < arraySize; i++ )
    {
        double v[3];
        v[0] = strtod( value[i*3].asChar(), NULL );
        v[1] = strtod( value[i*3+1].asChar(), NULL );
        v[2] = strtod( value[i*3+2].asChar(), NULL );

        array.set( v, i );
    }
    
    return MS::kSuccess;
}

MStatus 
XmlCacheFormat::readFloatVectorArray( MFloatVectorArray& array, unsigned arraySize )
{
    MStringArray value;
    readXmlTagValue(floatVectorArrayTag, value);

    assert( value.length() == arraySize * 3 );

    array.clear();
    array.setLength( arraySize );
    for (unsigned i = 0; i < arraySize; i++ )
    {
        float v[3];
        v[0] = (float)strtod( value[i*3].asChar(), NULL );
        v[1] = (float)strtod( value[i*3+1].asChar(), NULL );
        v[2] = (float)strtod( value[i*3+2].asChar(), NULL );

        array.set(v,i);
    }

    return MS::kSuccess;
}

MString
XmlCacheFormat::extension()
{
    return fExtension;
}

bool
XmlCacheFormat::handlesDescription()
{
    return true;
}

static bool readKeyAndValue( fstream& file, std::string& key, std::string& value )
{
    char line[256];
    for ( ;; )
    {
        if ( file.eof() )
        {
            key.clear();
            value.clear();
            return true;
        }
        if ( !file.good() )
            return false;
        line[0] = 0;
        file.getline( line, sizeof line );
        if ( line[0] != 0 )
            break;
    }
    char* delimiter = strchr( line, '=' );
    if ( delimiter == NULL )
        return false;
    *delimiter = 0;
    key = line;
    value = delimiter+1;
    return true;
}

static bool readValue( fstream& file, const std::string& key, std::string& value )
{
    std::string readKey;
    if ( !readKeyAndValue( file, readKey, value ) )
        return false;
    if ( readKey != key )
        return false;
    return true;
}

static bool readValue( fstream& file, const std::string& key, MTime& time )
{
    std::string value;
    if ( !readValue( file, key, value ) )
        return false;
    double d;
    if ( 1 != sscanf( value.c_str(), "%lf", &d ) )
        return false;
    time = MTime( d, MTime::k6000FPS );
    return true;
}

MStatus
XmlCacheFormat::readDescription( MCacheFormatDescription& description,
                                 const MString& descriptionFileLocation,
                                 const MString& baseFileName )
{
    const MString filename = descriptionFileLocation + baseFileName + ".txt";

    fstream file;
    file.open( filename.asChar(), ios::in );
    if ( !file.is_open() )
        return MS::kFailure;

    char line[256] = "";
    file.getline( line, sizeof line );
    if ( line != Autodesk_Cache_File )
        return MS::kFailure;

    MStatus status = MS::kSuccess;
    int channels = 0;

    while ( file.good() )
    {
        std::string key, value;
        if ( !readKeyAndValue( file, key, value ) ) { status = MS::kFailure; break; }
        if ( key == cacheType_Type )
        {
            MCacheFormatDescription::CacheFileDistribution distribution = MCacheFormatDescription::kNoFile;
            if ( value == OneFilePerFrame )
                distribution = MCacheFormatDescription::kOneFilePerFrame;
            else if ( value == OneFile )
                distribution = MCacheFormatDescription::kOneFile;
            else
            {
                status = MS::kFailure;
                break;
            }
            description.setDistribution( distribution );
        }
        else if ( key == cacheType_Format )
        {
            if ( value != fCacheFormatName.asChar() )
            {
                status = MS::kFailure;
                break;
            }
        }
        else if ( key == time_Range )
        {
            // no-op
        }
        else if ( key == cacheTimePerFrame_TimePerFrame )
        {
            double time = 0.0;
            sscanf( value.c_str(), "%lf", &time );
            if ( time == 0.0 )
            {
                status = MS::kFailure;
                break;
            }
            description.setTimePerFrame( MTime( time, MTime::k6000FPS ) );
        }
        else if ( key == cacheVersion_Version )
        {
            // no-op
        }
        else if ( key == extra )
        {
            description.addDescriptionInfo( MString( value.c_str() ) );
        }
        else if ( key == Channels )
        {
            sscanf( value.c_str(), "%d", &channels );
            break;
        }
    }

    if ( status && !channels )
    {
        status = MS::kFailure;
    }
    if ( status )
    {
        // parse channels
        while ( file.good() )
        {
            std::string key, channelName;
            if ( !readKeyAndValue( file, key, channelName ) ) { status = MS::kFailure; break; }
            if ( key != ChannelName )
                continue;
            std::string interpretation, dataTypeString, samplingTypeString;
            if ( !readValue( file, ChannelType, dataTypeString ) ) { status = MS::kFailure; break; }
            if ( !readValue( file, ChannelInterpretation, interpretation ) ) { status = MS::kFailure; break; }
            if ( !readValue( file, SamplingType, samplingTypeString ) ) { status = MS::kFailure; break; }

            MCacheFormatDescription::CacheDataType dataType;
            if ( dataTypeString == Double )
            {
                dataType = MCacheFormatDescription::kDouble;
            }
            else if ( dataTypeString == DoubleArray )
            {
                dataType = MCacheFormatDescription::kDoubleArray;
            }
            else if ( dataTypeString == DoubleVectorArray )
            {
                dataType = MCacheFormatDescription::kDoubleVectorArray;
            }
            else if ( dataTypeString == Int32Array )
            {
                dataType = MCacheFormatDescription::kInt32Array;
            }
            else if ( dataTypeString == FloatArray )
            {
                dataType = MCacheFormatDescription::kFloatArray;
            }
            else if ( dataTypeString == FloatVectorArray )
            {
                dataType = MCacheFormatDescription::kFloatVectorArray;
            }
            else
            {
                status = MS::kFailure;
                break;
            }

            MCacheFormatDescription::CacheSamplingType samplingType;
            if ( samplingTypeString == Regular )
            {
                samplingType = MCacheFormatDescription::kRegular;
            }
            else if ( samplingTypeString == Irregular )
            {
                samplingType = MCacheFormatDescription::kIrregular;
            }
            else
            {
                status = MS::kFailure;
                break;
            }

            MTime samplingRate, startTime, endTime;
            if ( !readValue( file, SamplingRate, samplingRate ) ) { status = MS::kFailure; break; }
            if ( !readValue( file, StartTime, startTime ) ) { status = MS::kFailure; break; }
            if ( !readValue( file, EndTime, endTime ) ) { status = MS::kFailure; break; }

            description.addChannel( 
                        MString( channelName.c_str() ),
                        MString( interpretation.c_str() ),
                        dataType,
                        samplingType,
                        samplingRate,
                        startTime,
                        endTime,
                        &status );
            if ( !status )
                break;
        }
    }

    file.close();

    return status;
}

MStatus
XmlCacheFormat::writeDescription( const MCacheFormatDescription& description,
                                  const MString& descriptionFileLocation,
                                  const MString& baseFileName )
{
    const MString filename = descriptionFileLocation + baseFileName + ".txt";

    fstream file;
    file.open( filename.asChar(), ios::out );
    if ( !file.is_open() )
        return MS::kFailure;

    MStatus status = MS::kSuccess;

    file << Autodesk_Cache_File << "\n";

    file << cacheType_Type << "=";
    MCacheFormatDescription::CacheFileDistribution distribution = description.getDistribution();
    switch ( distribution )
    {
    case MCacheFormatDescription::kOneFile:         file << OneFile;            break;
    case MCacheFormatDescription::kOneFilePerFrame: file << OneFilePerFrame;    break;
    default:
        status = MS::kFailure;
        break;
    }
    file << "\n";

    file << cacheType_Format << "=" << fCacheFormatName << "\n";

    MTime startTime, endTime;
    description.getStartAndEndTimes( startTime, endTime );
    file << time_Range << "=" << (int)startTime.as( MTime::k6000FPS ) << "-" << (int)endTime.as( MTime::k6000FPS ) << "\n";

    MTime timePerFrame = description.getTimePerFrame();
    file << cacheTimePerFrame_TimePerFrame << "=" << (int)timePerFrame.as( MTime::k6000FPS ) << "\n";

    file << cacheVersion_Version << "=" << "2.0" << "\n";

    MStringArray info;
    description.getDescriptionInfo( info );
    for ( unsigned i=0; i<info.length(); ++i )
        file << extra << "=" << info[i] << "\n";

    unsigned int channels = description.getNumChannels();
    file << Channels << "=" << channels << "\n";

    for ( unsigned i=0; i<channels; ++i )
    {
        MString channelName = description.getChannelName( i );
        MString interpretation = description.getChannelInterpretation( i );
        MCacheFormatDescription::CacheDataType dataType = description.getChannelDataType( i );
        MCacheFormatDescription::CacheSamplingType samplingType = description.getChannelSamplingType( i );
        MTime samplingRate = description.getChannelSamplingRate( i );
        MTime startTime = description.getChannelStartTime( i );
        MTime endTime = description.getChannelEndTime( i );

        file << ChannelName << "=" << channelName << "\n";
        file << ChannelType << "=";
        switch ( dataType )
        {
        case MCacheFormatDescription::kDouble:              file << Double;             break;
        case MCacheFormatDescription::kDoubleArray:         file << DoubleArray;        break;
        case MCacheFormatDescription::kDoubleVectorArray:   file << DoubleVectorArray;  break;
        case MCacheFormatDescription::kInt32Array:          file << Int32Array;         break;
        case MCacheFormatDescription::kFloatArray:          file << FloatArray;         break;
        case MCacheFormatDescription::kFloatVectorArray:    file << FloatVectorArray;   break;
        default:
            status = MS::kFailure;
            break;
        }
        file << "\n";
        file << ChannelInterpretation << "=" << interpretation << "\n";
        file << SamplingType << "=";
        switch ( samplingType )
        {
        case MCacheFormatDescription::kRegular:         file << Regular;        break;
        case MCacheFormatDescription::kIrregular:       file << Irregular;      break;
        default:
            status = MS::kFailure;
            break;
        }
        file << "\n";
        file << SamplingRate << "=" << (int)samplingRate.as( MTime::k6000FPS ) << "\n";
        file << StartTime << "=" << (int)startTime.as( MTime::k6000FPS ) << "\n";
        file << EndTime << "=" << (int)endTime.as( MTime::k6000FPS ) << "\n";
    }

    file.close();

    return status;
}

// ****************************************
//
//  Helper functions
//

void XmlCacheFormat::startXmlBlock( string& t )
{
    fXmlStack.push(t);
    fFile << "<" << t << ">\n";
}


void XmlCacheFormat::endXmlBlock()
{
    string block = fXmlStack.top();
    fFile << "</" << block << ">\n";
    fXmlStack.pop();
}

void XmlCacheFormat::writeXmlTagValue( string& tag, string value )
{
    for (unsigned int i = 0; i < fXmlStack.size(); i++ )
        fFile << "\t";

    fFile << "<" << tag << "> ";    // Extra space is important for reading
    fFile << value;
    fFile << " </" << tag << ">\n"; // Extra space is important for reading
}

void XmlCacheFormat::writeXmlTagValue( string& tag, int value )
{
    for (unsigned int i = 0; i < fXmlStack.size(); i++ )
        fFile << "\t";

    fFile << "<" << tag << "> ";    // Extra space is important for reading
    ostringstream oss;
    oss << value;
    fFile << oss.str();
    fFile << " </" << tag << ">\n"; // Extra space is important for reading
}

bool XmlCacheFormat::readXmlTagValue( string tag, MStringArray& values )
{
    string endTag = XMLENDTAG(tag);
    bool status = true;

    values.clear();

    // Yes this could be much much smarter
    if( findXmlStartTag(tag) )
    {
        string token;
        fFile >> token;
        while ( !fFile.eof() && token != endTag )
        {
            values.append( token.data() );
            fFile >> token;
        } 
    }
    else
    {
        status = false;
    }

    return status;
}


bool XmlCacheFormat::readXmlTagValueInChunk( string tag, MStringArray& values )
{
    string endTag = XMLENDTAG(tag);
    bool status = true;

    values.clear();

    // Find the tag in the currently read chunk.
    if( findXmlStartTagInChunk(tag) )
    {
        string token;
        fFile >> token;
        // Look for the values within the bounds of the tag.
        while ( !fFile.eof() && token != endTag )
        {
            values.append( token.data() );
            fFile >> token;
        } 
    }
    else
    {
        status = false;
    }

    return status;
}

void XmlCacheFormat::readXmlTag( string& value )
{
    value.clear();
        fFile >> value;
}

bool XmlCacheFormat::findXmlStartTag( string& tag )
{
    string tagRead;
    string tagExpected = XMLSTARTTAG(tag);

    fFile >> tagRead;
    // Keep looking all the way to EOF
    while(!fFile.eof() && tagRead != tagExpected) 
    {
        fFile >> tagRead;
    }
    if( tagRead != tagExpected )
    {
    }

    return ( tagRead == tagExpected );
}

bool XmlCacheFormat::findXmlStartTagInChunk( string& tag )
//
// Look for the given tag within the currently read chunk.
//
{
    string tagRead;
    string tagExpected = XMLSTARTTAG(tag);
    string tagEndChunk("</"+chunkTag+">");

    fFile >> tagRead;

    // Keep looking all the way to EOF
    while((!fFile.eof()) && (tagRead != tagExpected) && (tagRead != tagEndChunk)) 
    {
        fFile >> tagRead;
    }
    if( (tagRead != tagExpected) && (tagRead != tagEndChunk) )
    {
    }

    return ( tagRead == tagExpected );
}

bool XmlCacheFormat::findXmlEndTag(string& tag)
{
    string tagRead;
    string tagExpected("</"+tag+">");

    fFile >> tagRead;
    if( tagRead != tagExpected )
    {
    }

    return ( tagRead == tagExpected );
}

void XmlCacheFormat::writeXmlValue( string& value )
{
    fFile << value << " ";
}

void XmlCacheFormat::writeXmlValue( double value )
{
    fFile << value << " ";
}

void XmlCacheFormat::writeXmlValue( float value )
{
    fFile << value << " ";
}

void XmlCacheFormat::writeXmlValue( int value )
{
    fFile << value << " ";
}



// ****************************************

MStatus initializePlugin( MObject obj )
{
    MFnPlugin plugin( obj, PLUGIN_COMPANY, "1.0", "Any" );

    plugin.registerCacheFormat(
        XmlCacheFormat::translatorName(),
        XmlCacheFormat::creator
    );

    return MS::kSuccess;
}


MStatus uninitializePlugin( MObject obj )
{
    MFnPlugin plugin( obj );

    plugin.deregisterCacheFormat( XmlCacheFormat::translatorName() );

    return MS::kSuccess;
}