ControlNetFileV0001.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ControlNetFileV0001.proto

#ifndef PROTOBUF_ControlNetFileV0001_2eproto__INCLUDED
#define PROTOBUF_ControlNetFileV0001_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2004000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
// @@protoc_insertion_point(includes)

namespace Isis {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();

class ControlNetFileProtoV0001;
class ControlNetFileProtoV0001_Pedigree;
class ControlNetFileProtoV0001_PBControlPoint;
class ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure;
class ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure;
class ControlNetFileProtoV0001_PBNetCubes;
class ControlNetFileProtoV0001_PBNetCubes_PBCubeList;
class ControlNetLogDataProtoV0001;
class ControlNetLogDataProtoV0001_Point;
class ControlNetLogDataProtoV0001_Point_Measure;
class ControlNetLogDataProtoV0001_Point_Measure_DataEntry;

enum ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType {
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Candidate = 1,
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Manual = 2,
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_RegisteredPixel = 3,
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_RegisteredSubPixel = 4
};
bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_IsValid(int value);
const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_MIN = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Candidate;
const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_MAX = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_RegisteredSubPixel;
const int ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_ARRAYSIZE = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_MAX + 1;

const ::google::protobuf::EnumDescriptor* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_descriptor();
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Name(ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType value) {
  return ::google::protobuf::internal::NameOfEnum(
    ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_descriptor(), value);
}
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Parse(
    const ::std::string& name, ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType>(
    ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_descriptor(), name, value);
}
enum ControlNetFileProtoV0001_PBControlPoint_PointType {
  ControlNetFileProtoV0001_PBControlPoint_PointType_Tie = 0,
  ControlNetFileProtoV0001_PBControlPoint_PointType_Ground = 1
};
bool ControlNetFileProtoV0001_PBControlPoint_PointType_IsValid(int value);
const ControlNetFileProtoV0001_PBControlPoint_PointType ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_MIN = ControlNetFileProtoV0001_PBControlPoint_PointType_Tie;
const ControlNetFileProtoV0001_PBControlPoint_PointType ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_MAX = ControlNetFileProtoV0001_PBControlPoint_PointType_Ground;
const int ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_ARRAYSIZE = ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_MAX + 1;

const ::google::protobuf::EnumDescriptor* ControlNetFileProtoV0001_PBControlPoint_PointType_descriptor();
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint_PointType_Name(ControlNetFileProtoV0001_PBControlPoint_PointType value) {
  return ::google::protobuf::internal::NameOfEnum(
    ControlNetFileProtoV0001_PBControlPoint_PointType_descriptor(), value);
}
inline bool ControlNetFileProtoV0001_PBControlPoint_PointType_Parse(
    const ::std::string& name, ControlNetFileProtoV0001_PBControlPoint_PointType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ControlNetFileProtoV0001_PBControlPoint_PointType>(
    ControlNetFileProtoV0001_PBControlPoint_PointType_descriptor(), name, value);
}
enum ControlNetFileProtoV0001_PBControlPoint_AprioriSource {
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_None = 0,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_User = 1,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AverageOfMeasures = 2,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Reference = 3,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Ellipsoid = 4,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_DEM = 5,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Basemap = 6,
  ControlNetFileProtoV0001_PBControlPoint_AprioriSource_BundleSolution = 7
};
bool ControlNetFileProtoV0001_PBControlPoint_AprioriSource_IsValid(int value);
const ControlNetFileProtoV0001_PBControlPoint_AprioriSource ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_MIN = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_None;
const ControlNetFileProtoV0001_PBControlPoint_AprioriSource ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_MAX = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_BundleSolution;
const int ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_ARRAYSIZE = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_MAX + 1;

const ::google::protobuf::EnumDescriptor* ControlNetFileProtoV0001_PBControlPoint_AprioriSource_descriptor();
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Name(ControlNetFileProtoV0001_PBControlPoint_AprioriSource value) {
  return ::google::protobuf::internal::NameOfEnum(
    ControlNetFileProtoV0001_PBControlPoint_AprioriSource_descriptor(), value);
}
inline bool ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Parse(
    const ::std::string& name, ControlNetFileProtoV0001_PBControlPoint_AprioriSource* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ControlNetFileProtoV0001_PBControlPoint_AprioriSource>(
    ControlNetFileProtoV0001_PBControlPoint_AprioriSource_descriptor(), name, value);
}
// ===================================================================

class ControlNetFileProtoV0001_Pedigree : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001_Pedigree();
  virtual ~ControlNetFileProtoV0001_Pedigree();
  
  ControlNetFileProtoV0001_Pedigree(const ControlNetFileProtoV0001_Pedigree& from);
  
  inline ControlNetFileProtoV0001_Pedigree& operator=(const ControlNetFileProtoV0001_Pedigree& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001_Pedigree& default_instance();
  
  void Swap(ControlNetFileProtoV0001_Pedigree* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001_Pedigree* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001_Pedigree& from);
  void MergeFrom(const ControlNetFileProtoV0001_Pedigree& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required float version = 1 [default = 1];
  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 1;
  inline float version() const;
  inline void set_version(float value);
  
  // required string date = 2 [default = "2010/11/18"];
  inline bool has_date() const;
  inline void clear_date();
  static const int kDateFieldNumber = 2;
  inline const ::std::string& date() const;
  inline void set_date(const ::std::string& value);
  inline void set_date(const char* value);
  inline void set_date(const char* value, size_t size);
  inline ::std::string* mutable_date();
  inline ::std::string* release_date();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001.Pedigree)
 private:
  inline void set_has_version();
  inline void clear_has_version();
  inline void set_has_date();
  inline void clear_has_date();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* date_;
  static const ::std::string _default_date_;
  float version_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001_Pedigree* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure();
  virtual ~ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure();
  
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& from);
  
  inline ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& operator=(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& default_instance();
  
  void Swap(ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& from);
  void MergeFrom(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional double sample = 1;
  inline bool has_sample() const;
  inline void clear_sample();
  static const int kSampleFieldNumber = 1;
  inline double sample() const;
  inline void set_sample(double value);
  
  // optional double line = 2;
  inline bool has_line() const;
  inline void clear_line();
  static const int kLineFieldNumber = 2;
  inline double line() const;
  inline void set_line(double value);
  
  // optional double sampleResidual = 3;
  inline bool has_sampleresidual() const;
  inline void clear_sampleresidual();
  static const int kSampleResidualFieldNumber = 3;
  inline double sampleresidual() const;
  inline void set_sampleresidual(double value);
  
  // optional double lineResidual = 4;
  inline bool has_lineresidual() const;
  inline void clear_lineresidual();
  static const int kLineResidualFieldNumber = 4;
  inline double lineresidual() const;
  inline void set_lineresidual(double value);
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure.PBMeasure)
 private:
  inline void set_has_sample();
  inline void clear_has_sample();
  inline void set_has_line();
  inline void clear_has_line();
  inline void set_has_sampleresidual();
  inline void clear_has_sampleresidual();
  inline void set_has_lineresidual();
  inline void clear_has_lineresidual();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  double sample_;
  double line_;
  double sampleresidual_;
  double lineresidual_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure();
  virtual ~ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure();
  
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& from);
  
  inline ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& operator=(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& default_instance();
  
  void Swap(ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& from);
  void MergeFrom(const ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure PBMeasure;
  
  typedef ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType MeasureType;
  static const MeasureType Candidate = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Candidate;
  static const MeasureType Manual = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Manual;
  static const MeasureType RegisteredPixel = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_RegisteredPixel;
  static const MeasureType RegisteredSubPixel = ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_RegisteredSubPixel;
  static inline bool MeasureType_IsValid(int value) {
    return ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_IsValid(value);
  }
  static const MeasureType MeasureType_MIN =
    ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_MIN;
  static const MeasureType MeasureType_MAX =
    ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_MAX;
  static const int MeasureType_ARRAYSIZE =
    ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_MeasureType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  MeasureType_descriptor() {
    return ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_descriptor();
  }
  static inline const ::std::string& MeasureType_Name(MeasureType value) {
    return ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Name(value);
  }
  static inline bool MeasureType_Parse(const ::std::string& name,
      MeasureType* value) {
    return ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required string serialnumber = 1;
  inline bool has_serialnumber() const;
  inline void clear_serialnumber();
  static const int kSerialnumberFieldNumber = 1;
  inline const ::std::string& serialnumber() const;
  inline void set_serialnumber(const ::std::string& value);
  inline void set_serialnumber(const char* value);
  inline void set_serialnumber(const char* value, size_t size);
  inline ::std::string* mutable_serialnumber();
  inline ::std::string* release_serialnumber();
  
  // required .Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure.MeasureType type = 2 [default = Candidate];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType type() const;
  inline void set_type(::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType value);
  
  // optional string choosername = 3;
  inline bool has_choosername() const;
  inline void clear_choosername();
  static const int kChoosernameFieldNumber = 3;
  inline const ::std::string& choosername() const;
  inline void set_choosername(const ::std::string& value);
  inline void set_choosername(const char* value);
  inline void set_choosername(const char* value, size_t size);
  inline ::std::string* mutable_choosername();
  inline ::std::string* release_choosername();
  
  // optional string datetime = 4;
  inline bool has_datetime() const;
  inline void clear_datetime();
  static const int kDatetimeFieldNumber = 4;
  inline const ::std::string& datetime() const;
  inline void set_datetime(const ::std::string& value);
  inline void set_datetime(const char* value);
  inline void set_datetime(const char* value, size_t size);
  inline ::std::string* mutable_datetime();
  inline ::std::string* release_datetime();
  
  // optional bool editLock = 5 [default = false];
  inline bool has_editlock() const;
  inline void clear_editlock();
  static const int kEditLockFieldNumber = 5;
  inline bool editlock() const;
  inline void set_editlock(bool value);
  
  // optional bool ignore = 6 [default = false];
  inline bool has_ignore() const;
  inline void clear_ignore();
  static const int kIgnoreFieldNumber = 6;
  inline bool ignore() const;
  inline void set_ignore(bool value);
  
  // optional bool jigsawRejected = 7 [default = false];
  inline bool has_jigsawrejected() const;
  inline void clear_jigsawrejected();
  static const int kJigsawRejectedFieldNumber = 7;
  inline bool jigsawrejected() const;
  inline void set_jigsawrejected(bool value);
  
  // optional .Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure.PBMeasure measurement = 8;
  inline bool has_measurement() const;
  inline void clear_measurement();
  static const int kMeasurementFieldNumber = 8;
  inline const ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& measurement() const;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* mutable_measurement();
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* release_measurement();
  
  // optional double diameter = 9;
  inline bool has_diameter() const;
  inline void clear_diameter();
  static const int kDiameterFieldNumber = 9;
  inline double diameter() const;
  inline void set_diameter(double value);
  
  // optional double apriorisample = 10;
  inline bool has_apriorisample() const;
  inline void clear_apriorisample();
  static const int kApriorisampleFieldNumber = 10;
  inline double apriorisample() const;
  inline void set_apriorisample(double value);
  
  // optional double aprioriline = 11;
  inline bool has_aprioriline() const;
  inline void clear_aprioriline();
  static const int kApriorilineFieldNumber = 11;
  inline double aprioriline() const;
  inline void set_aprioriline(double value);
  
  // optional double samplesigma = 12;
  inline bool has_samplesigma() const;
  inline void clear_samplesigma();
  static const int kSamplesigmaFieldNumber = 12;
  inline double samplesigma() const;
  inline void set_samplesigma(double value);
  
  // optional double linesigma = 13;
  inline bool has_linesigma() const;
  inline void clear_linesigma();
  static const int kLinesigmaFieldNumber = 13;
  inline double linesigma() const;
  inline void set_linesigma(double value);
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure)
 private:
  inline void set_has_serialnumber();
  inline void clear_has_serialnumber();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_choosername();
  inline void clear_has_choosername();
  inline void set_has_datetime();
  inline void clear_has_datetime();
  inline void set_has_editlock();
  inline void clear_has_editlock();
  inline void set_has_ignore();
  inline void clear_has_ignore();
  inline void set_has_jigsawrejected();
  inline void clear_has_jigsawrejected();
  inline void set_has_measurement();
  inline void clear_has_measurement();
  inline void set_has_diameter();
  inline void clear_has_diameter();
  inline void set_has_apriorisample();
  inline void clear_has_apriorisample();
  inline void set_has_aprioriline();
  inline void clear_has_aprioriline();
  inline void set_has_samplesigma();
  inline void clear_has_samplesigma();
  inline void set_has_linesigma();
  inline void clear_has_linesigma();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* serialnumber_;
  ::std::string* choosername_;
  ::std::string* datetime_;
  int type_;
  bool editlock_;
  bool ignore_;
  bool jigsawrejected_;
  ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* measurement_;
  double diameter_;
  double apriorisample_;
  double aprioriline_;
  double samplesigma_;
  double linesigma_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(13 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetFileProtoV0001_PBControlPoint : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001_PBControlPoint();
  virtual ~ControlNetFileProtoV0001_PBControlPoint();
  
  ControlNetFileProtoV0001_PBControlPoint(const ControlNetFileProtoV0001_PBControlPoint& from);
  
  inline ControlNetFileProtoV0001_PBControlPoint& operator=(const ControlNetFileProtoV0001_PBControlPoint& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001_PBControlPoint& default_instance();
  
  void Swap(ControlNetFileProtoV0001_PBControlPoint* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001_PBControlPoint* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001_PBControlPoint& from);
  void MergeFrom(const ControlNetFileProtoV0001_PBControlPoint& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure PBControlMeasure;
  
  typedef ControlNetFileProtoV0001_PBControlPoint_PointType PointType;
  static const PointType Tie = ControlNetFileProtoV0001_PBControlPoint_PointType_Tie;
  static const PointType Ground = ControlNetFileProtoV0001_PBControlPoint_PointType_Ground;
  static inline bool PointType_IsValid(int value) {
    return ControlNetFileProtoV0001_PBControlPoint_PointType_IsValid(value);
  }
  static const PointType PointType_MIN =
    ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_MIN;
  static const PointType PointType_MAX =
    ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_MAX;
  static const int PointType_ARRAYSIZE =
    ControlNetFileProtoV0001_PBControlPoint_PointType_PointType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  PointType_descriptor() {
    return ControlNetFileProtoV0001_PBControlPoint_PointType_descriptor();
  }
  static inline const ::std::string& PointType_Name(PointType value) {
    return ControlNetFileProtoV0001_PBControlPoint_PointType_Name(value);
  }
  static inline bool PointType_Parse(const ::std::string& name,
      PointType* value) {
    return ControlNetFileProtoV0001_PBControlPoint_PointType_Parse(name, value);
  }
  
  typedef ControlNetFileProtoV0001_PBControlPoint_AprioriSource AprioriSource;
  static const AprioriSource None = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_None;
  static const AprioriSource User = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_User;
  static const AprioriSource AverageOfMeasures = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AverageOfMeasures;
  static const AprioriSource Reference = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Reference;
  static const AprioriSource Ellipsoid = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Ellipsoid;
  static const AprioriSource DEM = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_DEM;
  static const AprioriSource Basemap = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Basemap;
  static const AprioriSource BundleSolution = ControlNetFileProtoV0001_PBControlPoint_AprioriSource_BundleSolution;
  static inline bool AprioriSource_IsValid(int value) {
    return ControlNetFileProtoV0001_PBControlPoint_AprioriSource_IsValid(value);
  }
  static const AprioriSource AprioriSource_MIN =
    ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_MIN;
  static const AprioriSource AprioriSource_MAX =
    ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_MAX;
  static const int AprioriSource_ARRAYSIZE =
    ControlNetFileProtoV0001_PBControlPoint_AprioriSource_AprioriSource_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  AprioriSource_descriptor() {
    return ControlNetFileProtoV0001_PBControlPoint_AprioriSource_descriptor();
  }
  static inline const ::std::string& AprioriSource_Name(AprioriSource value) {
    return ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Name(value);
  }
  static inline bool AprioriSource_Parse(const ::std::string& name,
      AprioriSource* value) {
    return ControlNetFileProtoV0001_PBControlPoint_AprioriSource_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required string id = 1;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 1;
  inline const ::std::string& id() const;
  inline void set_id(const ::std::string& value);
  inline void set_id(const char* value);
  inline void set_id(const char* value, size_t size);
  inline ::std::string* mutable_id();
  inline ::std::string* release_id();
  
  // required .Isis.ControlNetFileProtoV0001.PBControlPoint.PointType type = 2 [default = Tie];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType type() const;
  inline void set_type(::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType value);
  
  // optional string chooserName = 3;
  inline bool has_choosername() const;
  inline void clear_choosername();
  static const int kChooserNameFieldNumber = 3;
  inline const ::std::string& choosername() const;
  inline void set_choosername(const ::std::string& value);
  inline void set_choosername(const char* value);
  inline void set_choosername(const char* value, size_t size);
  inline ::std::string* mutable_choosername();
  inline ::std::string* release_choosername();
  
  // optional string datetime = 4;
  inline bool has_datetime() const;
  inline void clear_datetime();
  static const int kDatetimeFieldNumber = 4;
  inline const ::std::string& datetime() const;
  inline void set_datetime(const ::std::string& value);
  inline void set_datetime(const char* value);
  inline void set_datetime(const char* value, size_t size);
  inline ::std::string* mutable_datetime();
  inline ::std::string* release_datetime();
  
  // optional bool editLock = 5 [default = false];
  inline bool has_editlock() const;
  inline void clear_editlock();
  static const int kEditLockFieldNumber = 5;
  inline bool editlock() const;
  inline void set_editlock(bool value);
  
  // optional bool ignore = 6 [default = false];
  inline bool has_ignore() const;
  inline void clear_ignore();
  static const int kIgnoreFieldNumber = 6;
  inline bool ignore() const;
  inline void set_ignore(bool value);
  
  // optional bool jigsawRejected = 7 [default = false];
  inline bool has_jigsawrejected() const;
  inline void clear_jigsawrejected();
  static const int kJigsawRejectedFieldNumber = 7;
  inline bool jigsawrejected() const;
  inline void set_jigsawrejected(bool value);
  
  // optional int32 referenceIndex = 21;
  inline bool has_referenceindex() const;
  inline void clear_referenceindex();
  static const int kReferenceIndexFieldNumber = 21;
  inline ::google::protobuf::int32 referenceindex() const;
  inline void set_referenceindex(::google::protobuf::int32 value);
  
  // optional .Isis.ControlNetFileProtoV0001.PBControlPoint.AprioriSource aprioriSurfPointSource = 8;
  inline bool has_apriorisurfpointsource() const;
  inline void clear_apriorisurfpointsource();
  static const int kAprioriSurfPointSourceFieldNumber = 8;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource apriorisurfpointsource() const;
  inline void set_apriorisurfpointsource(::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource value);
  
  // optional string aprioriSurfPointSourceFile = 9;
  inline bool has_apriorisurfpointsourcefile() const;
  inline void clear_apriorisurfpointsourcefile();
  static const int kAprioriSurfPointSourceFileFieldNumber = 9;
  inline const ::std::string& apriorisurfpointsourcefile() const;
  inline void set_apriorisurfpointsourcefile(const ::std::string& value);
  inline void set_apriorisurfpointsourcefile(const char* value);
  inline void set_apriorisurfpointsourcefile(const char* value, size_t size);
  inline ::std::string* mutable_apriorisurfpointsourcefile();
  inline ::std::string* release_apriorisurfpointsourcefile();
  
  // optional .Isis.ControlNetFileProtoV0001.PBControlPoint.AprioriSource aprioriRadiusSource = 10;
  inline bool has_aprioriradiussource() const;
  inline void clear_aprioriradiussource();
  static const int kAprioriRadiusSourceFieldNumber = 10;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource aprioriradiussource() const;
  inline void set_aprioriradiussource(::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource value);
  
  // optional string aprioriRadiusSourceFile = 11;
  inline bool has_aprioriradiussourcefile() const;
  inline void clear_aprioriradiussourcefile();
  static const int kAprioriRadiusSourceFileFieldNumber = 11;
  inline const ::std::string& aprioriradiussourcefile() const;
  inline void set_aprioriradiussourcefile(const ::std::string& value);
  inline void set_aprioriradiussourcefile(const char* value);
  inline void set_aprioriradiussourcefile(const char* value, size_t size);
  inline ::std::string* mutable_aprioriradiussourcefile();
  inline ::std::string* release_aprioriradiussourcefile();
  
  // optional bool latitudeConstrained = 22 [default = true];
  inline bool has_latitudeconstrained() const;
  inline void clear_latitudeconstrained();
  static const int kLatitudeConstrainedFieldNumber = 22;
  inline bool latitudeconstrained() const;
  inline void set_latitudeconstrained(bool value);
  
  // optional bool longitudeConstrained = 23 [default = true];
  inline bool has_longitudeconstrained() const;
  inline void clear_longitudeconstrained();
  static const int kLongitudeConstrainedFieldNumber = 23;
  inline bool longitudeconstrained() const;
  inline void set_longitudeconstrained(bool value);
  
  // optional bool radiusConstrained = 24 [default = true];
  inline bool has_radiusconstrained() const;
  inline void clear_radiusconstrained();
  static const int kRadiusConstrainedFieldNumber = 24;
  inline bool radiusconstrained() const;
  inline void set_radiusconstrained(bool value);
  
  // optional double aprioriX = 12;
  inline bool has_apriorix() const;
  inline void clear_apriorix();
  static const int kAprioriXFieldNumber = 12;
  inline double apriorix() const;
  inline void set_apriorix(double value);
  
  // optional double aprioriY = 13;
  inline bool has_aprioriy() const;
  inline void clear_aprioriy();
  static const int kAprioriYFieldNumber = 13;
  inline double aprioriy() const;
  inline void set_aprioriy(double value);
  
  // optional double aprioriZ = 14;
  inline bool has_aprioriz() const;
  inline void clear_aprioriz();
  static const int kAprioriZFieldNumber = 14;
  inline double aprioriz() const;
  inline void set_aprioriz(double value);
  
  // repeated double aprioriCovar = 15 [packed = true];
  inline int aprioricovar_size() const;
  inline void clear_aprioricovar();
  static const int kAprioriCovarFieldNumber = 15;
  inline double aprioricovar(int index) const;
  inline void set_aprioricovar(int index, double value);
  inline void add_aprioricovar(double value);
  inline const ::google::protobuf::RepeatedField< double >&
      aprioricovar() const;
  inline ::google::protobuf::RepeatedField< double >*
      mutable_aprioricovar();
  
  // optional double adjustedX = 16;
  inline bool has_adjustedx() const;
  inline void clear_adjustedx();
  static const int kAdjustedXFieldNumber = 16;
  inline double adjustedx() const;
  inline void set_adjustedx(double value);
  
  // optional double adjustedY = 17;
  inline bool has_adjustedy() const;
  inline void clear_adjustedy();
  static const int kAdjustedYFieldNumber = 17;
  inline double adjustedy() const;
  inline void set_adjustedy(double value);
  
  // optional double adjustedZ = 18;
  inline bool has_adjustedz() const;
  inline void clear_adjustedz();
  static const int kAdjustedZFieldNumber = 18;
  inline double adjustedz() const;
  inline void set_adjustedz(double value);
  
  // repeated double adjustedCovar = 19 [packed = true];
  inline int adjustedcovar_size() const;
  inline void clear_adjustedcovar();
  static const int kAdjustedCovarFieldNumber = 19;
  inline double adjustedcovar(int index) const;
  inline void set_adjustedcovar(int index, double value);
  inline void add_adjustedcovar(double value);
  inline const ::google::protobuf::RepeatedField< double >&
      adjustedcovar() const;
  inline ::google::protobuf::RepeatedField< double >*
      mutable_adjustedcovar();
  
  // repeated .Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure measures = 20;
  inline int measures_size() const;
  inline void clear_measures();
  static const int kMeasuresFieldNumber = 20;
  inline const ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& measures(int index) const;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* mutable_measures(int index);
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* add_measures();
  inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure >&
      measures() const;
  inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure >*
      mutable_measures();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001.PBControlPoint)
 private:
  inline void set_has_id();
  inline void clear_has_id();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_choosername();
  inline void clear_has_choosername();
  inline void set_has_datetime();
  inline void clear_has_datetime();
  inline void set_has_editlock();
  inline void clear_has_editlock();
  inline void set_has_ignore();
  inline void clear_has_ignore();
  inline void set_has_jigsawrejected();
  inline void clear_has_jigsawrejected();
  inline void set_has_referenceindex();
  inline void clear_has_referenceindex();
  inline void set_has_apriorisurfpointsource();
  inline void clear_has_apriorisurfpointsource();
  inline void set_has_apriorisurfpointsourcefile();
  inline void clear_has_apriorisurfpointsourcefile();
  inline void set_has_aprioriradiussource();
  inline void clear_has_aprioriradiussource();
  inline void set_has_aprioriradiussourcefile();
  inline void clear_has_aprioriradiussourcefile();
  inline void set_has_latitudeconstrained();
  inline void clear_has_latitudeconstrained();
  inline void set_has_longitudeconstrained();
  inline void clear_has_longitudeconstrained();
  inline void set_has_radiusconstrained();
  inline void clear_has_radiusconstrained();
  inline void set_has_apriorix();
  inline void clear_has_apriorix();
  inline void set_has_aprioriy();
  inline void clear_has_aprioriy();
  inline void set_has_aprioriz();
  inline void clear_has_aprioriz();
  inline void set_has_adjustedx();
  inline void clear_has_adjustedx();
  inline void set_has_adjustedy();
  inline void clear_has_adjustedy();
  inline void set_has_adjustedz();
  inline void clear_has_adjustedz();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* id_;
  ::std::string* choosername_;
  ::std::string* datetime_;
  int type_;
  bool editlock_;
  bool ignore_;
  bool jigsawrejected_;
  bool latitudeconstrained_;
  ::google::protobuf::int32 referenceindex_;
  int apriorisurfpointsource_;
  ::std::string* apriorisurfpointsourcefile_;
  ::std::string* aprioriradiussourcefile_;
  int aprioriradiussource_;
  bool longitudeconstrained_;
  bool radiusconstrained_;
  double apriorix_;
  double aprioriy_;
  double aprioriz_;
  ::google::protobuf::RepeatedField< double > aprioricovar_;
  mutable int _aprioricovar_cached_byte_size_;
  double adjustedx_;
  double adjustedy_;
  double adjustedz_;
  ::google::protobuf::RepeatedField< double > adjustedcovar_;
  mutable int _adjustedcovar_cached_byte_size_;
  ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure > measures_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(24 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001_PBControlPoint* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetFileProtoV0001_PBNetCubes_PBCubeList : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001_PBNetCubes_PBCubeList();
  virtual ~ControlNetFileProtoV0001_PBNetCubes_PBCubeList();
  
  ControlNetFileProtoV0001_PBNetCubes_PBCubeList(const ControlNetFileProtoV0001_PBNetCubes_PBCubeList& from);
  
  inline ControlNetFileProtoV0001_PBNetCubes_PBCubeList& operator=(const ControlNetFileProtoV0001_PBNetCubes_PBCubeList& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001_PBNetCubes_PBCubeList& default_instance();
  
  void Swap(ControlNetFileProtoV0001_PBNetCubes_PBCubeList* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001_PBNetCubes_PBCubeList* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001_PBNetCubes_PBCubeList& from);
  void MergeFrom(const ControlNetFileProtoV0001_PBNetCubes_PBCubeList& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string filename = 1;
  inline bool has_filename() const;
  inline void clear_filename();
  static const int kFilenameFieldNumber = 1;
  inline const ::std::string& filename() const;
  inline void set_filename(const ::std::string& value);
  inline void set_filename(const char* value);
  inline void set_filename(const char* value, size_t size);
  inline ::std::string* mutable_filename();
  inline ::std::string* release_filename();
  
  // optional string serialnumber = 2;
  inline bool has_serialnumber() const;
  inline void clear_serialnumber();
  static const int kSerialnumberFieldNumber = 2;
  inline const ::std::string& serialnumber() const;
  inline void set_serialnumber(const ::std::string& value);
  inline void set_serialnumber(const char* value);
  inline void set_serialnumber(const char* value, size_t size);
  inline ::std::string* mutable_serialnumber();
  inline ::std::string* release_serialnumber();
  
  // optional int32 lines = 3;
  inline bool has_lines() const;
  inline void clear_lines();
  static const int kLinesFieldNumber = 3;
  inline ::google::protobuf::int32 lines() const;
  inline void set_lines(::google::protobuf::int32 value);
  
  // optional int32 samples = 4;
  inline bool has_samples() const;
  inline void clear_samples();
  static const int kSamplesFieldNumber = 4;
  inline ::google::protobuf::int32 samples() const;
  inline void set_samples(::google::protobuf::int32 value);
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001.PBNetCubes.PBCubeList)
 private:
  inline void set_has_filename();
  inline void clear_has_filename();
  inline void set_has_serialnumber();
  inline void clear_has_serialnumber();
  inline void set_has_lines();
  inline void clear_has_lines();
  inline void set_has_samples();
  inline void clear_has_samples();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* filename_;
  ::std::string* serialnumber_;
  ::google::protobuf::int32 lines_;
  ::google::protobuf::int32 samples_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001_PBNetCubes_PBCubeList* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetFileProtoV0001_PBNetCubes : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001_PBNetCubes();
  virtual ~ControlNetFileProtoV0001_PBNetCubes();
  
  ControlNetFileProtoV0001_PBNetCubes(const ControlNetFileProtoV0001_PBNetCubes& from);
  
  inline ControlNetFileProtoV0001_PBNetCubes& operator=(const ControlNetFileProtoV0001_PBNetCubes& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001_PBNetCubes& default_instance();
  
  void Swap(ControlNetFileProtoV0001_PBNetCubes* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001_PBNetCubes* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001_PBNetCubes& from);
  void MergeFrom(const ControlNetFileProtoV0001_PBNetCubes& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetFileProtoV0001_PBNetCubes_PBCubeList PBCubeList;
  
  // accessors -------------------------------------------------------
  
  // optional string cubelistfile = 1;
  inline bool has_cubelistfile() const;
  inline void clear_cubelistfile();
  static const int kCubelistfileFieldNumber = 1;
  inline const ::std::string& cubelistfile() const;
  inline void set_cubelistfile(const ::std::string& value);
  inline void set_cubelistfile(const char* value);
  inline void set_cubelistfile(const char* value, size_t size);
  inline ::std::string* mutable_cubelistfile();
  inline ::std::string* release_cubelistfile();
  
  // repeated .Isis.ControlNetFileProtoV0001.PBNetCubes.PBCubeList filelist = 2;
  inline int filelist_size() const;
  inline void clear_filelist();
  static const int kFilelistFieldNumber = 2;
  inline const ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList& filelist(int index) const;
  inline ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList* mutable_filelist(int index);
  inline ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList* add_filelist();
  inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList >&
      filelist() const;
  inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList >*
      mutable_filelist();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001.PBNetCubes)
 private:
  inline void set_has_cubelistfile();
  inline void clear_has_cubelistfile();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::std::string* cubelistfile_;
  ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList > filelist_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001_PBNetCubes* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetFileProtoV0001 : public ::google::protobuf::Message {
 public:
  ControlNetFileProtoV0001();
  virtual ~ControlNetFileProtoV0001();
  
  ControlNetFileProtoV0001(const ControlNetFileProtoV0001& from);
  
  inline ControlNetFileProtoV0001& operator=(const ControlNetFileProtoV0001& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetFileProtoV0001& default_instance();
  
  void Swap(ControlNetFileProtoV0001* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetFileProtoV0001* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetFileProtoV0001& from);
  void MergeFrom(const ControlNetFileProtoV0001& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetFileProtoV0001_Pedigree Pedigree;
  typedef ControlNetFileProtoV0001_PBControlPoint PBControlPoint;
  typedef ControlNetFileProtoV0001_PBNetCubes PBNetCubes;
  
  // accessors -------------------------------------------------------
  
  // required .Isis.ControlNetFileProtoV0001.Pedigree pedigree = 1;
  inline bool has_pedigree() const;
  inline void clear_pedigree();
  static const int kPedigreeFieldNumber = 1;
  inline const ::Isis::ControlNetFileProtoV0001_Pedigree& pedigree() const;
  inline ::Isis::ControlNetFileProtoV0001_Pedigree* mutable_pedigree();
  inline ::Isis::ControlNetFileProtoV0001_Pedigree* release_pedigree();
  
  // optional string networkId = 2;
  inline bool has_networkid() const;
  inline void clear_networkid();
  static const int kNetworkIdFieldNumber = 2;
  inline const ::std::string& networkid() const;
  inline void set_networkid(const ::std::string& value);
  inline void set_networkid(const char* value);
  inline void set_networkid(const char* value, size_t size);
  inline ::std::string* mutable_networkid();
  inline ::std::string* release_networkid();
  
  // optional string targetName = 3;
  inline bool has_targetname() const;
  inline void clear_targetname();
  static const int kTargetNameFieldNumber = 3;
  inline const ::std::string& targetname() const;
  inline void set_targetname(const ::std::string& value);
  inline void set_targetname(const char* value);
  inline void set_targetname(const char* value, size_t size);
  inline ::std::string* mutable_targetname();
  inline ::std::string* release_targetname();
  
  // optional string created = 4;
  inline bool has_created() const;
  inline void clear_created();
  static const int kCreatedFieldNumber = 4;
  inline const ::std::string& created() const;
  inline void set_created(const ::std::string& value);
  inline void set_created(const char* value);
  inline void set_created(const char* value, size_t size);
  inline ::std::string* mutable_created();
  inline ::std::string* release_created();
  
  // optional string lastModified = 5;
  inline bool has_lastmodified() const;
  inline void clear_lastmodified();
  static const int kLastModifiedFieldNumber = 5;
  inline const ::std::string& lastmodified() const;
  inline void set_lastmodified(const ::std::string& value);
  inline void set_lastmodified(const char* value);
  inline void set_lastmodified(const char* value, size_t size);
  inline ::std::string* mutable_lastmodified();
  inline ::std::string* release_lastmodified();
  
  // optional string description = 6;
  inline bool has_description() const;
  inline void clear_description();
  static const int kDescriptionFieldNumber = 6;
  inline const ::std::string& description() const;
  inline void set_description(const ::std::string& value);
  inline void set_description(const char* value);
  inline void set_description(const char* value, size_t size);
  inline ::std::string* mutable_description();
  inline ::std::string* release_description();
  
  // optional string userName = 7;
  inline bool has_username() const;
  inline void clear_username();
  static const int kUserNameFieldNumber = 7;
  inline const ::std::string& username() const;
  inline void set_username(const ::std::string& value);
  inline void set_username(const char* value);
  inline void set_username(const char* value, size_t size);
  inline ::std::string* mutable_username();
  inline ::std::string* release_username();
  
  // repeated .Isis.ControlNetFileProtoV0001.PBControlPoint points = 8;
  inline int points_size() const;
  inline void clear_points();
  static const int kPointsFieldNumber = 8;
  inline const ::Isis::ControlNetFileProtoV0001_PBControlPoint& points(int index) const;
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint* mutable_points(int index);
  inline ::Isis::ControlNetFileProtoV0001_PBControlPoint* add_points();
  inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint >&
      points() const;
  inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint >*
      mutable_points();
  
  // optional .Isis.ControlNetFileProtoV0001.PBNetCubes netcubes = 9;
  inline bool has_netcubes() const;
  inline void clear_netcubes();
  static const int kNetcubesFieldNumber = 9;
  inline const ::Isis::ControlNetFileProtoV0001_PBNetCubes& netcubes() const;
  inline ::Isis::ControlNetFileProtoV0001_PBNetCubes* mutable_netcubes();
  inline ::Isis::ControlNetFileProtoV0001_PBNetCubes* release_netcubes();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetFileProtoV0001)
 private:
  inline void set_has_pedigree();
  inline void clear_has_pedigree();
  inline void set_has_networkid();
  inline void clear_has_networkid();
  inline void set_has_targetname();
  inline void clear_has_targetname();
  inline void set_has_created();
  inline void clear_has_created();
  inline void set_has_lastmodified();
  inline void clear_has_lastmodified();
  inline void set_has_description();
  inline void clear_has_description();
  inline void set_has_username();
  inline void clear_has_username();
  inline void set_has_netcubes();
  inline void clear_has_netcubes();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::Isis::ControlNetFileProtoV0001_Pedigree* pedigree_;
  ::std::string* networkid_;
  ::std::string* targetname_;
  ::std::string* created_;
  ::std::string* lastmodified_;
  ::std::string* description_;
  ::std::string* username_;
  ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint > points_;
  ::Isis::ControlNetFileProtoV0001_PBNetCubes* netcubes_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetFileProtoV0001* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetLogDataProtoV0001_Point_Measure_DataEntry : public ::google::protobuf::Message {
 public:
  ControlNetLogDataProtoV0001_Point_Measure_DataEntry();
  virtual ~ControlNetLogDataProtoV0001_Point_Measure_DataEntry();
  
  ControlNetLogDataProtoV0001_Point_Measure_DataEntry(const ControlNetLogDataProtoV0001_Point_Measure_DataEntry& from);
  
  inline ControlNetLogDataProtoV0001_Point_Measure_DataEntry& operator=(const ControlNetLogDataProtoV0001_Point_Measure_DataEntry& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetLogDataProtoV0001_Point_Measure_DataEntry& default_instance();
  
  void Swap(ControlNetLogDataProtoV0001_Point_Measure_DataEntry* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetLogDataProtoV0001_Point_Measure_DataEntry* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetLogDataProtoV0001_Point_Measure_DataEntry& from);
  void MergeFrom(const ControlNetLogDataProtoV0001_Point_Measure_DataEntry& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required int32 dataType = 2;
  inline bool has_datatype() const;
  inline void clear_datatype();
  static const int kDataTypeFieldNumber = 2;
  inline ::google::protobuf::int32 datatype() const;
  inline void set_datatype(::google::protobuf::int32 value);
  
  // required double dataValue = 3;
  inline bool has_datavalue() const;
  inline void clear_datavalue();
  static const int kDataValueFieldNumber = 3;
  inline double datavalue() const;
  inline void set_datavalue(double value);
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetLogDataProtoV0001.Point.Measure.DataEntry)
 private:
  inline void set_has_datatype();
  inline void clear_has_datatype();
  inline void set_has_datavalue();
  inline void clear_has_datavalue();
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  double datavalue_;
  ::google::protobuf::int32 datatype_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetLogDataProtoV0001_Point_Measure_DataEntry* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetLogDataProtoV0001_Point_Measure : public ::google::protobuf::Message {
 public:
  ControlNetLogDataProtoV0001_Point_Measure();
  virtual ~ControlNetLogDataProtoV0001_Point_Measure();
  
  ControlNetLogDataProtoV0001_Point_Measure(const ControlNetLogDataProtoV0001_Point_Measure& from);
  
  inline ControlNetLogDataProtoV0001_Point_Measure& operator=(const ControlNetLogDataProtoV0001_Point_Measure& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetLogDataProtoV0001_Point_Measure& default_instance();
  
  void Swap(ControlNetLogDataProtoV0001_Point_Measure* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetLogDataProtoV0001_Point_Measure* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetLogDataProtoV0001_Point_Measure& from);
  void MergeFrom(const ControlNetLogDataProtoV0001_Point_Measure& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetLogDataProtoV0001_Point_Measure_DataEntry DataEntry;
  
  // accessors -------------------------------------------------------
  
  // repeated .Isis.ControlNetLogDataProtoV0001.Point.Measure.DataEntry loggedMeasureData = 2;
  inline int loggedmeasuredata_size() const;
  inline void clear_loggedmeasuredata();
  static const int kLoggedMeasureDataFieldNumber = 2;
  inline const ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry& loggedmeasuredata(int index) const;
  inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry* mutable_loggedmeasuredata(int index);
  inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry* add_loggedmeasuredata();
  inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry >&
      loggedmeasuredata() const;
  inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry >*
      mutable_loggedmeasuredata();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetLogDataProtoV0001.Point.Measure)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry > loggedmeasuredata_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetLogDataProtoV0001_Point_Measure* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetLogDataProtoV0001_Point : public ::google::protobuf::Message {
 public:
  ControlNetLogDataProtoV0001_Point();
  virtual ~ControlNetLogDataProtoV0001_Point();
  
  ControlNetLogDataProtoV0001_Point(const ControlNetLogDataProtoV0001_Point& from);
  
  inline ControlNetLogDataProtoV0001_Point& operator=(const ControlNetLogDataProtoV0001_Point& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetLogDataProtoV0001_Point& default_instance();
  
  void Swap(ControlNetLogDataProtoV0001_Point* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetLogDataProtoV0001_Point* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetLogDataProtoV0001_Point& from);
  void MergeFrom(const ControlNetLogDataProtoV0001_Point& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetLogDataProtoV0001_Point_Measure Measure;
  
  // accessors -------------------------------------------------------
  
  // repeated .Isis.ControlNetLogDataProtoV0001.Point.Measure measures = 2;
  inline int measures_size() const;
  inline void clear_measures();
  static const int kMeasuresFieldNumber = 2;
  inline const ::Isis::ControlNetLogDataProtoV0001_Point_Measure& measures(int index) const;
  inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure* mutable_measures(int index);
  inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure* add_measures();
  inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure >&
      measures() const;
  inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure >*
      mutable_measures();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetLogDataProtoV0001.Point)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure > measures_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetLogDataProtoV0001_Point* default_instance_;
};
// -------------------------------------------------------------------

class ControlNetLogDataProtoV0001 : public ::google::protobuf::Message {
 public:
  ControlNetLogDataProtoV0001();
  virtual ~ControlNetLogDataProtoV0001();
  
  ControlNetLogDataProtoV0001(const ControlNetLogDataProtoV0001& from);
  
  inline ControlNetLogDataProtoV0001& operator=(const ControlNetLogDataProtoV0001& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const ControlNetLogDataProtoV0001& default_instance();
  
  void Swap(ControlNetLogDataProtoV0001* other);
  
  // implements Message ----------------------------------------------
  
  ControlNetLogDataProtoV0001* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ControlNetLogDataProtoV0001& from);
  void MergeFrom(const ControlNetLogDataProtoV0001& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef ControlNetLogDataProtoV0001_Point Point;
  
  // accessors -------------------------------------------------------
  
  // repeated .Isis.ControlNetLogDataProtoV0001.Point points = 1;
  inline int points_size() const;
  inline void clear_points();
  static const int kPointsFieldNumber = 1;
  inline const ::Isis::ControlNetLogDataProtoV0001_Point& points(int index) const;
  inline ::Isis::ControlNetLogDataProtoV0001_Point* mutable_points(int index);
  inline ::Isis::ControlNetLogDataProtoV0001_Point* add_points();
  inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point >&
      points() const;
  inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point >*
      mutable_points();
  
  // @@protoc_insertion_point(class_scope:Isis.ControlNetLogDataProtoV0001)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point > points_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_AssignDesc_ControlNetFileV0001_2eproto();
  friend void protobuf_ShutdownFile_ControlNetFileV0001_2eproto();
  
  void InitAsDefaultInstance();
  static ControlNetLogDataProtoV0001* default_instance_;
};
// ===================================================================


// ===================================================================

// ControlNetFileProtoV0001_Pedigree

// required float version = 1 [default = 1];
inline bool ControlNetFileProtoV0001_Pedigree::has_version() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001_Pedigree::set_has_version() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001_Pedigree::clear_has_version() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001_Pedigree::clear_version() {
  version_ = 1;
  clear_has_version();
}
inline float ControlNetFileProtoV0001_Pedigree::version() const {
  return version_;
}
inline void ControlNetFileProtoV0001_Pedigree::set_version(float value) {
  set_has_version();
  version_ = value;
}

// required string date = 2 [default = "2010/11/18"];
inline bool ControlNetFileProtoV0001_Pedigree::has_date() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetFileProtoV0001_Pedigree::set_has_date() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetFileProtoV0001_Pedigree::clear_has_date() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetFileProtoV0001_Pedigree::clear_date() {
  if (date_ != &_default_date_) {
    date_->assign(_default_date_);
  }
  clear_has_date();
}
inline const ::std::string& ControlNetFileProtoV0001_Pedigree::date() const {
  return *date_;
}
inline void ControlNetFileProtoV0001_Pedigree::set_date(const ::std::string& value) {
  set_has_date();
  if (date_ == &_default_date_) {
    date_ = new ::std::string;
  }
  date_->assign(value);
}
inline void ControlNetFileProtoV0001_Pedigree::set_date(const char* value) {
  set_has_date();
  if (date_ == &_default_date_) {
    date_ = new ::std::string;
  }
  date_->assign(value);
}
inline void ControlNetFileProtoV0001_Pedigree::set_date(const char* value, size_t size) {
  set_has_date();
  if (date_ == &_default_date_) {
    date_ = new ::std::string;
  }
  date_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_Pedigree::mutable_date() {
  set_has_date();
  if (date_ == &_default_date_) {
    date_ = new ::std::string(_default_date_);
  }
  return date_;
}
inline ::std::string* ControlNetFileProtoV0001_Pedigree::release_date() {
  clear_has_date();
  if (date_ == &_default_date_) {
    return NULL;
  } else {
    ::std::string* temp = date_;
    date_ = const_cast< ::std::string*>(&_default_date_);
    return temp;
  }
}

// -------------------------------------------------------------------

// ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure

// optional double sample = 1;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::has_sample() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_has_sample() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_has_sample() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_sample() {
  sample_ = 0;
  clear_has_sample();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::sample() const {
  return sample_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_sample(double value) {
  set_has_sample();
  sample_ = value;
}

// optional double line = 2;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::has_line() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_has_line() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_has_line() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_line() {
  line_ = 0;
  clear_has_line();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::line() const {
  return line_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_line(double value) {
  set_has_line();
  line_ = value;
}

// optional double sampleResidual = 3;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::has_sampleresidual() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_has_sampleresidual() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_has_sampleresidual() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_sampleresidual() {
  sampleresidual_ = 0;
  clear_has_sampleresidual();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::sampleresidual() const {
  return sampleresidual_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_sampleresidual(double value) {
  set_has_sampleresidual();
  sampleresidual_ = value;
}

// optional double lineResidual = 4;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::has_lineresidual() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_has_lineresidual() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_has_lineresidual() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::clear_lineresidual() {
  lineresidual_ = 0;
  clear_has_lineresidual();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::lineresidual() const {
  return lineresidual_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::set_lineresidual(double value) {
  set_has_lineresidual();
  lineresidual_ = value;
}

// -------------------------------------------------------------------

// ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure

// required string serialnumber = 1;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_serialnumber() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_serialnumber() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_serialnumber() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_serialnumber() {
  if (serialnumber_ != &::google::protobuf::internal::kEmptyString) {
    serialnumber_->clear();
  }
  clear_has_serialnumber();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::serialnumber() const {
  return *serialnumber_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_serialnumber(const ::std::string& value) {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  serialnumber_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_serialnumber(const char* value) {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  serialnumber_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_serialnumber(const char* value, size_t size) {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  serialnumber_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::mutable_serialnumber() {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  return serialnumber_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::release_serialnumber() {
  clear_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = serialnumber_;
    serialnumber_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required .Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure.MeasureType type = 2 [default = Candidate];
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_type() {
  type_ = 1;
  clear_has_type();
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::type() const {
  return static_cast< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType >(type_);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_type(::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType value) {
  GOOGLE_DCHECK(::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string choosername = 3;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_choosername() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_choosername() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_choosername() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_choosername() {
  if (choosername_ != &::google::protobuf::internal::kEmptyString) {
    choosername_->clear();
  }
  clear_has_choosername();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::choosername() const {
  return *choosername_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_choosername(const ::std::string& value) {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  choosername_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_choosername(const char* value) {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  choosername_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_choosername(const char* value, size_t size) {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  choosername_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::mutable_choosername() {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  return choosername_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::release_choosername() {
  clear_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = choosername_;
    choosername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string datetime = 4;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_datetime() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_datetime() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_datetime() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_datetime() {
  if (datetime_ != &::google::protobuf::internal::kEmptyString) {
    datetime_->clear();
  }
  clear_has_datetime();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::datetime() const {
  return *datetime_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_datetime(const ::std::string& value) {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  datetime_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_datetime(const char* value) {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  datetime_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_datetime(const char* value, size_t size) {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  datetime_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::mutable_datetime() {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  return datetime_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::release_datetime() {
  clear_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = datetime_;
    datetime_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional bool editLock = 5 [default = false];
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_editlock() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_editlock() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_editlock() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_editlock() {
  editlock_ = false;
  clear_has_editlock();
}
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::editlock() const {
  return editlock_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_editlock(bool value) {
  set_has_editlock();
  editlock_ = value;
}

// optional bool ignore = 6 [default = false];
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_ignore() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_ignore() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_ignore() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_ignore() {
  ignore_ = false;
  clear_has_ignore();
}
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::ignore() const {
  return ignore_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_ignore(bool value) {
  set_has_ignore();
  ignore_ = value;
}

// optional bool jigsawRejected = 7 [default = false];
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_jigsawrejected() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_jigsawrejected() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_jigsawrejected() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_jigsawrejected() {
  jigsawrejected_ = false;
  clear_has_jigsawrejected();
}
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::jigsawrejected() const {
  return jigsawrejected_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_jigsawrejected(bool value) {
  set_has_jigsawrejected();
  jigsawrejected_ = value;
}

// optional .Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure.PBMeasure measurement = 8;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_measurement() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_measurement() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_measurement() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_measurement() {
  if (measurement_ != NULL) measurement_->::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure::Clear();
  clear_has_measurement();
}
inline const ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure& ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::measurement() const {
  return measurement_ != NULL ? *measurement_ : *default_instance_->measurement_;
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::mutable_measurement() {
  set_has_measurement();
  if (measurement_ == NULL) measurement_ = new ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure;
  return measurement_;
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::release_measurement() {
  clear_has_measurement();
  ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_PBMeasure* temp = measurement_;
  measurement_ = NULL;
  return temp;
}

// optional double diameter = 9;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_diameter() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_diameter() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_diameter() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_diameter() {
  diameter_ = 0;
  clear_has_diameter();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::diameter() const {
  return diameter_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_diameter(double value) {
  set_has_diameter();
  diameter_ = value;
}

// optional double apriorisample = 10;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_apriorisample() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_apriorisample() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_apriorisample() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_apriorisample() {
  apriorisample_ = 0;
  clear_has_apriorisample();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::apriorisample() const {
  return apriorisample_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_apriorisample(double value) {
  set_has_apriorisample();
  apriorisample_ = value;
}

// optional double aprioriline = 11;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_aprioriline() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_aprioriline() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_aprioriline() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_aprioriline() {
  aprioriline_ = 0;
  clear_has_aprioriline();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::aprioriline() const {
  return aprioriline_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_aprioriline(double value) {
  set_has_aprioriline();
  aprioriline_ = value;
}

// optional double samplesigma = 12;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_samplesigma() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_samplesigma() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_samplesigma() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_samplesigma() {
  samplesigma_ = 0;
  clear_has_samplesigma();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::samplesigma() const {
  return samplesigma_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_samplesigma(double value) {
  set_has_samplesigma();
  samplesigma_ = value;
}

// optional double linesigma = 13;
inline bool ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::has_linesigma() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_has_linesigma() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_has_linesigma() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::clear_linesigma() {
  linesigma_ = 0;
  clear_has_linesigma();
}
inline double ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::linesigma() const {
  return linesigma_;
}
inline void ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure::set_linesigma(double value) {
  set_has_linesigma();
  linesigma_ = value;
}

// -------------------------------------------------------------------

// ControlNetFileProtoV0001_PBControlPoint

// required string id = 1;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_id() {
  if (id_ != &::google::protobuf::internal::kEmptyString) {
    id_->clear();
  }
  clear_has_id();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint::id() const {
  return *id_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_id(const ::std::string& value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_id(const char* value) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_id(const char* value, size_t size) {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  id_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::mutable_id() {
  set_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    id_ = new ::std::string;
  }
  return id_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::release_id() {
  clear_has_id();
  if (id_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = id_;
    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// required .Isis.ControlNetFileProtoV0001.PBControlPoint.PointType type = 2 [default = Tie];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType ControlNetFileProtoV0001_PBControlPoint::type() const {
  return static_cast< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType >(type_);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_type(::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType value) {
  GOOGLE_DCHECK(::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType_IsValid(value));
  set_has_type();
  type_ = value;
}

// optional string chooserName = 3;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_choosername() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_choosername() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_choosername() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_choosername() {
  if (choosername_ != &::google::protobuf::internal::kEmptyString) {
    choosername_->clear();
  }
  clear_has_choosername();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint::choosername() const {
  return *choosername_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_choosername(const ::std::string& value) {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  choosername_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_choosername(const char* value) {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  choosername_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_choosername(const char* value, size_t size) {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  choosername_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::mutable_choosername() {
  set_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    choosername_ = new ::std::string;
  }
  return choosername_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::release_choosername() {
  clear_has_choosername();
  if (choosername_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = choosername_;
    choosername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string datetime = 4;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_datetime() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_datetime() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_datetime() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_datetime() {
  if (datetime_ != &::google::protobuf::internal::kEmptyString) {
    datetime_->clear();
  }
  clear_has_datetime();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint::datetime() const {
  return *datetime_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_datetime(const ::std::string& value) {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  datetime_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_datetime(const char* value) {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  datetime_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_datetime(const char* value, size_t size) {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  datetime_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::mutable_datetime() {
  set_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    datetime_ = new ::std::string;
  }
  return datetime_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::release_datetime() {
  clear_has_datetime();
  if (datetime_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = datetime_;
    datetime_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional bool editLock = 5 [default = false];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_editlock() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_editlock() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_editlock() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_editlock() {
  editlock_ = false;
  clear_has_editlock();
}
inline bool ControlNetFileProtoV0001_PBControlPoint::editlock() const {
  return editlock_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_editlock(bool value) {
  set_has_editlock();
  editlock_ = value;
}

// optional bool ignore = 6 [default = false];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_ignore() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_ignore() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_ignore() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_ignore() {
  ignore_ = false;
  clear_has_ignore();
}
inline bool ControlNetFileProtoV0001_PBControlPoint::ignore() const {
  return ignore_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_ignore(bool value) {
  set_has_ignore();
  ignore_ = value;
}

// optional bool jigsawRejected = 7 [default = false];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_jigsawrejected() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_jigsawrejected() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_jigsawrejected() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_jigsawrejected() {
  jigsawrejected_ = false;
  clear_has_jigsawrejected();
}
inline bool ControlNetFileProtoV0001_PBControlPoint::jigsawrejected() const {
  return jigsawrejected_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_jigsawrejected(bool value) {
  set_has_jigsawrejected();
  jigsawrejected_ = value;
}

// optional int32 referenceIndex = 21;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_referenceindex() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_referenceindex() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_referenceindex() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_referenceindex() {
  referenceindex_ = 0;
  clear_has_referenceindex();
}
inline ::google::protobuf::int32 ControlNetFileProtoV0001_PBControlPoint::referenceindex() const {
  return referenceindex_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_referenceindex(::google::protobuf::int32 value) {
  set_has_referenceindex();
  referenceindex_ = value;
}

// optional .Isis.ControlNetFileProtoV0001.PBControlPoint.AprioriSource aprioriSurfPointSource = 8;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_apriorisurfpointsource() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_apriorisurfpointsource() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_apriorisurfpointsource() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_apriorisurfpointsource() {
  apriorisurfpointsource_ = 0;
  clear_has_apriorisurfpointsource();
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource ControlNetFileProtoV0001_PBControlPoint::apriorisurfpointsource() const {
  return static_cast< ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource >(apriorisurfpointsource_);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_apriorisurfpointsource(::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource value) {
  GOOGLE_DCHECK(::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource_IsValid(value));
  set_has_apriorisurfpointsource();
  apriorisurfpointsource_ = value;
}

// optional string aprioriSurfPointSourceFile = 9;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_apriorisurfpointsourcefile() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_apriorisurfpointsourcefile() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_apriorisurfpointsourcefile() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_apriorisurfpointsourcefile() {
  if (apriorisurfpointsourcefile_ != &::google::protobuf::internal::kEmptyString) {
    apriorisurfpointsourcefile_->clear();
  }
  clear_has_apriorisurfpointsourcefile();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint::apriorisurfpointsourcefile() const {
  return *apriorisurfpointsourcefile_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_apriorisurfpointsourcefile(const ::std::string& value) {
  set_has_apriorisurfpointsourcefile();
  if (apriorisurfpointsourcefile_ == &::google::protobuf::internal::kEmptyString) {
    apriorisurfpointsourcefile_ = new ::std::string;
  }
  apriorisurfpointsourcefile_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_apriorisurfpointsourcefile(const char* value) {
  set_has_apriorisurfpointsourcefile();
  if (apriorisurfpointsourcefile_ == &::google::protobuf::internal::kEmptyString) {
    apriorisurfpointsourcefile_ = new ::std::string;
  }
  apriorisurfpointsourcefile_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_apriorisurfpointsourcefile(const char* value, size_t size) {
  set_has_apriorisurfpointsourcefile();
  if (apriorisurfpointsourcefile_ == &::google::protobuf::internal::kEmptyString) {
    apriorisurfpointsourcefile_ = new ::std::string;
  }
  apriorisurfpointsourcefile_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::mutable_apriorisurfpointsourcefile() {
  set_has_apriorisurfpointsourcefile();
  if (apriorisurfpointsourcefile_ == &::google::protobuf::internal::kEmptyString) {
    apriorisurfpointsourcefile_ = new ::std::string;
  }
  return apriorisurfpointsourcefile_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::release_apriorisurfpointsourcefile() {
  clear_has_apriorisurfpointsourcefile();
  if (apriorisurfpointsourcefile_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = apriorisurfpointsourcefile_;
    apriorisurfpointsourcefile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional .Isis.ControlNetFileProtoV0001.PBControlPoint.AprioriSource aprioriRadiusSource = 10;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_aprioriradiussource() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_aprioriradiussource() {
  _has_bits_[0] |= 0x00000400u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_aprioriradiussource() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_aprioriradiussource() {
  aprioriradiussource_ = 0;
  clear_has_aprioriradiussource();
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource ControlNetFileProtoV0001_PBControlPoint::aprioriradiussource() const {
  return static_cast< ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource >(aprioriradiussource_);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioriradiussource(::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource value) {
  GOOGLE_DCHECK(::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource_IsValid(value));
  set_has_aprioriradiussource();
  aprioriradiussource_ = value;
}

// optional string aprioriRadiusSourceFile = 11;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_aprioriradiussourcefile() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_aprioriradiussourcefile() {
  _has_bits_[0] |= 0x00000800u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_aprioriradiussourcefile() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_aprioriradiussourcefile() {
  if (aprioriradiussourcefile_ != &::google::protobuf::internal::kEmptyString) {
    aprioriradiussourcefile_->clear();
  }
  clear_has_aprioriradiussourcefile();
}
inline const ::std::string& ControlNetFileProtoV0001_PBControlPoint::aprioriradiussourcefile() const {
  return *aprioriradiussourcefile_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioriradiussourcefile(const ::std::string& value) {
  set_has_aprioriradiussourcefile();
  if (aprioriradiussourcefile_ == &::google::protobuf::internal::kEmptyString) {
    aprioriradiussourcefile_ = new ::std::string;
  }
  aprioriradiussourcefile_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioriradiussourcefile(const char* value) {
  set_has_aprioriradiussourcefile();
  if (aprioriradiussourcefile_ == &::google::protobuf::internal::kEmptyString) {
    aprioriradiussourcefile_ = new ::std::string;
  }
  aprioriradiussourcefile_->assign(value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioriradiussourcefile(const char* value, size_t size) {
  set_has_aprioriradiussourcefile();
  if (aprioriradiussourcefile_ == &::google::protobuf::internal::kEmptyString) {
    aprioriradiussourcefile_ = new ::std::string;
  }
  aprioriradiussourcefile_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::mutable_aprioriradiussourcefile() {
  set_has_aprioriradiussourcefile();
  if (aprioriradiussourcefile_ == &::google::protobuf::internal::kEmptyString) {
    aprioriradiussourcefile_ = new ::std::string;
  }
  return aprioriradiussourcefile_;
}
inline ::std::string* ControlNetFileProtoV0001_PBControlPoint::release_aprioriradiussourcefile() {
  clear_has_aprioriradiussourcefile();
  if (aprioriradiussourcefile_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = aprioriradiussourcefile_;
    aprioriradiussourcefile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional bool latitudeConstrained = 22 [default = true];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_latitudeconstrained() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_latitudeconstrained() {
  _has_bits_[0] |= 0x00001000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_latitudeconstrained() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_latitudeconstrained() {
  latitudeconstrained_ = true;
  clear_has_latitudeconstrained();
}
inline bool ControlNetFileProtoV0001_PBControlPoint::latitudeconstrained() const {
  return latitudeconstrained_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_latitudeconstrained(bool value) {
  set_has_latitudeconstrained();
  latitudeconstrained_ = value;
}

// optional bool longitudeConstrained = 23 [default = true];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_longitudeconstrained() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_longitudeconstrained() {
  _has_bits_[0] |= 0x00002000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_longitudeconstrained() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_longitudeconstrained() {
  longitudeconstrained_ = true;
  clear_has_longitudeconstrained();
}
inline bool ControlNetFileProtoV0001_PBControlPoint::longitudeconstrained() const {
  return longitudeconstrained_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_longitudeconstrained(bool value) {
  set_has_longitudeconstrained();
  longitudeconstrained_ = value;
}

// optional bool radiusConstrained = 24 [default = true];
inline bool ControlNetFileProtoV0001_PBControlPoint::has_radiusconstrained() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_radiusconstrained() {
  _has_bits_[0] |= 0x00004000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_radiusconstrained() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_radiusconstrained() {
  radiusconstrained_ = true;
  clear_has_radiusconstrained();
}
inline bool ControlNetFileProtoV0001_PBControlPoint::radiusconstrained() const {
  return radiusconstrained_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_radiusconstrained(bool value) {
  set_has_radiusconstrained();
  radiusconstrained_ = value;
}

// optional double aprioriX = 12;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_apriorix() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_apriorix() {
  _has_bits_[0] |= 0x00008000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_apriorix() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_apriorix() {
  apriorix_ = 0;
  clear_has_apriorix();
}
inline double ControlNetFileProtoV0001_PBControlPoint::apriorix() const {
  return apriorix_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_apriorix(double value) {
  set_has_apriorix();
  apriorix_ = value;
}

// optional double aprioriY = 13;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_aprioriy() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_aprioriy() {
  _has_bits_[0] |= 0x00010000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_aprioriy() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_aprioriy() {
  aprioriy_ = 0;
  clear_has_aprioriy();
}
inline double ControlNetFileProtoV0001_PBControlPoint::aprioriy() const {
  return aprioriy_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioriy(double value) {
  set_has_aprioriy();
  aprioriy_ = value;
}

// optional double aprioriZ = 14;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_aprioriz() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_aprioriz() {
  _has_bits_[0] |= 0x00020000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_aprioriz() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_aprioriz() {
  aprioriz_ = 0;
  clear_has_aprioriz();
}
inline double ControlNetFileProtoV0001_PBControlPoint::aprioriz() const {
  return aprioriz_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioriz(double value) {
  set_has_aprioriz();
  aprioriz_ = value;
}

// repeated double aprioriCovar = 15 [packed = true];
inline int ControlNetFileProtoV0001_PBControlPoint::aprioricovar_size() const {
  return aprioricovar_.size();
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_aprioricovar() {
  aprioricovar_.Clear();
}
inline double ControlNetFileProtoV0001_PBControlPoint::aprioricovar(int index) const {
  return aprioricovar_.Get(index);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_aprioricovar(int index, double value) {
  aprioricovar_.Set(index, value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::add_aprioricovar(double value) {
  aprioricovar_.Add(value);
}
inline const ::google::protobuf::RepeatedField< double >&
ControlNetFileProtoV0001_PBControlPoint::aprioricovar() const {
  return aprioricovar_;
}
inline ::google::protobuf::RepeatedField< double >*
ControlNetFileProtoV0001_PBControlPoint::mutable_aprioricovar() {
  return &aprioricovar_;
}

// optional double adjustedX = 16;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_adjustedx() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_adjustedx() {
  _has_bits_[0] |= 0x00080000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_adjustedx() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_adjustedx() {
  adjustedx_ = 0;
  clear_has_adjustedx();
}
inline double ControlNetFileProtoV0001_PBControlPoint::adjustedx() const {
  return adjustedx_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_adjustedx(double value) {
  set_has_adjustedx();
  adjustedx_ = value;
}

// optional double adjustedY = 17;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_adjustedy() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_adjustedy() {
  _has_bits_[0] |= 0x00100000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_adjustedy() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_adjustedy() {
  adjustedy_ = 0;
  clear_has_adjustedy();
}
inline double ControlNetFileProtoV0001_PBControlPoint::adjustedy() const {
  return adjustedy_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_adjustedy(double value) {
  set_has_adjustedy();
  adjustedy_ = value;
}

// optional double adjustedZ = 18;
inline bool ControlNetFileProtoV0001_PBControlPoint::has_adjustedz() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_has_adjustedz() {
  _has_bits_[0] |= 0x00200000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_has_adjustedz() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_adjustedz() {
  adjustedz_ = 0;
  clear_has_adjustedz();
}
inline double ControlNetFileProtoV0001_PBControlPoint::adjustedz() const {
  return adjustedz_;
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_adjustedz(double value) {
  set_has_adjustedz();
  adjustedz_ = value;
}

// repeated double adjustedCovar = 19 [packed = true];
inline int ControlNetFileProtoV0001_PBControlPoint::adjustedcovar_size() const {
  return adjustedcovar_.size();
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_adjustedcovar() {
  adjustedcovar_.Clear();
}
inline double ControlNetFileProtoV0001_PBControlPoint::adjustedcovar(int index) const {
  return adjustedcovar_.Get(index);
}
inline void ControlNetFileProtoV0001_PBControlPoint::set_adjustedcovar(int index, double value) {
  adjustedcovar_.Set(index, value);
}
inline void ControlNetFileProtoV0001_PBControlPoint::add_adjustedcovar(double value) {
  adjustedcovar_.Add(value);
}
inline const ::google::protobuf::RepeatedField< double >&
ControlNetFileProtoV0001_PBControlPoint::adjustedcovar() const {
  return adjustedcovar_;
}
inline ::google::protobuf::RepeatedField< double >*
ControlNetFileProtoV0001_PBControlPoint::mutable_adjustedcovar() {
  return &adjustedcovar_;
}

// repeated .Isis.ControlNetFileProtoV0001.PBControlPoint.PBControlMeasure measures = 20;
inline int ControlNetFileProtoV0001_PBControlPoint::measures_size() const {
  return measures_.size();
}
inline void ControlNetFileProtoV0001_PBControlPoint::clear_measures() {
  measures_.Clear();
}
inline const ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure& ControlNetFileProtoV0001_PBControlPoint::measures(int index) const {
  return measures_.Get(index);
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* ControlNetFileProtoV0001_PBControlPoint::mutable_measures(int index) {
  return measures_.Mutable(index);
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure* ControlNetFileProtoV0001_PBControlPoint::add_measures() {
  return measures_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure >&
ControlNetFileProtoV0001_PBControlPoint::measures() const {
  return measures_;
}
inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure >*
ControlNetFileProtoV0001_PBControlPoint::mutable_measures() {
  return &measures_;
}

// -------------------------------------------------------------------

// ControlNetFileProtoV0001_PBNetCubes_PBCubeList

// optional string filename = 1;
inline bool ControlNetFileProtoV0001_PBNetCubes_PBCubeList::has_filename() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_has_filename() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_has_filename() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_filename() {
  if (filename_ != &::google::protobuf::internal::kEmptyString) {
    filename_->clear();
  }
  clear_has_filename();
}
inline const ::std::string& ControlNetFileProtoV0001_PBNetCubes_PBCubeList::filename() const {
  return *filename_;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_filename(const ::std::string& value) {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  filename_->assign(value);
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_filename(const char* value) {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  filename_->assign(value);
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_filename(const char* value, size_t size) {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  filename_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBNetCubes_PBCubeList::mutable_filename() {
  set_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    filename_ = new ::std::string;
  }
  return filename_;
}
inline ::std::string* ControlNetFileProtoV0001_PBNetCubes_PBCubeList::release_filename() {
  clear_has_filename();
  if (filename_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = filename_;
    filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string serialnumber = 2;
inline bool ControlNetFileProtoV0001_PBNetCubes_PBCubeList::has_serialnumber() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_has_serialnumber() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_has_serialnumber() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_serialnumber() {
  if (serialnumber_ != &::google::protobuf::internal::kEmptyString) {
    serialnumber_->clear();
  }
  clear_has_serialnumber();
}
inline const ::std::string& ControlNetFileProtoV0001_PBNetCubes_PBCubeList::serialnumber() const {
  return *serialnumber_;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_serialnumber(const ::std::string& value) {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  serialnumber_->assign(value);
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_serialnumber(const char* value) {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  serialnumber_->assign(value);
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_serialnumber(const char* value, size_t size) {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  serialnumber_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBNetCubes_PBCubeList::mutable_serialnumber() {
  set_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    serialnumber_ = new ::std::string;
  }
  return serialnumber_;
}
inline ::std::string* ControlNetFileProtoV0001_PBNetCubes_PBCubeList::release_serialnumber() {
  clear_has_serialnumber();
  if (serialnumber_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = serialnumber_;
    serialnumber_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional int32 lines = 3;
inline bool ControlNetFileProtoV0001_PBNetCubes_PBCubeList::has_lines() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_has_lines() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_has_lines() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_lines() {
  lines_ = 0;
  clear_has_lines();
}
inline ::google::protobuf::int32 ControlNetFileProtoV0001_PBNetCubes_PBCubeList::lines() const {
  return lines_;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_lines(::google::protobuf::int32 value) {
  set_has_lines();
  lines_ = value;
}

// optional int32 samples = 4;
inline bool ControlNetFileProtoV0001_PBNetCubes_PBCubeList::has_samples() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_has_samples() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_has_samples() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::clear_samples() {
  samples_ = 0;
  clear_has_samples();
}
inline ::google::protobuf::int32 ControlNetFileProtoV0001_PBNetCubes_PBCubeList::samples() const {
  return samples_;
}
inline void ControlNetFileProtoV0001_PBNetCubes_PBCubeList::set_samples(::google::protobuf::int32 value) {
  set_has_samples();
  samples_ = value;
}

// -------------------------------------------------------------------

// ControlNetFileProtoV0001_PBNetCubes

// optional string cubelistfile = 1;
inline bool ControlNetFileProtoV0001_PBNetCubes::has_cubelistfile() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001_PBNetCubes::set_has_cubelistfile() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001_PBNetCubes::clear_has_cubelistfile() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001_PBNetCubes::clear_cubelistfile() {
  if (cubelistfile_ != &::google::protobuf::internal::kEmptyString) {
    cubelistfile_->clear();
  }
  clear_has_cubelistfile();
}
inline const ::std::string& ControlNetFileProtoV0001_PBNetCubes::cubelistfile() const {
  return *cubelistfile_;
}
inline void ControlNetFileProtoV0001_PBNetCubes::set_cubelistfile(const ::std::string& value) {
  set_has_cubelistfile();
  if (cubelistfile_ == &::google::protobuf::internal::kEmptyString) {
    cubelistfile_ = new ::std::string;
  }
  cubelistfile_->assign(value);
}
inline void ControlNetFileProtoV0001_PBNetCubes::set_cubelistfile(const char* value) {
  set_has_cubelistfile();
  if (cubelistfile_ == &::google::protobuf::internal::kEmptyString) {
    cubelistfile_ = new ::std::string;
  }
  cubelistfile_->assign(value);
}
inline void ControlNetFileProtoV0001_PBNetCubes::set_cubelistfile(const char* value, size_t size) {
  set_has_cubelistfile();
  if (cubelistfile_ == &::google::protobuf::internal::kEmptyString) {
    cubelistfile_ = new ::std::string;
  }
  cubelistfile_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001_PBNetCubes::mutable_cubelistfile() {
  set_has_cubelistfile();
  if (cubelistfile_ == &::google::protobuf::internal::kEmptyString) {
    cubelistfile_ = new ::std::string;
  }
  return cubelistfile_;
}
inline ::std::string* ControlNetFileProtoV0001_PBNetCubes::release_cubelistfile() {
  clear_has_cubelistfile();
  if (cubelistfile_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = cubelistfile_;
    cubelistfile_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated .Isis.ControlNetFileProtoV0001.PBNetCubes.PBCubeList filelist = 2;
inline int ControlNetFileProtoV0001_PBNetCubes::filelist_size() const {
  return filelist_.size();
}
inline void ControlNetFileProtoV0001_PBNetCubes::clear_filelist() {
  filelist_.Clear();
}
inline const ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList& ControlNetFileProtoV0001_PBNetCubes::filelist(int index) const {
  return filelist_.Get(index);
}
inline ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList* ControlNetFileProtoV0001_PBNetCubes::mutable_filelist(int index) {
  return filelist_.Mutable(index);
}
inline ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList* ControlNetFileProtoV0001_PBNetCubes::add_filelist() {
  return filelist_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList >&
ControlNetFileProtoV0001_PBNetCubes::filelist() const {
  return filelist_;
}
inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBNetCubes_PBCubeList >*
ControlNetFileProtoV0001_PBNetCubes::mutable_filelist() {
  return &filelist_;
}

// -------------------------------------------------------------------

// ControlNetFileProtoV0001

// required .Isis.ControlNetFileProtoV0001.Pedigree pedigree = 1;
inline bool ControlNetFileProtoV0001::has_pedigree() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_pedigree() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetFileProtoV0001::clear_has_pedigree() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetFileProtoV0001::clear_pedigree() {
  if (pedigree_ != NULL) pedigree_->::Isis::ControlNetFileProtoV0001_Pedigree::Clear();
  clear_has_pedigree();
}
inline const ::Isis::ControlNetFileProtoV0001_Pedigree& ControlNetFileProtoV0001::pedigree() const {
  return pedigree_ != NULL ? *pedigree_ : *default_instance_->pedigree_;
}
inline ::Isis::ControlNetFileProtoV0001_Pedigree* ControlNetFileProtoV0001::mutable_pedigree() {
  set_has_pedigree();
  if (pedigree_ == NULL) pedigree_ = new ::Isis::ControlNetFileProtoV0001_Pedigree;
  return pedigree_;
}
inline ::Isis::ControlNetFileProtoV0001_Pedigree* ControlNetFileProtoV0001::release_pedigree() {
  clear_has_pedigree();
  ::Isis::ControlNetFileProtoV0001_Pedigree* temp = pedigree_;
  pedigree_ = NULL;
  return temp;
}

// optional string networkId = 2;
inline bool ControlNetFileProtoV0001::has_networkid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_networkid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetFileProtoV0001::clear_has_networkid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetFileProtoV0001::clear_networkid() {
  if (networkid_ != &::google::protobuf::internal::kEmptyString) {
    networkid_->clear();
  }
  clear_has_networkid();
}
inline const ::std::string& ControlNetFileProtoV0001::networkid() const {
  return *networkid_;
}
inline void ControlNetFileProtoV0001::set_networkid(const ::std::string& value) {
  set_has_networkid();
  if (networkid_ == &::google::protobuf::internal::kEmptyString) {
    networkid_ = new ::std::string;
  }
  networkid_->assign(value);
}
inline void ControlNetFileProtoV0001::set_networkid(const char* value) {
  set_has_networkid();
  if (networkid_ == &::google::protobuf::internal::kEmptyString) {
    networkid_ = new ::std::string;
  }
  networkid_->assign(value);
}
inline void ControlNetFileProtoV0001::set_networkid(const char* value, size_t size) {
  set_has_networkid();
  if (networkid_ == &::google::protobuf::internal::kEmptyString) {
    networkid_ = new ::std::string;
  }
  networkid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001::mutable_networkid() {
  set_has_networkid();
  if (networkid_ == &::google::protobuf::internal::kEmptyString) {
    networkid_ = new ::std::string;
  }
  return networkid_;
}
inline ::std::string* ControlNetFileProtoV0001::release_networkid() {
  clear_has_networkid();
  if (networkid_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = networkid_;
    networkid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string targetName = 3;
inline bool ControlNetFileProtoV0001::has_targetname() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_targetname() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ControlNetFileProtoV0001::clear_has_targetname() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ControlNetFileProtoV0001::clear_targetname() {
  if (targetname_ != &::google::protobuf::internal::kEmptyString) {
    targetname_->clear();
  }
  clear_has_targetname();
}
inline const ::std::string& ControlNetFileProtoV0001::targetname() const {
  return *targetname_;
}
inline void ControlNetFileProtoV0001::set_targetname(const ::std::string& value) {
  set_has_targetname();
  if (targetname_ == &::google::protobuf::internal::kEmptyString) {
    targetname_ = new ::std::string;
  }
  targetname_->assign(value);
}
inline void ControlNetFileProtoV0001::set_targetname(const char* value) {
  set_has_targetname();
  if (targetname_ == &::google::protobuf::internal::kEmptyString) {
    targetname_ = new ::std::string;
  }
  targetname_->assign(value);
}
inline void ControlNetFileProtoV0001::set_targetname(const char* value, size_t size) {
  set_has_targetname();
  if (targetname_ == &::google::protobuf::internal::kEmptyString) {
    targetname_ = new ::std::string;
  }
  targetname_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001::mutable_targetname() {
  set_has_targetname();
  if (targetname_ == &::google::protobuf::internal::kEmptyString) {
    targetname_ = new ::std::string;
  }
  return targetname_;
}
inline ::std::string* ControlNetFileProtoV0001::release_targetname() {
  clear_has_targetname();
  if (targetname_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = targetname_;
    targetname_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string created = 4;
inline bool ControlNetFileProtoV0001::has_created() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_created() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ControlNetFileProtoV0001::clear_has_created() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ControlNetFileProtoV0001::clear_created() {
  if (created_ != &::google::protobuf::internal::kEmptyString) {
    created_->clear();
  }
  clear_has_created();
}
inline const ::std::string& ControlNetFileProtoV0001::created() const {
  return *created_;
}
inline void ControlNetFileProtoV0001::set_created(const ::std::string& value) {
  set_has_created();
  if (created_ == &::google::protobuf::internal::kEmptyString) {
    created_ = new ::std::string;
  }
  created_->assign(value);
}
inline void ControlNetFileProtoV0001::set_created(const char* value) {
  set_has_created();
  if (created_ == &::google::protobuf::internal::kEmptyString) {
    created_ = new ::std::string;
  }
  created_->assign(value);
}
inline void ControlNetFileProtoV0001::set_created(const char* value, size_t size) {
  set_has_created();
  if (created_ == &::google::protobuf::internal::kEmptyString) {
    created_ = new ::std::string;
  }
  created_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001::mutable_created() {
  set_has_created();
  if (created_ == &::google::protobuf::internal::kEmptyString) {
    created_ = new ::std::string;
  }
  return created_;
}
inline ::std::string* ControlNetFileProtoV0001::release_created() {
  clear_has_created();
  if (created_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = created_;
    created_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string lastModified = 5;
inline bool ControlNetFileProtoV0001::has_lastmodified() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_lastmodified() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ControlNetFileProtoV0001::clear_has_lastmodified() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ControlNetFileProtoV0001::clear_lastmodified() {
  if (lastmodified_ != &::google::protobuf::internal::kEmptyString) {
    lastmodified_->clear();
  }
  clear_has_lastmodified();
}
inline const ::std::string& ControlNetFileProtoV0001::lastmodified() const {
  return *lastmodified_;
}
inline void ControlNetFileProtoV0001::set_lastmodified(const ::std::string& value) {
  set_has_lastmodified();
  if (lastmodified_ == &::google::protobuf::internal::kEmptyString) {
    lastmodified_ = new ::std::string;
  }
  lastmodified_->assign(value);
}
inline void ControlNetFileProtoV0001::set_lastmodified(const char* value) {
  set_has_lastmodified();
  if (lastmodified_ == &::google::protobuf::internal::kEmptyString) {
    lastmodified_ = new ::std::string;
  }
  lastmodified_->assign(value);
}
inline void ControlNetFileProtoV0001::set_lastmodified(const char* value, size_t size) {
  set_has_lastmodified();
  if (lastmodified_ == &::google::protobuf::internal::kEmptyString) {
    lastmodified_ = new ::std::string;
  }
  lastmodified_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001::mutable_lastmodified() {
  set_has_lastmodified();
  if (lastmodified_ == &::google::protobuf::internal::kEmptyString) {
    lastmodified_ = new ::std::string;
  }
  return lastmodified_;
}
inline ::std::string* ControlNetFileProtoV0001::release_lastmodified() {
  clear_has_lastmodified();
  if (lastmodified_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = lastmodified_;
    lastmodified_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string description = 6;
inline bool ControlNetFileProtoV0001::has_description() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_description() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ControlNetFileProtoV0001::clear_has_description() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ControlNetFileProtoV0001::clear_description() {
  if (description_ != &::google::protobuf::internal::kEmptyString) {
    description_->clear();
  }
  clear_has_description();
}
inline const ::std::string& ControlNetFileProtoV0001::description() const {
  return *description_;
}
inline void ControlNetFileProtoV0001::set_description(const ::std::string& value) {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  description_->assign(value);
}
inline void ControlNetFileProtoV0001::set_description(const char* value) {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  description_->assign(value);
}
inline void ControlNetFileProtoV0001::set_description(const char* value, size_t size) {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  description_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001::mutable_description() {
  set_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    description_ = new ::std::string;
  }
  return description_;
}
inline ::std::string* ControlNetFileProtoV0001::release_description() {
  clear_has_description();
  if (description_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = description_;
    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string userName = 7;
inline bool ControlNetFileProtoV0001::has_username() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_username() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ControlNetFileProtoV0001::clear_has_username() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ControlNetFileProtoV0001::clear_username() {
  if (username_ != &::google::protobuf::internal::kEmptyString) {
    username_->clear();
  }
  clear_has_username();
}
inline const ::std::string& ControlNetFileProtoV0001::username() const {
  return *username_;
}
inline void ControlNetFileProtoV0001::set_username(const ::std::string& value) {
  set_has_username();
  if (username_ == &::google::protobuf::internal::kEmptyString) {
    username_ = new ::std::string;
  }
  username_->assign(value);
}
inline void ControlNetFileProtoV0001::set_username(const char* value) {
  set_has_username();
  if (username_ == &::google::protobuf::internal::kEmptyString) {
    username_ = new ::std::string;
  }
  username_->assign(value);
}
inline void ControlNetFileProtoV0001::set_username(const char* value, size_t size) {
  set_has_username();
  if (username_ == &::google::protobuf::internal::kEmptyString) {
    username_ = new ::std::string;
  }
  username_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* ControlNetFileProtoV0001::mutable_username() {
  set_has_username();
  if (username_ == &::google::protobuf::internal::kEmptyString) {
    username_ = new ::std::string;
  }
  return username_;
}
inline ::std::string* ControlNetFileProtoV0001::release_username() {
  clear_has_username();
  if (username_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = username_;
    username_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// repeated .Isis.ControlNetFileProtoV0001.PBControlPoint points = 8;
inline int ControlNetFileProtoV0001::points_size() const {
  return points_.size();
}
inline void ControlNetFileProtoV0001::clear_points() {
  points_.Clear();
}
inline const ::Isis::ControlNetFileProtoV0001_PBControlPoint& ControlNetFileProtoV0001::points(int index) const {
  return points_.Get(index);
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint* ControlNetFileProtoV0001::mutable_points(int index) {
  return points_.Mutable(index);
}
inline ::Isis::ControlNetFileProtoV0001_PBControlPoint* ControlNetFileProtoV0001::add_points() {
  return points_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint >&
ControlNetFileProtoV0001::points() const {
  return points_;
}
inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetFileProtoV0001_PBControlPoint >*
ControlNetFileProtoV0001::mutable_points() {
  return &points_;
}

// optional .Isis.ControlNetFileProtoV0001.PBNetCubes netcubes = 9;
inline bool ControlNetFileProtoV0001::has_netcubes() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ControlNetFileProtoV0001::set_has_netcubes() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ControlNetFileProtoV0001::clear_has_netcubes() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ControlNetFileProtoV0001::clear_netcubes() {
  if (netcubes_ != NULL) netcubes_->::Isis::ControlNetFileProtoV0001_PBNetCubes::Clear();
  clear_has_netcubes();
}
inline const ::Isis::ControlNetFileProtoV0001_PBNetCubes& ControlNetFileProtoV0001::netcubes() const {
  return netcubes_ != NULL ? *netcubes_ : *default_instance_->netcubes_;
}
inline ::Isis::ControlNetFileProtoV0001_PBNetCubes* ControlNetFileProtoV0001::mutable_netcubes() {
  set_has_netcubes();
  if (netcubes_ == NULL) netcubes_ = new ::Isis::ControlNetFileProtoV0001_PBNetCubes;
  return netcubes_;
}
inline ::Isis::ControlNetFileProtoV0001_PBNetCubes* ControlNetFileProtoV0001::release_netcubes() {
  clear_has_netcubes();
  ::Isis::ControlNetFileProtoV0001_PBNetCubes* temp = netcubes_;
  netcubes_ = NULL;
  return temp;
}

// -------------------------------------------------------------------

// ControlNetLogDataProtoV0001_Point_Measure_DataEntry

// required int32 dataType = 2;
inline bool ControlNetLogDataProtoV0001_Point_Measure_DataEntry::has_datatype() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::set_has_datatype() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::clear_has_datatype() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::clear_datatype() {
  datatype_ = 0;
  clear_has_datatype();
}
inline ::google::protobuf::int32 ControlNetLogDataProtoV0001_Point_Measure_DataEntry::datatype() const {
  return datatype_;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::set_datatype(::google::protobuf::int32 value) {
  set_has_datatype();
  datatype_ = value;
}

// required double dataValue = 3;
inline bool ControlNetLogDataProtoV0001_Point_Measure_DataEntry::has_datavalue() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::set_has_datavalue() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::clear_has_datavalue() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::clear_datavalue() {
  datavalue_ = 0;
  clear_has_datavalue();
}
inline double ControlNetLogDataProtoV0001_Point_Measure_DataEntry::datavalue() const {
  return datavalue_;
}
inline void ControlNetLogDataProtoV0001_Point_Measure_DataEntry::set_datavalue(double value) {
  set_has_datavalue();
  datavalue_ = value;
}

// -------------------------------------------------------------------

// ControlNetLogDataProtoV0001_Point_Measure

// repeated .Isis.ControlNetLogDataProtoV0001.Point.Measure.DataEntry loggedMeasureData = 2;
inline int ControlNetLogDataProtoV0001_Point_Measure::loggedmeasuredata_size() const {
  return loggedmeasuredata_.size();
}
inline void ControlNetLogDataProtoV0001_Point_Measure::clear_loggedmeasuredata() {
  loggedmeasuredata_.Clear();
}
inline const ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry& ControlNetLogDataProtoV0001_Point_Measure::loggedmeasuredata(int index) const {
  return loggedmeasuredata_.Get(index);
}
inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry* ControlNetLogDataProtoV0001_Point_Measure::mutable_loggedmeasuredata(int index) {
  return loggedmeasuredata_.Mutable(index);
}
inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry* ControlNetLogDataProtoV0001_Point_Measure::add_loggedmeasuredata() {
  return loggedmeasuredata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry >&
ControlNetLogDataProtoV0001_Point_Measure::loggedmeasuredata() const {
  return loggedmeasuredata_;
}
inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure_DataEntry >*
ControlNetLogDataProtoV0001_Point_Measure::mutable_loggedmeasuredata() {
  return &loggedmeasuredata_;
}

// -------------------------------------------------------------------

// ControlNetLogDataProtoV0001_Point

// repeated .Isis.ControlNetLogDataProtoV0001.Point.Measure measures = 2;
inline int ControlNetLogDataProtoV0001_Point::measures_size() const {
  return measures_.size();
}
inline void ControlNetLogDataProtoV0001_Point::clear_measures() {
  measures_.Clear();
}
inline const ::Isis::ControlNetLogDataProtoV0001_Point_Measure& ControlNetLogDataProtoV0001_Point::measures(int index) const {
  return measures_.Get(index);
}
inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure* ControlNetLogDataProtoV0001_Point::mutable_measures(int index) {
  return measures_.Mutable(index);
}
inline ::Isis::ControlNetLogDataProtoV0001_Point_Measure* ControlNetLogDataProtoV0001_Point::add_measures() {
  return measures_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure >&
ControlNetLogDataProtoV0001_Point::measures() const {
  return measures_;
}
inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point_Measure >*
ControlNetLogDataProtoV0001_Point::mutable_measures() {
  return &measures_;
}

// -------------------------------------------------------------------

// ControlNetLogDataProtoV0001

// repeated .Isis.ControlNetLogDataProtoV0001.Point points = 1;
inline int ControlNetLogDataProtoV0001::points_size() const {
  return points_.size();
}
inline void ControlNetLogDataProtoV0001::clear_points() {
  points_.Clear();
}
inline const ::Isis::ControlNetLogDataProtoV0001_Point& ControlNetLogDataProtoV0001::points(int index) const {
  return points_.Get(index);
}
inline ::Isis::ControlNetLogDataProtoV0001_Point* ControlNetLogDataProtoV0001::mutable_points(int index) {
  return points_.Mutable(index);
}
inline ::Isis::ControlNetLogDataProtoV0001_Point* ControlNetLogDataProtoV0001::add_points() {
  return points_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point >&
ControlNetLogDataProtoV0001::points() const {
  return points_;
}
inline ::google::protobuf::RepeatedPtrField< ::Isis::ControlNetLogDataProtoV0001_Point >*
ControlNetLogDataProtoV0001::mutable_points() {
  return &points_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace Isis

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType>() {
  return ::Isis::ControlNetFileProtoV0001_PBControlPoint_PBControlMeasure_MeasureType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType>() {
  return ::Isis::ControlNetFileProtoV0001_PBControlPoint_PointType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource>() {
  return ::Isis::ControlNetFileProtoV0001_PBControlPoint_AprioriSource_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_ControlNetFileV0001_2eproto__INCLUDED