[llvm-commits] [llvm] r100889 - /llvm/trunk/include/llvm/ADT/Optional.h

[Daniel Dunbar]

On Fri, Apr 9, 2010 at 1:25 PM, Ted Kremenek <kremenek at apple.com> wrote:
> Author: kremenek
> Date: Fri Apr  9 15:25:54 2010
> New Revision: 100889
>
> URL: http://llvm.org/viewvc/llvm-project?rev=100889&view=rev
> Log:
> Move 'Optional' class from Clang to LLVM/ADT.

Want to add a doxyment giving a nice example while you are here?

 - Daniel

> Added:
>    llvm/trunk/include/llvm/ADT/Optional.h
>
> Added: llvm/trunk/include/llvm/ADT/Optional.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/Optional.h?rev=100889&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/ADT/Optional.h (added)
> +++ llvm/trunk/include/llvm/ADT/Optional.h Fri Apr  9 15:25:54 2010
> @@ -0,0 +1,66 @@
> +//===-- Optional.h - Simple variant for passing optional values ---*- C++ -*-=//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +//  This file provides Optional, a template class modeled in the spirit of
> +//  OCaml's 'opt' variant.  The idea is to strongly type whether or not
> +//  a value can be optional.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_ADT_OPTIONAL
> +#define LLVM_ADT_OPTIONAL
> +
> +#include <cassert>
> +
> +namespace llvm {
> +
> +template<typename T>
> +class Optional {
> +  T x;
> +  unsigned hasVal : 1;
> +public:
> +  explicit Optional() : x(), hasVal(false) {}
> +  Optional(const T &y) : x(y), hasVal(true) {}
> +
> +  static inline Optional create(const T* y) {
> +    return y ? Optional(*y) : Optional();
> +  }
> +
> +  Optional &operator=(const T &y) {
> +    x = y;
> +    hasVal = true;
> +    return *this;
> +  }
> +
> +  const T* getPointer() const { assert(hasVal); return &x; }
> +  const T& getValue() const { assert(hasVal); return x; }
> +
> +  operator bool() const { return hasVal; }
> +  bool hasValue() const { return hasVal; }
> +  const T* operator->() const { return getPointer(); }
> +  const T& operator*() const { assert(hasVal); return x; }
> +};
> +
> +template<typename T> struct simplify_type;
> +
> +template <typename T>
> +struct simplify_type<const Optional<T> > {
> +  typedef const T* SimpleType;
> +  static SimpleType getSimplifiedValue(const Optional<T> &Val) {
> +    return Val.getPointer();
> +  }
> +};
> +
> +template <typename T>
> +struct simplify_type<Optional<T> >
> +  : public simplify_type<const Optional<T> > {};
> +
> +} // end llvm namespace
> +
> +#endif
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>