global.h

Go to the documentation of this file.

#ifndef LWPP_GLOBAL_H
#define LWPP_GLOBAL_H
#include <lwpp/debug.h>
#include <lwrender.h>
#include <lwglobsrv.h>
#include <lwpp/lw_version.h>
#include <lwpp/lw_server.h>
#include <lwpp/exception.h>
#include <lwhost.h>

#ifndef NULL
#define NULL 0
#endif // 0

#if defined(_MSC_VER)
// C4661: '...' : no suitable definition provided for explicit template instantiation request
#pragma warning(disable: 4661)
#endif

#define TOKENIZE(x) x

#define IMPLEMENT_GLOBAL(base, name) \
template<> base * GlobalBase< base >::globPtr = 0; \
template<> size_t GlobalBase< base >::usage_count = 0; \
template<> const char * GlobalBase< base >::m_globalName = name;

#define IMPLEMENT_NAMED_GLOBAL(base, name) \
template<> base * nGlobalBase< base, name>::globPtr = 0; \
template<> size_t nGlobalBase< base, name>::usage_count = 0;

namespace lwpp
{
  // LW version information
  class LightWave
  {
    static unsigned int systemID;
    static unsigned int productInfo;
  public:
    void static Init(void);
    unsigned int static Context(void)
    {
      return (systemID & LWSYS_TYPEBITS);
    }
    unsigned int static DongleID(void)
    {
      Init();
      #define LWSYS_NEW_SERIALBITS 0x0000FFFF // redefine, this seems to be a bug in the SDK ... or modeler
      return (systemID & LWSYS_NEW_SERIALBITS);
      //return (systemID & LWSYS_SERIALBITS);
    }
    bool static isLayout()
    {
      return (Context() == LWSYS_LAYOUT);
    }
    bool static isModeler()
    {
      return (Context() == LWSYS_MODELER);
    }
    bool static isScreamernet()
    {
      return (Context() == LWSYS_SCREAMERNET);
    }
    unsigned int static Major()
    {
      return LWINF_GETMAJOR(productInfo);
    }
    unsigned int static Minor()
    {
      return LWINF_GETMINOR(productInfo);
    }

    unsigned int static Build()
    {
      return LWINF_GETBUILD(productInfo);
    }
    static bool isAtLeast(const unsigned int major, const unsigned int minor)
    {
      if (major < Major()) return true;
      if (major > Major()) return false;
      if (minor <= Minor()) return true;
      return false;
    }
    static bool is(const unsigned int major, const unsigned int minor)
    {
      return (major == Major()) && (minor == Minor());
    }
    static bool isAtLeast(const unsigned int major, const unsigned int minor, const unsigned build)
    {
      if (isAtLeast(major, minor))
      {
        return (build >= Build());
      }
      return false;
    }
    int static GetNumCores();
  };


  extern GlobalFunc *SuperGlobal;

  void SetSuperGlobal(GlobalFunc *g);


  template<class G>
  class GlobalBase
  {
  private:
    static const char *m_globalName; 
    static size_t usage_count; 
  protected:
    static G   *globPtr; 
    bool _acquireGlobal()
    {
      return (globPtr = reinterpret_cast<G *> (SuperGlobal(m_globalName, GFUSE_ACQUIRE))) != 0;
    }
  public:
    GlobalBase()
    {
      if (usage_count < 1)
      {
        if (_acquireGlobal())
        {
          usage_count++;
        }
        else
        {
          //throw MissingGlobal(name);
        }
      }
    }
    virtual ~GlobalBase()
    {
#ifdef _DEBUG
    //lwpp::dostream dout;
    //dout << "Releasing Global: " << m_name << " (Post)\n";
#endif
      usage_count--;
      if (usage_count == 0)
      {
        SuperGlobal(m_globalName, GFUSE_RELEASE); // release global
      }
    }

    virtual bool available() const
    {
      return (globPtr != 0);
    }

    G* operator->() {return globPtr;}

    virtual G *getGlobal() {return globPtr;}
  };

  class genericGlobal
  {
  public:
    genericGlobal() {}
    virtual ~genericGlobal() {}
  };

  template<typename G, const char *globalName>
  class nGlobalBase : public genericGlobal
  {
  private:
    static size_t usage_count; 
  protected:
    static G   *globPtr; 
  public:
    explicit nGlobalBase()
    {
      if ((globPtr = reinterpret_cast<G *> (SuperGlobal(globalName, GFUSE_ACQUIRE))) != 0)
      {
        usage_count++;
      }
      else
      {
        //throw MissingGlobal(name);
      }
    }
    virtual ~nGlobalBase()
    {
#ifdef _DEBUG
    //lwpp::dostream dout;
    //dout << "Releasing Global: " << m_name << " (Post)\n";
#endif
      usage_count--;
      if (usage_count == 0)
      {
        SuperGlobal(globalName, GFUSE_RELEASE); // release global
      }
    }

    virtual bool available()
    {
      return (globPtr != 0);
    }

    G* operator->() {return globPtr;}

    virtual G *getGlobal() {return globPtr;}
  };

  template<class T>
  class TransientGlobalBase
  {
  protected:
    static T  *globPtr;
  public:
    explicit TransientGlobalBase(const char *global_name)
    {
      globPtr = static_cast<T *> (SuperGlobal(global_name, GFUSE_TRANSIENT));
    }
  };

  template <class T>
  T *getTransGlobal(const char *globalName)
  {
    return static_cast<T *> (SuperGlobal(globalName, GFUSE_TRANSIENT));
  }


  class GlobalMemory : protected GlobalBase<LWGlobalPool>
  {
  public:
    GlobalMemory() {}
    LWMemChunk first(void) {return globPtr->first();}
    LWMemChunk next(LWMemChunk chunk) {return globPtr->next(chunk);}
    const char *ID(LWMemChunk chunk) {return globPtr->ID(chunk);}
    int size(LWMemChunk chunk) {return globPtr->size(chunk);}
    LWMemChunk find(const char *ID) {return globPtr->find(ID);}
    LWMemChunk create(const char *ID, int size) {return globPtr->create(ID, size);}

    template <class T>
    T *Find (const char *ID)
    {
      return static_cast<T *>(globPtr->find(ID));
    }
    template <class T>
    T* Create(const char *ID)
    {
      return static_cast<T *>(globPtr->create(ID, sizeof(T)));
    }
    /*
    template <class T>
    bool Get(const char *ID, T*& type)
    {
      type = Find<T>(ID);
      if (type) return true;
      type = Create<T>(ID);
      return false;
    }
    */

    template <class T>
    bool Get(const char *ID, T*& type, T& defaultVal)
    {
      if (available())
      {
        type = Find<T>(ID);
        if (type) return true;
        type = Create<T>(ID);
        return false;
      }
      else // if the global is not available, return a default value
      {
        type = &defaultVal;
        return true;
      }
    }
  };


  class ServerInfo : public GlobalBase<LWServerInfo>
  {
  public:
    const char *getPath(std::string server_class, std::string server_name)
    {
      if (available()) return globPtr->path(server_class.c_str(), server_name.c_str());
      return 0;
    }
  };

  class CustomGlobal
  {
    public:
      CustomGlobal(const char *name, ActivateFunc *activate, ServerTagInfo *tags)
      {
        LWServer::AddPlugin(LWGLOBALSERVICE_CLASS, name, activate, tags);
      }
  };

  namespace lwsdk10 
  {
    //#define LWSERVERINFO_GLOBAL "LW Server Info"

    typedef struct st_LWServerInfo
    {
        const char*  (*path)        (const char* server_class,const char* server_name);
        const char** (*list)        (const char* server_class);
    } LWServerInfo;
  }

  class ServerInfo10 : public GlobalBase<lwsdk10::LWServerInfo>
  {
  public:
    const char *getPath(std::string server_class, std::string server_name)
    {
      if (available()) return globPtr->path(server_class.c_str(), server_name.c_str());
      return 0;
    }
    std::vector<std::string> getList (std::string server_class)
    {
      std::vector<std::string> pList;
      const char **plugList = globPtr->list(server_class.c_str());
      if (plugList)
      {
        int i = 0;
        while (plugList[i])
        {
          pList.push_back(plugList[i]);
          ++i;
        }
      }
      return pList;
    }
  };

} // end namespace lwpp

#endif // LWPP_GLOBAL