FnAsset.h

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

#ifndef FNASSET__H
#define FNASSET__H

#include <FnPlatform/internal/UniquePtr.h>
#include <FnPluginSystem/FnPluginSystem.h>
#include <FnPluginSystem/FnPlugin.h>
#include <FnAsset/FnAssetAPI.h>
#include <FnAsset/suite/FnAssetSuite.h>

#include <FnAttribute/FnAttribute.h>

#include <string>
#include <memory>
#include <map>

namespace Foundry
{
  namespace Katana
  {
    class AssetTransaction;

    class FNASSET_API Asset
    {
    public:
      typedef std::map<std::string, std::string> StringMap;
      typedef std::vector<std::string> StringVector;

      Asset() { /* Empty */ }
      virtual ~Asset() { /* Empty */ }

      virtual void  reset() = 0;

      virtual bool  isAssetId(const std::string& str) = 0;

      virtual bool  containsAssetId(const std::string& str) = 0;

      virtual bool checkPermissions(const std::string &assetId, const StringMap &context) = 0;

      virtual bool runAssetPluginCommand(const std::string &assetId, const std::string &command, const StringMap &commandArgs) = 0;

      virtual void  resolveAsset(const std::string& assetId, std::string& ret) = 0;

      virtual void  resolveAllAssets(const std::string& str, std::string& ret) = 0;

      virtual void  resolvePath(const std::string& str, const int frame, std::string& ret) = 0;

      virtual void  resolveAssetVersion(const std::string& assetId,
        std::string& ret, const std::string& versionStr = std::string()) = 0;

      virtual void  getUniqueScenegraphLocationFromAssetId(const std::string& assetId,
              bool includeVersion, std::string& ret) = 0;

      virtual void getAssetDisplayName(const std::string& assetId, std::string& ret) = 0;

      virtual void getAssetVersions(const std::string& assetId, StringVector& ret) = 0;

      virtual void  getRelatedAssetId(const std::string& assetId, const std::string& relation,
        std::string& ret) = 0;

      virtual void  getAssetFields(const std::string& assetId, bool includeDefaults,
        StringMap& returnFields) = 0;

      virtual void  buildAssetId(const StringMap& fields, std::string& ret) = 0;

      virtual void  getAssetAttributes(const std::string& assetId, const std::string& scope,
        StringMap& returnAttrs) = 0;

      virtual void  setAssetAttributes(const std::string& assetId, const std::string& scope,
        const StringMap& attrs) = 0;

      virtual void  getAssetIdForScope(const std::string& assetId, const std::string& scope,
        std::string& ret) = 0;

      virtual void  createAssetAndPath(AssetTransaction* txn, const std::string& assetType,
        const StringMap& assetFields, const StringMap& args, bool createDirectory,
        std::string& assetId) = 0;

      virtual void  postCreateAsset(AssetTransaction* txn, const std::string& assetType,
              const StringMap& assetFields, const StringMap& args,
              std::string& assetId) = 0;


      virtual AssetTransaction * createTransaction();

      static FnPlugStatus             setHost(FnPluginHost* host);
      static FnPluginHost*            getHost();
      static FnAssetPluginSuite_v1    createSuite(FnAssetHandle (*create)());

      static FnAssetHandle            newAssetHandle(Asset* asset);
      static FnAssetTransactionHandle newAssetTransactionHandle(AssetTransaction* txn);

      static unsigned int           _apiVersion;
      static const char*            _apiName;

    private:
      static FnPluginHost*          _host;

    };

    class FNASSET_API AssetTransaction
    {
    public:
      AssetTransaction() {/* Empty */}
      virtual ~AssetTransaction() {/* Empty */}

      virtual void cancel() = 0;

      virtual bool commit() = 0;
    };

    class FNASSET_API SimpleAction
    {
    public:
      virtual ~SimpleAction() {}
      virtual bool doit() = 0;
      virtual void rollback() = 0;
    };

    class FNASSET_API SimpleTransaction : public AssetTransaction
    {
    public:
      virtual ~SimpleTransaction();

      void addAction(SimpleAction *action);

      void cancel();

      bool commit();

    private:
      std::vector<SimpleAction *> _actions;

      void _clearActions();
    };

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

namespace FnKat = Foundry::Katana;


#define DEFINE_ASSET_PLUGIN(ASSET_CLASS)                                    \
                                                                            \
  FnPlugin ASSET_CLASS##_plugin;                                            \
                                                                            \
  FnAssetHandle ASSET_CLASS##_create()                                      \
  {                                                                         \
    return Foundry::Katana::Asset::newAssetHandle(ASSET_CLASS::create());   \
  }                                                                         \
                                                                            \
  FnAssetPluginSuite_v1 ASSET_CLASS##_suite =                               \
    Foundry::Katana::Asset::createSuite(ASSET_CLASS##_create);              \
                                                                            \
  const void* ASSET_CLASS##_getSuite()                                      \
  {                                                                         \
    return &ASSET_CLASS##_suite;                                            \
  }                                                                         \


struct FnAssetStruct
{
public:
  FnAssetStruct(Foundry::Katana::Asset* asset) :
    _asset(asset) { /* Empty */ }
  ~FnAssetStruct() { /* Empty */ }

  Foundry::Katana::Asset& getAsset()
  {
      return *_asset;
  }

private:
  FnPlatform::internal::UniquePtr<Foundry::Katana::Asset>::type _asset;
};

struct FnAssetTransactionStruct
{
public:
  FnAssetTransactionStruct(Foundry::Katana::AssetTransaction* txn) :
    _assetTransaction(txn) { /* Empty */ }
  ~FnAssetTransactionStruct() { /* Empty */ }

  Foundry::Katana::AssetTransaction& getAssetTransaction()
  {
    return *_assetTransaction;
  }

private:
  FnPlatform::internal::UniquePtr<Foundry::Katana::AssetTransaction>::type
      _assetTransaction;
};


#endif  // #ifndef FNASSET__H