DataSet.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Copyright (C) 2009-2010 Cassio Neri Moreira
 *
 * This file is part of the KeyValue library.
 *
 * The KeyValue library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or (at
 * your option) any later version.
 *
 * The KeyValue library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with KeyValue. If not, see <http://www.gnu.org/licenses/>.
 *
 * If you modify this library, or any covered work, by linking or combining
 * it with Excel (or a modified version of that program), containing parts
 * covered by the terms of End-User License Agreement for Microsoft
 * Software, the licensors of KeyValue grant you additional permission to
 * convey the resulting work.
 *
 **************************************************************************/

#ifndef KEYVALUE_MNGT_DATASET_H_
#define KEYVALUE_MNGT_DATASET_H_

#include <map>
#include <typeinfo>

#include <boost/any.hpp>
#include <boost/utility.hpp>
#include <boost/weak_ptr.hpp>

#include "keyvalue/extern/String.h"
#include "keyvalue/extern/SharedPtr.h"
#include "keyvalue/key/Key.h"
#include "keyvalue/value/Result.h"
#include "keyvalue/value/TypeName.h"
#include "keyvalue/value/Value.h"
#include "keyvalue/sys/exception/Exception.h"

#ifndef NDEBUG
#include "keyvalue/sys/logger/Logger.h"
#include "keyvalue/util/Global.h"
#endif

namespace keyvalue {

// Forward declaration
class Processor;

class DataSet: private boost::noncopyable {

public:

  explicit
  DataSet(const string& name);

  string
  getName() const;

  void
  add(const string& key, const value::Value& value);

  template<typename KeyType>
  typename KeyType::OutputType_*
  find(const KeyType& key) const;

  template<typename KeyType>
  typename KeyType::OutputType_
  getValue(const KeyType& key) const;

  value::Result
  process() const;

  value::Result
  process(const Processor& processor) const;

  bool
  mustUpdate() const;

  friend std::ostream&
  operator<<(std::ostream& os, const DataSet& dataSet);

private:

  struct Record {

    typedef boost::weak_ptr<Record> WeakPtr;

    explicit
    Record(const value::Value& rawValue);

    Record(WeakPtr next, WeakPtr driver);

    value::Value    rawValue_;
    bool            isBusy_;
    WeakPtr         next_;
    WeakPtr         driver_;
    boost::any      cache_;
    std::type_info* keyType_;
  };

  struct Graph {

    Graph();

    Graph(shared_ptr<Record> first, shared_ptr<Record> last,
      bool hasChanged);

    shared_ptr<Record>  first_;
    shared_ptr<Record>  last_;
    bool                hasChanged_;
  };

  class CircularReference : public RuntimeError {
  };

  Graph
  getGraph(const string& key, bool start = true) const;

  Graph
  getGraph(shared_ptr<Record> first, const string& key) const;

  value::Result
  doProcess(const Processor& processor) const;

  typedef std::map<string, shared_ptr<Record> > MapType_;
  typedef MapType_::value_type                  ValueType_;
  string                                        name_;

  mutable MapType_                              map_;
  mutable bool                                  mustUpdate_;
  mutable value::Result                         result_;

}; // class DataSet

/*--------------------------------------------------------------------------
 * DataSet::find()
 *------------------------------------------------------------------------*/

template<typename KeyType>
typename KeyType::OutputType_*
DataSet::find(const KeyType& key) const {

  typedef typename KeyType::OutputType_ OutputType;

  Graph graph(getGraph(key.getName()));
  if (!graph.last_)
    return static_cast<OutputType*>(0);

  // Syntactic sugar.
  shared_ptr<Record>& last(graph.last_);

  if (KeyType::isBasicOrEnum) {
    if (!graph.hasChanged_ && &typeid(KeyType) == last->keyType_) {

      #ifndef NDEBUG
      util::Global<logger::Logger>::get()->log(Debug(10) & "Returning "
        "cached value for key '" & key.getName() & "'.");
      #endif

      return boost::any_cast<OutputType>(&last->cache_);
    }
    mustUpdate_ = true;
  }

  typedef typename KeyType::InputType_ InputType;

  const InputType* container(last->rawValue_.get<InputType>());

  if (!container)
    throw RuntimeError() & "Value for key '" & key.getName() & "' in "
      "data set '" & name_ & "' must be a " &
      value::TypeName<InputType>::value_ & "!";

  key.checkInput(*container);

  // If execution gets here, then the memoization above didn't work. In
  // particular:
  //
  // (1) If the output container element type is a basic type, then the
  // cached value (if any) is out of date and must be recalculated.
  //
  // (2) If the output container element type is an object type, then even
  // if the raw value (a container of object names) haven't changed since
  // last time this key was processed, the objects themselves could have
  // been rebuilt. Hence, the cached value (if any) might be out of date.
  // To check that, we provide the cached value to the container converter
  // which compares old objects with new ones.

  OutputType* cache(0);
  if (!KeyType::isBasicOrEnum && &typeid(KeyType) == last->keyType_)
    cache = boost::any_cast<OutputType>(&last->cache_);

  typename KeyType::ConverterType_ converter(*container, cache);

  while (!converter.isEmpty()) {
    converter.insert(key.map(converter.pop()));
    key.checkSoFar(converter);
  }

  OutputType output(converter.getOutput());
  key.checkOutput(output);

  mustUpdate_ = mustUpdate_ || converter.mustUpdate();

  last->cache_   = output;
  last->keyType_ = const_cast<std::type_info*>(&typeid(KeyType));

  return boost::any_cast<OutputType>(&last->cache_);
}

/*--------------------------------------------------------------------------
 * DataSet::getValue()
 *------------------------------------------------------------------------*/

template<typename KeyType>
typename KeyType::OutputType_
DataSet::getValue(const KeyType& key) const {

  typename KeyType::OutputType_* result(find(key));

  if (result)
    return *result;

  throw RuntimeError() & "Cannot resolve key '" & key.getName() & "' for "
    "data set '" & name_ & "'!";
}

} // namespace keyvalue

#endif // KEYVALUE_MNGT_DATASET_H_