PHP ReflectionObject::getConstant方法代码示例

 /**
  * Retrieves the value of a class constant, while avoiding the `T_PAAMAYIM_NEKUDOTAYIM` error. Misspelled because `const` is a reserved word.
  *
  * @param object $class (Required) An instance of the class containing the constant.
  * @param string $const (Required) The name of the constant to retrieve.
  * @return mixed The value of the class constant.
  */
 public function konst($class, $const)
 {
     if (is_string($class)) {
         $ref = new ReflectionClass($class);
     } else {
         $ref = new ReflectionObject($class);
     }
     return $ref->getConstant($const);
 }

 /**
  * Save PHPExcel to file
  *
  * @param     string         $pFilename
  * @throws     \PHPExcel\Writer\Exception
  */
 public function save($pFilename = null)
 {
     if ($this->spreadSheet !== null) {
         // garbage collect
         $this->spreadSheet->garbageCollect();
         // If $pFilename is php://output or php://stdout, make it a temporary file...
         $originalFilename = $pFilename;
         if (strtolower($pFilename) == 'php://output' || strtolower($pFilename) == 'php://stdout') {
             $pFilename = @tempnam(\PHPExcel\Shared\File::sysGetTempDir(), 'phpxltmp');
             if ($pFilename == '') {
                 $pFilename = $originalFilename;
             }
         }
         $saveDebugLog = \PHPExcel\Calculation::getInstance($this->spreadSheet)->getDebugLog()->getWriteDebugLog();
         \PHPExcel\Calculation::getInstance($this->spreadSheet)->getDebugLog()->setWriteDebugLog(false);
         $saveDateReturnType = \PHPExcel\Calculation\Functions::getReturnDateType();
         \PHPExcel\Calculation\Functions::setReturnDateType(\PHPExcel\Calculation\Functions::RETURNDATE_EXCEL);
         // Create string lookup table
         $this->stringTable = array();
         for ($i = 0; $i < $this->spreadSheet->getSheetCount(); ++$i) {
             $this->stringTable = $this->getWriterPart('StringTable')->createStringTable($this->spreadSheet->getSheet($i), $this->stringTable);
         }
         // Create styles dictionaries
         $this->styleHashTable->addFromSource($this->getWriterPart('Style')->allStyles($this->spreadSheet));
         $this->stylesConditionalHashTable->addFromSource($this->getWriterPart('Style')->allConditionalStyles($this->spreadSheet));
         $this->fillHashTable->addFromSource($this->getWriterPart('Style')->allFills($this->spreadSheet));
         $this->fontHashTable->addFromSource($this->getWriterPart('Style')->allFonts($this->spreadSheet));
         $this->bordersHashTable->addFromSource($this->getWriterPart('Style')->allBorders($this->spreadSheet));
         $this->numFmtHashTable->addFromSource($this->getWriterPart('Style')->allNumberFormats($this->spreadSheet));
         // Create drawing dictionary
         $this->drawingHashTable->addFromSource($this->getWriterPart('Drawing')->allDrawings($this->spreadSheet));
         // Create new ZIP file and open it for writing
         $zipClass = \PHPExcel\Settings::getZipClass();
         /** @var \ZipArchive $objZip */
         $objZip = new $zipClass();
         //    Retrieve OVERWRITE and CREATE constants from the instantiated zip class
         //    This method of accessing constant values from a dynamic class should work with all appropriate versions of PHP
         $ro = new \ReflectionObject($objZip);
         $zipOverWrite = $ro->getConstant('OVERWRITE');
         $zipCreate = $ro->getConstant('CREATE');
         if (file_exists($pFilename)) {
             unlink($pFilename);
         }
         // Try opening the ZIP file
         if ($objZip->open($pFilename, $zipOverWrite) !== true) {
             if ($objZip->open($pFilename, $zipCreate) !== true) {
                 throw new \PHPExcel\Writer\Exception("Could not open " . $pFilename . " for writing.");
             }
         }
         // Add [Content_Types].xml to ZIP file
         $objZip->addFromString('[Content_Types].xml', $this->getWriterPart('ContentTypes')->writeContentTypes($this->spreadSheet, $this->includeCharts));
         //if hasMacros, add the vbaProject.bin file, Certificate file(if exists)
         if ($this->spreadSheet->hasMacros()) {
             $macrosCode = $this->spreadSheet->getMacrosCode();
             if (!is_null($macrosCode)) {
                 // we have the code ?
                 $objZip->addFromString('xl/vbaProject.bin', $macrosCode);
                 //allways in 'xl', allways named vbaProject.bin
                 if ($this->spreadSheet->hasMacrosCertificate()) {
                     //signed macros ?
                     // Yes : add the certificate file and the related rels file
                     $objZip->addFromString('xl/vbaProjectSignature.bin', $this->spreadSheet->getMacrosCertificate());
                     $objZip->addFromString('xl/_rels/vbaProject.bin.rels', $this->getWriterPart('RelsVBA')->writeVBARelationships($this->spreadSheet));
                 }
             }
         }
         //a custom UI in this workbook ? add it ("base" xml and additional objects (pictures) and rels)
         if ($this->spreadSheet->hasRibbon()) {
             $tmpRibbonTarget = $this->spreadSheet->getRibbonXMLData('target');
             $objZip->addFromString($tmpRibbonTarget, $this->spreadSheet->getRibbonXMLData('data'));
             if ($this->spreadSheet->hasRibbonBinObjects()) {
                 $tmpRootPath = dirname($tmpRibbonTarget) . '/';
                 $ribbonBinObjects = $this->spreadSheet->getRibbonBinObjects('data');
                 //the files to write
                 foreach ($ribbonBinObjects as $aPath => $aContent) {
                     $objZip->addFromString($tmpRootPath . $aPath, $aContent);
                 }
                 //the rels for files
                 $objZip->addFromString($tmpRootPath . '_rels/' . basename($tmpRibbonTarget) . '.rels', $this->getWriterPart('RelsRibbonObjects')->writeRibbonRelationships($this->spreadSheet));
             }
         }
         // Add relationships to ZIP file
         $objZip->addFromString('_rels/.rels', $this->getWriterPart('Rels')->writeRelationships($this->spreadSheet));
         $objZip->addFromString('xl/_rels/workbook.xml.rels', $this->getWriterPart('Rels')->writeWorkbookRelationships($this->spreadSheet));
         // Add document properties to ZIP file
         $objZip->addFromString('docProps/app.xml', $this->getWriterPart('DocProps')->writeDocPropsApp($this->spreadSheet));
         $objZip->addFromString('docProps/core.xml', $this->getWriterPart('DocProps')->writeDocPropsCore($this->spreadSheet));
         $customPropertiesPart = $this->getWriterPart('DocProps')->writeDocPropsCustom($this->spreadSheet);
         if ($customPropertiesPart !== null) {
             $objZip->addFromString('docProps/custom.xml', $customPropertiesPart);
         }
         // Add theme to ZIP file
         $objZip->addFromString('xl/theme/theme1.xml', $this->getWriterPart('Theme')->writeTheme($this->spreadSheet));
         // Add string table to ZIP file
//.........这里部分代码省略.........

 /**
  * Save PHPExcel to file
  *
  * @param 	string 		$pFilename
  * @throws 	PHPExcel_Writer_Exception
  */
 public function save($pFilename = null)
 {
     if ($this->_spreadSheet !== NULL) {
         // garbage collect
         $this->_spreadSheet->garbageCollect();
         // If $pFilename is php://output or php://stdout, make it a temporary file...
         $originalFilename = $pFilename;
         if (strtolower($pFilename) == 'php://output' || strtolower($pFilename) == 'php://stdout') {
             $pFilename = @tempnam(PHPExcel_Shared_File::sys_get_temp_dir(), 'phpxltmp');
             if ($pFilename == '') {
                 $pFilename = $originalFilename;
             }
         }
         $saveDebugLog = PHPExcel_Calculation::getInstance($this->_spreadSheet)->getDebugLog()->getWriteDebugLog();
         PHPExcel_Calculation::getInstance($this->_spreadSheet)->getDebugLog()->setWriteDebugLog(FALSE);
         $saveDateReturnType = PHPExcel_Calculation_Functions::getReturnDateType();
         PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
         // Create string lookup table
         $this->_stringTable = array();
         for ($i = 0; $i < $this->_spreadSheet->getSheetCount(); ++$i) {
             $this->_stringTable = $this->getWriterPart('StringTable')->createStringTable($this->_spreadSheet->getSheet($i), $this->_stringTable);
         }
         // Create styles dictionaries
         $this->_stylesConditionalHashTable->addFromSource($this->getWriterPart('Style')->allConditionalStyles($this->_spreadSheet));
         $this->_fillHashTable->addFromSource($this->getWriterPart('Style')->allFills($this->_spreadSheet));
         $this->_fontHashTable->addFromSource($this->getWriterPart('Style')->allFonts($this->_spreadSheet));
         $this->_bordersHashTable->addFromSource($this->getWriterPart('Style')->allBorders($this->_spreadSheet));
         $this->_numFmtHashTable->addFromSource($this->getWriterPart('Style')->allNumberFormats($this->_spreadSheet));
         // Create drawing dictionary
         $this->_drawingHashTable->addFromSource($this->getWriterPart('Drawing')->allDrawings($this->_spreadSheet));
         // Create new ZIP file and open it for writing
         $zipClass = PHPExcel_Settings::getZipClass();
         $objZip = new $zipClass();
         //	Retrieve OVERWRITE and CREATE constants from the instantiated zip class
         //	This method of accessing constant values from a dynamic class should work with all appropriate versions of PHP
         $ro = new ReflectionObject($objZip);
         $zipOverWrite = $ro->getConstant('OVERWRITE');
         $zipCreate = $ro->getConstant('CREATE');
         if (file_exists($pFilename)) {
             unlink($pFilename);
         }
         // Try opening the ZIP file
         if ($objZip->open($pFilename, $zipOverWrite) !== true) {
             if ($objZip->open($pFilename, $zipCreate) !== true) {
                 throw new PHPExcel_Writer_Exception("Could not open " . $pFilename . " for writing.");
             }
         }
         // Add [Content_Types].xml to ZIP file
         $objZip->addFromString('[Content_Types].xml', $this->getWriterPart('ContentTypes')->writeContentTypes($this->_spreadSheet, $this->_includeCharts));
         // Add relationships to ZIP file
         $objZip->addFromString('_rels/.rels', $this->getWriterPart('Rels')->writeRelationships($this->_spreadSheet));
         $objZip->addFromString('xl/_rels/workbook.xml.rels', $this->getWriterPart('Rels')->writeWorkbookRelationships($this->_spreadSheet));
         // Add document properties to ZIP file
         $objZip->addFromString('docProps/app.xml', $this->getWriterPart('DocProps')->writeDocPropsApp($this->_spreadSheet));
         $objZip->addFromString('docProps/core.xml', $this->getWriterPart('DocProps')->writeDocPropsCore($this->_spreadSheet));
         $customPropertiesPart = $this->getWriterPart('DocProps')->writeDocPropsCustom($this->_spreadSheet);
         if ($customPropertiesPart !== NULL) {
             $objZip->addFromString('docProps/custom.xml', $customPropertiesPart);
         }
         // Add theme to ZIP file
         $objZip->addFromString('xl/theme/theme1.xml', $this->getWriterPart('Theme')->writeTheme($this->_spreadSheet));
         // Add string table to ZIP file
         $objZip->addFromString('xl/sharedStrings.xml', $this->getWriterPart('StringTable')->writeStringTable($this->_stringTable));
         // Add styles to ZIP file
         $objZip->addFromString('xl/styles.xml', $this->getWriterPart('Style')->writeStyles($this->_spreadSheet));
         // Add workbook to ZIP file
         $objZip->addFromString('xl/workbook.xml', $this->getWriterPart('Workbook')->writeWorkbook($this->_spreadSheet, $this->_preCalculateFormulas));
         $chartCount = 0;
         // Add worksheets
         for ($i = 0; $i < $this->_spreadSheet->getSheetCount(); ++$i) {
             $objZip->addFromString('xl/worksheets/sheet' . ($i + 1) . '.xml', $this->getWriterPart('Worksheet')->writeWorksheet($this->_spreadSheet->getSheet($i), $this->_stringTable, $this->_includeCharts));
             if ($this->_includeCharts) {
                 $charts = $this->_spreadSheet->getSheet($i)->getChartCollection();
                 if (count($charts) > 0) {
                     foreach ($charts as $chart) {
                         $objZip->addFromString('xl/charts/chart' . ($chartCount + 1) . '.xml', $this->getWriterPart('Chart')->writeChart($chart));
                         $chartCount++;
                     }
                 }
             }
         }
         $chartRef1 = $chartRef2 = 0;
         // Add worksheet relationships (drawings, ...)
         for ($i = 0; $i < $this->_spreadSheet->getSheetCount(); ++$i) {
             // Add relationships
             $objZip->addFromString('xl/worksheets/_rels/sheet' . ($i + 1) . '.xml.rels', $this->getWriterPart('Rels')->writeWorksheetRelationships($this->_spreadSheet->getSheet($i), $i + 1, $this->_includeCharts));
             $drawings = $this->_spreadSheet->getSheet($i)->getDrawingCollection();
             $drawingCount = count($drawings);
             if ($this->_includeCharts) {
                 $chartCount = $this->_spreadSheet->getSheet($i)->getChartCount();
             }
             // Add drawing and image relationship parts
             if ($drawingCount > 0 || $chartCount > 0) {
                 // Drawing relationships
//.........这里部分代码省略.........

 public function getConstant($name)
 {
     $thisClassRefl = new ReflectionObject($this);
     return $thisClassRefl->getConstant($name);
 }

 /**
  * Create zip object
  *
  * @param string $pFilename            
  * @throws PHPExcel_Writer_Exception
  * @return ZipArchive
  */
 private function _createZip($pFilename)
 {
     // Create new ZIP file and open it for writing
     $zipClass = PHPExcel_Settings::getZipClass();
     $objZip = new $zipClass();
     
     // Retrieve OVERWRITE and CREATE constants from the instantiated zip class
     // This method of accessing constant values from a dynamic class should work with all appropriate versions of PHP
     $ro = new ReflectionObject($objZip);
     $zipOverWrite = $ro->getConstant('OVERWRITE');
     $zipCreate = $ro->getConstant('CREATE');
     
     if (file_exists($pFilename)) {
         unlink($pFilename);
     }
     // Try opening the ZIP file
     if ($objZip->open($pFilename, $zipOverWrite) !== true) {
         if ($objZip->open($pFilename, $zipCreate) !== true) {
             throw new PHPExcel_Writer_Exception("Could not open $pFilename for writing.");
         }
     }
     
     return $objZip;
 }

<?php

class C
{
    const a = 'hello from C';
}
class D extends C
{
}
class E extends D
{
}
class F extends E
{
    const a = 'hello from F';
}
class X
{
}
$classes = array("C", "D", "E", "F", "X");
foreach ($classes as $class) {
    echo "Reflecting on instance of class {$class}: \n";
    $rc = new ReflectionObject(new $class());
    var_dump($rc->getConstant('a'));
    var_dump($rc->getConstant('doesntexist'));
}

 /**
  * Get ZipArchive object
  *
  * @param string $filename
  * @return mixed ZipArchive object
  */
 protected function getZipArchive($filename)
 {
     // Create new ZIP file and open it for writing
     $zipClass = Settings::getZipClass();
     $objZip = new $zipClass();
     // Retrieve OVERWRITE and CREATE constants from the instantiated zip class
     // This method of accessing constant values from a dynamic class should work with all appropriate versions of PHP
     $reflection = new \ReflectionObject($objZip);
     $zipOverWrite = $reflection->getConstant('OVERWRITE');
     $zipCreate = $reflection->getConstant('CREATE');
     // Remove any existing file
     if (file_exists($filename)) {
         unlink($filename);
     }
     // Try opening the ZIP file
     if ($objZip->open($filename, $zipOverWrite) !== true) {
         if ($objZip->open($filename, $zipCreate) !== true) {
             throw new Exception("Could not open " . $filename . " for writing.");
         }
     }
     return $objZip;
 }

 public function prepModifyStatusEricsson($data, $orgId)
 {
     $proto = $this->_createProto(self::METHOD_NAME_PREPMODIFYSTATUS);
     $org = $this->_createOrganization($orgId);
     $proto->setOrganization($org);
     $subscriptions = new \Application\Proto\SubscriptionSelect();
     switch ($data['selection_type']) {
         case 'HANDLER':
             $subscriptions->selection_type = \Application\Proto\SubscriptionSelect\SelType::HANDLER;
             break;
         case 'LIST':
         default:
             $subscriptions->selection_type = \Application\Proto\SubscriptionSelect\SelType::SUBSCRIPTION_LIST;
     }
     switch ($data['selection_type']) {
         case 'HANDLER':
             $subscriptions->handler = array();
             foreach ($list['handlers'] as $handler) {
                 $subscriptions->handler[] = $handler;
             }
             break;
         case 'LIST':
         default:
             $subscriptions->list = array();
             $idType = new \Application\Proto\SubscriptionId\IdType();
             $refIdType = new \ReflectionObject($idType);
             foreach ($data['list'] as $item) {
                 $subscriptionId = new \Application\Proto\SubscriptionId();
                 $subscriptionId->type = $refIdType->getConstant($item['type']);
                 $subscriptionId->id = $item['id'];
                 $subscriptions->list[] = $subscriptionId;
             }
     }
     $proto->subscriptions = $subscriptions;
     $proto->new_state = $this->mapLifeCycleStatusToEricsson($data['new_state']);
     return $this->_sendAsyncRequest(self::METHOD_NAME_PREPMODIFYSTATUS, $proto, array($orgId));
 }

 public function getConstant($name)
 {
     $reflection = new ReflectionObject($this);
     return $reflection->getConstant($name);
 }

 public function init($myRole, $drivers)
 {
     //parent::init($myRole, $drivers);
     $this->_out->logNotice(">>>init " . get_class($this) . " driver as {$myRole}");
     // Amazon library SSL Connection Issues
     if (!defined('AWS_CERTIFICATE_AUTHORITY')) {
         define('AWS_CERTIFICATE_AUTHORITY', $this->_options['certificate_authority']);
     } else {
         $this->_out->logNotice("option 'certificate_authority' was already set, it can't be changed");
     }
     // receive information about the RDS instance
     $rds = new AmazonRDS(array('key' => $this->_options['key']['access'], 'secret' => $this->_options['key']['secret']));
     if ($this->_options['region']) {
         $r = new ReflectionObject($rds);
         $rds->set_region($r->getConstant($this->_options['region']));
     }
     if ($this->_options['dbinstance']) {
         $response = $rds->describe_db_instances(array('DBInstanceIdentifier' => $this->_options['dbinstance']));
         if (!$response->isOK()) {
             throw new Core_StopException("Not possible to get information about RDS instance '" . $this->_options['dbinstance'] . "'.", "MysqlAmazonRdsInit");
         }
         $instance = $response->body->DescribeDBInstancesResult->DBInstances[0]->DBInstance;
     } else {
         throw new Core_StopException("You have to provide parameter 'dbinstance', finding server based on server name/IP is not supported at this moment.", "MysqlAmazonRdsInit");
         $response = $rds->describe_db_instances();
         if (!$response->isOK()) {
             throw new Core_StopException("Not possible to get information about RDS instances.", "MysqlAmazonRdsInit");
         }
         // find instance name with mysql server configured in mysql storage
         foreach ($response->body->DescribeDBInstancesResult->DBInstances->children() as $instance) {
             if ($instance->Endpoint->Address == "") {
                 die;
             }
         }
     }
     //DBInstanceStatus
     $backupRetentionPeriod = $this->_fixGet($instance, 'BackupRetentionPeriod') * 1;
     if (!$backupRetentionPeriod > 0) {
         throw new Core_StopException("You need to set BackupRetentionPeriod>0 on RDS instance. Otherwise use the MySql and not the MysqlAmazonRds storage class.", "MysqlAmazonRdsInit");
     }
     $engine = $this->_fixGet($instance, 'Engine');
     if ($engine !== "mysql") {
         throw new Core_StopException("RDS instances has to use MySql, the current engine is '{$engine}'.", "MysqlAmazonRdsInit");
     }
     if ($this->_options['tempname']) {
         $tempName = $this->_options['tempname'];
     } else {
         $tempName = $this->_fixGet($instance, 'DBInstanceIdentifier') . "-BAK";
     }
     $response = $rds->describe_db_instances(array('DBInstanceIdentifier' => $tempName));
     $bakExists = $response->isOK();
     if ($bakExists && $this->_options['ifexists'] == 'exit') {
         throw new Core_StopException("There is already RDS instance named '{$tempName}', this name should be used for temporary DB instance.", "MysqlAmazonRdsInit");
     }
     if (!$bakExists) {
         // create temporary DB instance
         $opt = array('UseLatestRestorableTime' => true, 'AvailabilityZone' => $this->_fixGet($instance, 'AvailabilityZone'));
         if (false !== $this->_options['dbinstanceclass']) {
             $opt['DBInstanceClass'] = $this->_options['dbinstanceclass'];
         }
         $rds->restore_db_instance_to_point_in_time($this->_options['dbinstance'], $tempName, $opt);
         $dbInstanceName = $this->_options['dbinstance'];
         $this->_out->logNotice("point in time restore of '{$dbInstanceName}' started and '{$tempName}' will be created");
     }
     // wait for readiness
     $job = $this->_out->jobStart("waiting for temporary RDS instance '{$tempName}' to become 'available'");
     do {
         $response = $rds->describe_db_instances(array('DBInstanceIdentifier' => $tempName));
         $tmpInstance = $response->body->DescribeDBInstancesResult->DBInstances[0]->DBInstance;
         $status = $this->_fixGet($tmpInstance, 'DBInstanceStatus');
         // TODO reverse this check, this way may loop forever if unpredicted status is returned
         if (in_array($status, array('available'))) {
             break;
         }
         if (in_array($status, array('failed', 'storage-full', 'incompatible-parameters', 'incompatible-restore'))) {
             throw new Core_StopException("RDS backup instance '{$tempName}' has stalled in status '{$status}'. Please fix the situation and restart backup.", "MysqlAmazonRdsInit");
         }
         sleep(3);
     } while (true);
     $this->_out->jobEnd($job, "ready");
     // configure and execute mysql backup
     $this->_mysql->setHost($this->_fixGet($tmpInstance->Endpoint, 'Address'), $this->_fixGet($tmpInstance->Endpoint, 'Port'));
     $drivers['local'] = $this->_mysql;
     $this->_mysql->init($myRole, $drivers);
     if ($this->_options['droptemp']) {
         // drop temporary instance
         $job = $this->_out->jobStart("droping temporary RDS instance '{$tempName}'");
         $response = $rds->delete_db_instance($tempName, array('SkipFinalSnapshot' => true));
         if (!$response->isOK()) {
             $this->_out->jobEnd($job, "failed");
         } else {
             $this->_out->jobEnd($job, "started, not waiting for finish");
         }
     }
 }

 /**
  * @test
  */
 public function getVersion()
 {
     $refer = new \ReflectionObject($this->_version);
     $this->assertEquals($refer->getConstant('SIAL_VERSION'), $this->_version->get());
 }

 /**
  * is the nonce valid
  * @param  $source array
  * @param  $record object
  * @return boolean
  */
 public static function isNonceValid($source, $record)
 {
     $reflection = new \ReflectionObject($record);
     // Verify the WP nonce for CSRF protection
     $nonce = array_key_exists($reflection->getConstant('KEY_NONCE'), $source) ? $source[$reflection->getConstant('KEY_NONCE')] : null;
     if (!$record->verifyNonce($nonce)) {
         return false;
     }
     return true;
 }

<?php

class C
{
    const myConst = 1;
}
$rc = new ReflectionObject(new C());
var_dump($rc->getConstant());
var_dump($rc->getConstant("myConst", "myConst"));
var_dump($rc->getConstant(null));
var_dump($rc->getConstant(1));
var_dump($rc->getConstant(1.5));
var_dump($rc->getConstant(true));
var_dump($rc->getConstant(array(1, 2, 3)));
var_dump($rc->getConstant(new C()));