enum.h

Go to the documentation of this file.

// Copyright 2017-2020, Schlumberger
//
// 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.
 
#pragma once
 
#include <array>
#include <cstdint>
#include <memory>
#include <functional>
 
namespace InternalZGY {
#if 0
}
#endif
 
/*
 * The following type aliases are needed in class ZgyInternalBulk,
 * GenLodBase, CompressFactoryImpl, *CompressPlugin, and possibly
 * others. Might as well declare them directly in the InternalZGY
 * namespace instead of duplicating the definitions in each class
 * that uses them.
 *
 * The aliases are also used in the public api, in class ZgyWriterArgs
 * and IZgyMeta. Those places the typedefs are duplicated.
 */
 
typedef std::array<std::int64_t,3> index3_t;
 
typedef std::pair<std::shared_ptr<const void>, std::int64_t> rawdata_t;
 
typedef std::function<rawdata_t(const rawdata_t&,const index3_t&)> compressor_t;
 
enum class RawDataType
{
  SignedInt8    = 0,
  UnsignedInt8  = 1,
  SignedInt16   = 2,
  UnsignedInt16 = 3,
  SignedInt32   = 4,
  UnsignedInt32 = 5,
  Float32       = 6,
  IbmFloat32    = 7,
};
 
enum class RawCoordType
{
  Unknown        = 0,
  Meters         = 1,
  Feet           = 2,
  ArcSec         = 3,  // value = deg*3600 + min*60 + sec
  ArcDeg         = 4,  // value = deg + min/60 + sec/3600
  ArcDegMinSec   = 5,  // value = deg*10000 + min*100 + sec
};
 
enum class RawHorizontalDimension
{
  Unknown  = 0,
  Length   = 1,
  ArcAngle = 2,
};
 
enum class RawVerticalDimension
{
  Unknown    = 0,
  Depth      = 1,
  SeismicTWT = 2,
  SeismicOWT = 3,
};
 
enum class RawGridDefinition
{
  Unknown    = 0,
  Parametric = 1,
  ThreePoint = 2,
  FourPoint  = 3,
};
 
enum class BrickStatus
{
  Missing    = 0,
  Constant   = 1,
  Normal     = 2,
  Compressed = 3,
};
 
enum class UpdateMode
{
  Never = 0,       // Never allow updating. Can only write to "Missing" bricks.
 
  Constant = 1,   // Can write to both "Missing" and "Constant" bricks. This
                  // permission is needed if the client wants to establish
                    // a default value for missing samples by setting the entire
                    // survey to this default. Followed by writing real data.
                    // "Never" and "Constant" require that the application
                    // writes brick aligned data. If a read/modify/write is
                    // indicated then this will raise an exception.
                    // The only drawback of "Constant" over "Never" is that
                    // "Constant" can cause a slight confusion: A particular
                    // read/modify/write might be allowed if the previous write
                    // just happened to have all constant values.
 
  //NoCompress = 2, // Not recommended because it gives confusing behavior.
                  // Update is only allowed when both the old and the new
                  // brick is uncompressed. The only leaks allowed are those
                  // caused by the target block being in a closed segment on
                  // the cloud. The problem is that the decision is made
                  // per brick. It is more consistent to decide up front
                  // whether any compression might happen. If so, use
                  // Constant or Never. If not, just use Always.
 
  //NoLeaks = 3,   // Not recommended because it gives confusing behavior.
                  // As "Always" but if it turns out that a brick would be
                  // leaked, even in the rare "closed segment" case, the
                  // code will raise an exception.
 
  Always = 4,     // Always allow updating. This may cause leaked data in
                  // some cases. Uncompressed local data will not leak.
                  // Uncompressed cloud data can only leak when the target
                  // block being in a closed segment on the cloud.
                    // This can be the default for uncompressed data.
                    // For compressed data it is usually a bad idea.
                  // Not only could there be a lot more leakage, but if
                  // the reason for the overwrite is a read/modify/write
                  // and the data had lossy compression then the
                  // compression noise will accumulate.
 
  Pedantic = 5,   // As "Always", but when either the existing or the new
                  // brick is compressed then the old brick is leaked
                  // unconditionally. This gives more reproducible behavior
                  // but wastes more space.
};
 
} // namespace