diff -r 000000000000 -r 2b3e5ec03512 servlib/bundling/MetadataBlock.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/servlib/bundling/MetadataBlock.h Thu Apr 21 14:57:45 2011 +0100 @@ -0,0 +1,251 @@ +/* + * Copyright 2007 The MITRE Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * The US Government will not be charged any license fee and/or royalties + * related to this software. Neither name of The MITRE Corporation; nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + */ + +#ifndef _METADATA_BLOCK_H_ +#define _METADATA_BLOCK_H_ + +#include + +#include "BlockInfo.h" +#include "BlockProcessor.h" + +namespace dtn { + +/** + * The representation of a metadata extension block. + */ +class MetadataBlock : public BP_Local, public oasys::SerializableObject { +public: + + // Constructors + MetadataBlock(): lock_("MetadataBlock"), + id_(MetadataBlock::get_next_index()), + block_(NULL), generated_(false), error_(false), + source_id_(0), source_(false), flags_(0), + ontology_(0), metadata_(NULL), metadata_len_(0) {} + + MetadataBlock(BlockInfo *block): lock_("MetadataBlock"), + id_(MetadataBlock::get_next_index()), + block_(block), generated_(false), error_(false), + source_id_(0), source_(false), flags_(0), + ontology_(0), metadata_(NULL), metadata_len_(0) {} + + MetadataBlock(u_int64_t type, u_char* buf, u_int32_t len); + + MetadataBlock(unsigned int source_id, u_int64_t type, + u_char* buf, u_int32_t len); + + MetadataBlock(oasys::Builder& builder): lock_("MetadataBlock"), + id_(MetadataBlock::get_next_index()), + block_(NULL), generated_(false), error_(false), + source_id_(0), source_(false), flags_(0), + ontology_(0), metadata_(NULL), metadata_len_(0) + { (void)builder; } + + MetadataBlock(const MetadataBlock& copy); + + // Destructor + ~MetadataBlock(); + + // Accessors + unsigned int id() const { return id_; } + bool generated() const { return generated_; } + bool error() const { return error_; } + unsigned int source_id() const { return source_id_; } + bool source() const { return source_; } + u_int64_t flags() const { return flags_; } + u_int64_t ontology() const { return ontology_; } + u_char * metadata() const { return metadata_; } + u_int32_t metadata_len() const { return metadata_len_; } + + oasys::Lock* lock() { return &lock_; } + + // Set class data. + void set_flags(u_int64_t flags); + void set_block_error() { error_ = true; } + void set_ontology(u_int64_t ontology) { ontology_ = ontology; } + void set_metadata(u_char *buf, u_int32_t len); + + /** + * Mark the metadata block for removal from the bundle on the + * specified outgoing link. + * + * @returns true if the metadata block was successfully marked for + * removal; otherwise false. + */ + bool remove_outgoing_metadata(const LinkRef& link); + + /** + * Modify the metadata block for the specified outgoing link. + * + * @returns true if the metadata block was successfully modified; + * otherwise false. + */ + bool modify_outgoing_metadata(const LinkRef& link, + u_char* buf, u_int32_t len); + + /** + * @returns true if the metadata block is marked for removal from + * from the bundle on the specified outgoing link; otherwise false. + */ + bool metadata_removed(const LinkRef& link); + + /** + * @returns true if the metadata block is modified for the specified + * outgoing link; otherwise false. + */ + bool metadata_modified(const LinkRef& link); + + /** + * @returns true if the metadata block is modified for the specified + * outgoing link; otherwise false. The modified ontology data and + * length are returned if the metadata block was modified. + */ + bool metadata_modified(const LinkRef& link, u_char** buf, u_int32_t& len); + + /** + * Remove any outgoing metadata state for the specified link. + */ + void delete_outgoing_metadata(const LinkRef& link); + + /// Virtual from SerializableObject + virtual void serialize(oasys::SerializeAction* action) { (void)action; } + + void operator=(const MetadataBlock& copy); + + static unsigned int get_next_index() { return index_++; } + +private: + oasys::Mutex lock_; + + unsigned int id_; ///< unique identifier + BlockInfo * block_; ///< corresponding BlockInfo + + bool generated_; ///< flag that indicates if the metadata + ///< was locally generated, and therefore + ///< memory allocated to the ontology buf + + bool error_; ///< flag that indicates if the metadata + ///< block was received with errors + + unsigned int source_id_; + bool source_; // flag that indicates if the block + // is a link-specific modification + // of metadata generated at the API + + u_int64_t flags_; // flags specified at the API for + // generated metadata + + u_int64_t ontology_; + u_char * metadata_; + u_int32_t metadata_len_; + + class OutgoingMetadata { + public: + // Constructors + OutgoingMetadata(const LinkRef& link): + link_(link.object(), "OutgoingMetadata"), remove_(true), + metadata_(NULL), metadata_len_(0) {} + OutgoingMetadata(const LinkRef& link, u_char* buf, u_int32_t len); + OutgoingMetadata(const OutgoingMetadata& copy); + + // Destructor + ~OutgoingMetadata(); + + void operator=(const OutgoingMetadata& copy); + + // Accessors + const LinkRef& link() const { return link_; } + bool remove() const { return remove_; } + u_char * metadata() const { return metadata_; } + u_int32_t metadata_len() const { return metadata_len_; } + + private: + LinkRef link_; + bool remove_; + u_char * metadata_; + u_int32_t metadata_len_; + }; + + std::vector outgoing_metadata_; + + OutgoingMetadata* find_outgoing_metadata(const LinkRef& link); + bool has_outgoing_metadata(const LinkRef& link) + { return (find_outgoing_metadata(link) != NULL); } + + static unsigned int index_; +}; + +/** + * Typedef for a reference to a MetadataBlock. + */ +typedef oasys::Ref MetadataBlockRef; + +/** + * A vector of Metadata Block references. + */ +class MetadataVec : public std::vector { +public: + MetadataVec(const std::string& name) : name_(name) {} + + /** + * Wrapper around push_back that takes a vanilla MetadataBlock + * pointer. + */ + void push_back(MetadataBlock* block) { + std::vector:: + push_back(MetadataBlockRef(block, name_.c_str())); + } + +protected: + std::string name_; +}; + +/** + * Data structure to store a metadata block vector for each outgoing + * link, similar to LinkBlockSet. + */ +class LinkMetadataSet { +public: + // Destructor + virtual ~LinkMetadataSet(); + + MetadataVec* create_blocks(const LinkRef& link); + MetadataVec* find_blocks(const LinkRef& link) const; + void delete_blocks(const LinkRef& link); + +private: + struct Entry { + Entry(const LinkRef& link); + + MetadataVec* blocks_; + LinkRef link_; + }; + + typedef std::vector Vector; + typedef std::vector::iterator iterator; + typedef std::vector::const_iterator const_iterator; + Vector entries_; +}; + +} // namespace dtn + +#endif /* _METADATA_BLOCK_H_ */