Attachment #1945 for bug #1604

View | Details | Raw Unified | Return to bug 1604
Collapse All | Expand All





#include "attribute.h"
#include "attribute-accessor-helper.h"
#include "config.h"
#include <sstream>
#include "fatal-error.h"



/**
 * \ingroup attribute
 * \defgroup attributehelper Attribute Helpers
 *
 * All these macros can be used to generate automatically the code
 * for subclasses of AttributeValue, AttributeAccessor, and, AttributeChecker,

  return Ptr<AttributeChecker> (checker, false);
}

  

/**
 * \ingroup attributehelper
 *

                             Ptr<const AttributeChecker> checker);      \
  private:                                                              \
    type m_value;                                                       \
  }


/**
 * \ingroup attributehelper

  class type ## Checker : public AttributeChecker {};                   \
  Ptr<const AttributeChecker> Make ## type ## Checker (void)

/**
 * \ingroup attributehelper
 *
 * Declare the Config::GetDefaultValue<>() specializations for \p type.
 *
 * \param type The return type.
 *
 * This macro declares the Config::GetDefaultValue<>() specialization
 * returning the current default configuration value of an attribute,
 * as a \c type.  If the attribute at the configuration path is not
 * compatible with the requested type, the function will raise a
 * fatal error.
 *
 * This macro is typically invoked in the class header file.
 *
 * \note This macro must be invoked from <tt>namespace ns3</tt>.
 *
 * \see
 *   GetDefaultValue<>()
 */
#define ATTRIBUTE_GETDEFAULT_DEFINE(type)                               \
  namespace Config {                                                    \
    template<> type                                                     \
      GetDefaultValue<type> (const std::string attributePath);          \
  } /* namespace Config */


/**
 * \ingroup attributehelper

  Ptr<const AttributeChecker> Make ## type ## Checker (void) {          \
    return MakeSimpleAttributeChecker<type ## Value,type ## Checker>    \
      (# type "Value", name);                                           \
  }


namespace Config {
  
/**
 * \ingroup config
 * Config::GetDefaultValue<>() helper to fetch an attribute path as
 * the base AttributeValue.
 *
 * \param attributePath The configuration path for the attribute.
 * \returns The AttributeValue.
 *
 * \internal
 * This is declared in attribute-helper.h to break an include cycle.
 * The implementation is in config.cc.
 */
Ptr<const AttributeValue>
GetDefaultAttributeValue (const std::string attributePath);
  
}  // namespace Config


/**
 * \ingroup attributehelper
 *
 * Define the Config::GetDefaultValue<>() specialization for the attribute
 * value class \c \typeValue, for underlying class \p type.
 *
 * \param type The underlying type name.
 * \param typeValue The derived AttributeValue class corresponding to
 * \c type.
 *
 * This macro implements the Config::GetDefaultValue<>() specialization
 * returning the current default configuration value of an attribute
 * as a \c type.  If the attribute at the configuration path is not
 * compatible with the requested type, the function will raise a
 * fatal error.
 *
 * This macro is typically invoked in the source file.
 *
 * \note This macro must be invoked from <tt>namespace ns3</tt>.
 *
 * \see Config::GetDefaultValue<>()
 */
#define ATTRIBUTE_GETDEFAULT_IMPLEMENT_WITH_NAME(type,typeValue)        \
  namespace Config {                                                    \
    template<> type                                                     \
      GetDefaultValue<type> (const std::string attributePath)           \
      {                                                                 \
        Ptr<const AttributeValue> attrValue =                           \
          GetDefaultAttributeValue (attributePath);                     \
        Ptr<const typeValue> attr =                                     \
          DynamicCast<const typeValue> (attrValue);                     \
        if (!attr) {                                                    \
          NS_FATAL_ERROR ("Unable to convert attribute \""              \
                          << attributePath << "\" to type "             \
                          << #typeValue );                              \
        }                                                               \
        return attr->Get ();                                            \
      }                                                                 \
  } /* namespace Config */


/**
 * \ingroup attributehelper
 *
 * Define the Config::GetDefaultValue<>() specialization for the attribute
 * value class \p \<Name>Value, for underlying class \p Name.
 *
 * \param Name The underlying type name.
 *
 * This macro implements the Config::GetDefaultValue<>() specialization
 * returning the current default configuration value of an attribute,
 * as a \c Name.  If the attribute at the configuration path is not
 * compatible with the requested type, the function will raise a
 * fatal error.
 *
 * This macro is typically invoked in the source file.
 *
 * \note This macro must be invoked from <tt>namespace ns3</tt>.
 *
 * \see Config::GetDefaultValue<>()
 */
#define ATTRIBUTE_GETDEFAULT_IMPLEMENT(Name)                            \
  ATTRIBUTE_GETDEFAULT_IMPLEMENT_WITH_NAME(Name, Name ## Value)

/**
 * \ingroup attributehelper
 *
 * Declare the attribute value, accessor, checkers and
 * Config::GetDefaultValue<>() specialization for class \p type
 *
 * \param type the name of the class
 *

 *   - The AttributeChecker class \p \<type>Checker
 *     and the \c MakeTypeChecker function,
 *
 *   - The Config::GetDefaultValue<>() specialization for getting the default
 *     configuration value of an attribute as a \p type,
 *
 * for class \p type.
 *
 * This macro should be invoked outside of the class
 * declaration in its public header, normally in <tt>namespace ns3<tt>.
 */
#define ATTRIBUTE_HELPER_HEADER(type)                                   \
  ATTRIBUTE_VALUE_DEFINE (type);                                        \
  ATTRIBUTE_ACCESSOR_DEFINE (type);                                     \
  ATTRIBUTE_CHECKER_DEFINE (type);                                      \
  ATTRIBUTE_GETDEFAULT_DEFINE (type)

/**
 * \ingroup attributehelper
 *
 * Define the attribute value, accessor, checkers and
 * Config::GetDefaultValue<>() specialization for class \p type
 *
 * \param type the name of the class
 *

 *
 *   - The \c MakeTypeChecker function,
 *
 *   - The Config::GetDefaultValue<>() specialization,
 *
 * for class \p type.
 *
 * This macro should be invoked from the class implementation file,
 * normally in <tt>namespace ns3</tt>.
 */
#define ATTRIBUTE_HELPER_CPP(type)                                      \
  ATTRIBUTE_CHECKER_IMPLEMENT (type);                                   \
  ATTRIBUTE_VALUE_IMPLEMENT (type);                                     \
  ATTRIBUTE_GETDEFAULT_IMPLEMENT (type)

  
}  // namespace ns3

#endif /* ATTRIBUTE_HELPER_H */

(-)a/src/core/model/callback.h (-1 / +16 lines)

Lines 1718-1730	Link Here

1718

  virtual bool DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker);

1718

  virtual bool DeserializeFromString (std::string value, Ptr<const AttributeChecker> checker);

1719

private:

1719

private:

1720

  CallbackBase m_value;                 //!< the CallbackBase

1720

  CallbackBase m_value;                 //!< the CallbackBase

1721

};

1721

1722

};  // class CallbackValue

1722

1723

ATTRIBUTE_ACCESSOR_DEFINE (Callback);

1724

ATTRIBUTE_ACCESSOR_DEFINE (Callback);

1724

ATTRIBUTE_CHECKER_DEFINE (Callback);

1725

ATTRIBUTE_CHECKER_DEFINE (Callback);

1726

/*

1727

  Can't implement Config::GetDefault<> specialization for

1728

  Callback<R, T1, T2, T3, T4, T5, T6, T7, T8, T9>

1729

1730

  This ends up being a function partial specialization,

1731

  which isn't allowed.

1732

1733

ATTRIBUTE_GETDEFAULT_DEFINE (Callback);

1734

*/

1725

1735

1726

} // namespace ns3

1736

} // namespace ns3

1727

1737

1738

1739

/********************************************************************

1740

 *  Implementation of templates defined above

1741

 ********************************************************************/

1742

1728

namespace ns3 {

1743

namespace ns3 {

1729

1744

1730

template <typename T>

1745

template <typename T>




  return Singleton<ConfigImpl>::Get ()->GetRootNamespaceObject (i);
}

/**
 * \ingroup config
 * GetDefaultValue<>() helper to fetch the TypeId::AttributeInformation.
 *
 * \param attributePath The configuration path for the attribute.
 * \returns The TypeId::AttributeInformation.
 *
 * This is internal to the Config system.
 */
Ptr<struct TypeId::AttributeInformation>
GetAttributeInformation(const std::string attributePath)
{
  NS_LOG_FUNCTION (attributePath);
  // Attribute name is last token
  size_t colon = attributePath.rfind ("::");
  const std::string typeName = attributePath.substr (0, colon);
  NS_LOG_DEBUG ("typeName: '" << typeName << "', colon: " << colon);
  
  TypeId tid;
  if (!TypeId::LookupByNameFailSafe (typeName, &tid))
    {
      NS_FATAL_ERROR ("Unknown type=" << typeName);
    }

  const std::string attrName = attributePath.substr (colon + 2);
  Ptr<struct TypeId::AttributeInformation> info =
    Create<struct TypeId::AttributeInformation> ();
  if (!tid.LookupAttributeByName (attrName, PeekPointer (info)) )
    {
      NS_FATAL_ERROR ("Attribute not found: " << attributePath);
    }
  return info;
}

Ptr<const AttributeValue>
GetDefaultAttributeValue (const std::string attributePath)
{
  Ptr<struct TypeId::AttributeInformation> info =
    GetAttributeInformation (attributePath);
  Ptr<const AttributeValue> attr = info->initialValue;
  return attr;
}


} // namespace Config

} // namespace ns3




 */
Ptr<Object> GetRootNamespaceObject (uint32_t i);

/**
 * \ingroup config
 * Get the current default value for an attribute.
 *
 * The current default is the initial value which would be
 * used by new instances of the type, including any
 * CommandLine or environment variable configuration.
 *
 * \tparam R The type to return.
 * \param attributePath The configuration path for the attribute.
 * \returns The default value.
 *
 * GetDefaultValue<>() will raise a fatal error if the attribute
 * can't be converted to the desired type.
 *
 * \internal
 *
 * GetDefaultValue<>() proceeds by first looking up the default value as a base
 * AttributeValue, then attempting to upcast to the derived AttributeValue
 * type associated with the requested return type, then finally
 * getting the default value from the derived AttributeValue.
 *
 * For example, if the desired return type is an ns3::DataRate, the
 * base AttributeValue will be upcast to a DataRateValue.  If this fails
 * GetDefaultValue<>() will raise a fatal error.
 *
 * There is no generic template declaration; only specializations
 * of this template exist.  Specializations are declared and implemented
 * by the ATTRIBUTE_GETDEFAULT_DEFINE() and ATTRIBUTE_GETDEFAULT_IMPLEMENT()
 * macros, which are normally invoked by the ATTRIBUTE_HELPER_HEADER() and
 * ATTRIBUTE_HELPER_CPP() macros.
 */
template <typename R>
R
GetDefaultValue (const std::string attributePath);

} // namespace Config

} // namespace ns3

(-)a/src/core/model/double.cc (+1 lines)

Lines 27-32	Link Here

NS_LOG_COMPONENT_DEFINE ("Double");

NS_LOG_COMPONENT_DEFINE ("Double");

ATTRIBUTE_VALUE_IMPLEMENT_WITH_NAME (double, Double);

ATTRIBUTE_VALUE_IMPLEMENT_WITH_NAME (double, Double);

ATTRIBUTE_GETDEFAULT_IMPLEMENT_WITH_NAME (double, DoubleValue);

namespace internal {

namespace internal {

(-)a/src/core/model/double.h (+1 lines)

Lines 34-39	Link Here

*/

*/

ATTRIBUTE_VALUE_DEFINE_WITH_NAME (double, Double);

ATTRIBUTE_VALUE_DEFINE_WITH_NAME (double, Double);

ATTRIBUTE_ACCESSOR_DEFINE (Double);

ATTRIBUTE_ACCESSOR_DEFINE (Double);

ATTRIBUTE_GETDEFAULT_DEFINE (double);

template <typename T>

template <typename T>

Ptr<const AttributeChecker> MakeDoubleChecker (void);

Ptr<const AttributeChecker> MakeDoubleChecker (void);

(-)a/src/core/model/integer.cc (+1 lines)

Lines 27-32	Link Here

NS_LOG_COMPONENT_DEFINE ("Integer");

NS_LOG_COMPONENT_DEFINE ("Integer");

ATTRIBUTE_VALUE_IMPLEMENT_WITH_NAME (int64_t, Integer);

ATTRIBUTE_VALUE_IMPLEMENT_WITH_NAME (int64_t, Integer);

ATTRIBUTE_GETDEFAULT_IMPLEMENT_WITH_NAME (int64_t, IntegerValue);

namespace internal {

namespace internal {

(-)a/src/core/model/integer.h (+1 lines)

Lines 37-42	Link Here

*/

*/

ATTRIBUTE_VALUE_DEFINE_WITH_NAME (int64_t, Integer);

ATTRIBUTE_VALUE_DEFINE_WITH_NAME (int64_t, Integer);

ATTRIBUTE_ACCESSOR_DEFINE (Integer);

ATTRIBUTE_ACCESSOR_DEFINE (Integer);

ATTRIBUTE_GETDEFAULT_DEFINE (int64_t);

template <typename T>

template <typename T>

Ptr<const AttributeChecker> MakeIntegerChecker (void);

Ptr<const AttributeChecker> MakeIntegerChecker (void);

(-)a/src/core/model/nstime.h (+1 lines)

Lines 919-924	Link Here

919

 * \brief Attribute for objects of type ns3::Time

919

 * \brief Attribute for objects of type ns3::Time

920

*/

920

*/

921

ATTRIBUTE_VALUE_DEFINE (Time);

921

ATTRIBUTE_VALUE_DEFINE (Time);

922

ATTRIBUTE_GETDEFAULT_DEFINE (Time);

922

923

/**

924

/**

924

 *  Attribute accessor function for Time

925

 *  Attribute accessor function for Time

(-)a/src/core/model/type-id.h (-2 / +3 lines)

Lines 60-66	Link Here

    ATTR_CONSTRUCT = 1<<2, /**< The attribute can be written at construction-time */

    ATTR_CONSTRUCT = 1<<2, /**< The attribute can be written at construction-time */

    ATTR_SGC = ATTR_GET | ATTR_SET | ATTR_CONSTRUCT, /**< The attribute can be read, and written at any time */

    ATTR_SGC = ATTR_GET | ATTR_SET | ATTR_CONSTRUCT, /**< The attribute can be read, and written at any time */

};

};

  struct AttributeInformation {

  struct AttributeInformation : public SimpleRefCount<AttributeInformation>

    std::string name;

    std::string name;

    std::string help;

    std::string help;

    uint32_t flags;

    uint32_t flags;

Lines 412-418	Link Here

412

 * \brief hold objects of type ns3::TypeId

413

 * \brief hold objects of type ns3::TypeId

413

*/

414

*/

414

415

416

ATTRIBUTE_HELPER_HEADER (TypeId);

417

ATTRIBUTE_HELPER_HEADER (TypeId);

417

418

} // namespace ns3

419

} // namespace ns3




{
  return is;
}

ATTRIBUTE_VALUE_DEFINE (ValueClassTest);
ATTRIBUTE_ACCESSOR_DEFINE (ValueClassTest);
ATTRIBUTE_CHECKER_DEFINE (ValueClassTest);

namespace ns3 {
ATTRIBUTE_GETDEFAULT_DEFINE (ValueClassTest);
}

ATTRIBUTE_CHECKER_IMPLEMENT (ValueClassTest);
ATTRIBUTE_VALUE_IMPLEMENT (ValueClassTest);
namespace ns3 {
ATTRIBUTE_GETDEFAULT_IMPLEMENT (ValueClassTest);
}

class Derived : public Object
{

(-)a/src/mesh/model/dot11s/ie-dot11s-id.cc (-2 / +5 lines)

Lines 151-158	Link Here

151

  return is;

151

  return is;

152

153

154

ATTRIBUTE_HELPER_CPP (IeMeshId);

154

ATTRIBUTE_VALUE_IMPLEMENT (IeMeshId);

155

ATTRIBUTE_CHECKER_IMPLEMENT (IeMeshId);

156

157

} // namespace dot11s

157

} // namespace dot11s

158

159

ATTRIBUTE_GETDEFAULT_IMPLEMENT (ns3::dot11s::IeMeshId);

160

158

} // namespace ns3

161

} // namespace ns3

(-)a/src/mesh/model/dot11s/ie-dot11s-id.h (-5 / +6 lines)

Lines 58-69	Link Here

std::ostream &operator << (std::ostream &os, const IeMeshId &meshId);

std::ostream &operator << (std::ostream &os, const IeMeshId &meshId);

/**

ATTRIBUTE_VALUE_DEFINE (IeMeshId);

 * \class ns3::IeMeshIdValue

ATTRIBUTE_ACCESSOR_DEFINE (IeMeshId);

 * \brief hold objects of type ns3::IeMeshId

ATTRIBUTE_CHECKER_DEFINE (IeMeshId);

*/

ATTRIBUTE_HELPER_HEADER (IeMeshId);

} // namespace dot11s

} // namespace dot11s

ATTRIBUTE_GETDEFAULT_DEFINE (ns3::dot11s::IeMeshId);

} // namespace ns3

} // namespace ns3

#endif /* MESH_ID_H */

#endif /* MESH_ID_H */

Return to bug 1604