Resource.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Resource.h"
 
// Qt library
#include <QSharedPointer>
#include <QString>
 
// boost library
#include <boost/foreach.hpp>
 
// other ISIS
#include "IException.h"
#include "PvlContainer.h"
#include "PvlFlatMap.h"
#include "PvlKeyword.h"
#include "PvlObject.h"
 
using namespace std;
 
namespace Isis {
 
  Resource::Resource(): m_data( new ResourceData("Resource") ), 
                        m_discard( false ) { 
    setName( m_data->m_name );
  }
 
 
  Resource::Resource(const QString &name) : m_data( new ResourceData(name) ), 
                                            m_discard( false ) { 
    setName(name);
  }
 
 
  Resource::Resource(const QString &name, const PvlFlatMap &profile) : 
                     m_data( new ResourceData(name, profile) ),
                     m_discard(false) { 
    setName(name);
  }
 
 
  Resource::Resource(const Resource &other) : m_data( other.m_data ),
                                              m_discard( other.m_discard ) {
  }
 
 
  Resource::Resource(const Resource &other, const bool deepcopy) :
                     m_data( new ResourceData( *other.m_data ) ),
                     m_discard( other.m_discard ) { 
    if ( deepcopy ) { m_data.detach(); }
  }
 
 
  Resource::Resource(const QString &name, const PvlContainer &profile) :
                     m_data( new ResourceData(name, PvlFlatMap(profile) ) ),
                     m_discard(false) {
    setName(name);
  }
 
 
  Resource::~Resource() {
  }
 
 
  QString Resource::name() const {
    return ( m_data->m_name );
  }
 
 
  void Resource::setName(const QString &identity) {
    m_data->m_name = identity;
    add("Identity", identity);
    return;
  }
 
 
  bool Resource::isEqual(const Resource &other) const {
    return ( name().toLower() == other.name().toLower() );
  }
 
 
  bool Resource::exists(const QString &keywordName) const {
    return ( m_data->m_keys.exists(keywordName) );
  }
 
 
  int Resource::count(const QString &keywordName) const {
    return ( m_data->m_keys.count(keywordName) );
  }
 
 
  bool Resource::isNull(const QString &keywordName, const int index) const {
    return ( m_data->m_keys.isNull(keywordName, index) );
  }
 
 
  const PvlFlatMap &Resource::keys() const {
    return ( m_data->m_keys );
  }
 
 
  QString Resource::value(const QString &keywordName, const int &index) const {
    return ( m_data->m_keys.get(keywordName, index) );
  }
 
 
  QString Resource::value(const QString &keywordName, const QString &defaultValue,
                          const int &index) const {
    QString keywordValue(defaultValue);
    if ( !isNull(keywordName, index) ) {
      keywordValue = value(keywordName, index);
    }
    return (keywordValue);
  }
 
 
  PvlKeyword Resource::keyword(const QString &keywordName) const {
    if ( m_data->m_keys.exists(keywordName) ) {
      return ( m_data->m_keys.keyword(keywordName) );
    }
    // Return empty keyword
    return (PvlKeyword(keywordName));
  }
 
 
  void Resource::add(const QString &keywordName, const QString &keywordValue) {
     m_data->m_keys.add(keywordName, keywordValue);
     return;
  }
 
 
  void Resource::add(const PvlKeyword &keyword) {
    m_data->m_keys.add(keyword);
  }
 
 
  void Resource::add(const PvlFlatMap &keys) {
    BOOST_FOREACH ( PvlKeyword keyword, keys ) {
      add(keyword);
    }
    return;
  }
 
 
  void Resource::append(const QString &keywordName, const QString &keywordValue) {
    m_data->m_keys.append(keywordName, keywordValue);
    return;
  }
 
 
  int Resource::erase(const QString &keywordName) {
    return ( m_data->m_keys.erase(keywordName) );
  }
 
 
  void Resource::add(GisGeometry *geom) {
    m_data->m_geom = SharedGisGeometry(geom);
    return;
  }
 
 
  void Resource::add(SharedGisGeometry &geom) {
    m_data->m_geom = geom;
    return;
  }
 
 
  bool Resource::hasGeometry() const {
    return ( !m_data->m_geom.isNull() );
  }
 
 
  bool Resource::hasValidGeometry() const {
    if ( hasGeometry() ) {
      return ( !m_data->m_geom->isEmpty() );
    }
 
    return (false);
  }
 
 
  SharedGisGeometry Resource::geometry() const {
    return ( m_data->m_geom );
  }
 
 
  void Resource::activate() {
    m_discard = false;
  }
 
 
  bool Resource::isActive() const {
    return ( !m_discard );
  }
 
 
  void Resource::discard() {
    m_discard = true;
  }
 
 
  bool Resource::isDiscarded() const {
    return ( m_discard );
  }
 
 
  bool Resource::hasAsset(const QString &assetName) const {
    return ( m_data->m_assets.contains(assetName.toLower()) );
  }
 
 
  void Resource::addAsset(const QString &assetName, QVariant &assetValue) {
    m_data->m_assets.insert(assetName.toLower(), assetValue);
    return;
  }
 
 
  int Resource::removeAsset(const QString &assetName) {
    return ( m_data->m_assets.remove(assetName.toLower()) );
  }
 
 
  int Resource::clearAssets() {
    int n = m_data->m_assets.size();
    m_data->m_assets.clear();
    return (n);
  }
 
 
  QVariant Resource::asset(const QString &assetName) const {
    if ( !hasAsset(assetName) ) {
      throw IException(IException::Programmer,
                        "Requested asset " + assetName + " does not exist.", 
                       _FILEINFO_);
    }
    return ( m_data->m_assets.value(assetName.toLower()) );
  }
 
 
  Resource *Resource::copy() const {
    Resource *resource = new Resource(*this, false);
    resource->m_discard = m_discard;
    return (resource); 
  }
 
 
  Resource *Resource::clone(const QString &name, const bool &withAssets) const {
    Resource *resource = new Resource(*this, true);
    if ( !withAssets ) { resource->clearAssets(); }
    resource->activate();
    return (resource);
  }
 
 
  PvlObject Resource::toPvl(const QString &pvlName) const {
    PvlObject object(pvlName);
    PvlFlatMap::ConstPvlFlatMapIterator key = m_data->m_keys.begin();
    while (  key != m_data->m_keys.end() ) {
      object.addKeyword(key.value());
      ++key;
    }
    return ( object );
  }
 
}  //namespace Isis