openrj/cpp/databasebase.hpp

Go to the documentation of this file.

/* /////////////////////////////////////////////////////////////////////////////
 * File:    openrj/cpp/databasebase.hpp
 *
 * Purpose: DatabaseBase class, in the C++ mapping of the Open-RJ library
 *
 * Created: 12th April 2005
 * Updated: 10th July 2006
 *
 * Home:    http://openrj.org/
 *
 * Copyright (c) 2005, Matthew Wilson and Synesis Software
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the names of Matthew Wilson and Synesis Software nor the names of
 *   any contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * ////////////////////////////////////////////////////////////////////////// */


#ifndef OPENRJ_INCL_OPENRJ_CPP_HPP_DATABASEBASE
#define OPENRJ_INCL_OPENRJ_CPP_HPP_DATABASEBASE

/* /////////////////////////////////////////////////////////////////////////////
 * Version information
 */

#ifndef OPENRJ_DOCUMENTATION_SKIP_SECTION
# define OPENRJ_VER_OPENRJ_CPP_HPP_DATABASEBASE_MAJOR       1
# define OPENRJ_VER_OPENRJ_CPP_HPP_DATABASEBASE_MINOR       1
# define OPENRJ_VER_OPENRJ_CPP_HPP_DATABASEBASE_REVISION    2
# define OPENRJ_VER_OPENRJ_CPP_HPP_DATABASEBASE_EDIT        8
#endif /* !OPENRJ_DOCUMENTATION_SKIP_SECTION */

/* /////////////////////////////////////////////////////////////////////////////
 * Includes
 */

#include <openrj/cpp/openrj.hpp>
#include <openrj/cpp/field.hpp>
#include <openrj/cpp/record.hpp>

#include <stlsoft/util/operator_bool_adaptor.hpp>

/* /////////////////////////////////////////////////////////////////////////////
 * Namespace
 */

namespace openrj
{
namespace cpp
{

/* /////////////////////////////////////////////////////////////////////////////
 * Classes
 */

class DatabaseBase
    : public ::stlsoft::operator_bool_adaptor<DatabaseBase>
{
public:
    typedef DatabaseBase    class_type;
    typedef Record          value_type;

protected:
    explicit DatabaseBase(ORJDatabase const *database)
        : m_database(database)
    {}
public:
    virtual ~DatabaseBase()
    {
        Close();
    }

    virtual void Close()
    {
        if(NULL != m_database)
        {
            ORJ_FreeDatabase(m_database);
            m_database = NULL;
        }
    }

public:
    bool is_open() const
    {
        return NULL != m_database;
    }

public:
    size_t GetNumLines() const
    {
        openrj_assert(NULL != m_database);

        return ORJ_Database_GetNumLinesA(m_database);
    }
    size_t GetNumFields() const
    {
        openrj_assert(NULL != m_database);

        return ORJ_Database_GetNumFieldsA(m_database);
    }
    size_t GetNumRecords() const
    {
        openrj_assert(NULL != m_database);

        return ORJ_Database_GetNumRecordsA(m_database);
    }

public:
    const Record    GetRecord(size_t index) const
    {
        return operator [](index);
    }

    const Record operator [](size_t index) const
    {
        openrj_assert(index <= GetNumRecords());

        return Record(m_database->records[index]);
    }
    const Record operator [](int index) const
    {
        return operator [](static_cast<size_t>(index));
    }

    const Field GetField(size_t index) const
    {
        openrj_assert(index <= GetNumFields());

        return Field(&m_database->fields[index]);
    }

private:
    ORJDatabase const   *m_database;

// Not to be implemented
private:
    DatabaseBase(DatabaseBase const &);
    DatabaseBase const &operator =(DatabaseBase const &);
};

/* /////////////////////////////////////////////////////////////////////////////
 * Namespace
 */

} // namespace cpp
} // namespace openrj

/* ////////////////////////////////////////////////////////////////////////// */

#endif /* !OPENRJ_INCL_OPENRJ_CPP_HPP_DATABASEBASE */

/* ////////////////////////////////////////////////////////////////////////// */

Open-RJ Library documentation © Synesis Software Pty Ltd, 2004-2005