TopicKeys::Iterator Class Reference

#include <topic_keys.h>

Collaboration diagram for TopicKeys::Iterator:

Public Types
typedef AST_Decl *	value_type
	{ More...
typedef AST_Decl **	pointer
typedef AST_Decl *&	reference
typedef std::input_iterator_tag	iterator_category

Public Member Functions
	Iterator ()
	} More...
	Iterator (TopicKeys &parent)
	Iterator (const Iterator &other)
	~Iterator ()
Iterator &	operator= (const Iterator &other)
Iterator &	operator++ ()
Iterator	operator++ (int)
AST_Decl *	operator* () const
bool	operator== (const Iterator &other) const
bool	operator!= (const Iterator &other) const
std::string	path ()
std::string	canonical_path ()
size_t	level () const
RootType	root_type () const
RootType	parents_root_type () const
AST_Type *	get_ast_type () const

Static Public Member Functions
static Iterator	end_value ()

Private Member Functions
	Iterator (AST_Type *root, Iterator *parent)
	Iterator (AST_Field *root, Iterator *parent)
void	path_i (std::stringstream &ss, bool canonical=false)
void	cleanup ()

Private Attributes
Iterator *	parent_
unsigned	pos_
Iterator *	child_
AST_Decl *	current_value_
	Current value of the entire iterator stack. More...
AST_Decl *	root_
RootType	root_type_
size_t	level_
bool	recursive_
std::vector< size_t >	dimensions_
	The Dimensions of the Array. More...
size_t	element_count_
	Element Count in the Array. More...
bool	implied_keys_
	Used in struct field key iteration. More...

Detailed Description

Iterator for traversing the TAO_IDL AST, looking for nodes within a topic type node that are annotated with .

Definition at line 72 of file topic_keys.h.

Member Typedef Documentation

iterator_category

typedef std::input_iterator_tag TopicKeys::Iterator::iterator_category

Definition at line 81 of file topic_keys.h.

pointer

typedef AST_Decl** TopicKeys::Iterator::pointer

Definition at line 79 of file topic_keys.h.

reference

typedef AST_Decl*& TopicKeys::Iterator::reference

Definition at line 80 of file topic_keys.h.

value_type

typedef AST_Decl* TopicKeys::Iterator::value_type

{

Standard Iterator Type Declarations

Definition at line 78 of file topic_keys.h.

Constructor & Destructor Documentation

Iterator() [1/5]

TopicKeys::Iterator::Iterator

(

)

}

Create new iterator equal to TopicKeys::end()

Definition at line 70 of file topic_keys.cpp.

Referenced by operator++(), and operator=().

  : parent_(0)
  , pos_(0)
  , child_(0)
  , current_value_(0)
  , root_(0)
  , root_type_(InvalidType)
  , level_(0)
  , recursive_(false)
  , element_count_(0)
  , implied_keys_(false)
{
}

Iterator() [2/5]

TopicKeys::Iterator::Iterator

(

TopicKeys &

parent

)

Create new iterator pointing to the first topic key or equal to TopicKeys::end() if there are no keys.

Definition at line 84 of file topic_keys.cpp.

References TopicKeys::root(), root_, TopicKeys::root_type(), and root_type_.

  : parent_(0)
  , pos_(0)
  , child_(0)
  , current_value_(0)
  , level_(0)
  , recursive_(parent.recursive())
  , element_count_(0)
  , implied_keys_(false)
{
  root_ = parent.root();
  root_type_ = parent.root_type();
  ++*this;
}

Iterator() [3/5]

TopicKeys::Iterator::Iterator

(

const Iterator &

other

)

Create a completely separate copy of another iterator

Definition at line 134 of file topic_keys.cpp.

  : pos_(0)
  , child_(0)
  , current_value_(0)
  , root_(0)
  , root_type_(InvalidType)
  , level_(0)
  , recursive_(false)
  , element_count_(0)
  , implied_keys_(false)
{
  *this = other;
}

~Iterator()

TopicKeys::Iterator::~Iterator

(

)

Definition at line 148 of file topic_keys.cpp.

References cleanup().

{
  cleanup();
}

Iterator() [4/5]

TopicKeys::Iterator::Iterator ( AST_Type *  root, Iterator *  parent  )

private

Definition at line 99 of file topic_keys.cpp.

References TopicKeys::root(), root_, TopicKeys::root_type(), and root_type_.

  : parent_(parent)
  , pos_(0)
  , child_(0)
  , current_value_(0)
  , level_(parent->level() + 1)
  , recursive_(parent->recursive_)
  , element_count_(0)
  , implied_keys_(false)
{
  root_type_ = TopicKeys::root_type(root);
  root_ = root;
  ++(*this);
}

Iterator() [5/5]

TopicKeys::Iterator::Iterator ( AST_Field *  root, Iterator *  parent  )

private

Definition at line 114 of file topic_keys.cpp.

References TopicKeys::PrimitiveType, TopicKeys::root(), root_, TopicKeys::root_type(), and root_type_.

  : parent_(parent)
  , pos_(0)
  , child_(0)
  , current_value_(0)
  , level_(parent->level() + 1)
  , recursive_(parent->recursive_)
  , element_count_(0)
  , implied_keys_(false)
{
  AST_Type* type = root->field_type()->unaliased_type();
  root_type_ = TopicKeys::root_type(type);
  if (root_type_ == PrimitiveType) {
    root_ = root;
  } else {
    root_ = type;
  }
  ++(*this);
}

Member Function Documentation

canonical_path()

std::string TopicKeys::Iterator::canonical_path

(

)

Definition at line 342 of file topic_keys.cpp.

References path_i().

{
  std::stringstream ss;
  path_i(ss, true);
  return ss.str();
}

cleanup()

void TopicKeys::Iterator::cleanup ( void  )

private

Definition at line 392 of file topic_keys.cpp.

References child_.

Referenced by operator=(), and ~Iterator().

{
  delete child_;
}

end_value()

TopicKeys::Iterator TopicKeys::Iterator::end_value ( )

static

Definition at line 533 of file topic_keys.cpp.

References TopicKeys::end().

Referenced by TopicKeys::end(), and operator++().

{
  static Iterator end;
  return end;
}

get_ast_type()

AST_Type * TopicKeys::Iterator::get_ast_type

(

)

const

Get the AST_Type of the current value

Returns 0 if the iterator is invalid

Definition at line 412 of file topic_keys.cpp.

References TopicKeys::ArrayType, child_, current_value_, get_ast_type(), level_, parents_root_type(), recursive_, root_type(), TopicKeys::SequenceType, TopicKeys::StructureType, and TopicKeys::UnionType.

Referenced by get_ast_type().

{
  AST_Field* field = 0;
  switch (root_type()) {
  case UnionType:
    return dynamic_cast<AST_Type*>(current_value_);
  case StructureType:
    if (level_ > 0) {
      if (!recursive_) {
        return dynamic_cast<AST_Type*>(current_value_);
      }
    } else {
      return child_->get_ast_type();
    }
    break;
  default:
    break;
  }
  switch (parents_root_type()) {
  case StructureType:
    field = dynamic_cast<AST_Field*>(current_value_);
    if (field) {
      return field->field_type();
    }
    break;
  case ArrayType:
    return dynamic_cast<AST_Type*>(current_value_);
  case SequenceType:
    return dynamic_cast<AST_Type*>(current_value_);
  default:
    break;
  }
  return 0;
}

level()

size_t TopicKeys::Iterator::level

(

)

const

Get the level of recursion

Definition at line 407 of file topic_keys.cpp.

References child_, level(), and level_.

Referenced by level().

{
  return child_ ? child_->level() : level_;
}

operator!=()

bool TopicKeys::Iterator::operator!=

(

const Iterator &

other

)

const

Definition at line 330 of file topic_keys.cpp.

{
  return !(*this == other);
}

operator*()

AST_Decl * TopicKeys::Iterator::operator*

(

void

)

const

Definition at line 308 of file topic_keys.cpp.

References current_value_.

{
  return current_value_;
}

operator++() [1/2]

TopicKeys::Iterator & TopicKeys::Iterator::operator++

(

void

)

Definition at line 169 of file topic_keys.cpp.

References TopicKeys::ArrayType, be_global, Fields::begin(), OpenDDS::DCPS::child(), child_, current_value_, dimensions_, element_count_, Fields::end(), end_value(), implied_keys_, TopicKeys::InvalidType, Iterator(), level_, pos_, TopicKeys::PrimitiveType, recursive_, root_, root_type_, TopicKeys::SequenceType, TopicKeys::StructureType, and TopicKeys::UnionType.

{
  // Nop if we are a invalid iterator of any type
  if (!root_ || root_type_ == InvalidType) {
    return *this;
  }

  // If we have a child iterator, ask it for the next value
  if (child_) {
    Iterator& child = *child_;
    ++child;
    if (child == end_value()) {
      delete child_;
      child_ = 0;
      pos_++;
    } else {
      current_value_ = *child;
      return *this;
    }
  }

  if (root_type_ == StructureType) {
    // If we are recursive and at a structure, look for key fields
    if (recursive_ || level_ == 0) {
      AST_Structure* struct_root = dynamic_cast<AST_Structure*>(root_);
      if (!struct_root) {
        throw Error(root_, "Invalid Key Iterator");
      }
      const Fields fields(struct_root);
      const Fields::Iterator fields_end = fields.end();

      // If a nested struct marked as a key has no keys, all the fields are
      // implied to be keys (expect those marked with @key(FALSE)).
      if (pos_ == 0) {
        if (level_ > 0) {
          implied_keys_ = true;
          for (Fields::Iterator i = fields.begin(); i != fields_end && implied_keys_; ++i) {
            bool key_annotation_value;
            const bool has_key_annotation = be_global->check_key(*i, key_annotation_value);
            if (has_key_annotation && key_annotation_value) {
              implied_keys_ = false;
            }
          }
        } else {
          implied_keys_ = false;
        }
      }

      for (Fields::Iterator i = fields[pos_]; i != fields_end; ++i) {
        bool key_annotation_value;
        const bool has_key_annotation = be_global->check_key(*i, key_annotation_value);
        const bool implied_key = implied_keys_ && !(has_key_annotation && !key_annotation_value);
        if (key_annotation_value || implied_key) {
          child_ = new Iterator(*i, this);
          Iterator& child = *child_;
          if (child == end_value()) {
            delete child_;
            child_ = 0;
            throw Error(*i, std::string("field is ") + (implied_key ? "implicitly" : "explicitly") +
              " marked as key, but does not contain any keys.");
          } else {
            current_value_ = *child;
            pos_ = i.pos();
            return *this;
          }
        }
      }
    } else if (pos_ == 0) { // Else return "this" once
      pos_ = 1;
      current_value_ = root_;
      return *this;
    }

  // If we are an array, use the base type and repeat for every element
  } else if (root_type_ == ArrayType) {
    AST_Array* array_node = dynamic_cast<AST_Array*>(root_);
    if (!array_node) {
      throw Error(root_, "Invalid Key Iterator");
    }
    if (element_count_ == 0) {
      element_count_ = 1;
      ACE_CDR::ULong array_dimension_count = array_node->n_dims();
      for (unsigned i = 0; i < array_dimension_count; i++) {
        ACE_CDR::ULong dimension = array_node->dims()[i]->ev()->u.ulval;
        dimensions_.push_back(dimension);
        element_count_ *= dimension;
      }
    }
    AST_Type* type_node = array_node->base_type();
    AST_Type* unaliased_type_node = type_node->unaliased_type();
    if (pos_ < element_count_) {
      child_ = new Iterator(unaliased_type_node, this);
      Iterator& child = *child_;
      if (child == Iterator()) {
        delete child_;
        child_ = 0;
        throw Error(array_node, "array type is marked as key, but its base type "
          "does not contain any keys.");
      }
      current_value_ = *child;
      return *this;
    }

  // If we are a union, use self if we have a key
  } else if (root_type_ == UnionType) {
    if (pos_ == 0) { // Only Allow One Iteration
      pos_ = 1;
      AST_Union* union_node = dynamic_cast<AST_Union*>(root_);
      if (level_ > 0 || be_global->union_discriminator_is_key(union_node)) {
        current_value_ = root_;
        return *this;
      }
    }

  } else if (root_type_ == SequenceType) {
    throw Error(root_, "sequence types are not supported as keys");

  // If we are a primitive type, use self
  } else if (root_type_ == PrimitiveType) {
    if (pos_ == 0) { // Only Allow One Iteration
      pos_ = 1;
      current_value_ = root_;
      return *this;
    }
  }

  // Nothing left to do, set this to null
  *this = end_value();

  return *this;
}

operator++() [2/2]

TopicKeys::Iterator TopicKeys::Iterator::operator++

(

int

)

Definition at line 301 of file topic_keys.cpp.

{
  Iterator prev(*this);
  ++(*this);
  return prev;
}

operator=()

TopicKeys::Iterator & TopicKeys::Iterator::operator=

(

const Iterator &

other

)

Definition at line 153 of file topic_keys.cpp.

References child_, cleanup(), current_value_, dimensions_, element_count_, Iterator(), level_, parent_, pos_, recursive_, root_, and root_type_.

{
  cleanup();
  parent_ = other.parent_;
  pos_ = other.pos_;
  current_value_ = other.current_value_;
  root_ = other.root_;
  root_type_ = other.root_type_;
  level_ = other.level_;
  recursive_ = other.recursive_;
  dimensions_ = other.dimensions_;
  child_ = other.child_ ? new Iterator(*other.child_) : 0;
  element_count_ = other.element_count_;
  return *this;
}

operator==()

bool TopicKeys::Iterator::operator==

(

const Iterator &

other

)

const

Definition at line 313 of file topic_keys.cpp.

References child_, current_value_, dimensions_, element_count_, level_, parent_, pos_, recursive_, root_, and root_type_.

{
  return
    parent_ == other.parent_ &&
    root_ == other.root_ &&
    root_type_ == other.root_type_ &&
    pos_ == other.pos_ &&
    current_value_ == other.current_value_ &&
    level_ == other.level_ &&
    recursive_ == other.recursive_ &&
    dimensions_ == other.dimensions_ &&
    element_count_ == other.element_count_ &&
    (
      (child_ && other.child_) ? *child_ == *other.child_ : child_ == other.child_
    );
}

parents_root_type()

TopicKeys::RootType TopicKeys::Iterator::parents_root_type

(

)

const

Get the final child's parent's root type

Returns InvalidType if it is the root or a invalid iterator

Definition at line 402 of file topic_keys.cpp.

References child_, TopicKeys::InvalidType, parent_, parents_root_type(), and root_type_.

Referenced by get_ast_type(), and parents_root_type().

{
  return child_ ? child_->parents_root_type() : (parent_ ? parent_->root_type_ : InvalidType);
}

path()

std::string TopicKeys::Iterator::path

(

)

Get the path of the key in reference to the root_

Definition at line 335 of file topic_keys.cpp.

References path_i().

Referenced by keys_generator::gen_struct(), and marshal_generator::gen_typedef().

{
  std::stringstream ss;
  path_i(ss);
  return ss.str();
}

path_i()

void TopicKeys::Iterator::path_i ( std::stringstream &  ss, bool  canonical = false  )

private

Internal Recursive Impl. of path()

Definition at line 349 of file topic_keys.cpp.

References TopicKeys::ArrayType, canonical_name(), child_, dimensions_, level_, path_i(), pos_, TopicKeys::PrimitiveType, recursive_, root_, root_type_, TopicKeys::StructureType, and TopicKeys::UnionType.

Referenced by canonical_path(), path(), and path_i().

{
  const char* error_msg = "Can't get path for invalid topic key iterator!";
  if (root_type_ == StructureType) {
    AST_Structure* struct_root = dynamic_cast<AST_Structure*>(root_);
    if (!struct_root) {
      throw Error(root_, error_msg);
    }
    AST_Field* field = *Fields(struct_root)[child_ ? pos_ : pos_ - 1];
    ss << (level_ ? "." : "");
    if (canonical) {
      ss << canonical_name(field);
    } else {
      ss << field->local_name()->get_string();
    }
  } else if (root_type_ == UnionType) {
    // Nothing
  } else if (root_type_ == ArrayType) {
    // Figure out what the vector version of the scalar pos_ is
    std::vector<size_t>::reverse_iterator di, dfinished = dimensions_.rend();
    size_t acc = pos_;
    size_t div = 1;
    std::vector<size_t> results;
    for (di = dimensions_.rbegin(); di != dfinished; ++di) {
      acc /= div;
      results.push_back(acc % *di);
      div = *di;
    }

    std::vector<size_t>::reverse_iterator
      ri = results.rbegin(),
      rfinished = results.rend();
    for (; ri != rfinished; ++ri) {
      ss << '[' << *ri << ']';
    }
  } else if (root_type_ != PrimitiveType) {
    throw Error(root_, error_msg);
  }
  if (child_ && recursive_) {
    child_->path_i(ss, canonical);
  }
}

root_type()

TopicKeys::RootType TopicKeys::Iterator::root_type

(

)

const

Get the root type of the final child

Definition at line 397 of file topic_keys.cpp.

References child_, root_type(), and root_type_.

Referenced by get_ast_type(), and root_type().

{
  return child_ ? child_->root_type() : root_type_;
}

Member Data Documentation

child_

Iterator* TopicKeys::Iterator::child_

private

Definition at line 147 of file topic_keys.h.

Referenced by cleanup(), get_ast_type(), level(), operator++(), operator=(), operator==(), parents_root_type(), path_i(), and root_type().

current_value_

AST_Decl* TopicKeys::Iterator::current_value_

private

Current value of the entire iterator stack.

Definition at line 149 of file topic_keys.h.

Referenced by get_ast_type(), operator*(), operator++(), operator=(), and operator==().

dimensions_

std::vector<size_t> TopicKeys::Iterator::dimensions_

private

The Dimensions of the Array.

Definition at line 155 of file topic_keys.h.

Referenced by operator++(), operator=(), operator==(), and path_i().

element_count_

size_t TopicKeys::Iterator::element_count_

private

Element Count in the Array.

Definition at line 157 of file topic_keys.h.

Referenced by operator++(), operator=(), and operator==().

implied_keys_

bool TopicKeys::Iterator::implied_keys_

private

Used in struct field key iteration.

Definition at line 160 of file topic_keys.h.

Referenced by operator++().

level_

size_t TopicKeys::Iterator::level_

private

Definition at line 152 of file topic_keys.h.

Referenced by get_ast_type(), level(), operator++(), operator=(), operator==(), and path_i().

parent_

Iterator* TopicKeys::Iterator::parent_

private

Definition at line 145 of file topic_keys.h.

Referenced by operator=(), operator==(), and parents_root_type().

pos_

unsigned TopicKeys::Iterator::pos_

private

Definition at line 146 of file topic_keys.h.

Referenced by operator++(), operator=(), operator==(), and path_i().

recursive_

bool TopicKeys::Iterator::recursive_

private

Definition at line 153 of file topic_keys.h.

Referenced by get_ast_type(), operator++(), operator=(), operator==(), and path_i().

root_

AST_Decl* TopicKeys::Iterator::root_

private

Definition at line 150 of file topic_keys.h.

Referenced by Iterator(), operator++(), operator=(), operator==(), and path_i().

root_type_

RootType TopicKeys::Iterator::root_type_

private

Definition at line 151 of file topic_keys.h.

Referenced by Iterator(), operator++(), operator=(), operator==(), parents_root_type(), path_i(), and root_type().

---

The documentation for this class was generated from the following files:

• topic_keys.h
• topic_keys.cpp