HLAfixedArrayImpl.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2010 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: HLAfixedArrayImpl.h,v $ $Revision: 1.0 $ $State: Exp $
*********************************************************************/
#ifndef HLAfixedArrayImpl_H_
#define HLAfixedArrayImpl_H_

#ifdef DtIFSPEC1516E

#include <RTI/encoding/DataElement.h>
#include "encodingImplHelpers.h"
#include <memory>

namespace rti1516e
{
    class VariableLengthData;

    class HLAfixedArrayImplementation
    {
    public:
        // Constructor which initializes the array with copies of a prototype element
        HLAfixedArrayImplementation( const DataElement& proto, size_t length );

        // Copy Constructor: source must have same element type
        // Copied elements use internal memory
        HLAfixedArrayImplementation(HLAfixedArrayImplementation const & rhs)
            throw (EncoderException);

        // Destructor
        ~HLAfixedArrayImplementation();

        // Encode this element into a new rti1516e::VariableLengthData
        // @return a rti1516e::VariableLengthData containing an encoded element
        virtual rti1516e::VariableLengthData encode() const;

        // Encode this element into an existing rti1516e::VariableLengthData
        // @param data a rti1516e::VariableLengthData to which the element will be written
        virtual void encode(rti1516e::VariableLengthData& inData) const;

        // Encode this element and append it to a buffer
        // @param buffer a character buffer to which the encoding will be appended
        virtual void encodeInto( std::vector<Octet>& buffer ) const;

        // Decode this element from the RTI's VariableLengthData.
        // @param data a VariableLengthData containing an encoded element
        virtual void decode(rti1516e::VariableLengthData const & inData)
            throw (EncoderException);

        // Decode this element starting at the index in the provided buffer
        // @param buffer a character buffer from which the element will be decoded
        // @param index location of the encoded bytes in the buffer
        virtual size_t decodeFrom( std::vector<Octet> const & buffer, unsigned int index )
            throw (EncoderException);

        // Return the size in bytes of this element's encoding.
        // @return size
        virtual size_t getEncodedLength() const;

        // Return the octet boundary of this element.
        // @return the alignment of the element
        virtual unsigned int getOctetBoundary() const;

        // Return the number of elements in this fixed array.
        // @return
        virtual size_t size() const;

        // Return true if given element matches prototype of array.
        virtual bool hasPrototypeSameTypeAs(DataElement const& dataElement ) const;

        // Return true if the prototype of given array matches prototype of this array.
        virtual bool hasSamePrototypeTypeAs(HLAfixedArrayImplementation const& inData) const;

        // Sets the element at the given index to a copy of the given element instance
        // Element must match prototype.
        virtual void set(size_t index, const DataElement& dataElement)
            throw (EncoderException);

        // Sets the element at the given index to the given element instance
        // Element must match prototype.
        // Null pointer results in an exception.
        virtual void setElementPointer(size_t index, DataElement* dataElement,
            bool takeOwnership=false)
            throw (EncoderException);

        // Return the element at the specified index.
        // @param index
        // @return
        virtual const rti1516e::DataElement& get(
            size_t index) const
            throw (EncoderException);

    protected:

        // Reset the cached length if it has changed.
        // Return current encoded length
        virtual size_t resetEncodedLength( );

        // Empty and delete memory for existing elements.
        // Does not change array size
        virtual void clear( );

        // Remove const
        HLAfixedArrayImplementation* self() const;

    private:

        // Default Constructor not allowed
        HLAfixedArrayImplementation();

    private:

        std::auto_ptr<rti1516e::DataElement> myPrototypeElement;
        mutable std::vector<rti1516e::DataElement*> myData;
        mutable std::vector<bool> myDataOwnership;
        bool myDirtyState;
        unsigned int myOctetBoundary;
        unsigned int myEncodedLength;
    };
}

#endif
#endif  // DtIFSPEC1516E