ShVariant.hpp

//
// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#ifndef SHVARIANT_HPP
#define SHVARIANT_HPP

#include <string>
#include <vector>
#include <ostream>
#include "ShDllExport.hpp"
#include "ShPool.hpp"
#include "ShSwizzle.hpp"
#include "ShVariableType.hpp"
#include "ShDataType.hpp"
#include "ShRefCount.hpp"

namespace SH {


class 
SH_DLLEXPORT 
ShVariant: public ShRefCountable {
  public:
    ShVariant();
    virtual ~ShVariant();


    virtual ShValueType valueType() const = 0; 

    virtual ShDataType dataType() const = 0; 

    virtual bool typeMatches(ShValueType valueType, ShDataType dataType) const = 0;

    virtual const char* typeName() const = 0; 

    virtual int size() const = 0;

    virtual int datasize() const = 0;

    virtual bool managed() const = 0;

    virtual void negate() = 0;


    virtual void set(ShPointer<const ShVariant> other) = 0;
    virtual void set(const ShVariant* other) = 0;
    // @}

    virtual void set(ShPointer<const ShVariant> other, int index) = 0;
    virtual void set(const ShVariant* other, int index) = 0;
    // @}

    virtual void set(ShPointer<const ShVariant> other, bool neg, const ShSwizzle &writemask) = 0;
    virtual void set(const ShVariant* other, bool neg, const ShSwizzle &writemask) = 0;
    // @}

    virtual ShPointer<ShVariant> get() const = 0;

    virtual ShPointer<ShVariant> get(int index) const = 0;

    virtual ShPointer<ShVariant> get(bool neg, const ShSwizzle &swizzle, int count=1) const = 0; 

    // This uses shDataTypeEquals
    //
    // @see ShDataType.hpp
    virtual bool equals(ShPointer<const ShVariant> other) const = 0;
    virtual bool equals(const ShVariant* other) const = 0;

    // @see ShDataType.hpp
    virtual bool isTrue() const = 0;


    virtual void* array() = 0;
    virtual const void* array() const = 0;
    // @}


    virtual std::string encode() const = 0;
    virtual std::string encode(int index, int repeats=1) const = 0;
    virtual std::string encode(bool neg, const ShSwizzle &swizzle) const = 0;

    virtual std::string encodeArray() const = 0;
};

typedef ShPointer<ShVariant> ShVariantPtr;
typedef ShPointer<const ShVariant> ShVariantCPtr;

/* A fixed-size array of a specific data type that can act as an ShVariant 
 *
 * This is different from ShMemory objects which hold arbitrary typed
 * data in byte arrays (that eventually may include some 
 * unordered collection of several types)
 *
 * @see ShMemory 
 **/ 
template<typename T, ShDataType DT=SH_HOST>
class ShDataVariant: public ShVariant {
  public:
    static const ShValueType value_type = ShStorageTypeInfo<T>::value_type;
    static const ShDataType data_type = DT;
    typedef ShDataVariant<T, DT>* PtrType;
    typedef const ShDataVariant<T, DT>* CPtrType;
    typedef typename ShDataTypeCppType<T, DT>::type DataType;
    typedef DataType* iterator;
    typedef const DataType* const_iterator;

    ShDataVariant(int N); 

    ShDataVariant(int N, const DataType &value); 

    ShDataVariant(std::string encodedValue);

    ShDataVariant(int N, void *data, bool managed = true);

    ShDataVariant(const ShDataVariant<T, DT> &other);
    ShDataVariant(const ShDataVariant<T, DT> &other, bool neg, const ShSwizzle &swizzle, int count=1); 

    virtual ~ShDataVariant();

    ShValueType valueType() const; 
    ShDataType dataType() const; 
    bool typeMatches(ShValueType valueType, ShDataType dataType) const; 

    const char* typeName() const; 

    //std::string typeName() const; 
    
    int size() const; 
    int datasize() const; 

    bool managed() const;

    void negate();

    void set(ShVariantCPtr other);
    void set(const ShVariant* other);
    void set(ShVariantCPtr other, int index);
    void set(const ShVariant* other, int index);
    void set(ShVariantCPtr other, bool neg, const ShSwizzle &writemask);
    void set(const ShVariant* other, bool neg, const ShSwizzle &writemask);

    ShVariantPtr get() const; 
    ShVariantPtr get(int index) const; 
    ShVariantPtr get(bool neg, const ShSwizzle &swizzle, int count=1) const; 

    bool equals(ShVariantCPtr other) const; 
    bool equals(const ShVariant* other) const; 

    bool isTrue() const;

    void* array(); 
    const void* array() const; 

    DataType& operator[](int index);
    const DataType& operator[](int index) const;

    iterator begin();
    iterator end();

    const_iterator begin() const;
    const_iterator end() const;

    std::string encode() const;
    std::string encode(int index, int repeats=1) const; 
    std::string encode(bool neg, const ShSwizzle &swizzle) const; 

    //
    
    std::string encodeArray() const;

#ifdef SH_USE_MEMORY_POOL
    // Memory pool stuff.
    void* operator new(std::size_t size);
    void operator delete(void* d, std::size_t size);
#endif
    
  protected:
    DataType *m_begin; 
    DataType *m_end; 

    bool m_managed; 

    void alloc(int N);

#ifdef SH_USE_MEMORY_POOL
    static ShPool* m_pool;
#endif
};


// Cast to the specified data variant using dynamic_cast
//
// Refcounted and non-refcounted versions
template<typename T, ShDataType DT>
ShPointer<ShDataVariant<T, DT> > variant_cast(ShVariantPtr c);

template<typename T, ShDataType DT>
ShPointer<const ShDataVariant<T, DT> > variant_cast(ShVariantCPtr c);

template<typename T, ShDataType DT>
ShDataVariant<T, DT>* variant_cast(ShVariant* c);

template<typename T, ShDataType DT>
const ShDataVariant<T, DT>* variant_cast(const ShVariant* c);
// @}

// Make a copy of c cast to the requested type 
template<typename T, ShDataType DT>
ShPointer<ShDataVariant<T, DT> > variant_convert(ShVariantCPtr c);
// @}


}

#include "ShVariantImpl.hpp"

#endif

---