return gnuradio::get_initial_sptr(new gr_kludge_copy(itemsize));

	gr_sptr_magic.cc			\

	qa_gr_hier_block2_derived.cc		\

	gr_sptr_magic.h				\

	qa_gr_hier_block2_derived.h		\

 * Copyright 2006,2008 Free Software Foundation, Inc.

#include <gr_sptr_magic.h>

 * Copyright 2006,2007,2008 Free Software Foundation, Inc.

gr_hier_block2_sptr

gr_make_hier_block2(const std::string &name, 

                    gr_io_signature_sptr input_signature,

                    gr_io_signature_sptr output_signature)

  return gnuradio::get_initial_sptr(new gr_hier_block2(name, input_signature, output_signature));

  // This bit of magic ensures that self() works in the constructors of derived classes.

  gnuradio::detail::sptr_magic::create_and_stash_initial_sptr(this);

gr_hier_block2::opaque_self

gr_hier_block2::self()

{

  return shared_from_this();

}

 * Copyright 2006,2007,2008 Free Software Foundation, Inc.

   * \brief typedef for object returned from self().

   *

   * This type is only guaranteed to be passable to connect and disconnect.

   * No other assumptions should be made about it.

   */

  typedef gr_basic_block_sptr	opaque_self;

  /*!

   * \brief Return an object, representing the current block, which can be passed to connect.

   *

   * The returned object may only be used as an argument to connect or disconnect.

   * Any other use of self() results in unspecified (erroneous) behavior.

   */

  opaque_self self();

  /*!

inline gr_hier_block2_sptr cast_to_hier_block2_sptr(gr_basic_block_sptr block) {

  gr_hier_block2_sptr src_block(cast_to_hier_block2_sptr(src));

  gr_hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst));

  gr_hier_block2_sptr src_block(cast_to_hier_block2_sptr(src));

  gr_hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst));

  gr_hier_block2_sptr hier_block2(cast_to_hier_block2_sptr(endp.block()));

    gr_hier_block2_sptr hier_block2(cast_to_hier_block2_sptr(*p));

/* -*- c++ -*- */

/*

 * Copyright 2008 Free Software Foundation, Inc.

 * 

 * This file is part of GNU Radio

 * 

 * GNU Radio 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, or (at your option)

 * any later version.

 * 

 * GNU Radio 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 this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <gr_sptr_magic.h>

#include <gr_hier_block2.h>

#include <map>

#include <stdexcept>

#if 0

  #include <boost/thread.hpp>

  typedef boost::mutex			mutex;

  typedef boost::mutex::scoped_lock	scoped_lock;

#else

  #include <omnithread.h>

  typedef omni_mutex			mutex;

  typedef omni_mutex_lock		scoped_lock;

#endif

namespace gnuradio {

  static mutex		s_mutex;

  typedef std::map<gr_basic_block*, gr_basic_block_sptr> sptr_map;

  static sptr_map	s_map;

  void

  detail::sptr_magic::create_and_stash_initial_sptr(gr_hier_block2 *p)

  {

    gr_basic_block_sptr sptr(p);

    scoped_lock	l();

    s_map.insert(sptr_map::value_type(static_cast<gr_basic_block *>(p), sptr));

  }

  gr_basic_block_sptr 

  detail::sptr_magic::fetch_initial_sptr(gr_basic_block *p)

  {

    /*

     * If p isn't a subclass of gr_hier_block2, just create the

     * shared ptr and return it.

     */

    gr_hier_block2 *hb2 = dynamic_cast<gr_hier_block2 *>(p);

    if (!hb2){

      return gr_basic_block_sptr(p);

    }

    /*

     * p is a subclass of gr_hier_block2, thus we've already created the shared pointer

     * and stashed it away.  Fish it out and return it.

     */

    scoped_lock	l();

    sptr_map::iterator pos = s_map.find(static_cast<gr_basic_block *>(p));

    if (pos == s_map.end())

      throw std::invalid_argument("gr_sptr_magic: invalid pointer!");

    gr_basic_block_sptr sptr = pos->second;

    s_map.erase(pos);

    return sptr;

  }

};

/* -*- c++ -*- */

/*

 * Copyright 2008 Free Software Foundation, Inc.

 * 

 * This file is part of GNU Radio

 * 

 * GNU Radio 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, or (at your option)

 * any later version.

 * 

 * GNU Radio 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 this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#ifndef INCLUDED_GR_SPTR_MAGIC_H

#define INCLUDED_GR_SPTR_MAGIC_H

#include <boost/shared_ptr.hpp>

class gr_basic_block;

class gr_hier_block2;

namespace gnuradio {

  namespace detail {

    class sptr_magic {

    public:

      static boost::shared_ptr<gr_basic_block> fetch_initial_sptr(gr_basic_block *p);

      static void create_and_stash_initial_sptr(gr_hier_block2 *p);

    };

  };

  /* 

   * \brief New!  Improved!  Standard method to get/create the boost::shared_ptr for a block.

   */

  template<class T>

  boost::shared_ptr<T>

  get_initial_sptr(T *p)

  {

    return boost::dynamic_pointer_cast<T, gr_basic_block>(detail::sptr_magic::fetch_initial_sptr(p));

  }

};

#endif /* INCLUDED_GR_SPTR_MAGIC_H */

  return gnuradio::get_initial_sptr(new gr_top_block(name));

 * Copyright 2006,2008 Free Software Foundation, Inc.

						 gr_make_io_signature(1, 2, 1 * sizeof(int)),

						 gr_make_io_signature(3, 4, 2 * sizeof(int))));

    CPPUNIT_ASSERT_EQUAL(1 * (int) sizeof(int), 

			 src1->input_signature()->sizeof_stream_item(0));

    CPPUNIT_ASSERT_EQUAL(1, src1->input_signature()->min_streams());

    CPPUNIT_ASSERT_EQUAL(2, src1->input_signature()->max_streams());

    CPPUNIT_ASSERT_EQUAL(2 * (int) sizeof(int), 

    CPPUNIT_ASSERT_EQUAL(3, src1->output_signature()->min_streams());

    CPPUNIT_ASSERT_EQUAL(4, src1->output_signature()->max_streams());

/* -*- c++ -*- */

/*

 * Copyright 2006,2008 Free Software Foundation, Inc.

 * 

 * This file is part of GNU Radio

 * 

 * GNU Radio 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, or (at your option)

 * any later version.

 * 

 * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street,

 * Boston, MA 02110-1301, USA.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <qa_gr_hier_block2_derived.h>

#include <gr_top_block.h>

#include <gr_io_signature.h>

#include <gr_null_source.h>

#include <gr_null_sink.h>

#include <gr_head.h>

#include <gr_kludge_copy.h>

// Declare a test C++ hierarchical block

class gr_derived_block;

typedef boost::shared_ptr<gr_derived_block> gr_derived_block_sptr;

gr_derived_block_sptr gr_make_derived_block();

class gr_derived_block : public gr_hier_block2

{

private:

  friend gr_derived_block_sptr gr_make_derived_block();

  gr_derived_block();

public:

  ~gr_derived_block();

};

gr_derived_block_sptr

gr_make_derived_block()

{

  return gnuradio::get_initial_sptr(new gr_derived_block());

}

gr_derived_block::gr_derived_block()

  : gr_hier_block2("gr_derived_block",

		   gr_make_io_signature(1, 1, sizeof(int)), // Input signature

		   gr_make_io_signature(1, 1, sizeof(int))) // Output signature

{

  gr_block_sptr copy(gr_make_kludge_copy(sizeof(int)));

  connect(self(), 0, copy, 0);

  connect(copy, 0, self(), 0);

}

gr_derived_block::~gr_derived_block()

{

}

void qa_gr_hier_block2_derived::test_1()

{

  gr_top_block_sptr     tb(gr_make_top_block("test"));

  gr_block_sptr         src(gr_make_null_source(sizeof(int)));

  gr_block_sptr         head(gr_make_head(sizeof(int), 1000));

  gr_derived_block_sptr blk(gr_make_derived_block());

  gr_block_sptr         dst(gr_make_null_sink(sizeof(int)));

  tb->connect(src,  0, head, 0);

  tb->connect(head, 0, blk,  0);

  tb->connect(blk,  0, dst,  0);

  tb->run();

}

/* -*- c++ -*- */

/*

 * Copyright 2006,2008 Free Software Foundation, Inc.

 * 

 * This file is part of GNU Radio

 * 

 * GNU Radio 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, or (at your option)

 * any later version.

 * 

 * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street,

 * Boston, MA 02110-1301, USA.

 */

#ifndef INCLUDED_QA_GR_HIER_BLOCK2_DERIVED_H

#define INCLUDED_QA_GR_HIER_BLOCK2_DERIVED_H

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/TestCase.h>

#include <stdexcept>

// Declare a QA test case

class qa_gr_hier_block2_derived : public CppUnit::TestCase 

{

  CPPUNIT_TEST_SUITE(qa_gr_hier_block2_derived);

  CPPUNIT_TEST(test_1);

  CPPUNIT_TEST_SUITE_END();

private:

  void test_1();

};

#endif /* INCLUDED_QA_GR_HIER_BLOCK2_DERIVED_H */

#include <qa_gr_hier_block2_derived.h>

  s->addTest (qa_gr_hier_block2_derived::suite ());