otl.h

Go to the documentation of this file.

// OSB library ********************************************* -*- C++ -*-
/*
  AUTHOR(S): Andreas Huggel (ahu)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.28 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _OSBOTL_H_
#define _OSBOTL_H_

// *********************************************************************
// included header files
#include <string>

#include <config.h>                     // for OTL configuration

// Pragmas to disable cxx compiler warnings on Compaq Tru64 UNIX
#pragma message save
#pragma message disable (intconlosbit, setbutnotused, unrfunprm)
#include <otlv4.h>
#pragma message restore

#include "osbid.h"
#include "chrono.h"

// *********************************************************************
// class declarations
namespace OSB_DB {
    class DbException;
    class ChildFound;
}

// *********************************************************************
// namespace extensions
namespace OSB_DB {

    const short FEW_ROWS  =  50;
    const short MANY_ROWS = 2000;

    const unsigned int MAX_NAME =  63;   // OSB_LIB::MAX_NAME
    const unsigned int MAX_DES  = 255;   // OSB_LIB::MAX_DES
    const std::string DES_DB = "<char[256]>";
    const std::string NAME_DB = "<char[64]>";
    const std::string ROWID_DB = "<char[32]>";

    enum SqlCode { CHILD_FOUND                = -2292,
                   NO_PARENT                  = -2291,
                   DEAD_LOCK                  =   -60,
                   RESOURCE_BUSY              =   -54,
                   UNIQUE_CONSTRAINT_VIOLATED =    -1,
                   SUCCESSFUL_COMPLETION      =     0,
                   NO_DATA_FOUND              =  1403 };

    DbException dbException(const otl_exception& e);
    DbException dbException(long errNo, const otl_exception& e);

    ChildFound childFound(const otl_exception& e);
    ChildFound childFound(long errNo, const otl_exception& e);

    std::string otlErrMsg(const otl_exception& e);

    class OtlString : public otl_value<std::string> {
    public:


        OtlString();
        OtlString(const otl_null& rhs);

        explicit OtlString(const std::string& rhs);

        operator std::string() const;
    };                                  // class OtlString

    class OtlId : public otl_value<long> {
    public:


        OtlId() : otl_value<long>() {}
        OtlId(const otl_null& rhs) : otl_value<long>(rhs) {}

        template <typename T>
        explicit OtlId(const OSB_LIB::Id<T>& rhs)
          : otl_value<long>(rhs.id())
        {
            if (rhs.notSet()) set_null();
        }
        long id() const
        {
            return is_null() ? nvl() : v;
        }
        static long nvl()
        {
            return OSB_LIB::ID_NOT_SET;
        }
    };                                  // class OtlId

    class OtlId2 {
    public:


        template <typename T>
        explicit OtlId2(const OSB_LIB::Id2<T>& id)
          : id1_(id.id1_), id2_(id.id2_)
        {
            if (OSB_LIB::ID_NOT_SET == id1_.v) id1_.set_null();
            if (OSB_LIB::ID_NOT_SET == id2_.v) id2_.set_null();
        }



        OtlId2() : id1_(OSB_LIB::ID_NOT_SET),
                   id2_(OSB_LIB::ID_NOT_SET)
        {
            id1_.set_null();
            id2_.set_null();
        }
        long id1() const
        {
            return id1_.is_null() ? nvl() : id1_.v;
        }
        long id2() const
        {
            return id2_.is_null() ? nvl() : id2_.v;
        }

        static long nvl()
        {
            return OSB_LIB::ID_NOT_SET;
        }
    public:
        otl_value<long> id1_;
        otl_value<long> id2_;
    };

    class OtlDateTime : public otl_value<otl_datetime> {
    public:


        OtlDateTime() : otl_value<otl_datetime>() {}
        OtlDateTime(const otl_value<otl_datetime>& rhs)
            : otl_value<otl_datetime>(rhs) {}
        OtlDateTime(const otl_datetime& rhs)
            : otl_value<otl_datetime>(rhs) {}
        OtlDateTime(const otl_null& rhs)
            : otl_value<otl_datetime>(rhs) {}



        OtlDateTime(const OSB_LIB::Date&);
        OtlDateTime(const OSB_LIB::DateTime&);



        OSB_LIB::Date date() const;
        OSB_LIB::DateTime dateTime() const;
    };                                  // class OtlDateTime
}

#endif                                  // #ifndef _OSBOTL_H_

---