XdmValue.h

 
// Copyright (c) 2022 - 2025 Saxonica Limited.
// This Source Code Form is subject to the terms of the Mozilla Public License,
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
// obtain one at http://mozilla.org/MPL/2.0/. This Source Code Form is
// "Incompatible With Secondary Licenses", as defined by the Mozilla Public
// License, v. 2.0.
 
#ifndef SAXON_XDMVALUE_H
#define SAXON_XDMVALUE_H
 
#include "saxonc_export.h"
#include "saxonc/SaxonCGlue.h"
#include "saxonc/SaxonCXPath.h"
#include "saxonc/SaxonProcessor.h"
#include <deque>
#include <list>
#include <string.h>
#include <typeinfo> //used for testing only
#include <vector>
 
class SaxonProcessor;
class XdmItem;
class XdmAtomicValue;
class XdmNode;
 
typedef enum saxonTypeEnum {
  enumNode,
  enumString,
  enumInteger,
  enumDouble,
  enumFloat,
  enumBool,
  enumArrXdmValue
} PRIMITIVE_TYPE;
 
class SAXONC_EXPORT XdmValue {
 
public:
  XdmValue() { initialize(); }
 
  XdmValue(const XdmValue &other);
 
  void addXdmItem(XdmItem *val);
 
 virtual bool operator==(const XdmValue& other) const
 {
  std::cerr<<"C++ XdmValue equals operator called !!!!"<<std::endl;
  return false;
  /*char result = j_xdmNodeEquals(SaxonProcessor::sxn_environ->thread, (void *)value, (void *)other.value);
  if((int)result == SXN_EXCEPTION) {
   throw SaxonApiException();
  }
  return result != 0;*/
 }
 
  void addXdmItemFromUnderlyingValue(XdmItem *val);
 
  void addUnderlyingValue(int64_t val);
 
  XdmValue(int64_t val, bool arrFlag);
 
  XdmValue(int64_t val);
 
  virtual ~XdmValue();
 
  void releaseXdmValue();
 
  virtual XdmItem *getHead();
 
  virtual XdmItem *itemAt(int n);
 
  virtual int size();
 
  virtual const char *toString(const char *encoding = nullptr);
 
  int getRefCount() {
    if (getenv("SAXONC_DEBUG_FLAG")) {
      std::cerr << "getRefCount-xdmVal=" << refCount << " ob ref=" << (this)
                << std::endl;
    }
    return refCount;
  }
 
  virtual void incrementRefCount();
 
  virtual void decrementRefCount();
 
  virtual int64_t getUnderlyingValue();
 
  virtual XDM_TYPE getType();
 
  void resetRelinquishedItems();
 
  void incrementRefCountForRelinquishedValue(int i);
 
protected:
  inline void initialize() {
    jValues = SXN_UNSET;
    refCount = 0;
    valueType = nullptr;
    xdmSize = 0;
    toStringValue = nullptr;
    values_cap = 0;
    values = nullptr;
    relinquished_values = nullptr;
    // relinquished_values[0] = 0;
  }
 
  char *valueType; 
  XdmItem **values; 
  char *relinquished_values; 
  int values_cap; 
  int xdmSize;  
  int refCount; 
  int64_t value;            
private:
  char *toStringValue; 
  int64_t jValues;     
  int addXdmItemToValue(XdmItem *val);
};
 
#endif