// 
// File:          Ordering_IntOrderTest_Impl.hh
// Symbol:        Ordering.IntOrderTest-v0.1
// Symbol Type:   class
// Babel Version: 0.10.2
// Description:   Server-side implementation for Ordering.IntOrderTest
// 
// WARNING: Automatically generated; only changes within splicers preserved
// 
// babel-version = 0.10.2
// 

#ifndef included_Ordering_IntOrderTest_Impl_hh
#define included_Ordering_IntOrderTest_Impl_hh

#ifndef included_sidl_cxx_hh
#include "sidl_cxx.hh"
#endif
#ifndef included_Ordering_IntOrderTest_IOR_h
#include "Ordering_IntOrderTest_IOR.h"
#endif
// 
// Includes for all method dependencies.
// 
#ifndef included_Ordering_IntOrderTest_hh
#include "Ordering_IntOrderTest.hh"
#endif
#ifndef included_sidl_BaseInterface_hh
#include "sidl_BaseInterface.hh"
#endif
#ifndef included_sidl_ClassInfo_hh
#include "sidl_ClassInfo.hh"
#endif


#line 36 "../../../../babel/regression/ordering/libCxx/Ordering_IntOrderTest_Impl.hh"
// DO-NOT-DELETE splicer.begin(Ordering.IntOrderTest._includes)
// Put additional includes or other arbitrary code here...
// DO-NOT-DELETE splicer.end(Ordering.IntOrderTest._includes)
#line 40 "Ordering_IntOrderTest_Impl.hh"

namespace Ordering { 

  /**
   * Symbol "Ordering.IntOrderTest" (version 0.1)
   * 
   * This class provides methods to verify that the array ordering
   * capabilities work for arrays of int.
   */
  class IntOrderTest_impl
#line 49 "../../../../babel/regression/ordering/libCxx/Ordering_IntOrderTest_Impl.hh"
  // DO-NOT-DELETE splicer.begin(Ordering.IntOrderTest._inherits)
  // Put additional inheritance here...
  // DO-NOT-DELETE splicer.end(Ordering.IntOrderTest._inherits)
#line 55 "Ordering_IntOrderTest_Impl.hh"
  {

  private:
    // Pointer back to IOR.
    // Use this to dispatch back through IOR vtable.
    IntOrderTest self;

#line 59 "../../../../babel/regression/ordering/libCxx/Ordering_IntOrderTest_Impl.hh"
    // DO-NOT-DELETE splicer.begin(Ordering.IntOrderTest._implementation)
    // Put additional implementation details here...
    // DO-NOT-DELETE splicer.end(Ordering.IntOrderTest._implementation)
#line 67 "Ordering_IntOrderTest_Impl.hh"

  private:
    // private default constructor (required)
    IntOrderTest_impl() 
    {} 

  public:
    // sidl constructor (required)
    // Note: alternate Skel constructor doesn't call addref()
    // (fixes bug #275)
    IntOrderTest_impl( struct Ordering_IntOrderTest__object * s ) : self(s,
      true) { _ctor(); }

    // user defined construction
    void _ctor();

    // virtual destructor (required)
    virtual ~IntOrderTest_impl() { _dtor(); }

    // user defined destruction
    void _dtor();

    // static class initializer
    static void _load();

  public:

    /**
     * Create a column-major matrix satisfying condition I.
     */
    static ::sidl::array<int32_t>
    makeColumnIMatrix (
      /* in */ int32_t size,
      /* in */ bool useCreateCol
    )
    throw () 
    ;


    /**
     * Create a row-major matrix satisfying condition I.
     */
    static ::sidl::array<int32_t>
    makeRowIMatrix (
      /* in */ int32_t size,
      /* in */ bool useCreateRow
    )
    throw () 
    ;


    /**
     * Create a 4-D matrix satisfying condition I.  Each dimension has
     * size elements numbers 0 through size-1.
     */
    static ::sidl::array<int32_t>
    makeIMatrix (
      /* in */ int32_t size,
      /* in */ bool useCreateColumn
    )
    throw () 
    ;


    /**
     * Create a column-major matrix satisfying condition I.
     */
    static void
    createColumnIMatrix (
      /* in */ int32_t size,
      /* in */ bool useCreateCol,
      /* out */ ::sidl::array<int32_t>& res
    )
    throw () 
    ;


    /**
     * Create a row-major matrix satisfying condition I.
     */
    static void
    createRowIMatrix (
      /* in */ int32_t size,
      /* in */ bool useCreateRow,
      /* out */ ::sidl::array<int32_t>& res
    )
    throw () 
    ;


    /**
     * Make sure an array is column-major.  No changes to the dimension or
     * values in a are made.
     */
    static void
    ensureColumn (
      /* inout */ ::sidl::array<int32_t>& a
    )
    throw () 
    ;


    /**
     * Make sure an array is row-major.  No changes to the dimension or
     * values in a are made.
     */
    static void
    ensureRow (
      /* inout */ ::sidl::array<int32_t>& a
    )
    throw () 
    ;


    /**
     *  Return <code>true</code> iff the implementation sees
     *  an incoming array satisfying condition I.
     */
    static bool
    isIMatrixOne (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation sees
     * an incoming column-major array satisfying condition I.
     */
    static bool
    isColumnIMatrixOne (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation sees
     * an incoming row-major array satisfying condition I.
     */
    static bool
    isRowIMatrixOne (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     *  Return <code>true</code> iff the implementation sees
     *  an incoming array satisfying condition I.
     */
    static bool
    isIMatrixTwo (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation sees
     * an incoming column-major array satisfying condition I.
     */
    static bool
    isColumnIMatrixTwo (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation sees
     * an incoming row-major array satisfying condition I.
     */
    static bool
    isRowIMatrixTwo (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     *  Return <code>true</code> iff the implementation sees
     *  an incoming array satisfying condition I.
     */
    static bool
    isIMatrixFour (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation sees
     * an incoming column-major array satisfying condition I.
     */
    static bool
    isColumnIMatrixFour (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation sees
     * an incoming row-major array satisfying condition I.
     */
    static bool
    isRowIMatrixFour (
      /* in */ ::sidl::array<int32_t> A
    )
    throw () 
    ;


    /**
     * Return <code>true</code> iff the implementation of slice
     * and smart copy is correct.
     */
    static bool
    isSliceWorking (
      /* in */ bool useCreateCol
    )
    throw () 
    ;


  };  // end class IntOrderTest_impl

} // end namespace Ordering

#line 300 "../../../../babel/regression/ordering/libCxx/Ordering_IntOrderTest_Impl.hh"
// DO-NOT-DELETE splicer.begin(Ordering.IntOrderTest._misc)
// Put miscellaneous things here...
// DO-NOT-DELETE splicer.end(Ordering.IntOrderTest._misc)
#line 310 "Ordering_IntOrderTest_Impl.hh"

#endif