Profile.hpp

//
// Laser stripe position detected in a Frame.
// Copyright (C) 2008-2010 AQSENSE, S.L.
//
#if !defined (AQSENSE_SAL3DPP_PROFILE_HPP)
#define AQSENSE_SAL3DPP_PROFILE_HPP

#if defined (_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif // _MSC_VER && _MSC_VER >= 1020

#include <sal3d/profile.h>
#include <cstddef>
#include <stdexcept>
#include <sal3dpp/Common.hpp>

namespace sal3d
{
    class Profile
    {
        public:
            typedef float value_type;
            typedef value_type *iterator;
            typedef const value_type *const_iterator;

            Profile (value_type *start, int length):
                _length(length),
                _values(start)
            {
                Error e;
                sal3d_profile_new_from_memory(start, length, &_profile, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            explicit Profile (sal3d_profile profile):
                _length (sal3d_profile_get_length (profile)),
                _profile (profile),
                _values (0)
            {
                Error e;
                sal3d_profile_get_values (_profile, &_values, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            Profile (const Profile &profile):
                _length (profile._length),
                _profile (profile._profile),
                _values (profile._values)
            {
                Error e;
                sal3d_profile_share (_profile, &e.e);
                if (e.e.value < 0)
                    throw e;
            }

            ~Profile ()
            {
                sal3d_profile_release (_profile);
            }

            sal3d_profile
            c_profile () const
            {
                return _profile;
            }

            const_iterator
            begin () const
            {
                return _values;
            }

            iterator
            begin ()
            {
                return const_cast<iterator>(
                        static_cast<const Profile &>(*this).begin() );
            }

            const_iterator
            end () const
            {
                return _values + length ();
            }

            iterator
            end ()
            {
                return const_cast<iterator> (
                        static_cast<const Profile &>(*this).end() );
            }

            int
            length () const
            {
                return _length;
            }

            Profile &
            operator= (const Profile &rhs)
            {
                Error e;
                sal3d_profile_share (rhs._profile, &e.e);
                if (e.e.value < 0)
                    throw e;
                
                sal3d_profile_release (_profile);
                _length = rhs._length;
                _profile = rhs._profile;
                _values = rhs._values;

                return *this;
            }

            const value_type &
            operator[] (int index) const
            {
                if ( length () <= index )
                {
                    throw std::out_of_range ("profile's index not valid");
                }
                return *(begin () + index);
            }


            value_type &
            operator[] (int index)
            {
                return const_cast<value_type &> (
                        static_cast<const Profile &>(*this)[index] );
            }

        private:
            int _length;
            sal3d_profile _profile;
            iterator _values;
    };
}

#endif // !AQSENSE_SAL3DPP_PROFILE_HPP