sdsarray.hh

Go to the documentation of this file.

#ifndef _DRAMA2_SDSARRAY_INC
#define _DRAMA2_SDSARRAY_INC
 
/*
 * History:
     07-Jan-2014 - TJF - Original version
 */
#include "sds.h"
#include <string>
 
namespace drama { 
 
    namespace sds {
 
        template<typename SDS_T> int CodeForType() { return -1; }
        
        template <> int CodeForType<double>();
        template <> int CodeForType<float>();
        template <> int CodeForType<short>();
        template <> int CodeForType<INT32>();
        template <> int CodeForType<INT64>();
        template <> int CodeForType<unsigned short>();
        template <> int CodeForType<UINT32>();
        template <> int CodeForType<UINT64>();
        template <> int CodeForType<signed char>();
        template <> int CodeForType<unsigned char>();
        //template <> int CodeForType<std::string>();
        template <> int CodeForType<const std::string&>();
 
        template <> int CodeForType<char>();
 
        template <> int CodeForType<bool> ();
 
 
        class  Id;
 
 
 
        template <typename T> class ArrayAccessHelper {
        public:
            friend class drama::sds::Id;
        private:
            SdsCodeType code;         /* The SDS code of the item */
            unsigned long elements;   /* Number of element in the array */
            T* data;                  /* The array pointer is written here */
 
            /*
             * Remaining private items used by sds::Id to set this item up.
             */
            /*
             * Set the data pointer to be the specified address.
             */
            void SetDataToAddr(void *dataAddr) {
                data = static_cast<T*>(dataAddr);
            }
            
            /*
             * Set the number of elements in the array.
             *
             * This is used by SdsId.AccessArray() set the number of 
             *  elements in the array.
             */
            void SetNumElements(unsigned long nelem) {
                elements = nelem;
            }
 
        protected:
 
            /*
             * Helper function used to check an index is valid.  Also checks
             * that we have some data. Throws expections on problems.
             */
            void CheckIndexAndData(unsigned long index) const {
                if (!data)
                {
                    DramaTHROW_S(DRAMA2__SDS_ARRAY_ERR,
                                 "drama::Sds::ArrayAccessHelper Index %, Code %, elements % - data is invalid", index, code, elements);
                }
                if (index >= elements)
                {
                    DramaTHROW_S(DRAMA2__SDS_ARRAY_ERR,
                                 "drama::Sds::ArrayAccessHelper Index %, Code %, elements % - index is invalid", index, code, elements);
                }
            }
            
 
 
            T * GetDataAddress() {
                return this->data;
            }
            const T * GetDataAddress() const {
                return this->data;
            }
 
        public:
            ArrayAccessHelper() : code(CodeForType<T>()), elements(0), data(0) {
                if ((code < 0)||(code > SDS_C_MAXCODE))
                    DramaTHROW_S(SDS__INVTYPE,
                                 "ArrayAccessHelper constructor with invalid code %, must be in range 0 to %s",
                                 code, SDS_C_MAXCODE);
            }
 
            SdsCodeType Code() const { return code; }
            unsigned long Size() const { return elements; }
 
 
        };  /* Sds::ArrayAccessHelper */
 
 
        template <typename T> class ArrayWriteHelper : public ArrayAccessHelper<T> {
        public:
            ArrayWriteHelper() { }
 
            T  & operator[](const unsigned long index) {
                /* Note, "this->" is required for both of these to avoid
                 * compiler not knowing the type applied to the code
                 */
                this->CheckIndexAndData(index);
                return this->GetDataAddress()[index];
            }
            T const & operator[](const unsigned long index) const {
                /* Note, "this->" is required for both of these to avoid
                 * compiler not knowing the type applied to the code
                 */
                this->CheckIndexAndData(index);
                return this->GetDataAddress()[index];
            }
 
            T * DataAddress() {
                return this->GetDataAddress();
            }
        };  /* Sds::ArrayWriteHelper */
 
        template <typename T> class ArrayReadHelper : public ArrayAccessHelper<T> {
        public:
            ArrayReadHelper() { }
 
            T const & operator[](const unsigned long index) const {
                /* Note, "this->" is required for both of these to avoid
                 * compiler not knowing the type applied to the code
                 */
                this->CheckIndexAndData(index);
                return this->GetDataAddress()[index];
            }
            const T * DataAddress() const {
                return this->GetDataAddress();
            }
        };  /* Sds::ArrayReadHelper */
 
 
 
 
    } // namespace sds
 
} // namespace drama
 
#endif