sbPropertyBagUtils.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 :miv */
/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2010 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

#ifndef SB_PROPERTY_BAG_UTILS_H__
#define SB_PROPERTY_BAG_UTILS_H__

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Property bag utilities defs.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Property bag utilities imported services.
//
//------------------------------------------------------------------------------

// Songbird imports.
#include <sbVariantUtils.h>

// Mozilla imports.
#include <nsIWritablePropertyBag.h>
#include <nsIWritablePropertyBag2.h>


//------------------------------------------------------------------------------
//
// Property bag helper classes.
//
//------------------------------------------------------------------------------

// Forward declarations.
class sbPropertyBagHelper;

class sbPropertyHelper
{
  //----------------------------------------------------------------------------
  //
  // Public interface.
  //
  //----------------------------------------------------------------------------

public:

  sbPropertyHelper(nsIPropertyBag*  aPropertyBag,
                   const nsAString& aKey,
                   nsresult*        aRV = nsnull) :
    mPropertyBag(aPropertyBag),
    mKey(aKey),
    mRV(aRV),
    mInternalRV(NS_OK)
  {
    // Use internal return value if none specified.
    if (!mRV)
      mRV = &mInternalRV;
  }


  explicit sbPropertyHelper(nsresult* aRV = nsnull) :
    mRV(aRV),
    mInternalRV(NS_OK)
  {
    // Use internal return value if none specified.
    if (!mRV)
      mRV = &mInternalRV;
  }


  template<class T>
  operator T() const
  {
    // Validate state.
    NS_ENSURE_TRUE(mPropertyBag, T());

    // Get the value as a variant.
    nsCOMPtr<nsIVariant> value;
    *mRV = mPropertyBag->GetProperty(mKey, getter_AddRefs(value));
    NS_ENSURE_SUCCESS(*mRV, T());

    // Return the value.
    return sbVariantHelper(value, mRV);
  }


  template <class T>
  sbPropertyHelper& operator=(T aValue)
  {
    // Validate state.
    NS_ENSURE_TRUE(mPropertyBag, *this);

    // Get a writable property bag.
    nsCOMPtr<nsIWritablePropertyBag>
      propertyBag = do_QueryInterface(mPropertyBag, mRV);
    NS_ENSURE_SUCCESS(*mRV, *this);

    // Set the property value.
    *mRV = propertyBag->SetProperty(mKey, sbNewVariant(aValue));
    NS_ENSURE_SUCCESS(*mRV, *this);

    return *this;
  }


  sbPropertyHelper& operator=(nsIVariant* aValue)
  {
    // Validate state.
    NS_ENSURE_TRUE(mPropertyBag, *this);

    // Get a writable property bag.
    nsCOMPtr<nsIWritablePropertyBag>
      propertyBag = do_QueryInterface(mPropertyBag, mRV);
    NS_ENSURE_SUCCESS(*mRV, *this);

    // Set the property value.
    *mRV = propertyBag->SetProperty(mKey, aValue);
    NS_ENSURE_SUCCESS(*mRV, *this);

    return *this;
  }


  sbPropertyHelper operator[](const char* aKey)
  {
    // Validate state.
    NS_ENSURE_TRUE(mPropertyBag, sbPropertyHelper(mRV));

    // Get the property bag.
    nsCOMPtr<nsIPropertyBag2>
      propertyBag = do_QueryInterface(mPropertyBag, mRV);
    NS_ENSURE_SUCCESS(*mRV, sbPropertyHelper(mRV));

    // Get the value property bag.
    nsCOMPtr<nsIPropertyBag> valuePropertyBag;
    *mRV = propertyBag->GetPropertyAsInterface(mKey,
                                               NS_GET_IID(nsIPropertyBag),
                                               getter_AddRefs(valuePropertyBag));
    NS_ENSURE_SUCCESS(*mRV, sbPropertyHelper(mRV));

    // Return the value.
    return sbPropertyHelper(valuePropertyBag, sbAutoString(aKey), mRV);
  }

  nsresult rv()
  {
    return *mRV;
  }


  //----------------------------------------------------------------------------
  //
  // Protected interface.
  //
  //----------------------------------------------------------------------------

private:

  //
  // mPropertyBag               Bag containing property.
  // mKey                       Property key.
  // mRV                        Pointer to return value.
  // mInternalRV                Internal return value storage.
  //

  nsCOMPtr<nsIPropertyBag>      mPropertyBag;
  nsString                      mKey;
  nsresult*                     mRV;
  nsresult                      mInternalRV;
};


class sbPropertyBagHelper
{
  //----------------------------------------------------------------------------
  //
  // Public interface.
  //
  //----------------------------------------------------------------------------

public:

  // Forward nsIPropertyBag methods.
  NS_FORWARD_SAFE_NSIPROPERTYBAG(mPropertyBag)
  NS_FORWARD_SAFE_NSIPROPERTYBAG2(mPropertyBag2)
  NS_FORWARD_SAFE_NSIWRITABLEPROPERTYBAG(mWritablePropertyBag)
  NS_FORWARD_SAFE_NSIWRITABLEPROPERTYBAG2(mWritablePropertyBag2)


  
  sbPropertyBagHelper(nsresult* aRV = nsnull) :
    mRV(aRV),
    mInternalRV(NS_OK)
  {
    // Use internal return value if none specified.
    if (!mRV)
      mRV = &mInternalRV;

    // Create property bag.
    mPropertyBag =
      do_CreateInstance("@songbirdnest.com/moz/xpcom/sbpropertybag;1", mRV);
    NS_ENSURE_SUCCESS(*mRV, /* void */);
    mPropertyBag2 = do_QueryInterface(mPropertyBag);
    mWritablePropertyBag = do_QueryInterface(mPropertyBag);
    mWritablePropertyBag2 = do_QueryInterface(mPropertyBag);
  }


  sbPropertyBagHelper(nsISupports* aPropertyBag,
                      nsresult*    aRV = nsnull) :
    mRV(aRV),
    mInternalRV(NS_OK)
  {
    // Use internal return value if none specified.
    if (!mRV)
      mRV = &mInternalRV;

    // Get the property bag.
    mPropertyBag = do_QueryInterface(aPropertyBag, mRV);
    NS_ENSURE_SUCCESS(*mRV, /* void */);
    mPropertyBag2 = do_QueryInterface(aPropertyBag);
    mWritablePropertyBag = do_QueryInterface(mPropertyBag);
    mWritablePropertyBag2 = do_QueryInterface(mPropertyBag);
  }


  nsIPropertyBag* GetBag()
  {
    return mPropertyBag;
  }

  operator nsIPropertyBag*() const
  {
    return mPropertyBag;
  }

  operator nsIPropertyBag2*() const
  {
    return mPropertyBag2;
  }

  operator nsIWritablePropertyBag*() const
  {
    return mWritablePropertyBag;
  }

  operator nsIWritablePropertyBag2*() const
  {
    return mWritablePropertyBag2;
  }


  sbPropertyHelper Get(const char* aKey) const
  {
    return sbPropertyHelper(mPropertyBag, sbAutoString(aKey), mRV);
  }


  sbPropertyHelper operator[](const char* aKey) const
  {
    return Get(aKey);
  }

  sbPropertyHelper operator[](const nsACString & aKey) const
  {
    return Get(aKey.BeginReading());
  }
  sbPropertyBagHelper* operator->()
  {
    return this;
  }

  sbPropertyBagHelper& operator*()
  {
    return *this;
  }


  template <class T>
  nsresult Set(char* aKey,
               T     aValue)
  {
    // Validate state and arguments.
    NS_ENSURE_STATE(mWritablePropertyBag);
    NS_ENSURE_ARG_POINTER(aKey);

    // Set the property.
    *mRV = mWritablePropertyBag->SetProperty(sbAutoString(aKey),
                                             sbNewVariant(aValue));
    NS_ENSURE_SUCCESS(*mRV, *mRV);

    return NS_OK;
  }


  PRBool HasKey(const char* aKey)
  {
    // Validate state.
    NS_ENSURE_TRUE(mPropertyBag2, PR_FALSE);

    // Check for key.
    PRBool hasKey;
    *mRV = mPropertyBag2->HasKey(sbAutoString(aKey), &hasKey);
    NS_ENSURE_SUCCESS(*mRV, PR_FALSE);

    return hasKey;
  }


  nsresult rv()
  {
    return *mRV;
  }


  //----------------------------------------------------------------------------
  //
  // Private interface.
  //
  //----------------------------------------------------------------------------

private:

  //
  // mPropertyBag               Bag containing property.
  // mPropertyBag2
  // mWritablePropertyBag
  // mWritablePropertyBag2
  // mRV                        Pointer to return value.
  // mInternalRV                Internal return value storage.
  //

  nsCOMPtr<nsIPropertyBag>      mPropertyBag;
  nsCOMPtr<nsIPropertyBag2>     mPropertyBag2;
  nsCOMPtr<nsIWritablePropertyBag>
                                mWritablePropertyBag;
  nsCOMPtr<nsIWritablePropertyBag2>
                                mWritablePropertyBag2;
  nsresult*                     mRV;
  nsresult                      mInternalRV;
};


#endif /* SB_PROPERTY_BAG_UTILS_H__ */