OpenSubdiv
Loading...
Searching...
No Matches
array.h
Go to the documentation of this file.
1//
2// Copyright 2014 DreamWorks Animation LLC.
3//
4// Licensed under the Apache License, Version 2.0 (the "Apache License")
5// with the following modification; you may not use this file except in
6// compliance with the Apache License and the following modification to it:
7// Section 6. Trademarks. is deleted and replaced with:
8//
9// 6. Trademarks. This License does not grant permission to use the trade
10// names, trademarks, service marks, or product names of the Licensor
11// and its affiliates, except as required to comply with Section 4(c) of
12// the License and to reproduce the content of the NOTICE file.
13//
14// You may obtain a copy of the Apache License at
15//
16// http://www.apache.org/licenses/LICENSE-2.0
17//
18// Unless required by applicable law or agreed to in writing, software
19// distributed under the Apache License with the above modification is
20// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21// KIND, either express or implied. See the Apache License for the specific
22// language governing permissions and limitations under the Apache License.
23//
24#ifndef OPENSUBDIV3_VTR_ARRAY_INTERFACE_H
25#define OPENSUBDIV3_VTR_ARRAY_INTERFACE_H
26
27#include "../version.h"
28
29#include <cassert>
30
31namespace OpenSubdiv {
32namespace OPENSUBDIV_VERSION {
33
34namespace Vtr {
35
36//
37// This class provides a simple array-like interface -- a subset std::vector's interface -- for
38// a sequence of elements stored in contiguous memory. It provides a unified representation for
39// referencing data on the stack, all or a subset of std::vector<>, or anywhere else in memory.
40//
41// Note that its members are head/size rather than begin/end as in std::vector -- we frequently
42// need only the size for many queries, and that is most often what is stored elsewhere in other
43// classes, so we hope to reduce unnecessary address arithmetic constructing the interface and
44// accessing the size. The size type is also specifically 32-bit (rather than size_t) to match
45// internal usage and avoid unnecessary conversion to/from 64-bit.
46//
47// Question:
48// Naming is at issue here... formerly called ArrayInterface until that was shot down it has
49// been simplified to Array but needs to be distanced from std::array as it DOES NOT store its
50// own memory and is simply an interface to memory stored elsewhere.
51//
52template <typename TYPE>
54
55public:
56 typedef TYPE value_type;
57 typedef int size_type;
58
59 typedef TYPE const& const_reference;
60 typedef TYPE const* const_iterator;
61
62 typedef TYPE& reference;
63 typedef TYPE* iterator;
64
65public:
66
67 ConstArray() : _begin(0), _size(0) { }
68
69 ConstArray(value_type const * ptr, size_type sizeArg) :
70 _begin(ptr), _size(sizeArg) { }
71
72 size_type size() const { return _size; }
73
74 bool empty() const { return _size==0; }
75
76 const_reference operator[](int index) const { return _begin[index]; }
77 const_iterator begin() const { return _begin; }
78 const_iterator end() const { return _begin + _size; }
79
81 assert(_size>=4);
82 if (value == _begin[0]) return 0;
83 if (value == _begin[1]) return 1;
84 if (value == _begin[2]) return 2;
85 if (value == _begin[3]) return 3;
86 assert("FindIndexIn4Tuple() did not find expected value!" == 0);
87 return -1;
88 }
89
91 for (size_type i=0; i<size(); ++i) {
92 if (value==_begin[i]) {
93 return i;
94 }
95 }
96 return -1;
97 }
98
99protected:
102};
103
104template <typename TYPE>
105class Array : public ConstArray<TYPE> {
106
107public:
108 typedef TYPE value_type;
109 typedef int size_type;
110
111 typedef TYPE const& const_reference;
112
113 typedef TYPE& reference;
114 typedef TYPE* iterator;
115
116public:
117
118 Array() : ConstArray<TYPE>() { }
119
120 Array(value_type * ptr, size_type sizeArg) : ConstArray<TYPE>(ptr, sizeArg) { }
121
122public:
123
124 const_reference operator[](int index) const {
125 return ConstArray<TYPE>::_begin[index];
126 }
127
129 return const_cast<reference>(ConstArray<TYPE>::_begin[index]);
130 }
131
133 return const_cast<iterator>(ConstArray<TYPE>::_begin);
134 }
135
137 return const_cast<iterator>(ConstArray<TYPE>::_begin +
139 }
140};
141
142} // end namespace Vtr
143
144} // end namespace OPENSUBDIV_VERSION
145using namespace OPENSUBDIV_VERSION;
146} // end namespace OpenSubdiv
147
148#endif /* OPENSUBDIV3_VTR_ARRAY_INTERFACE_H */
const_reference operator[](int index) const
Definition: array.h:76
size_type FindIndexIn4Tuple(value_type value) const
Definition: array.h:80
ConstArray(value_type const *ptr, size_type sizeArg)
Definition: array.h:69
size_type FindIndex(value_type value) const
Definition: array.h:90
const_reference operator[](int index) const
Definition: array.h:124
Array(value_type *ptr, size_type sizeArg)
Definition: array.h:120