I originally purchased this book because it discusses many slieghts used in most card magic. I was also short on budget and couldn't afford the entire "Card College (Volumes 1-5)" by Roberto Giobbi at the time of purchase.
The routines contained within "The Card Magic of Nick Trost" are great for the historical card magician. There are lots of references to Dai Vernon and other past greats. Many of the routines are older and have been reworked by Trost to take on a contemporary flair at the time of publishing. However, due to the fact that most of the routines are fairly old they are somewhat lengthy and cumbersome in contrast with today's fast paced, hard hitting street magic as seen by David Blaine or T.H.E.M.
If you're looking for a nice collection of older, less common routines, this is a great book. I have adapted many of the routines for my own personal tastes. I find many of the routines contained herein work great with an older crowd, especially when you are in a sit-down, close-up environment where their attention is all yours.


text:
BSLS_IDENT_RCSID(balcl_typeinfo_cpp,"$Id$ $CSID$")

#include <balcl_optionvalue.h>

#include <bdlb_numericparseutil.h>
#include <bdlb_print.h>

#include <bdlt_iso8601util.h>

#include <bslma_default.h>

#include <bslmf_allocatorargt.h>
#include <bslmf_assert.h>

#include <bsls_assert.h>
#include <bsls_keyword.h> // 'BSLS_KEYWORD_OVERRIDE'

#include <bsl_cstddef.h>  // 'bsl::size_t'
#include <bsl_cstring.h>  // 'bsl::strlen'
#include <bsl_ostream.h>
#include <bsl_sstream.h>

namespace BloombergLP {
namespace balcl {

                   // ========================
                   // class TypeInfoConstraint
                   // ========================

class TypeInfoConstraint {
    // This class defines a protocol for objects implementing constraints on
    // option values.  Note that although this class not visible in the header
    // of this component, the class is publicly known by name to allow the
    // sharing of a constraint as an opaque object by use of the 'constraint'
    // accessor and 'setConstraint' manipulator methods.

  public:
    // CREATORS
    virtual ~TypeInfoConstraint();
        // Destroy this polymorphic constraint object.

    // ACCESSORS
    virtual bool parse(OptionValue        *element,
                       bsl::ostream&       stream,
                       const bsl::string&  input) const = 0;
        // Load into the specified 'element' the result of parsing the
        // specified 'input', parsed as a value of the 'balcl::OptionType' of
        // this constraint, and output to the specified 'stream' any error
        // message.  Return 'true' if this value, parsed without error,
        // satisfies this constraint, and 'false' if parsing fails or the value
        // does not satisfy the constraint.  If parsing fails, 'element' is
        // unchanged.  The behavior is undefined unless
        // 'type() == element->type()'.

    virtual OptionType::Enum type() const = 0;
        // Return the 'balcl::OptionType' of this constraint object.

    virtual bool validate(const OptionValue& element) const = 0;
    virtual bool validate(const OptionValue& element,
                          bsl::ostream&      stream)  const = 0;
        // Return 'true' if the specified 'element' satisfies this constraint,
        // and 'false' otherwise.  Optionally specify a 'stream' to which a
        // descriptive error message is written if this constraint is not
        // satisfied.  The behavior is undefined unless 'element'
        // 'type() == element->type()'.
};
                       // ------------------------
                       // class TypeInfoConstraint
                       // ------------------------

// CREATORS
TypeInfoConstraint::~TypeInfoConstraint()
{
}

namespace {
namespace u {

                            // ==============
                            // struct Ordinal
                            // ==============

struct Ordinal {
    // This 'struct' assists in printing numbers as ordinals (1st, 2nd, etc.).

    bsl::size_t d_rank;  // rank (starting at 0)

    // CREATORS
    explicit Ordinal(bsl::size_t n);
        // Create an ordinal for the specified position 'n' (starting at 0).
};

// FREE OPERATORS
bsl::ostream& operator<<(bsl::ostream& stream, Ordinal position);
    // Output the specified 'position' (starting at 0) to the specified
    // 'stream' as an ordinal, mapping 0 to "1st", 1 to "2nd", 3 to "3rd", 4 to
    // "4th", etc. following correct English usage.

                            // --------------
                            // struct Ordinal
                            // --------------

// CREATORS
Ordinal::Ordinal(bsl::size_t n)
: d_rank(n)
{
}

} // close namespace u

bsl::ostream& u::operator<<(bsl::ostream& stream, Ordinal position)
{
    // ranks start at 0, but are displayed as 1st, 2nd, etc.
    int n = static_cast<int>(position.d_rank + 1);
    switch (n % 10) {
      case 1: {
        if (n % 100 == 11) {
            stream << n << "th";
        } else {
            stream << n << "st";
        }
      } break;
      case 2: {
        if (n % 100 == 12) {
            stream << n << "th";
        } else {
            stream << n << "nd";
        }
      } break;
      case 3: {
        if (n % 100 == 13) {
            stream << n << "th";
        } else {
            stream << n << "rd";
        }
      } break;
      default: {
        stream << n << "th";
      } break;
    }
    return stream;
}

 namespace u {

                         // ===================
                         // function parseValue
                         // ===================

bool parseValue(void             *value,
                const char       *input,
                OptionType::Enum  type)
    // Load, to the specified 'value', the value obtained by parsing the
    // parsing the specified 'input' that is (assumed) in the format expected
    // for values of the specified 'type'.  Return 'true' if the parse
    // succeeds, and 'false' otherwise.  Note that on success 'value' can be
    // legitimately cast to a pointer of the type associated with 'type'.
{
    BSLS_ASSERT(value);
    BSLS_ASSERT(input);

    bool result;

    switch (type) {
      case OptionType::e_CHAR: {
        *static_cast<char *>(value) = *input;
        result = *input;  // succeeds if non-null character
      } break;
      case OptionType::e_INT: {
        result = !bdlb::NumericParseUtil::parseInt(static_cast<int *>(value),
                                                   input);
      } break;
      case OptionType::e_INT64: {
        result = !bdlb::NumericParseUtil::parseInt64(
                                      static_cast<bsls::Types::Int64 *>(value),
                                      input);
      } break;
      case OptionType::e_DOUBLE: {
        result = !bdlb::NumericParseUtil::parseDouble(
                                                  static_cast<double *>(value),
                                                  input);
      } break;
      case OptionType::e_STRING: {
        *static_cast<bsl::string *>(value) = input;
        result = true;
      } break;
      case OptionType::e_DATETIME: {
        result = !bdlt::Iso8601Util::parse(
                                         static_cast<bdlt::Datetime *>(value),
                                         input,
                                         static_cast<int>(bsl::strlen(input)));
      } break;
      case OptionType::e_DATE: {
        result = !bdlt::Iso8601Util::parse(
                                         static_cast<bdlt::Date *>(value),
                                         input,
                                         static_cast<int>(bsl::strlen(input)));
      } break;
      case OptionType::e_TIME: {
        result = !bdlt::Iso8601Util::parse(
                                         static_cast<bdlt::Time *>(value),
                                         input,
                                         static_cast<int>(bsl::strlen(input)));
      } break;
      default: {
        BSLS_ASSERT(0);
        result = false;
      } break;
    }
    return result;
}
                         // =========================
                         // function elemTypeToString
                         // =========================

const char *elemTypeToString(OptionType::Enum elemType)
    // Return the address of a string literal that describes the specified
    // 'elemType' value.
{
    const char *typeString;

    switch (elemType) {
      case OptionType::e_CHAR: {
        typeString = "A 'char'";
      } break;
      case OptionType::e_INT: {
        typeString = "An 'int'";
      } break;
      case OptionType::e_INT64: {
        typeString = "A 64-bit integer";
      } break;
      case OptionType::e_DOUBLE: {
        typeString = "A 'double'";
      } break;
      case OptionType::e_STRING: {
        typeString = "A string";
      } break;
      case OptionType::e_DATETIME: {
        typeString = "A 'bdlt::Datetime'";
      } break;
      case OptionType::e_DATE: {
        typeString = "A 'bdlt::Date'";
      } break;
      case OptionType::e_TIME: {
        typeString = "A 'bdlt::Time'";
      } break;
      default: {
        BSLS_ASSERT(0);
        typeString = "An unknown type";
      } break;
    }

    return typeString;
}

                         // ====================
                         // class BoolConstraint
                         // ====================

class BoolConstraint : public TypeInfoConstraint {
    // This concrete implementation of the 'Constraint' protocol provides a
    // 'bool' empty constraint that always returns 'true' after this option has
    // been parsed.  The individual contracts for each method are identical to
    // the protocol and not repeated here.

    // NOT IMPLEMENTED
    BoolConstraint(const BoolConstraint&);
    BoolConstraint& operator=(const BoolConstraint&);

  public:
    // CREATORS
    explicit BoolConstraint(bslma::Allocator *basicAllocator = 0);
        // Create a 'bool' constraint object.  Optionally specify a
        // 'basicAllocator', which is ignored.

    ~BoolConstraint() BSLS_KEYWORD_OVERRIDE;
        // Destroy this object.

    // ACCESSORS
    OptionType::Enum type() const BSLS_KEYWORD_OVERRIDE;
        // Return 'OptionType::e_BOOL'.

    bool parse(OptionValue        *element,
               bsl::ostream&       stream,
               const bsl::string&  input) const BSLS_KEYWORD_OVERRIDE;
        // Store the value 'true' into the specified 'element'.  If there are
        // any issues with the specified 'input' a warning message may be
        // written to the specified 'stream'.  The behavior is undefined unless
        // 'OptionType::e_BOOL == element->type()'.

    bool validate(const OptionValue& element) const BSLS_KEYWORD_OVERRIDE;
    bool validate(const OptionValue& element,
                  bsl::ostream&      stream)  const BSLS_KEYWORD_OVERRIDE;
        // Return 'true', and leave the optionally specified 'stream'
        // unchanged.  The behavior is undefined unless the specified 'element'
        // satisfies 'OptionType::e_BOOL == element->type()'.
};

                         // --------------------
                         // class BoolConstraint
                         // --------------------

// CREATORS
BoolConstraint::BoolConstraint(bslma::Allocator *)
{
}

BoolConstraint::~BoolConstraint()
{
}

// BDE_VERIFY pragma: -FABC01  // not in alphabetic order

// ACCESSORS
OptionType::Enum BoolConstraint::type() const
{
    return OptionType::e_BOOL;
}

bool BoolConstraint::parse(OptionValue        *element,
                           bsl::ostream&       stream,
                           const bsl::string&  input) const
{
    BSLS_ASSERT(element);
    BSLS_ASSERT(element->hasNonVoidType());
    BSLS_ASSERT(OptionType::e_BOOL == element->type());

    element->set(true);

    if (!input.empty()) {
        // WARNING: A value is provided for flag, using equality sign.  Values
        // are not acceptable for flags.  Such input will be considered as
        // erroneous in future BDE releases, so parsing will fail.

        stream << "Warning: A value has been provided for the flag."
               << '\n' << bsl::flush;

        // return false;                                              // RETURN
    }

    return true;
}

bool BoolConstraint::validate(const OptionValue&) const
{
    return true;
}

bool BoolConstraint::validate(const OptionValue&, bsl::ostream&)
                                                                          const
{
    return true;
}

// BDE_VERIFY pragma: +FABC01  // not in alphabetic order

                   // ===========================
                   // class ScalarConstraint<...>
                   // ===========================

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
class ScalarConstraint : public TypeInfoConstraint {
    // This concrete implementation of the 'Constraint' protocol provides a
    // constraint of the parameterized 'CONSTRAINT_TYPE', which enables the
    // parsing and validation of values of parameterized 'TYPE'.

    // DATA
    CONSTRAINT_TYPE d_constraint;

    // NOT IMPLEMENTED
    ScalarConstraint(const ScalarConstraint&);
    ScalarConstraint& operator=(const ScalarConstraint&);

  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(ScalarConstraint,
                                   bslma::UsesBslmaAllocator);

    // CREATORS
    explicit ScalarConstraint(const CONSTRAINT_TYPE&  constraint,
                              bslma::Allocator       *basicAllocator = 0);
        // Create a constraint object storing the specified 'constraint'
        // functor.  Optionally specify a 'basicAllocator' used to supply
        // memory.  If 'basicAllocator' is 0, the currently-installed default
        // allocator is used.

    ~ScalarConstraint() BSLS_KEYWORD_OVERRIDE;
        // Destroy this polymorphic constraint object.

    // ACCESSORS
    OptionType::Enum type() const BSLS_KEYWORD_OVERRIDE;
        // Return the 'balcl::OptionType' element type of this constraint.

    bool parse(OptionValue        *element,
               bsl::ostream&       stream,
               const bsl::string&  input) const BSLS_KEYWORD_OVERRIDE;
        // Load into the instance of parameterized 'TYPE' stored in the
        // specified 'element' the result of parsing the specified 'input',
        // interpreted as an instance of 'TYPE'.  Return 'true' if parsing
        // succeeds and the parsed value satisfies the constraint.  Return
        // 'false' otherwise, and write to the specified 'stream' a descriptive
        // error message.  The behavior is undefined unless
        // 'type() == element->type()'.

    bool validate(const OptionValue& element) const BSLS_KEYWORD_OVERRIDE;
    bool validate(const OptionValue& element,
                  bsl::ostream&      stream)  const BSLS_KEYWORD_OVERRIDE;
        // Return 'true' if the specified 'element' satisfies this constraint,
        // and 'false' otherwise.  Optionally specify a 'stream' to which a
        // descriptive error message is written if this constraint is not
        // satisfied.  The behavior is undefined unless
        // 'type() == element->type()'.
};

                   // ---------------------------
                   // class ScalarConstraint<...>
                   // ---------------------------

// CREATORS
template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
ScalarConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::ScalarConstraint(
                                        const CONSTRAINT_TYPE&  constraint,
                                        bslma::Allocator       *basicAllocator)
: d_constraint(bsl::allocator_arg, basicAllocator, constraint)
{
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
ScalarConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::~ScalarConstraint()
{
}

// BDE_VERIFY pragma: -FABC01  // not in alphabetic order

// ACCESSORS
template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
OptionType::Enum
ScalarConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::type() const
{
    BSLMF_ASSERT(OptionType::e_VOID <= static_cast<OptionType::Enum>(
                                                                   ELEM_TYPE));

    BSLMF_ASSERT(static_cast<OptionType::Enum>(ELEM_TYPE) <=
                                                     OptionType::e_TIME_ARRAY);

    return static_cast<OptionType::Enum>(ELEM_TYPE);
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
bool
ScalarConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::parse(
                                               OptionValue        *element,
                                               bsl::ostream&       stream,
                                               const bsl::string&  input) const
{
    BSLS_ASSERT(element);
    BSLS_ASSERT(element->hasNonVoidType());

    const OptionType::Enum elemType = element->type();

    BSLS_ASSERT(ELEM_TYPE == elemType);

    TYPE value = TYPE();
    if (!parseValue(&value, input.c_str(), elemType)) {
        stream << elemTypeToString(elemType)
               << " value was expected, instead of \""
               << input << "\"" << '\n' << bsl::flush;
        return false;                                                 // RETURN
    }

    element->set<TYPE>(value);
    return validate(*element, stream);
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
bool
ScalarConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::validate(
                                              const OptionValue& element) const
{
    bsl::ostringstream oss;
    return validate(element, oss);
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
bool
ScalarConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::validate(
                                               const OptionValue& element,
                                               bsl::ostream&      stream) const
{
    BSLS_ASSERT(element.hasNonVoidType());
    BSLS_ASSERT(ELEM_TYPE == element.type());

    return d_constraint
         ? d_constraint(&element.the<TYPE>(), stream)
         : true;
}

// BDE_VERIFY pragma: +FABC01  // not in alphabetic order

// SPECIALIZATIONS
template
class ScalarConstraint<char,
                       Constraint::CharConstraint,
                       OptionType::e_CHAR>;
template
class ScalarConstraint<int,
                       Constraint::IntConstraint,
                       OptionType::e_INT>;
template
class ScalarConstraint<bsls::Types::Int64,
                       Constraint::Int64Constraint,
                       OptionType::e_INT64>;
template
class ScalarConstraint<double,
                       Constraint::DoubleConstraint,
                       OptionType::e_DOUBLE>;
template
class ScalarConstraint<bsl::string,
                       Constraint::StringConstraint,
                       OptionType::e_STRING>;
template
class ScalarConstraint<bdlt::Datetime,
                       Constraint::DatetimeConstraint,
                       OptionType::e_DATETIME>;
template
class ScalarConstraint<bdlt::Date,
                       Constraint::DateConstraint,
                       OptionType::e_DATE>;
template
class ScalarConstraint<bdlt::Time,
                       Constraint::TimeConstraint,
                       OptionType::e_TIME>;
    // Explicit specializations (to force instantiation of all variants).

                 // ==============================
                 // class template ArrayConstraint
                 // ==============================

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
class ArrayConstraint : public TypeInfoConstraint {
    // This concrete implementation of the 'Constraint' protocol provides a
    // constraint of the parameterized 'CONSTRAINT_TYPE', which enables the
    // parsing and validation of values of parameterized 'bsl::vector<TYPE>'
    // type.

    // DATA
    CONSTRAINT_TYPE d_constraint;

    // NOT IMPLEMENTED
    ArrayConstraint(const ArrayConstraint&);
    ArrayConstraint& operator=(const ArrayConstraint&);

  public:
    // TRAITS
    BSLMF_NESTED_TRAIT_DECLARATION(ArrayConstraint,
                                   bslma::UsesBslmaAllocator);

    // CREATORS
    explicit ArrayConstraint(const CONSTRAINT_TYPE&  constraint,
                             bslma::Allocator       *basicAllocator);
        // Create a constraint object storing the specified 'constraint'
        // functor.  Optionally specify a 'basicAllocator' used to supply
        // memory.  If 'basicAllocator' is 0, the currently-installed default
        // allocator is used.

    ~ArrayConstraint() BSLS_KEYWORD_OVERRIDE;
        // Destroy this polymorphic constraint object.

    // ACCESSORS
    OptionType::Enum type() const BSLS_KEYWORD_OVERRIDE;
        // Return the 'balcl::OptionType' element type of this constraint.

    bool parse(OptionValue        *element,
               bsl::ostream&       stream,
               const bsl::string&  input) const BSLS_KEYWORD_OVERRIDE;
        // Append to the instance of 'bsl::vector<TYPE>' stored in the
        // specified 'element' the result of parsing the specified 'input',
        // interpreted as an instance of parameterized 'TYPE'.  Return 'true'
        // if parsing succeeds and the parsed value satisfies the constraint.
        // Return 'false' otherwise, and write to the specified 'stream' a
        // descriptive error message.  The behavior is undefined unless
        // 'OptionType::toArrayType(type()) == element->type()'.

    bool validate(const OptionValue& element) const BSLS_KEYWORD_OVERRIDE;
    bool validate(const OptionValue& element,
                  bsl::ostream&      stream)  const BSLS_KEYWORD_OVERRIDE;
        // Return 'true' if the specified 'element' satisfies this constraint,
        // and 'false' otherwise.  Optionally specify a 'stream' to which a
        // descriptive error message is written if this constraint is not
        // satisfied.  The behavior is undefined unless 'element'
        // 'type() == element->type()'.
};

                 // ------------------------------
                 // class template ArrayConstraint
                 // ------------------------------

// CREATORS
template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
ArrayConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::ArrayConstraint(
                                        const CONSTRAINT_TYPE&  constraint,
                                        bslma::Allocator       *basicAllocator)
: d_constraint(bsl::allocator_arg, basicAllocator, constraint)
{
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
ArrayConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::~ArrayConstraint()
{
}

// BDE_VERIFY pragma: -FABC01  // not in alphabetic order

// ACCESSORS
template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
OptionType::Enum
ArrayConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::type() const
{
    BSLMF_ASSERT(OptionType::e_VOID <=
                          static_cast<OptionType::Enum>(ELEM_TYPE));

    BSLMF_ASSERT(static_cast<OptionType::Enum>(ELEM_TYPE) <=
                                          OptionType::e_TIME_ARRAY);

    return static_cast<OptionType::Enum>(ELEM_TYPE);
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
bool
ArrayConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::parse(
                                               OptionValue        *element,
                                               bsl::ostream&       stream,
                                               const bsl::string&  input) const
{
    BSLS_ASSERT(element);
    BSLS_ASSERT(element->hasNonVoidType());

    const OptionType::Enum elemType = element->type();

    BSLS_ASSERT(ELEM_TYPE == elemType);

    OptionType::Enum scalarType = OptionType::fromArrayType(elemType);

    TYPE value;
    if (!parseValue(&value, input.c_str(), scalarType)) {
        stream << elemTypeToString(scalarType)
               << " value was expected, instead of \""
               << input << "\"" << '\n' << bsl::flush;
        return false;                                                 // RETURN
    }

// BDE_VERIFY pragma: -ADC01  // Passing address of char 'value' where a
                              // null-terminated string may be expected
    if (d_constraint && !d_constraint(&value, stream)) {
        return false;                                                 // RETURN
    }
// BDE_VERIFY pragma: +ADC01

    if (element->isNull()) {
        bsl::vector<TYPE> tmp;
        element->set(tmp);
    }

    element->the<bsl::vector<TYPE> >().push_back(value);

    return true;
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
bool
ArrayConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::validate(
                                              const OptionValue& element) const
{
    bsl::ostringstream oss;
    return validate(element, oss);
}

template <class TYPE, class CONSTRAINT_TYPE, int ELEM_TYPE>
bool
ArrayConstraint<TYPE, CONSTRAINT_TYPE, ELEM_TYPE>::validate(
                                               const OptionValue& element,
                                               bsl::ostream&      stream) const
{
    BSLS_ASSERT(element.hasNonVoidType());
    BSLS_ASSERT(ELEM_TYPE == element.type());

    typedef typename bsl::vector<TYPE>::size_type size_type;
    const bsl::vector<TYPE>& vec = element.the<bsl::vector<TYPE> >();

    if (d_constraint) {
        for (size_type i = 0; i < vec.size(); ++i) {
            if (!d_constraint(&vec[i], stream)) {
                stream << "The above error occurred while parsing the "
                       << u::Ordinal(i)
                       << " element of the vector."
                       << '\n' << bsl::flush;
                return false;                                         // RETURN
            }
        }
    }
    return true;
}

// BDE_VERIFY pragma: -FABC01  // not in alphabetic order

// SPECIALIZATIONS
template
class ArrayConstraint<char,
                      Constraint::CharConstraint,
                      OptionType::e_CHAR_ARRAY>;
template
class ArrayConstraint<int,
                      Constraint::IntConstraint,
                      OptionType::e_INT_ARRAY>;
template
class ArrayConstraint<bsls::Types::Int64,
                      Constraint::Int64Constraint,
                      OptionType::e_INT64_ARRAY>;
template
class ArrayConstraint<double,
                      Constraint::DoubleConstraint,
                      OptionType::e_DOUBLE_ARRAY>;
template
class ArrayConstraint<bsl::string,
                      Constraint::StringConstraint,
                      OptionType::e_STRING_ARRAY>;
template
class ArrayConstraint<bdlt::Datetime,
                      Constraint::DatetimeConstraint,
                      OptionType::e_DATETIME_ARRAY>;
template
class ArrayConstraint<bdlt::Date,
                      Constraint::DateConstraint,
                      OptionType::e_DATE_ARRAY>;
template
class ArrayConstraint<bdlt::Time,
                      Constraint::TimeConstraint,
                      OptionType::e_TIME_ARRAY>;
    // Explicit specializations (to force instantiation of all variants).

                      // ===============================
                      // typedef template TYPEConstraint
                      // ===============================

// Note: for 'BoolConstraint', see non-'typedef' implementations.

typedef ScalarConstraint<char,
                         Constraint::CharConstraint,
                         OptionType::e_CHAR> CharConstraint;
    // The type 'CharConstraint' is an alias for a scalar constraint on type
    // 'char' using the 'Constraint::CharConstraint' functor.

typedef ScalarConstraint<int,
                         Constraint::IntConstraint,
                         OptionType::e_INT> IntConstraint;
    // The type 'IntConstraint' is an alias for a scalar constraint on type
    // 'int' using the 'Constraint::IntConstraint' functor.

typedef ScalarConstraint<bsls::Types::Int64,
                         Constraint::Int64Constraint,
                         OptionType::e_INT64>  Int64Constraint;
    // The type 'Int64Constraint' is an alias for a scalar constraint on type
    // 'bsls::Types::Int64' using the 'Constraint::Int64Constraint' functor.

typedef ScalarConstraint<double,
                         Constraint::DoubleConstraint,
                         OptionType::e_DOUBLE> DoubleConstraint;
    // The type 'DoubleConstraint' is an alias for a scalar constraint on type
    // 'double' using the 'Constraint::DoubleConstraint' functor.

typedef ScalarConstraint<bsl::string,
                         Constraint::StringConstraint,
                         OptionType::e_STRING> StringConstraint;
    // The type 'StringConstraint' is an alias for a scalar constraint on type
    // 'bsl::string' using the 'Constraint::StringConstraint' functor.

typedef ScalarConstraint<bdlt::Datetime,
                         Constraint::DatetimeConstraint,
                         OptionType::e_DATETIME> DatetimeConstraint;
    // The type 'DatetimeConstraint' is an alias for a scalar constraint of
    // type 'bdlt::Datetime' using the 'Constraint::DatetimeConstraint'
    // functor.

typedef ScalarConstraint<bdlt::Date,
                         Constraint::DateConstraint,
                         OptionType::e_DATE> DateConstraint;
    // The type 'DateConstraint' is an alias for a scalar constraint on type
    // 'bdlt::Date' using the 'Constraint::DateConstraint' functor.

typedef ScalarConstraint<bdlt::Time,
                         Constraint::TimeConstraint,
                         OptionType::e_TIME> TimeConstraint;
    // The type 'TimeConstraint' is an alias for a scalar constraint on type
    // 'bdlt::Time' using the 'Constraint::TimeConstraint' functor.

                    // ================================
                    // typedef template ArrayConstraint
                    // ================================

typedef ArrayConstraint<char,
                        Constraint::CharConstraint,
                        OptionType::e_CHAR_ARRAY> CharArrayConstraint;
    // The type 'CharArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<char>' using the 'Constraint::CharConstraint' functor.

typedef ArrayConstraint<int,
                        Constraint::IntConstraint,
                        OptionType::e_INT_ARRAY> IntArrayConstraint;
    // The type 'IntArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<int>' using the 'Constraint::IntConstraint' functor.

typedef ArrayConstraint<bsls::Types::Int64,
                       Constraint::Int64Constraint,
                       OptionType::e_INT64_ARRAY> Int64ArrayConstraint;
    // The type 'Int64ArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<bsls::Types::Int64>' using the
    // 'Constraint::Int64Constraint' functor.

typedef ArrayConstraint<double,
                        Constraint::DoubleConstraint,
                        OptionType::e_DOUBLE_ARRAY> DoubleArrayConstraint;
    // The type 'DoubleArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<double>' using the 'Constraint::DoubleConstraint' functor.

typedef ArrayConstraint<bsl::string,
                        Constraint::StringConstraint,
                        OptionType::e_STRING_ARRAY> StringArrayConstraint;
    // The type 'StringArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<bsl::string>' using the 'Constraint::StringConstraint'
    // functor.

typedef ArrayConstraint<bdlt::Datetime,
                        Constraint::DatetimeConstraint,
                        OptionType::e_DATETIME_ARRAY> DatetimeArrayConstraint;
    // The type 'DatetimeArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<bdlt::Datetime>' using the 'Constraint::DatetimeConstraint'
    // functor.

typedef ArrayConstraint<bdlt::Date,
                        Constraint::DateConstraint,
                        OptionType::e_DATE_ARRAY> DateArrayConstraint;
    // The type 'DateArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<bdlt::Date>' using the 'Constraint::DateConstraint'
    // functor.

typedef ArrayConstraint<bdlt::Time,
                        Constraint::TimeConstraint,
                        OptionType::e_TIME_ARRAY> TimeArrayConstraint;
    // The type 'TimeArrayConstraint' is an alias for a constraint on type
    // 'bsl::vector<bdlt::Time>' using the 'Constraint::TimeConstraint'
    // functor.

                        // ======================
                        // struct OptionValueUtil
                        // ======================

struct OptionValueUtil {
    // This 'struct' provides a namespace for utility functions on
    // 'OptionValue' objects.

    // CLASS METHODS
    static void setValue(OptionValue *dst, const void  *src);
        // Assign to the specified '*dst' value found at the specified 'src'.
        // The behavior is undefined unless 'OptionType::e_VOID != src.type()'
        // and 'src' can be cast to a pointer to
        // 'OptionType::EnumToType<dst.type()>::type'.
};

                        // ---------------------
                        // class OptionValueUtil
                        // ---------------------

// CLASS METHODS
void OptionValueUtil::setValue(OptionValue *dst, const void  *src)
{
    BSLS_ASSERT(dst);
    BSLS_ASSERT(src);

    OptionType::Enum type = dst->type();

    typedef OptionType  Ot;

    switch (type) {
      case Ot::e_VOID: {
        BSLS_ASSERT(!"Not reachable.");
      } break;
      case Ot::e_BOOL: {
        dst->set(*(static_cast<const Ot::Bool          *>(src)));
      } break;
      case Ot::e_CHAR: {
        dst->set(*(static_cast<const Ot::Char          *>(src)));
      } break;
      case Ot::e_INT: {
        dst->set(*(static_cast<const Ot::Int           *>(src)));
      } break;
      case Ot::e_INT64: {
        dst->set(*(static_cast<const Ot::Int64         *>(src)));
      } break;
      case Ot::e_DOUBLE: {
        dst->set(*(static_cast<const Ot::Double        *>(src)));
      } break;
      case Ot::e_STRING: {
        dst->set(*(static_cast<const Ot::String        *>(src)));
      } break;
      case Ot::e_DATETIME: {
        dst->set(*(static_cast<const Ot::Datetime      *>(src)));
      } break;
      case Ot::e_DATE: {
        dst->set(*(static_cast<const Ot::Date          *>(src)));
      } break;
      case Ot::e_TIME: {
        dst->set(*(static_cast<const Ot::Time          *>(src)));
      } break;
      case Ot::e_CHAR_ARRAY: {
        dst->set(*(static_cast<const Ot::CharArray     *>(src)));
      } break;
      case Ot::e_INT_ARRAY: {
        dst->set(*(static_cast<const Ot::IntArray      *>(src)));
      } break;
      case Ot::e_INT64_ARRAY: {
        dst->set(*(static_cast<const Ot::Int64Array    *>(src)));
      } break;
      case Ot::e_DOUBLE_ARRAY: {
        dst->set(*(static_cast<const Ot::DoubleArray   *>(src)));
      } break;
      case Ot::e_STRING_ARRAY: {
        dst->set(*(static_cast<const Ot::StringArray   *>(src)));
      } break;
      case Ot::e_DATETIME_ARRAY: {
        dst->set(*(static_cast<const Ot::DatetimeArray *>(src)));
      } break;
      case Ot::e_DATE_ARRAY: {
        dst->set(*(static_cast<const Ot::DateArray     *>(src)));
      } break;
      case Ot::e_TIME_ARRAY: {
        dst->set(*(static_cast<const Ot::TimeArray     *>(src)));
      } break;
    }
}

}  // close namespace u
}  // close unnamed namespace

                       // --------------
                       // class TypeInfo
                       // --------------

// CREATORS
TypeInfo::TypeInfo()
: d_elemType(OptionType::e_STRING)
, d_linkedVariable_p(0)
, d_allocator_p(bslma::Default::allocator())
{
    resetConstraint();
}

TypeInfo::TypeInfo(bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_STRING)
, d_linkedVariable_p(0)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bool            *variable,
                  bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_BOOL)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(char             *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_CHAR)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(char                              *variable,
                   const Constraint::CharConstraint&  constraint,
                   bslma::Allocator                  *basicAllocator)
: d_elemType(OptionType::e_CHAR)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(int              *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_INT)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(int                              *variable,
                   const Constraint::IntConstraint&  constraint,
                   bslma::Allocator                 *basicAllocator)
: d_elemType(OptionType::e_INT)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsls::Types::Int64 *variable,
                   bslma::Allocator   *basicAllocator)
: d_elemType(OptionType::e_INT64)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsls::Types::Int64                 *variable,
                   const Constraint::Int64Constraint&  constraint,
                   bslma::Allocator                   *basicAllocator)
: d_elemType(OptionType::e_INT64)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(double           *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_DOUBLE)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(double                              *variable,
                   const Constraint::DoubleConstraint&  constraint,
                   bslma::Allocator                    *basicAllocator)
: d_elemType(OptionType::e_DOUBLE)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::string      *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_STRING)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::string                         *variable,
                   const Constraint::StringConstraint&  constraint,
                   bslma::Allocator                    *basicAllocator)
: d_elemType(OptionType::e_STRING)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bdlt::Datetime   *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_DATETIME)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bdlt::Datetime                        *variable,
                   const Constraint::DatetimeConstraint&  constraint,
                   bslma::Allocator                      *basicAllocator)
: d_elemType(OptionType::e_DATETIME)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bdlt::Date       *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_DATE)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bdlt::Date                        *variable,
                   const Constraint::DateConstraint&  constraint,
                   bslma::Allocator                  *basicAllocator)
: d_elemType(OptionType::e_DATE)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bdlt::Time       *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_TIME)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bdlt::Time                        *variable,
                   const Constraint::TimeConstraint&  constraint,
                   bslma::Allocator                  *basicAllocator)
: d_elemType(OptionType::e_TIME)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<char> *variable,
                   bslma::Allocator  *basicAllocator)
: d_elemType(OptionType::e_CHAR_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<char>                 *variable,
                   const Constraint::CharConstraint&  constraint,
                   bslma::Allocator                  *basicAllocator)
: d_elemType(OptionType::e_CHAR_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<int> *variable,
                   bslma::Allocator *basicAllocator)
: d_elemType(OptionType::e_INT_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<int>                 *variable,
                   const Constraint::IntConstraint&  constraint,
                   bslma::Allocator                 *basicAllocator)
: d_elemType(OptionType::e_INT_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<bsls::Types::Int64> *variable,
                   bslma::Allocator                *basicAllocator)
: d_elemType(OptionType::e_INT64_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<bsls::Types::Int64>    *variable,
                   const Constraint::Int64Constraint&  constraint,
                   bslma::Allocator                   *basicAllocator)
: d_elemType(OptionType::e_INT64_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<double> *variable,
                   bslma::Allocator    *basicAllocator)
: d_elemType(OptionType::e_DOUBLE_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<double>                 *variable,
                   const Constraint::DoubleConstraint&  constraint,
                   bslma::Allocator                    *basicAllocator)
: d_elemType(OptionType::e_DOUBLE_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<bsl::string> *variable,
                   bslma::Allocator         *basicAllocator)
: d_elemType(OptionType::e_STRING_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<bsl::string>            *variable,
                   const Constraint::StringConstraint&  constraint,
                   bslma::Allocator                    *basicAllocator)
: d_elemType(OptionType::e_STRING_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<bdlt::Datetime> *variable,
                   bslma::Allocator            *basicAllocator)
: d_elemType(OptionType::e_DATETIME_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<bdlt::Datetime>           *variable,
                   const Constraint::DatetimeConstraint&  constraint,
                   bslma::Allocator                      *basicAllocator)
: d_elemType(OptionType::e_DATETIME_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<bdlt::Date> *variable,
                   bslma::Allocator        *basicAllocator)
: d_elemType(OptionType::e_DATE_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<bdlt::Date>           *variable,
                   const Constraint::DateConstraint&  constraint,
                   bslma::Allocator                  *basicAllocator)
: d_elemType(OptionType::e_DATE_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(bsl::vector<bdlt::Time> *variable,
                   bslma::Allocator        *basicAllocator)
: d_elemType(OptionType::e_TIME_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    resetConstraint();
}

TypeInfo::TypeInfo(bsl::vector<bdlt::Time>           *variable,
                   const Constraint::TimeConstraint&  constraint,
                   bslma::Allocator                  *basicAllocator)
: d_elemType(OptionType::e_TIME_ARRAY)
, d_linkedVariable_p(variable)
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
    setConstraint(constraint);
}

TypeInfo::TypeInfo(const TypeInfo&   original,
                   bslma::Allocator *basicAllocator)
: d_elemType(original.d_elemType)
, d_linkedVariable_p(original.d_linkedVariable_p)
, d_constraint_p(original.d_constraint_p)  // share constraint
, d_allocator_p(bslma::Default::allocator(basicAllocator))
{
}

TypeInfo::~TypeInfo()
{
}

// MANIPULATORS
TypeInfo& TypeInfo::operator=(const TypeInfo& rhs)
{
    if (this != &rhs) {
        d_elemType         = rhs.d_elemType;
        d_linkedVariable_p = rhs.d_linkedVariable_p;
        d_constraint_p     = rhs.d_constraint_p;
    }

    return *this;
}

void TypeInfo::resetConstraint()
{
    static bslma::Allocator *ga = bslma::Default::globalAllocator(0);

    // STATIC DATA
    static u::BoolConstraint          defaultBoolConstraint(               ga);

    static u::CharConstraint          defaultCharConstraint(
                                         Constraint::CharConstraint(),     ga);

    static u::IntConstraint           defaultIntConstraint(
                                         Constraint::IntConstraint(),      ga);

    static u::Int64Constraint         defaultInt64Constraint(
                                         Constraint::Int64Constraint(),    ga);

    static u::DoubleConstraint        defaultDoubleConstraint(
                                         Constraint::DoubleConstraint(),   ga);

    static u::StringConstraint        defaultStringConstraint(
                                         Constraint::StringConstraint(),   ga);

    static u::DatetimeConstraint      defaultDatetimeConstraint(
                                         Constraint::DatetimeConstraint(), ga);

    static u::DateConstraint          defaultDateConstraint(
                                         Constraint::DateConstraint(),     ga);

    static u::TimeConstraint          defaultTimeConstraint(
                                         Constraint::TimeConstraint(),     ga);

    static u::CharArrayConstraint     defaultCharArrayConstraint(
                                         Constraint::CharConstraint(),     ga);

    static u::IntArrayConstraint      defaultIntArrayConstraint(
                                         Constraint::IntConstraint(),      ga);

    static u::Int64ArrayConstraint    defaultInt64ArrayConstraint(
                                         Constraint::Int64Constraint(),    ga);

    static u::DoubleArrayConstraint   defaultDoubleArrayConstraint(
                                         Constraint::DoubleConstraint(),   ga);

    static u::StringArrayConstraint   defaultStringArrayConstraint(
                                         Constraint::StringConstraint(),   ga);

    static u::DatetimeArrayConstraint defaultDatetimeArrayConstraint(
                                         Constraint::DatetimeConstraint(), ga);

    static u::DateArrayConstraint     defaultDateArrayConstraint(
                                         Constraint::DateConstraint(),     ga);

    static u::TimeArrayConstraint     defaultTimeArrayConstraint(
                                         Constraint::TimeConstraint(),     ga);
        // These static variables, default-initialized, are shared among all
        // type information objects that do not have constraints.  Note that
        // these objects are initialized with the global allocator and should
        // never be deleted.

    switch (d_elemType) {
      case OptionType::e_BOOL: {
        d_constraint_p.reset(&defaultBoolConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_CHAR: {
        d_constraint_p.reset(&defaultCharConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_INT: {
        d_constraint_p.reset(&defaultIntConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_INT64: {
        d_constraint_p.reset(&defaultInt64Constraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_DOUBLE: {
        d_constraint_p.reset(&defaultDoubleConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_STRING: {
        d_constraint_p.reset(&defaultStringConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_DATETIME: {
        d_constraint_p.reset(&defaultDatetimeConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_DATE: {
        d_constraint_p.reset(&defaultDateConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_TIME: {
        d_constraint_p.reset(&defaultTimeConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_CHAR_ARRAY: {
        d_constraint_p.reset(&defaultCharArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_INT_ARRAY: {
        d_constraint_p.reset(&defaultIntArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_INT64_ARRAY: {
        d_constraint_p.reset(&defaultInt64ArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_DOUBLE_ARRAY: {
        d_constraint_p.reset(&defaultDoubleArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_STRING_ARRAY: {
        d_constraint_p.reset(&defaultStringArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_DATETIME_ARRAY: {
        d_constraint_p.reset(&defaultDatetimeArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_DATE_ARRAY: {
        d_constraint_p.reset(&defaultDateArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      case OptionType::e_TIME_ARRAY: {
        d_constraint_p.reset(&defaultTimeArrayConstraint,
                             bslstl::SharedPtrNilDeleter());
      } break;
      default: {
        BSLS_ASSERT(0);
      } break;
    }
}

void TypeInfo::resetLinkedVariableAndConstraint()
{
    d_linkedVariable_p = 0;
    resetConstraint();
}

void TypeInfo::setConstraint(const Constraint::CharConstraint& constraint)
{
    if (OptionType::e_CHAR == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::CharConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_CHAR_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::CharArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::IntConstraint& constraint)
{
    if (OptionType::e_INT == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::IntConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_INT_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::IntArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::Int64Constraint& constraint)
{
    if (OptionType::e_INT64 == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::Int64Constraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_INT64_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::Int64ArrayConstraint(
                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::DoubleConstraint& constraint)
{
    if (OptionType::e_DOUBLE == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::DoubleConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_DOUBLE_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::DoubleArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::StringConstraint& constraint)
{
    if (OptionType::e_STRING == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::StringConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_STRING_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::StringArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::DatetimeConstraint& constraint)
{
    if (OptionType::e_DATETIME == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::DatetimeConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_DATETIME_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::DatetimeArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::DateConstraint& constraint)
{
    if (OptionType::e_DATE == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::DateConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_DATE_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::DateArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(const Constraint::TimeConstraint& constraint)
{
    if (OptionType::e_TIME == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::TimeConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else if (OptionType::e_TIME_ARRAY == d_elemType) {
        d_constraint_p.reset(new (*d_allocator_p) u::TimeArrayConstraint(
                                                                constraint,
                                                                d_allocator_p),
                             d_allocator_p);
    } else {
        BSLS_ASSERT(0);
    }
}

void TypeInfo::setConstraint(
                         const bsl::shared_ptr<TypeInfoConstraint>& constraint)
{
    d_constraint_p = constraint;
}

void TypeInfo::setLinkedVariable(bool *variable)
{
    d_elemType         = OptionType::e_BOOL;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(char *variable)
{
    d_elemType         = OptionType::e_CHAR;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(int *variable)
{
    d_elemType         = OptionType::e_INT;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsls::Types::Int64 *variable)
{
    d_elemType         = OptionType::e_INT64;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(double *variable)
{
    d_elemType         = OptionType::e_DOUBLE;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::string *variable)
{
    d_elemType         = OptionType::e_STRING;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bdlt::Datetime *variable)
{
    d_elemType         = OptionType::e_DATETIME;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bdlt::Date *variable)
{
    d_elemType         = OptionType::e_DATE;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bdlt::Time *variable)
{
    d_elemType         = OptionType::e_TIME;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<char> *variable)
{
    d_elemType         = OptionType::e_CHAR_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<int> *variable)
{
    d_elemType         = OptionType::e_INT_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<bsls::Types::Int64> *variable)
{
    d_elemType         = OptionType::e_INT64_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<double> *variable)
{
    d_elemType         = OptionType::e_DOUBLE_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<bsl::string> *variable)
{
    d_elemType         = OptionType::e_STRING_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<bdlt::Datetime> *variable)
{
    d_elemType         = OptionType::e_DATETIME_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<bdlt::Date> *variable)
{
    d_elemType         = OptionType::e_DATE_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

void TypeInfo::setLinkedVariable(bsl::vector<bdlt::Time> *variable)
{
    d_elemType         = OptionType::e_TIME_ARRAY;
    d_linkedVariable_p = variable;
    resetConstraint();
}

// ACCESSORS
bsl::shared_ptr<TypeInfoConstraint> TypeInfo::constraint() const
{
    return d_constraint_p;
}

void *TypeInfo::linkedVariable() const
{
    return d_linkedVariable_p;
}

OptionType::Enum TypeInfo::type() const
{
    return d_elemType;
}

                                  // Aspects

bslma::Allocator *TypeInfo::allocator() const
{
    return d_allocator_p;
}

bsl::ostream& TypeInfo::print(bsl::ostream& stream,
                              int           level,
                              int           spacesPerLevel) const
{
    BSLS_ASSERT(0 <= spacesPerLevel);

    if (stream.bad()) {
        return stream;                                                // RETURN
    }

    if (level < 0) {
        level = -level;
    }
    else {
        bdlb::Print::indent(stream, level, spacesPerLevel);
    }

    stream << "{";
    bdlb::Print::newlineAndIndent(stream, ++level, spacesPerLevel);
    stream << "TYPE       " << type();
    if (linkedVariable()) {
        bdlb::Print::newlineAndIndent(stream, level, spacesPerLevel);
        stream << "VARIABLE   " << static_cast<void *>(linkedVariable());
    }
    if (constraint()) {
        bdlb::Print::newlineAndIndent(stream, level, spacesPerLevel);
        stream << "CONSTRAINT " << static_cast<void *>(constraint().get());
    }
    bdlb::Print::newlineAndIndent(stream, --level, spacesPerLevel);
    stream << "}";

    return stream;
}

}  // close package namespace

// FREE OPERATORS
bool balcl::operator==(const TypeInfo& lhs, const TypeInfo& rhs)
{
    return lhs.type()           == rhs.type()
        && lhs.linkedVariable() == rhs.linkedVariable()
        && lhs.constraint()     == rhs.constraint();
}

bool balcl::operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
{
    return !(lhs == rhs);
}

bsl::ostream&
balcl::operator<<(bsl::ostream& stream, const TypeInfo& rhs)
{
    return rhs.print(stream);
}

namespace balcl {

                       // ------------------
                       // class TypeInfoUtil
                       // ------------------

bool TypeInfoUtil::satisfiesConstraint(const OptionValue& element,
                                       const TypeInfo&    typeInfo)
{
    BSLS_ASSERT(typeInfo.type() == element.type());

    return typeInfo.constraint()->validate(element);
}

bool TypeInfoUtil::satisfiesConstraint(const OptionValue& element,
                                       const TypeInfo&    typeInfo,
                                       bsl::ostream&      stream)
{
    BSLS_ASSERT(typeInfo.type() == element.type());

    return typeInfo.constraint()->validate(element, stream);
}

bool TypeInfoUtil::satisfiesConstraint(const void      *variable,
                                       const TypeInfo&  typeInfo)
{
    BSLS_ASSERT(variable);

    OptionValue value(typeInfo.type());
    u::OptionValueUtil::setValue(&value, variable);
    return typeInfo.constraint()->validate(value);
}

bool TypeInfoUtil::satisfiesConstraint(const void      *variable,
                                       const TypeInfo&  typeInfo,
                                       bsl::ostream&    stream)
{
    BSLS_ASSERT(variable);

    OptionValue value(typeInfo.type());
    u::OptionValueUtil::setValue(&value, variable);
    return typeInfo.constraint()->validate(value, stream);
}

bool TypeInfoUtil::parseAndValidate(OptionValue        *element,
                                    const bsl::string&  input,
                                    const TypeInfo&     typeInfo,
                                    bsl::ostream&       stream)
{
    BSLS_ASSERT(element);
    BSLS_ASSERT(element->type() == typeInfo.type());

    return typeInfo.constraint()->parse(element, stream, input);
}

}  // close package namespace
}  // close enterprise namespace

// ----------------------------------------------------------------------------
// Copyright 2020 Bloomberg Finance L.P.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ----------------------------- END-OF-FILE ----------------------------------

redpajama_set_name: RedPajamaGithub


Court is held the 4th Tuesday of the month at 100 N Washington Street (Hwy 59) in the Police Department.
Any person who receives an ordinance violation citation is issued a court date. If that person fails to appear for court, pay fines, or do what the Judge has ordered them to do, a warrant will be issued. Your drivers license will also be suspended.


text:
Home » Faculty / Staff » Student Data Systems
Access to data is assigned based on the requirements of a staff member's official duties, including students' qualification for entry, establishing their performance in programs and courses, providing the basis for awards and government funding and assisting the University in the academic and financial administration.
Guidelines & Procedures for Assigning Access to Student Records
This section describes the Office of University Registrar (OUR) guidelines and procedures, in accordance with the Freedom of Information and Protection of Privacy Act, for assigning access to student and applicant records. These records are collected to assess students' qualification for entry, establish a record of their performance in programs and courses, provide the basis for awards and government funding and to assist the University in the academic and financial administration of its affairs.
Also, as stipulated in the OUR's Student Applicant and Record Policy: Faculty and staff members of the University are given access to information contained in student records if they need to know the information in order to perform their official duties.
Guidelines and Procedures
1. Faculty and staff holding certain positions in academic departments (e.g., chair of undergraduate studies, departmental administrator) and Faculty Offices may request access to the contents of students' records contained in the student data warehouse, the degree list data warehouse, the student photo identification card database and the student information system.
Through the University's registration system, SOLUS, each student has access to his/her academic record. If an individual student seeks academic advice from a faculty or staff member who does not have OUR-authorized access to student record information, the student may, at his/her discretion, elect to share the SOLUS academic record with the member.
Access to the student information system data base is assigned according to the required level of access as determined by a member's official duties connected with the purpose for which the data was collected (i.e. to assess students' qualification for entry, establish a record of their performance in programs and courses, provide the basis for awards and government funding and to assist the University in the academic and financial administration of its affairs). Differing levels of access are available and these levels are defined as a series of "profiles." Each profile allows access to specific information and on either a query or update basis.
Students of Queen's University may be assigned access to students' records in the capacity of employees or volunteers. Supervisors assume the responsibility for ensuring confidentiality is maintained and for ensuring that students understand that violation of confidentiality constitutes a breach of the agreement to maintain confidentiality and a breach of the University's Code of Conduct. Access for defined period of time will be provided on authorization by the supervisor.
2. The procedure for obtaining access to the contents of students' records in the data bases referred to in 1. above, requires the faculty or staff member wishing access to be approved by the Department Head and the OUR Security Administrator.
If a status change occurs, e.g., a new NetID, a change in duties or position within the University, etc., the Security Administrator will approve the appropriate changes before continued access to student records takes place. Individuals newly receiving access to update profiles will be contacted and offered training on PeopleSoft screens (and related SOLUS screens).
The Student Data Systems are a collection of private, confidential information about applications, students, and instructors, in accordance with the Freedom of Information and Protection Act.
The Student & Applicant Record Policy defines the rights and obligations of students and of the University and its officers in matters pertaining to student records and applications.
The Electronic Information Security Policy sets out the responsibilities of members of the University community to safeguard information systems.
The Guidelines & Procedures for Assigning Access to Student Records describes the procedures administered by the Office of the University Registrar for assigning access to student data (See first section on this page for more details).
Access to the student data is assigned according to the required level of access as determined by a member's official duties connected with the purpose for which the data was collected (i.e. to assess students' qualification for entry, establish a record of their performance in programs and courses, provide the basis for awards and government funding and to assist the University in the academic and financial administration of its affairs).
All faculty and staff who need to have access to student data are required to complete and submit the PeopleSoft Student Systems Access Request Form to the Office of the University Registrar (OUR). If you currently have access to any of the Student Data Systems, then the OUR will already have a copy of your signed form; you'll be notified by the Student Data Security Administrator if this form is required for this application.
Degree Lists
The Degree List System is used by Faculty & Schools to create and modify their list of degree candidates for fall and spring convocations. Access to this system is restricted to authorized users within each Faculty/School office.
This system uses BI Query to access data that is stored in an Oracle database. There are a number of standard queries and reports available within the system to facilitate the production of the 'official' degree list.
Please email Chyrle Campsall, Convocation Coordinator, if you require access to the Degree List System. Chyrle will arrange for the software to be installed on your computer, and for you to have access to the data, along with the necessary training and documentation.
Student Photos
A photo of current Queen's students is stored electronically and is used to produce student cards for academic and campus security purposes. The photo can be made available to Faculty or Departmental Offices as required.
Student photos are confidential data, just like any other piece of student information, and fall under the same privacy guidelines as a student's name, address, marks, etc.. The onus is on all University staff and faculty to ensure the confidentiality of the data as outlined in the Student & Applicant Record Policy.
The Registrar's Office will not provide photos of any student who has requested complete privacy of their personal data. A request for complete privacy can be made by any student and would be granted for safety reasons only.
To Request Student Photos
Please read the process outlined below, then contact the Photo ID Assistant by phone (74128) or email student.card@queensu.ca if you have any questions.
For security reasons, we can respond to requests only from appropriate Faculty Office or Departmental administrators.
The Security Clearance & Undertaking Form must be completed before we give you the photos. If you currently have access to any of the Student Data Systems, then we should already have a copy of your signed form; you'll be notified if this form is required for this application.
You will need to send the Registrar's Office a list of the student numbers for whom you want a photo and the reason why. Send the .txt file(s) as an email attachment to student.card@queensu.ca .
Please put the numbers into a text (.txt) file, one number per line, with NO dashes, such as
We will run a job to get the photos based on the file you sent. This job will create one jpeg file for each student in your list for whom we have a picture. For example, if you had 50 student numbers in your list, the job should produce 50 separate jpeg files, each containing a picture of the student whom the student number on the file name refers to, such as:
** Please submit all 7-digit student numbers without the leading 0. The only accepted 8-digit numbers will be for students whose numbers are 1#######, 2#######., etc. **
We will then contact you to send the photo files. You have two options to receive the files:
1) The Photo ID Assistant will place the pictures in QShare and e-mail you when they are available; or,
2) The Photo ID Assistant can send the pictures via ftp to your designated, secure computer
Please see the Student ID Cards page for more information. You can also contact the Photo ID Assistant at 74128 or by email if you have questions about this process.
Employees of Queen's University who have access to information stored in the Student Data Systems must be familiar with the University privacy documents and sign an undertaking agreeing to use such personal information only as is necessary to perform legitimate University functions.
Faculty and staff members of the University are given access to information contained in student records if they NEED TO KNOW the information in order to perform their official duties. As a general rule, only employees involved in some aspect of academic administration or student affairs are given access to the contents of student records.
For example, individual instructors are not normally entitled to see any part of a student's record not directly related to her/his specific course, including past academic performance and letters of reference.
Request for Reports
Students: Please use SOLUS to request a transcript or to get a marks report.
A variety of enrolment reports are available to the public from the Office of Institutional Research and Planning.
We try to work on all Report Requests as quickly as possible; however, we can not guarantee same day service. We strive to provide a minimum turnaround time of 3 working days from the time of your request to completion of the project, but this is not always possible. Please do not expect same day service.
To file a request for a report, you will need to send an email to SDW Help with the following information:
Email Address (if different than the email address you are sending the request from)
Contact Person (if different than the email address you are sending the request from)
Answers to the following questions:
Have you asked for this report before? If so, please include any information that you think would help us find the report so that we can run it again for you.
What is the purpose of the report? (e.g., to mail out info or choose honour students, etc.)
What are your criteria? (e.g., Academic year, term, department, degree program, degree type, attendance, etc)
What information do you need to see on the report? (e.g., Student number, name, gender, etc)
What sort order would you like the report to be in?
What is the program name? (i.e., the name of the program that we ran for you to give the information previously - this is not the degree program name)
Job Changes @ Queen's
When a person who has access to any of the student data systems changes jobs within a department or within the University, they may or may not continue to have access to student data.
Access to all student data is provided for people to perform the specific duties of their current job. When a person changes jobs, and duties, then they may or may not continue to need access to the same student data.
The Registrar's Office is informed by Human Resources when anyone with access to any of the student data systems changes jobs, and unless you re-apply for access to the data to perform the duties of your new job, then your current access to all student data systems will be revoked.
To re-apply for access to any of the Student Data Systems, please refer to the instructions in the Request for Access section of this page.

redpajama_set_name: RedPajamaCommonCrawl


Ibm Pser Pseries Eserver 4way 1.5ghz, Ibm Pser 9131-52A-4W1.5.
* We have limited quantity of 9131-52A-4W1.5 in stock. Our inventory changes constantly and quantities listed are based on available stock. This item comes with our 100% Money-Back Guarantee.
We accept Credit Cards, Google Checkout, and Paypal payments for this Ibm Pser 9131-52A-4W1.5 Pseries Eserver 4way 1.5ghz by means of fast, convenient and secure checkout. Purchase this Ibm Pser 9131-52A-4W1.5 item today with Super Saver shipping while inventory and sale last.
Shipping Note: Your Ibm Pser 9131-52A-4W1.5 Pseries Eserver 4way 1.5ghz order will be professionally and carefully packed to ensure safe delivery.
If you ever have questions or concerns about your Ibm Pser 9131-52A-4W1.5 order, contact our Customer Service Department. Friendly customer service reps are available to assist you with your order.
Code Micro is the IT Professional's Choice for computer hardware and genuine Ibm Pser replacement parts. We have loyally served our customers since 1994. Our product expertise, quality customer service, competitive pricing -- on items like this Ibm Pser 9131-52A-4W1.5 Pseries Eserver 4way 1.5ghz -- are a few of the reasons why more IT Professional buy from Code Micro everyday.


War of the Rebellion: Serial 034 Page 0308 KY., MID. AND E. TENN., N. ALA., AND SW. VA. Chapter XXXV.
my force was too small, having only about 40 men present, to keep him back on the flanks, and that I would certainly be surrounded if I did not hastily retire. I accordingly fell back through their lines, and brought them, by so doing, immediately in our front again. We were pressed so hotly from the onset by such superior numbers that it was impossible to take our prisoners to the rear, so they all escaped except one, who was taken along by Captain Carpenter, and we only brought in 2 of the horses. When we gained the cover of the woods on the north side of the road we made a stand, and, through the "Butternuts" out-numbered us eight to on, and came down shouting, "Give the Yankee sons of b - s no quarter," they could not drive us from our position except as they were about to flank us. We repeatedly drove them, and at one charge, the last we made, swept them clean from the woods.
At this period they retired to remount, leaving only a few skirmishers to harass us. Finding my men suffering from excessive thirst and great exhaustion, I ordered them to fall back, which they did in good order, to a strong and safe position, where we rested until midnight. Having lost my guide, and not being familiar with the country, I found great difficulty in getting out to the road. About daylight, however, we struck a mountain road, which, from its course, I judged would lead us out of the wilderness, and which we followed until we discovered in the path before us about 50 men, whom we knew, from their peculiar dress, were rebel soldiers. Being too weak to engage them, we returned and retreat to the river, where we found a raft; embarked, cut it loose, and floated down to the ferry, reaching camp at 4 p. m., having been out forty-three hours.
Upon hearing guns Captain Carpenter immediately started to my assistance, but was met on the way by rebel cavalry, which he gallantly repulsed. Deeming it impossible to re-enforce me, however, he fell back on the road until met by Captain Barnes and Allen. Upon consultation it was prudent for Captain Barnes to fall rapidly back and hold the Narrows, while Captain Allen, with his whole detachment, would fall back leisurely. Before Captain Allen reached the reserve post, the rebel cavalry dashed down upon him in great force, but were unable to rout him. He was compelled, however, to fall back, which he did in good order until he reached the reserve, the rebels not caring to press very hard after him.
In the last engagement Captain Allen lost 1 man killed, 1 officer (Lieutenant [C. A.] Lounsberry) wounded and prisoner, and 1 missing. In the first encounter Lieutenant McCollum lost 1 killed, and Lieutenant Knight and 1 man taken prisoner, and 1 missing. The companies of kentucky Cavalry lost 2 killed, 1 wounded, and 6 missing.
I cannot speak too highly of the conduct of both officers and men engaged in this terribly unequal strife. That 40 men held 300 at bay for over two hours and finally drove them back, or that 30 should repulse 250, shows with what determined bravery they stood, and with what desperate energy they fought. While I must speak of the conduct of all in terms of highest praise, I am forced by conviction of what appears to me to be largely his due, to mention the name of Sergt. A. A. Day, Company H, who stood foremost in the fight, where the bullets rained through the whole of the engagement. Allow me, sir, to recommend him to your favorable notice.


text:
Uber driver banned from driving women after conviction for sex attack on passenger
Pervert Uber driver, Aliriza Kurt who sexually assaulted a passenger in London jailed for 18 months
An Uber driver has been jailed for 18 months after sexually assaulting a young woman in London after she booked the minicab firm, Uber
An Uber driver asked a female passenger if "she was comfortable with this" as he leant over and sexually assaulted her. Aliriza Kurt, of Blackstock Road, Finsbury Park, picked up the victim from Brixton Tube station at 11.15pm on May 8 last year.
The 24-year-old victim got in to the car and during the journey, Kurt, 42, leaned across and touched her, asking her "are you comfortable with this?" The woman escaped the vehicle and was able to call the police. Kurt was arrested at 3.50am the following day.
He was today sentenced to 18 months in prison after being found guilty at Inner London Crown Court and was made the subject of an indefinite Sexual Harm Prevention Order.
Under the order, Kurt is not allowed to have females, except family members, in any vehicle driven by him and cannot apply to be or work as a private hire vehicle driver in England and Wales. He also had his car seized and will be placed on the Sex Offenders' Register for 10 years.
Inspector Tracy Allison, from the Metropolitan Police cab enforcement unit, said: "This was an excellent result, which has seen a dangerous predator receive a jail sentence, entry on the sex offenders' register and an extensive sexual harm prevention order, which prohibits him from working as a private hire driver in England or Wales and applying to be a private hire driver in England or Wales.
The cab enforcement unit's number one priority is the safety of those travelling in taxis and private hire vehicles. If you commit an offence on London's transport network we will pursue and arrest you – we will get those responsible."
Siwan Hayward, Transport for London's deputy director of enforcement and on-street operations, said: "This victim's bravery in reporting this offence to the police has helped put this sex offender behind bars, preventing him from preying on any other vulnerable women.
"Our TfL funded resources within the MPS Cab Enforcement Unit work every week to apprehend those who commit cab related sexual offences, and we will continue to work with the police to push for the strongest convictions available to stop incidents like this happening again.
"If you ever experience unwanted sexual behaviour, report it to the police; you will always be taken seriously and the incident will be fully investigated."
An Uber spokesperson said: "As soon as we learned about this shocking incident we immediately stopped this licensed private hire driver from using the Uber app and offered our full assistance to both the police and the passenger.
"We welcome this conviction."
Kurt was sentenced at Inner London Crown court on Wednesday, having been convicted earlier this month.
TagsAliriza KurtLondonSexual AssaultUber
Previous article Passenger transport industry playing Russian Roulette with passengers lives by clocking fleets
Next article Emirates Airline UK chauffeur service, PCS Chauffeurs to stand trial for Conspiracy to Defraud
Computer glitch leaves Uber drivers without pay
Uber drivers are accused of 32 rapes or sexual assault in London in last 12 months
Leytonstone tube attacker was an UBER driver; with history of drug abuse and mental health issues
UK Uber drivers hit in the pocket by
Support LicensedTransportUncovered.com


text:
All Posts by roland
By Roland Lee
2023 Master Classes
One weekend each month Roland Lee invites four artists to his studio for two days of person to person instruction and help. This is only for experienced artists who are approved by Roland Lee. [...]
Watercolor Painting of a Creek
Zion Demo at Museum – Plein Air
Plein Air Watercolor Painting of Zion National Park
Altar of Sacrifice in Zion
Watercolor Painting of the Altar of Sacrifice in Zion National Park
5th Ward Chapel
Watercolor Painting of the St. George 5th Ward Chapel
Capitol Reef Quick Draw – Plein Air
Plein Air Watercolor Painting of Canyon in Capitol Reef National Park
Capitol Reef Study – Plein Air
Capitol Gorge – Plein Air
Grand Wash – Plein Air
Juniper Study – Plein Air
Plein Air Watercolor Painting of Juniper Tree in Capitol Reef National Park
The Fruita School House
Plein Air Watercolor Painting of Fruita School House in Capitol Reef National Park
Along Pleasant Creek – Plein Air
Watercolor Painting of Canyon in Capitol Reef National Park
The Arch Wall – Plein Air
Cliffs of Zion – Plein Air
Watercolor Painting of Refrigerator Canyon on Angels Landing Hike
Bessendorfer Blacksmith Shop
Above Midway – Plein Air
Plein Air Utah Demo
White House Shadows
Watercolor Painting of hike between Padre and Snow Canyon in Southern Utah
Water Brings Life
Watercolor Painting of a Small Canal Running Through a Field
Back Canyon Climb
This Might Be Heaven
Watercolor Painting of Red Cliffs Below Pine Valley Mountain in Southern Utah
Sinawava Riverbend
Watercolor Painting of the Temple of Sinawava viewpoint
Art Organizations art show art shows Art Supplies art workshops Awards Brea Gallery California Carolyn Lord Cedar Breaks Dixie State University Eccles Fine Art Center Events Exhibits Grandkids Art Kenosha Museum maynard dixon Milford Zornes Nature Photos News Article Other Artists outdoor painting painting outdoors PAPU plein air PLein Air Painters of Utah PLein Air Painting Plein Air Paintout Publications Robert and Peggy Sears Fine Arts Gallery School Visits Sears Invitational Art Show Spike Ress St. George Art Festival Studio Tour SUMA Talks Travels and Hikes Utah Watercolor Society Videos watercolor Watercolor Exhibit Watercolor West workshops zion natural history association
Archives Select Month December 2022 October 2022 September 2022 August 2022 May 2022 April 2022 March 2022 January 2022 December 2021 November 2021 October 2021 September 2021 August 2021 July 2021 June 2021 April 2021 March 2021 February 2021 January 2021 December 2020 October 2020 September 2020 July 2020 June 2020 May 2020 April 2020 March 2020 February 2020 January 2020 December 2019 November 2019 October 2019 September 2019 August 2019 July 2019 June 2019 May 2019 March 2019 February 2019 January 2019 November 2018 October 2018 September 2018 August 2018 July 2018 June 2018 May 2018 April 2018 March 2018 February 2018 January 2018 December 2017 October 2017 September 2017 August 2017 July 2017 June 2017 April 2017 December 2016 November 2016 October 2016 September 2016 August 2016 July 2016 June 2016 May 2016 March 2016 February 2016 January 2016 December 2015 November 2015 October 2015 September 2015 August 2015 July 2015 June 2015 May 2015 April 2015 March 2015 February 2015 January 2015 December 2014 November 2014 October 2014 August 2014 July 2014 June 2014 May 2014 April 2014 March 2014 February 2014 November 2013 October 2013 September 2013 August 2013 July 2013 June 2013 May 2013 April 2013 March 2013 February 2013 January 2013 December 2012 November 2012 October 2012 September 2012 July 2012 June 2012 May 2012 April 2012 March 2012 February 2012 January 2012 November 2011 October 2011 September 2011 August 2011 July 2011 June 2011 May 2011 April 2011 March 2011 February 2011 January 2011 December 2010 November 2010 October 2010 September 2010 August 2010 July 2010 June 2010 May 2010 April 2010 March 2010 February 2010 January 2010 December 2009 November 2009 October 2009 September 2009 August 2009 July 2009 June 2009 May 2009 April 2009 March 2009 February 2009 January 2009 December 2008 November 2008 October 2008 September 2008 August 2008 July 2008 June 2008 May 2008 April 2008 March 2008 February 2008 January 2008 December 2007 November 2007 October 2007 September 2007 August 2007 July 2007 June 2007 May 2007 April 2007 March 2007 February 2007 January 2007 December 2006 November 2006 October 2006 September 2006 August 2006 April 2006 June 2005 May 2005 April 2005


text:
Media centre Events High-level meeting: HSS respond to NCDs Participants
High-level meeting: HSS respond to NCDs
Objectives and expected outcome
Key questions on the agenda
The meeting is a forum for high-level representatives from the 53 Member States in the WHO European Region, relevant international organizations and selected nongovernmental organizations. Participants with diverse backgrounds representing a cross-section of health systems will engage in interdisciplinary dialogue.
They will include:
senior policy-makers and officials from ministries of health, finance, social protection, and other ministries and government branches responsible for overall health systems and/or NCD policies;
senior officials and/or experts from public health agencies with responsibilities for health promotion and prevention related to NCDs;
senior officials and/or experts in charge of policies, regulations, and relations with health service-delivery organizations, including primary and specialized care for NCDs;
senior officials and/or experts in funding and purchasing agencies working towards better contracts and incentives to step up early detection and disease prevention; and
representatives of national and local governments involved in intersectoral action.


This digital flipping-page book that contains three photos plus three wise sayings about the Bible. And that they have been converted into the software of Interactive Jigsaw Puzzles for you to enjoy interlocking for hours of pleasure and fun! Plus the Last Page is about the FREE offer of a huge digital catalog book if you ask me to send it to you via email.


text:
Introduction
============

circuits.web is a set of components for building high performance HTTP/1.1
and WSGI/1.0 compliant web applications. These components make it easy to
rapidly develop rich, scalable web applications with minimal effort.

circuits.web borrows from

* `CherryPy <http://www.cherrypy.org>`_
* BaseHTTPServer (*Python std. lib*)
* wsgiref (*Python std. lib*)


Due to unforeseen circumstances we have had to move the date of the ladies night to Friday 20th September. Anyone that has already booked can email JoJo Rimington on jojorimington@yahoo.co.uk and their ticket will automatically be transferred over to the new date.
However, we are absolutely delighted to announce that MCA Trust Patron, Che Chesterman will be joining us on the night for a fantastic performance! This really will be a night to remember! Please feel free to email or message us if you have any questions.
Acceptance of any payment, contribution, gift or grant is at the discretion of the MCA Trust. The MCA Trust will not accept any gift unless it can be used or expended consistently with the purpose and mission of the MCA Trust.
No irrevocable gift, whether outright or life-income in character, will be accepted if under any reasonable set of circumstances the gift would jeopardise the donor's financial security.
The MCA Trust will refrain from providing advice about the tax or other treatment of gifts and will encourage donors to seek guidance from their own professional advisers to assist them in the process of making their donation.
The MCA Trust will accept donations of cash or publicly traded securities. Gifts of in-kind services will be accepted at the discretion of the MCA Trust.
Certain other gifts, real property, personal property, in-kind gifts, non-liquid securities, and contributions whose sources are not transparent or whose use is restricted in some manner, must be reviewed prior to acceptance due to the special obligations raised or liabilities they may pose for the MCA Trust.
The MCA Trust will provide acknowledgements to donors meeting tax requirements for property received by the charity as a gift. However, except for gifts of cash and publicly traded securities, no value shall be ascribed to any receipt or other form of substantiation of a gift received by the MCA Trust.
The MCA Trust will respect the intent of the donor relating to gifts for restricted purposes and those relating to the desire to remain anonymous. With respect to anonymous gifts, the MCA Trust will restrict information about the donor to only those staff members with a need to know.
The MCA Trust will not compensate, whether through commissions, finders' fees, or other means, any third party for directing a gift or a donor to the MCA Trust.
The MCA Trust is a charity registered in England.
The Michael Charles Adams MBE Memorial Trust aids local children with brain related cancers.
The MCA Trust © 2019.