slice_error.hh

Go to the documentation of this file.

// -*- c++ -*-

// Copyright (C) 2009 Ed Rosten (er258@cam.ac.uk)
//
// This file is part of the TooN Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

namespace TooN {

namespace Internal
{
        template<bool StaticBad> 
        struct BadSlice;
        
        template<> 
        struct BadSlice<0>{
                static void check(){} 
        };
        
        template<int Size, int Start, int Length> 
        struct CheckSlice
        {
                
                template<int Num> struct N
                {
                        static int n(int num)
                        {
                                return Num==Dynamic?num:Num;
                        }
                };

                static void check()
                {
                        //Sanity check all basic static sizes
                        BadSlice<!(Size== Dynamic || Size > 0)>::check();
                        BadSlice<!(Start >= 0)>::check();
                        BadSlice<!(Length > 0)>::check();
                        BadSlice<(Size != Dynamic && (Start + Length > Size))>::check();
                }       

                static void check(int size, int start, int length)
                {
                        //Sanity check all basic static sizes
                        BadSlice<!(Size   == Dynamic || Size > 0)>::check();
                        BadSlice<!(Start  == Dynamic || Start >= 0)>::check();
                        BadSlice<!(Length == Dynamic || Length > 0)>::check();
                        
                        //We can make sure Length <= Size, even if Start is unknown
                        BadSlice<(Size!=Dynamic && Length != Dynamic && Length > Size)>::check();
                        
                        //We can make sure Start < Size even if Length is unknown
                        BadSlice<(Start != Dynamic && Size != Dynamic && Start >= Size)>::check();

                        BadSlice<(Size != Dynamic && Start != Dynamic && Length != Dynamic && Start + Length > Size)>::check();
                        #ifndef TOON_NDEBUG_MISMATCH
                                if(Start != Dynamic && Start != start)
                                {
                                        std::cerr << "TooN slice: mismatch between static and dynamic start.\n";
                                        std::abort();
                                }
                                if(Length != Dynamic && Length != length)
                                {
                                        std::cerr << "TooN slice: mismatch between static and dynamic length.\n";
                                        std::abort();
                                }
                                if(Size != Dynamic && Size != size)
                                {
                                        std::cerr << "TooN slice: mismatch between static and dynamic size.\n";
                                        std::abort();
                                }
                        #endif
                        if( N<Start>::n(start) + N<Length>::n(length) > N<Size>::n(size) || 
                           N<Start>::n(start) < 0 ||
                           N<Length>::n(length) < 0)
                        {
                                #ifdef TOON_TEST_INTERNALS
                                        throw Internal::SliceError();
                                #elif !defined TOON_NDEBUG_SLICE
                                        std::cerr << "TooN slice out of range" << std::endl;
                                        std::abort();
                                #endif
                        }
                }
        };      

        #ifdef TOON_TEST_INTERNALS
                template<bool StaticBad> 
                struct BadSlice{
                        static void check(){
                                throw Internal::StaticSliceError();
                        }
                };
        #endif
}

}

---

libtoon
Author(s): Florian Weisshardt
autogenerated on Fri Jan 11 10:09:37 2013