utility.h

Go to the documentation of this file.

#ifndef LWPP_UTILITY
#define LWPP_UTILITY

#include <lwpp/debug.h>

#include <lwenvel.h>
#include <lwxpanel.h>
#include <algorithm>

namespace lwpp
{
  #pragma warning(disable : 4996)

  class Nameable
  {
  public:
    std::string name;
  public:
    /*
     * @param _name Optional name to set the object to
     */
    explicit Nameable(const char *_name = 0) {SetName(_name);}
    explicit Nameable(std::string _name) {SetName(_name);}
    virtual ~Nameable() {;}
    virtual Nameable &operator=(const Nameable &from)
    {
      if (this != &from) 
      {
        name = from.name;
      }
      return *this;
    }
    virtual void SetName(const std::string _name)
    {
      name = _name;
    }
    virtual void SetName(const char *_name)
    {
      if (_name == 0)
      {
        name.clear(); // empty string       
      }
      else
      {
        SetName (std::string(_name));
      }
    }
    /*
    virtual const char *GetName() const
    {
      return name.empty() ? 0 : name.c_str();
    }
    */

    virtual const std::string &GetName() const
    {
      return name;
    }
  };

  class ReferenceCounted
  {
    public:
      int nReferences;
      ReferenceCounted() : nReferences(0) {}
    private:
      ReferenceCounted(const ReferenceCounted &);
      ReferenceCounted &operator=(const ReferenceCounted &);
  };

  template <class T>
  class Reference
  {
    private:
      T *ptr;
    public:
      Reference(T *p = 0)
        : ptr(p)
      {
        if (ptr) ++ptr->nReferences;
      }
      Reference(const Reference<T> &r)
      {
        ptr = r.ptr;
        if (ptr) ++ptr->nReferences;
      }
      Reference &operator=(const Reference<T> &r)
      {
        if (r.ptr) r.ptr->nReferences++;
        if (ptr && --ptr->nReferences == 0) delete ptr;
        ptr = r.ptr;
        return *this;
      }

      Reference &operator=(T *p)
      {
        if (p) p->nReferences++;
        if (ptr && --ptr->nReferences == 0) delete ptr;
        ptr = p;
        return *this;
      }
      ~Reference()
      {
        if (ptr && --ptr->nReferences == 0) delete ptr;
      }
      T *operator->()
      {
        assert(ptr);
        return ptr;
      }
      T *adress() const
      {
        return ptr;
      }
      const T *operator->() const
      {
        assert(ptr);
        return ptr;
      }
      operator bool() const {return ptr != 0;}
      bool operator<(const Reference<T> &r) const
      {
        return ptr < r.ptr;
      }
  };

  void OpenURL(const std::string urlString);
  /*
  {
    // Thanks to Willard Myers, on the qt-interest mailing list.
    ICInstance icInstance;
    if (ICStart ( &icInstance, '????') == noErr)  
    {
      ConstStr255Param hint (0x0);
      long l = urlString.length();
      long s = 0;
      ICLaunchURL (icInstance, hint, urlString.c_str(), l, &s, &l);
      ICStop (icInstance);
    }
  };
      */

  bool isDoubleClick(unsigned int milliseconds);

  struct to_lower
  {
    int operator() ( int ch )
    {
      return ::tolower ( ch );
    }
  };

  inline std::string &toLowercase(std::string &str)
  {
    std::transform (str.begin (), str.end (), str.begin (), to_lower());
    return str;
  }

  inline std::string &toCapitalize(std::string &str)
  {
    bool caps = true;
    for (size_t i = 0; i < str.length(); ++i)
    {
      if (caps)
      {
        str[i] = (char)::toupper(str[i]);
        caps = false;
      }
      else
      {
        str[i] = (char)::tolower(str[i]);
      }
      caps = str[i] == ' ';
    }
    return str;
  } 

  bool inline nocase_compare (const char c1, const char c2)
  {
      return ::toupper(c1) == ::toupper(c2);
  }

  bool inline cmpNoCase(const std::string &s1, const std::string &s2)
  {
    std::string::const_iterator pos;
    pos = std::search (s1.begin(),s1.end(),   // haystack
                           s2.begin(),s2.end(),   // needle
                            nocase_compare);    // comparison criterion
    return (pos != s1.end());
  }

}

#endif //LWPP_UTILITY