oaPlugInValue.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaPlugInValue.h
//
// This file contains basic implementations for value interfaces. These 
// implementations can be used directly to create value objects.
//
//  Value
//     This class is a value that implements the IValue interface. 
//
//  ValuePtr
//     This class is a convenience class to convert between C++ values and Value
//     objects. 
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaPlugInValue_P)
#define oaPlugInValue_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaPlugInScriptInterfaces.h"
#include "oaPlugInTypes.h"



// *****************************************************************************
// Declare and define types in the OpenAccess namespace.
// *****************************************************************************
BEGIN_OA_PLUGIN_NAMESPACE



// *****************************************************************************
// Value<T>
// *****************************************************************************
template<class T>
class Value : public PlugInBase<IValue<T> > {
public:
                            Value(T v);
    virtual inline          ~Value();

    virtual const char      *getType();
    virtual SRef<IString>   toString();

    virtual inline T        getValue();
    virtual inline void     setValue(T v);

private:
    T                       value;
};



// *****************************************************************************
// Value<const char*>
// *****************************************************************************
template<>
class Value<const char*> : public PlugInBase<IStringValue> {
public:
                                Value(const char *v);
    virtual inline              ~Value();

    virtual inline const char   *getType();
    virtual SRef<IString>       toString();

    virtual inline const char   *getValue();            
    virtual inline void         setValue(const char *v);

private:
    std::string                 value;
};



// *****************************************************************************
// TypeValue
// *****************************************************************************
class TypeValue : public PlugInBase<ITypeValue> {
public:
                            TypeValue(void          *v,
                                      const char    *t);
    virtual                 ~TypeValue();

    virtual const char      *getType();
    virtual SRef<IString>   toString();

    virtual void            *getValue();
    virtual void            setValue(void *v);

private:
    std::string             type;
    void                    *value;
};



// *****************************************************************************
// ValueTraits<T>
// *****************************************************************************
template<class T>
class ValueTraits {
public:
    enum {isPrimitive = 0};
};

template<>
class ValueTraits<char> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<oa::oaInt2> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<oa::oaUInt2> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<oa::oaInt4> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<oa::oaUInt4> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<oa::oaInt8> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<oa::oaUInt8> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<float> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<double> {
public:
    enum {isPrimitive = 1};
};
template<>
class ValueTraits<const char*> {
public:
    enum {isPrimitive = 1};
};



// *****************************************************************************
// ValuePtr<T, 1>
// *****************************************************************************
template<class T, const unsigned int prim = ValueTraits<T>::isPrimitive>
class ValuePtr;

template<class T>
class ValuePtr<T, 1> : public SPtr<IBaseValue> {
public:
                            ValuePtr();
                            ValuePtr(T v);
                            ValuePtr(IBaseValue *in);
                            ValuePtr(const SRef<IBaseValue> &in);

                            operator T();
    ValuePtr                &operator=(T v);
    ValuePtr                &operator=(const SRef<IBaseValue> &v);
};



// *****************************************************************************
// ValuePtr<T, 0>
// *****************************************************************************
template<class T>
class ValuePtr<T, 0> : public SPtr<IBaseValue> {
public:
                            ValuePtr();
                            ValuePtr(T          value,
                                     const char *type);
                            ValuePtr(IBaseValue *in,
                                     const char *type);
                            ValuePtr(const SRef<IBaseValue> &in,
                                     const char             *type);

    T                       getValue();

    ValuePtr<T, 0>          &operator=(const SRef<IBaseValue> &v);
};



END_OA_PLUGIN_NAMESPACE

#endif

Return to top of page

Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.