FnFileSequence.h

// Copyright (c) 2012 The Foundry Visionmongers Ltd. All Rights Reserved.

#ifndef FNFILESEQ__H
#define FNFILESEQ__H

#include <memory>
#include <string>
#include <vector>

#include <FnAttribute/FnAttribute.h>
#include <FnPlatform/internal/Portability.h>
#include <FnPlatform/internal/UniquePtr.h>
#include <FnPluginSystem/FnPlugin.h>
#include <FnPluginSystem/FnPluginSystem.h>

#include <FnAsset/FnAssetAPI.h>
#include <FnAsset/suite/FnAssetSuite.h>

namespace Foundry
{
  namespace Katana
  {
    class FileSequenceArray;

    class FNASSET_API FileSequence
    {
    public:
        FileSequence() {}
        FNKAT_DEPRECATED FileSequence(const std::string& /*fileseq*/)
        { /* Empty */
        }
        virtual ~FileSequence()
        { /* Empty */
        }

        virtual bool isValid() const = 0;

        virtual FileSequence* clone() const = 0;

        virtual void getAsString(std::string& retValue) = 0;

        virtual void getDirectory(std::string& retValue) = 0;

        virtual void getPrefix(std::string& retValue) = 0;

        virtual void getSuffix(std::string& retValue) = 0;

        virtual unsigned int getPadding() = 0;

        virtual void getResolvedPath(const int frame,
                                     std::string& retValue) = 0;

        virtual bool hasFrameSet() = 0;

        virtual bool isFrameInFrameSet(const int frame) = 0;

        virtual int getFirstFrameInFrameSet() = 0;

        virtual int getLastFrameInFrameSet() = 0;

        virtual void getNearestFramesInFrameSet(int frame,
                                                bool* hasLeft,
                                                int* nearestLeft,
                                                bool* hasRight,
                                                int* nearestRight) = 0;

        virtual void getFrameListFromFrameSet(std::vector<int>& returnList) = 0;

        static FnPlugStatus setHost(FnPluginHost* host);
        static FnPluginHost* getHost();

        static FnFileSequencePluginSuite_v1 createSuite(
            FnFileSequenceHandle (*create)(const char*,
                                           FnAttributeHandle* errorMessage),
            bool (*isFileSequence)(const char*,
                                   FnAttributeHandle* errorMessage),
            FnAttributeHandle (*buildFileSequenceString)(
                const char* prefix,
                const char* suffix,
                int padding,
                FnAttributeHandle* errorMessage),
            FnFileSequenceArrayHandle (*findSequence)(
                const char** fileList,
                unsigned int fileCount,
                FnAttributeHandle* errorMessage));

        static FnFileSequenceHandle newFileSequenceHandle(FileSequence* fs);
        static FnFileSequenceArrayHandle newFileSequenceArrayHandle(
            FileSequenceArray* fs);

        static unsigned int _apiVersion;
        static const char* _apiName;

    private:
      static FnPluginHost *_host;

    };

    class FNASSET_API FileSequenceArray
    {
    public:
      FileSequenceArray(std::vector<FileSequence*>& seq, std::vector<std::string>& nonseq) :
        _seq(seq),
        _nonseq(nonseq)
      {
        // Empty
      }

      virtual ~FileSequenceArray()
      {
        for (unsigned int i=0; i<_seq.size(); ++i)
        {
          delete _seq[i];
          _seq[i] = 0;
        }
        _seq.clear();
      }

      virtual int getFileSequenceCount()
      {
        return _seq.size();
      }

      virtual FileSequence* getFileSequence(const unsigned int index)
      {
        return _seq[index];
      }

      virtual void getFileNames(std::vector<std::string>& fileNames)
      {
        fileNames = _nonseq;
      }

    private:
      std::vector<FileSequence*>        _seq;
      std::vector<std::string>          _nonseq;
    };

  };  // namespace Katana
}; // namespace Foundry

namespace FnKat = Foundry::Katana;


// Plugin Registering Macro.

#define DEFINE_FS_PLUGIN(FS_CLASS)                                                              \
                                                                                                \
  FnPlugin FS_CLASS##_plugin;                                                                   \
                                                                                                \
  FnFileSequenceHandle FS_CLASS##_create(const char* fileseq, FnAttributeHandle *errorMessage)  \
  {                                                                                             \
    try                                                                                         \
    {                                                                                           \
      return Foundry::Katana::FileSequence::newFileSequenceHandle(FS_CLASS::create(fileseq));   \
    }                                                                                           \
    catch (std::exception & e)                                                                  \
    {                                                                                           \
      Foundry::Katana::Attribute errorAttr = Foundry::Katana::StringAttribute(e.what());        \
      *errorMessage = errorAttr.getRetainedHandle();                                            \
      return 0x0;                                                                               \
    }                                                                                           \
  }                                                                                             \
                                                                                                \
  bool FS_CLASS##_isFileSequence(const char* fileseq, FnAttributeHandle *errorMessage)          \
  {                                                                                             \
    try                                                                                         \
    {                                                                                           \
      return FS_CLASS::isFileSequence(fileseq);                                                 \
    }                                                                                           \
    catch (std::exception & e)                                                                  \
    {                                                                                           \
      Foundry::Katana::Attribute errorAttr = Foundry::Katana::StringAttribute(e.what());        \
      *errorMessage = errorAttr.getRetainedHandle();                                            \
      return false;                                                                             \
    }                                                                                           \
  }                                                                                             \
                                                                                                \
                                                                                                \
  FnAttributeHandle FS_CLASS##_buildFileSequenceString(const char *prefix,                      \
                                                       const char *suffix,                      \
                                                       int padding,                             \
                                                       FnAttributeHandle *errorMessage)         \
  {                                                                                             \
    try                                                                                         \
    {                                                                                           \
      std::string prefixStr = std::string(prefix);                                              \
      std::string suffixStr  = std::string(suffix);                                             \
      std::string fileSeqStr = FS_CLASS::buildFileSequenceString(prefixStr, suffixStr, padding);\
      FnAttribute::Attribute resultAttr = FnAttribute::StringAttribute(fileSeqStr.c_str());     \
      return resultAttr.getRetainedHandle();                                                    \
    }                                                                                           \
    catch (std::exception & e)                                                                  \
    {                                                                                           \
      Foundry::Katana::Attribute errorAttr = Foundry::Katana::StringAttribute(e.what());        \
      *errorMessage = errorAttr.getRetainedHandle();                                            \
      return 0x0;                                                                               \
    }                                                                                           \
  }                                                                                             \
                                                                                                \
                                                                                                \
  FnFileSequenceArrayHandle FS_CLASS##_findSequence(const char** fileList,                      \
                                                    unsigned int fileCount,                     \
                                                    FnAttributeHandle *errorMessage)            \
  {                                                                                             \
    try                                                                                         \
    {                                                                                           \
      return Foundry::Katana::FileSequence::newFileSequenceArrayHandle(                         \
        FS_CLASS::findSequence(fileList, fileCount));                                           \
    }                                                                                           \
    catch (std::exception & e)                                                                  \
    {                                                                                           \
      Foundry::Katana::Attribute errorAttr = Foundry::Katana::StringAttribute(e.what());        \
      *errorMessage = errorAttr.getRetainedHandle();                                            \
      return 0x0;                                                                               \
    }                                                                                           \
  }                                                                                             \
                                                                                                \
  FnFileSequencePluginSuite_v1 FS_CLASS##_suite =                                               \
    Foundry::Katana::FileSequence::createSuite(FS_CLASS##_create,                               \
                                               FS_CLASS##_isFileSequence,                       \
                                               FS_CLASS##_buildFileSequenceString,              \
                                               FS_CLASS##_findSequence);                        \
                                                                                                \
  const void* FS_CLASS##_getSuite()                                                             \
  {                                                                                             \
    return &FS_CLASS##_suite;                                                                   \
  }                                                                                             \



struct FnFileSequenceStruct
{
public:
  FnFileSequenceStruct(Foundry::Katana::FileSequence *context) :
    _fileSequence(context)
  {
    // Empty
  }

  ~FnFileSequenceStruct() { /* Empty */ };

  Foundry::Katana::FileSequence& getFileSequence()
  {
    return *_fileSequence;
  }

private:
  FnPlatform::internal::UniquePtr<Foundry::Katana::FileSequence>::type
      _fileSequence;
};

struct FnFileSequenceArrayStruct
{
  public:
    FnFileSequenceArrayStruct(Foundry::Katana::FileSequenceArray* context) :
      _fileSequenceArray(context)
    {
      // Empty
    }

    ~FnFileSequenceArrayStruct()
    {
      // Empty
    }

    Foundry::Katana::FileSequenceArray& getFileSequenceArray()
    {
      return *_fileSequenceArray;
    }

  private:
    FnPlatform::internal::UniquePtr<Foundry::Katana::FileSequenceArray>::type
        _fileSequenceArray;
};



#endif  // #ifndef FNFILESEQ__H