生物技术

开发平台：
C/C++

optional.hpp：源码内容
							/*
 * ===========================================================================
 * PRODUCTION $Log: optional.hpp,v $
 * PRODUCTION Revision 1000.0  2003/10/29 18:24:29  gouriano
 * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.1
 * PRODUCTION
 * ===========================================================================
 */
#ifndef APP_BLAST_CLIENT___OPTIONAL__HPP
#define APP_BLAST_CLIENT___OPTIONAL__HPP
/*  $Id: optional.hpp,v 1000.0 2003/10/29 18:24:29 gouriano Exp $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Kevin Bealer
 *
 */
/// Optional value idiom for blast_client.
///
/// Optional value concept (but not the actual code) is from the Boost
/// libraries.  Many times in programming, we have the concept of a
/// parameter which can either take a value or be omitted.  The
/// Optional<> template expresses this idea directly in code, wrapping
/// any value type.  Each optional object contains a boolean which is
/// set to true if there is a meaningful value present, or false
/// otherwise.  Attempts to read a false value will result in an
/// assertion.  The presence of the value can be checked.  Also
/// provided are functions which return an optional value from a CArgs
/// object based on name; CArgs (unlike the C toolkit counterpart)
/// preserves the information of whether an option was selected or
/// omitted.  This obviates the need for 'sentinel' values, special
/// "unreasonable" default values for each parameter, used to detect
/// the absence of the parameter.  Optional values semantics are
/// important to blast_client because of the design of the blast4
/// (netblast) network protocols.  This design states that the blast4
/// server would provide default values for (most) options if a value
/// is not specified by the client.  It is therefore important to
/// track which optional values are present.
#include <corelib/ncbiargs.hpp>
BEGIN_NCBI_SCOPE
/// Optional template - wrap any value type as an optional value.
///
/// Optional template - any value type may be wrapped as an optional
/// value.  If no value has been set, the object is considered invalid
/// and will fail an assertion if an attempt is made to read the
/// value.  This class also provides a few basic 'logic' operations on
/// optional values.
template <typename T>
class COptional
{
public:
    /// Value constructor - produces a valid (present) object.
    ///
    /// Copy the value from the value type, set object to valid.
    //  @param value The value to set.
    COptional(T value)
        : m_Value(value),
          m_Exists(true)
    {
    }
    
    /// Copy constructor - copies an existing object.
    ///
    /// Copy from another optional object.
    /// @param other COptional object (valid or not) to copy.
    COptional(const COptional<T> & other)
        : m_Exists(other.m_Exists)
    {
        if (m_Exists) {
            m_Value = other.m_Value;
        }
    }
    
    /// Blank constructor - construct an invalid object.
    COptional(void)
        : m_Exists(false)
    {
    }
    
    /// Returns true if the value is present/exists.
    bool Exists(void) const
    {
        return m_Exists;
    }
    
    /// Returns the value, or throws an assertion (if not valid).
    const T & GetValue(void) const
    {
        _ASSERT(m_Exists);
        return m_Value;
    }
        
    /// Boolean max() operator - return the max of existing values.
    ///
    /// If both arguments exist: return the max.  If neither argument
    /// exists, returns an invalid object.  Otherwise, one argument
    /// exists, so return that object.
    ///
    /// @param lhs One argument.
    /// @param rhs The other argument.
    static COptional<T> Max(const COptional<T> & lhs,
                            const COptional<T> & rhs);
    
    /// Boolean min() operator - return the min of existing values.
    ///
    /// If both arguments exist: return the min.  If neither argument
    /// exists, returns an invalid object.  Otherwise, one argument
    /// exists, so return that object.
    ///
    /// @param lhs One argument.
    /// @param rhs The other argument.
    static COptional<T> Min(const COptional<T> & lhs,
                            const COptional<T> & rhs);
    
    /// Unary inversion operator - return the inverse of the value.
    ///
    /// If the argument exists: return ! value().  Otherwise, return
    /// an invalid object.
    ///
    /// @param v The (possibly unset) value.
    
    static COptional<T> Invert(const COptional<T> & v);
    
    /// Assignment operator.
    ///
    /// Copy the state of another object.  If it exists, copy
    /// the value as well.
    
    const COptional<T> & operator= (const COptional<T> & other)
    {
        if (this != &other) {
            m_Exists = other.m_Exists;
                        
            if (m_Exists) {
                m_Value = other.m_Value;
            }
        }
                
        return *this;
    }
        
private:
    /// The actual value (if m_Exists is true).
    T    m_Value;
    
    /// If true, m_Value is meaningful.
    bool m_Exists;
};
using std::string;
/// Optional integer.
typedef COptional<int>            TOptInteger;
/// Optional bool.
typedef COptional<bool>           TOptBool;
/// Optional double prec float.
typedef COptional<double>         TOptDouble;
/// Optional string (pointer) value - be sure to delete the actual object.
typedef COptional<string> TOptString;
/// Optional input stream pointer - be sure to delete the actual object.
typedef COptional<CNcbiIstream *> TOptInfile;
/// Get existence and value from a boolean program parameter.
inline TOptBool CheckArgsBool(const CArgValue & val)
{
    if (val.HasValue()) {
        return TOptBool(val.AsBoolean());
    } else {
        return TOptBool();
    }
}
/// Get existence and value from a double program parameter.
inline TOptDouble CheckArgsDouble(const CArgValue & val)
{
    if (val.HasValue()) {
        return TOptDouble(val.AsDouble());
    } else {
        return TOptDouble();
    }
}
/// Get existence and value from an integer program parameter.
inline TOptInteger CheckArgsInteger(const CArgValue & val)
{
    if (val.HasValue()) {
        return TOptInteger(val.AsInteger());
    } else {
        return TOptInteger();
    }
}
/// Get existence and value from a string program parameter.
inline TOptString CheckArgsString(const CArgValue & val)
{
    if (val.HasValue()) {
        return TOptString(val.AsString());
    } else {
        return TOptString();
    }
}
template <class T>
inline COptional<T> COptional<T>::Max(const COptional<T> & lhs,
                                      const COptional<T> & rhs)
{
    COptional<T> result;
                
    if (lhs.m_Exists) {
        if (rhs.m_Exists) {
            result.m_Exists = true;
            result.m_Value = ((lhs.m_Value > rhs.m_Value)
                              ? lhs.m_Value
                              : rhs.m_Value);
        } else {
            result = lhs;
        }
    } else {
        if (rhs.m_Exists) {
            result = rhs;
        }
    }
                
    return result;
}
template <class T>
inline COptional<T> COptional<T>::Min(const COptional<T> & lhs,
                                      const COptional<T> & rhs)
{
    COptional<T> result;
                
    if (lhs.m_Exists) {
        if (rhs.m_Exists) {
            result.m_Exists = true;
            result.m_Value = ((lhs.m_Value < rhs.m_Value)
                              ? lhs.m_Value
                              : rhs.m_Value);
        } else {
            result = lhs;
        }
    } else {
        if (rhs.m_Exists) {
            result = rhs;
        }
    }
                
    return result;
}
template <class T>
inline COptional<T> COptional<T>::Invert(const COptional<T> & v)
{
    COptional<T> result;
    
    if (v.m_Exists) {
        result.m_Exists = true;
        result.m_Value = ! v.m_Value;
    }
    
    return result;
}
/*
 * ===========================================================================
 *
 * $Log: optional.hpp,v $
 * Revision 1000.0  2003/10/29 18:24:29  gouriano
 * PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.1
 *
 * Revision 1.1  2003/09/26 16:53:49  bealer
 * - Add blast_client project for netblast protocol, initial code commit.
 *
 * ===========================================================================
 */
END_NCBI_SCOPE
#endif // APP_BLAST_CLIENT___OPTIONAL__HPP

						