message_collection_impl.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2008, Willow Garage, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

namespace warehouse_ros
{
template <class M>
MessageCollection<M>::MessageCollection(MessageCollectionHelper::Ptr collection) : collection_(collection)
{
  typedef typename ros::message_traits::DataType<M> DataType;
  const std::string datatype = DataType().value();
  typedef typename ros::message_traits::MD5Sum<M> Md5;
  const std::string md5 = Md5().value();
  md5sum_matches_ = collection_->initialize(datatype, md5);
}

template <class M>
MessageCollection<M>::MessageCollection(const MessageCollection<M>& other)
  : collection_(other.collection_), md5sum_matches_(other.md5sum_matches_)
{
}

template <class M>
MessageCollection<M>::~MessageCollection()
{
}

template <class M>
MessageCollection<M>& MessageCollection<M>::operator=(const MessageCollection& other)
{
  collection_ = other.collection_;
  md5sum_matches_ = other.md5sum_matches_;
  return *this;
}

template <class M>
void MessageCollection<M>::insert(const M& msg, Metadata::Ptr metadata)
{
  if (!md5sum_matches_)
    throw Md5SumException("Cannot insert additional elements.");

  metadata->append("creation_time", ros::Time::now().toSec());

  size_t serial_size = ros::serialization::serializationLength(msg);
  boost::shared_array<uint8_t> buffer(new uint8_t[serial_size]);
  ros::serialization::OStream stream(buffer.get(), serial_size);
  ros::serialization::serialize(stream, msg);
  char* data = (char*)buffer.get();

  collection_->insert(data, serial_size, metadata);
}

template <class M>
typename QueryResults<M>::range_t MessageCollection<M>::query(Query::ConstPtr query, bool metadata_only,
                                                              const std::string& sort_by, bool ascending) const
{
  if (!md5sum_matches_ && !metadata_only)
    throw Md5SumException("Can only query metadata.");

  ResultIteratorHelper::Ptr results = collection_->query(query, sort_by, ascending);
  return typename QueryResults<M>::range_t(ResultIterator<M>(results, metadata_only), ResultIterator<M>());
}

template <class M>
std::vector<typename MessageWithMetadata<M>::ConstPtr> MessageCollection<M>::queryList(Query::ConstPtr query,
                                                                                       bool metadata_only,
                                                                                       const std::string& sort_by,
                                                                                       bool ascending) const
{
  typename QueryResults<M>::range_t res = this->query(query, metadata_only, sort_by, ascending);
  return std::vector<typename MessageWithMetadata<M>::ConstPtr>(res.first, res.second);
}

template <class M>
typename MessageWithMetadata<M>::ConstPtr MessageCollection<M>::findOne(Query::ConstPtr query,
                                                                        const bool metadata_only) const
{
  typename QueryResults<M>::range_t res = this->query(query, metadata_only);
  if (res.first == res.second)
    throw NoMatchingMessageException(collection_->collectionName());
  return *res.first;
}

template <class M>
unsigned MessageCollection<M>::removeMessages(Query::ConstPtr query)
{
  return collection_->removeMessages(query);
}

template <class M>
void MessageCollection<M>::modifyMetadata(Query::ConstPtr q, Metadata::ConstPtr m)
{
  collection_->modifyMetadata(q, m);
}

template <class M>
unsigned MessageCollection<M>::count()
{
  return collection_->count();
}

template <class M>
bool MessageCollection<M>::md5SumMatches() const
{
  return md5sum_matches_;
}

template <class M>
Query::Ptr MessageCollection<M>::createQuery() const
{
  return collection_->createQuery();
}

template <class M>
Metadata::Ptr MessageCollection<M>::createMetadata() const
{
  return collection_->createMetadata();
}

}  // namespace