From ddd2d9bad0b992621a3607d979f465f4f43fd689 Mon Sep 17 00:00:00 2001 From: dos-reis Date: Thu, 4 Apr 2013 04:19:29 +0000 Subject: Add initial io library files --- src/include/Input.H | 116 ++++++++++++++++++++++++++++++++++++++++++++++++ src/include/defaults.H | 64 ++++++++++++++++++++++++++ src/include/iterator.H | 83 ++++++++++++++++++++++++++++++++++ src/include/structure.H | 77 ++++++++++++++++++++++++++++++++ 4 files changed, 340 insertions(+) create mode 100644 src/include/Input.H create mode 100644 src/include/defaults.H create mode 100644 src/include/iterator.H create mode 100644 src/include/structure.H (limited to 'src/include') diff --git a/src/include/Input.H b/src/include/Input.H new file mode 100644 index 00000000..8da6a833 --- /dev/null +++ b/src/include/Input.H @@ -0,0 +1,116 @@ +// -*- C++ -*- +// Copyright (C) 2013, Gabriel Dos Reis. +// All rights reserved. +// Written by Gabriel Dos Reis. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// - Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// - Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in +// the documentation and/or other materials provided with the +// distribution. +// +// - Neither the name of OpenAxiom, nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef OPENAXIOM_INPUT_included +#define OPENAXIOM_INPUT_included + +#include +#include +#include +#include "open-axiom.h" +#include +#include + +namespace OpenAxiom { + namespace Input { + // -- Input text data + using Text = std::string; + + // -- Type of Thingies that iterate over text values + using TextIterator = Text::const_iterator; + + // -- Position of an input source line. + using LineNumber = Ordinal; + + // -- We keep info only for non-empty input lines. + struct NonEmptyLine : private structure::binary { + NonEmptyLine(LineNumber, const Text&); + LineNumber number() const { return first(); } + const Text& text() const { return second(); } + TextIterator begin() const { return text().begin(); } + TextIterator end() const { return text().end(); } + std::size_t size() const { return text().size(); } + }; + + struct Source; + // -- Index into input source lines -- + using Index = std::size_t; + + // -- Line -- + struct Line : private structure::binary { + using value_type = Text::value_type; + using const_reference = Text::const_reference; + using const_pointer = Text::const_pointer; + using difference_type = Text::difference_type; + using iterator = iterator::basic; + const NonEmptyLine& get() const; + const Text& text() const { return get().text(); } + LineNumber number() const { return get().number(); } + iterator begin() const { return { this, 0 }; } + iterator end() const { return { this, size() }; } + Cardinal size() const { return text().size(); } + const_reference at(Ordinal n) const { return text().at(n); } + private: + constexpr Line(const Source* s, Index i) + : structure::binary(s, i) + { } + const Source* source() const { return first(); } + Index index() const { return second(); } + + friend Source; + }; + + // -- LineIterator -- + using LineIterator = Line::iterator; + + // -- Source -- + struct Source : std::vector { + using iterator = OpenAxiom::iterator::basic; + using Index = Ordinal; // line index + Line line(Index i) const { return { this, i }; } + iterator begin() const { return { this, 0 }; } + iterator end() const { return { this, size() }; } + Line line(LineNumber, const Text&); + }; + + // -- Span -- + struct Span : structure::binary { + constexpr Span(Ordinal c, Cardinal l) + : structure::binary(c, l) { } + constexpr Ordinal column() const { return first(); } + constexpr Cardinal size() const { return second(); } + }; + } +} + +#endif // OPENAXIOM_INPUT_included diff --git a/src/include/defaults.H b/src/include/defaults.H new file mode 100644 index 00000000..db399419 --- /dev/null +++ b/src/include/defaults.H @@ -0,0 +1,64 @@ +// -*- C++ -*- +// Copyright (C) 2013, Gabriel Dos Reis. +// All rights reserved. +// Written by Gabriel Dos Reis. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// - Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// - Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in +// the documentation and/or other materials provided with the +// distribution. +// +// - Neither the name of OpenAxiom, nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef OPENAXIOM_DEFAULTS_included +#define OPENAXIOM_DEFAULTS_included + +namespace OpenAxiom { + // -- The sole purpose of classes defines in this header is to + // -- provoke the automatic generation of definitions for functions + // -- defined within. These functions are not really friend. The + // -- friendship is such a mechanism to convince the C++ compiler + // -- to do something else. This is standard technique, also + // -- known as `based class parameterized by derived classes', or + // -- `curiously recurring pattern'. + namespace defaults { + // generate definition for != assuming existence of ==. + template + struct neq { + friend bool operator!=(t x, t y) { return not(x == y); } + }; + + // generate definitions for ordering functions assuming <. + template + struct ordering { + friend bool operator<=(t x, t y) { return not(y < x); } + friend bool operator>(t x, t y) { return y < x; } + friend bool operator>=(t x, t y) { return not(x < y); } + }; + } +} + +#endif // OPENAXIOM_DEFAULTS_included + + diff --git a/src/include/iterator.H b/src/include/iterator.H new file mode 100644 index 00000000..048dc67c --- /dev/null +++ b/src/include/iterator.H @@ -0,0 +1,83 @@ +// -*- C++ -*- +// Copyright (C) 2013, Gabriel Dos Reis. +// All rights reserved. +// Written by Gabriel Dos Reis. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// - Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// - Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in +// the documentation and/or other materials provided with the +// distribution. +// +// - Neither the name of OpenAxiom, nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef OPENAXIOM_ITERATOR_included +#define OPENAXIOM_ITERATOR_included + +#include +#include +#include "open-axiom.h" + +namespace OpenAxiom { + // -- Read-only iterator over a sequence with random access capabilities. + namespace iterator { + template + struct basic + : std::iterator, + defaults::neq>, defaults::ordering> { + using reference = typename Seq::const_reference; + using pointer = typename Seq::const_pointer; + using difference_type = typename Seq::difference_type; + + reference operator*() const { return seq->at(idx); } + pointer operator->() const { return &seq->at(idx); } + reference operator[](Ordinal i) const { return seq->at(idx + i); } + + basic& operator++() { ++idx; return *this; } + basic operator++(int) { auto t = *this; ++idx; return t; } + basic& operator--() { --idx; return *this; } + basic operator--(int) { auto t = *this; --idx; return t; } + + basic& operator+=(Cardinal n) { idx += n; return *this; } + basic& operator-=(Cardinal n) { idx -= n; return *this; } + basic operator+(Cardinal n) const { return { seq, idx + n }; } + basic operator-(Cardinal n) const { return { seq, idx - n }; } + difference_type operator-(basic that) const { return idx - that.idx; } + + + bool operator==(basic that) const { return idx == that.idx; } + bool operator<(basic that) const { return idx < that.idx; } + + private: + friend Seq; + const Seq* seq; + Ordinal idx; + constexpr basic(const Seq* s, Cardinal i) : seq(s), idx(i) { } + }; + } +} + + +#endif // OPENAXIOM_ITERATOR_included + diff --git a/src/include/structure.H b/src/include/structure.H new file mode 100644 index 00000000..d9434423 --- /dev/null +++ b/src/include/structure.H @@ -0,0 +1,77 @@ +// Copyright (C) 2013, Gabriel Dos Reis. +// All rights reserved. +// Written by Gabriel Dos Reis. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// - Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// - Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in +// the documentation and/or other materials provided with the +// distribution. +// +// - Neither the name of OpenAxiom, nor the names of its contributors may +// be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef OPENAXIOM_STRUCTURE_included +#define OPENAXIOM_STRUCTURE_included + +#include + +namespace OpenAxiom { + // -- helper classes for structural abstractions -- + namespace structure { + // unary structures + template + struct unary { + explicit constexpr unary(const T& t) : arg(t) { }; + constexpr const T& operand() const { return arg; } + private: + const T arg; + }; + + // binary structures + template + struct binary { + constexpr binary(const T& t, const U& u) : arg0(t), arg1(u) { }; + constexpr const T& first() const { return arg0; } + constexpr const U& second() const { return arg1; } + private: + const T arg0; + const U arg1; + }; + + // ternary structures + template + struct ternary { + constexpr ternary(const T& t, const U& u, const V& v) + : arg0(t), arg1(u), arg2(v) { } + constexpr const T& first() const { return arg0; } + constexpr const U& second() const { return arg1; } + constexpr const V& third() const { return arg2; } + private: + const T arg0; + const U arg1; + const V arg2; + }; + } +} + +#endif // OPENAXIOM_STRUCTURE_included -- cgit v1.2.3